@clawlabz/clawnetwork 0.1.0 → 0.1.1

package/index.ts

@@ -13,10 +13,21 @@ const GITHUB_REPO = 'clawlabz/claw-network'
 const DEFAULT_RPC_PORT = 9710
 const DEFAULT_P2P_PORT = 9711
 const DEFAULT_NETWORK = 'mainnet'
-const DEFAULT_SYNC_MODE = 'full'
+const DEFAULT_SYNC_MODE = 'light'
 const DEFAULT_HEALTH_CHECK_SECONDS = 30
 const DEFAULT_UI_PORT = 19877
 const MAX_RESTART_ATTEMPTS = 3
+
+// Built-in bootstrap peers for each network
+const BOOTSTRAP_PEERS: Record<string, string[]> = {
+  mainnet: [
+    '/ip4/178.156.162.162/tcp/9711',
+  ],
+  testnet: [
+    '/ip4/178.156.162.162/tcp/9721',
+  ],
+  devnet: [], // local dev, no bootstrap
+}
 const RESTART_BACKOFF_BASE_MS = 5_000
 const DECIMALS = 9
 const ONE_CLAW = BigInt(10 ** DECIMALS)
@@ -81,6 +92,7 @@ interface PluginConfig {
   syncMode: string
   healthCheckSeconds: number
   uiPort: number
+  extraBootstrapPeers: string[]
 }
 
 function getConfig(api: OpenClawApi): PluginConfig {
@@ -95,6 +107,7 @@ function getConfig(api: OpenClawApi): PluginConfig {
     syncMode: typeof c.syncMode === 'string' ? c.syncMode : DEFAULT_SYNC_MODE,
     healthCheckSeconds: typeof c.healthCheckSeconds === 'number' ? c.healthCheckSeconds : DEFAULT_HEALTH_CHECK_SECONDS,
     uiPort: typeof c.uiPort === 'number' ? c.uiPort : DEFAULT_UI_PORT,
+    extraBootstrapPeers: Array.isArray(c.extraBootstrapPeers) ? c.extraBootstrapPeers.filter((p: unknown) => typeof p === 'string') : [],
   }
 }
 
@@ -542,6 +555,12 @@ function startNodeProcess(binaryPath: string, cfg: PluginConfig, api: OpenClawAp
 
   const args = ['start', '--network', cfg.network, '--rpc-port', String(cfg.rpcPort), '--p2p-port', String(cfg.p2pPort), '--sync-mode', cfg.syncMode, '--allow-genesis']
 
+  // Add bootstrap peers: built-in for the network + user-configured extra peers
+  const peers = [...(BOOTSTRAP_PEERS[cfg.network] ?? []), ...cfg.extraBootstrapPeers]
+  for (const peer of peers) {
+    args.push('--bootstrap', peer)
+  }
+
   api.logger?.info?.(`[clawnetwork] starting node: ${binaryPath} ${args.join(' ')}`)
 
   rotateLogIfNeeded()
@@ -699,6 +718,84 @@ async function autoRegisterAgent(cfg: PluginConfig, wallet: WalletData, api: Ope
   }
 }
 
+// ============================================================
+// Mining: Auto Miner Registration + Heartbeat Loop
+// ============================================================
+
+// Heartbeat interval: MINER_GRACE_BLOCKS is 2000, at 3s/block = ~6000s.
+// Send heartbeat every ~1000 blocks (~50 min) to stay well within grace period.
+const MINER_HEARTBEAT_INTERVAL_MS = 50 * 60 * 1000 // 50 minutes
+let minerHeartbeatTimer: unknown = null
+
+async function autoRegisterMiner(cfg: PluginConfig, wallet: WalletData, api: OpenClawApi): Promise<void> {
+  if (!wallet.address) return
+
+  const binary = findBinary()
+  if (!binary) return
+
+  // Register as miner
+  const minerName = sanitizeAgentName(`openclaw-miner-${wallet.address.slice(0, 8)}`)
+  try {
+    const output = execFileSync(binary, [
+      'register-miner', '--name', minerName,
+      '--rpc', `http://localhost:${cfg.rpcPort}`,
+    ], {
+      encoding: 'utf8',
+      timeout: 30_000,
+      env: { HOME: os.homedir(), PATH: process.env.PATH || '' },
+    })
+    api.logger?.info?.(`[clawnetwork] miner registered: ${minerName} — ${output.trim().slice(0, 200)}`)
+  } catch (e: unknown) {
+    // "already registered" is fine
+    const msg = (e as Error).message
+    if (msg.includes('already') || msg.includes('exists')) {
+      api.logger?.info?.(`[clawnetwork] miner already registered: ${wallet.address.slice(0, 12)}...`)
+    } else {
+      api.logger?.warn?.(`[clawnetwork] miner registration failed: ${msg.slice(0, 200)}`)
+    }
+  }
+
+  // Send first heartbeat immediately
+  await sendMinerHeartbeat(cfg, api)
+
+  // Start periodic heartbeat loop
+  startMinerHeartbeatLoop(cfg, api)
+}
+
+async function sendMinerHeartbeat(cfg: PluginConfig, api: OpenClawApi): Promise<void> {
+  const binary = findBinary()
+  if (!binary) return
+
+  try {
+    const output = execFileSync(binary, [
+      'miner-heartbeat',
+      '--rpc', `http://localhost:${cfg.rpcPort}`,
+    ], {
+      encoding: 'utf8',
+      timeout: 30_000,
+      env: { HOME: os.homedir(), PATH: process.env.PATH || '' },
+    })
+    api.logger?.info?.(`[clawnetwork] ${output.trim()}`)
+  } catch (e: unknown) {
+    api.logger?.warn?.(`[clawnetwork] heartbeat failed: ${(e as Error).message.slice(0, 200)}`)
+  }
+}
+
+function startMinerHeartbeatLoop(cfg: PluginConfig, api: OpenClawApi): void {
+  if (minerHeartbeatTimer) clearInterval(minerHeartbeatTimer)
+  minerHeartbeatTimer = setInterval(() => {
+    sendMinerHeartbeat(cfg, api).catch(() => {})
+  }, MINER_HEARTBEAT_INTERVAL_MS)
+  api.logger?.info?.(`[clawnetwork] miner heartbeat loop started (every ${Math.round(MINER_HEARTBEAT_INTERVAL_MS / 60000)}min)`)
+}
+
+function stopMinerHeartbeatLoop(): void {
+  if (minerHeartbeatTimer) {
+    clearInterval(minerHeartbeatTimer)
+    minerHeartbeatTimer = null
+  }
+}
+
 // ============================================================
 // WebUI Server
 // ============================================================
@@ -775,6 +872,24 @@ function buildUiHtml(cfg: PluginConfig): string {
 
     .toast { position: fixed; bottom: 24px; right: 24px; background: var(--bg-panel); border: 1px solid var(--accent); color: var(--accent); padding: 12px 20px; border-radius: 8px; font-size: 13px; opacity: 0; transition: 0.3s; z-index: 1000; }
     .toast.show { opacity: 1; }
+
+    .quick-actions { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 10px; margin: 16px 0; }
+    .quick-action { background: var(--bg-panel); border: 1px solid var(--border); border-radius: var(--radius); padding: 14px 16px; cursor: pointer; transition: 0.2s; display: flex; align-items: center; gap: 10px; font-size: 13px; color: var(--text); }
+    .quick-action:hover { border-color: var(--accent); color: var(--accent); transform: translateY(-1px); }
+    .quick-action .qa-icon { font-size: 18px; width: 28px; text-align: center; }
+    .quick-action .qa-label { font-weight: 500; }
+    .quick-action .qa-hint { font-size: 11px; color: var(--text-dim); margin-top: 2px; }
+    .quick-action.warn:hover { border-color: var(--danger); color: var(--danger); }
+
+    .modal-overlay { position: fixed; inset: 0; background: rgba(0,0,0,0.7); display: none; align-items: center; justify-content: center; z-index: 200; }
+    .modal-overlay.open { display: flex; }
+    .modal { background: var(--bg-panel); border: 1px solid var(--border); border-radius: var(--radius); padding: 28px; max-width: 520px; width: 90%; box-shadow: var(--shadow); }
+    .modal-title { font-size: 16px; font-weight: 700; margin-bottom: 12px; }
+    .modal-warn { background: rgba(255,85,85,0.1); border: 1px solid var(--danger); border-radius: 6px; padding: 10px 14px; font-size: 12px; color: var(--danger); margin-bottom: 14px; line-height: 1.5; }
+    .modal-key { font-family: var(--font-mono); font-size: 13px; background: var(--bg); padding: 12px; border-radius: 6px; border: 1px solid var(--border); word-break: break-all; line-height: 1.6; user-select: all; }
+    .modal-actions { display: flex; gap: 8px; margin-top: 16px; justify-content: flex-end; }
+    .modal-close { background: none; border: 1px solid var(--border); color: var(--text-dim); padding: 8px 16px; border-radius: 6px; cursor: pointer; font-size: 13px; }
+    .modal-close:hover { border-color: var(--text); color: var(--text); }
   </style>
 </head>
 <body>
@@ -818,6 +933,36 @@ function buildUiHtml(cfg: PluginConfig): string {
     <div class="panel">
       <div class="panel-title">Wallet</div>
       <div id="walletInfo">Loading...</div>
+      <div class="quick-actions" id="walletActions" style="display:none">
+        <div class="quick-action" onclick="copyAddress()">
+          <span class="qa-icon">&#x1F4CB;</span>
+          <div><div class="qa-label">Copy Address</div><div class="qa-hint">Share to receive CLAW</div></div>
+        </div>
+        <div class="quick-action" onclick="importToExtension()" id="qaImportExt" style="display:none">
+          <span class="qa-icon">&#x1F517;</span>
+          <div><div class="qa-label">Import to Extension</div><div class="qa-hint">One-click import to browser wallet</div></div>
+        </div>
+        <div class="quick-action warn" onclick="showExportKey()">
+          <span class="qa-icon">&#x1F511;</span>
+          <div><div class="qa-label">Export Private Key</div><div class="qa-hint">Manual copy for backup</div></div>
+        </div>
+        <div class="quick-action" onclick="openExplorer()">
+          <span class="qa-icon">&#x1F50D;</span>
+          <div><div class="qa-label">View on Explorer</div><div class="qa-hint">Transaction history</div></div>
+        </div>
+        <div class="quick-action" onclick="transferFromDashboard()">
+          <span class="qa-icon">&#x1F4B8;</span>
+          <div><div class="qa-label">Transfer CLAW</div><div class="qa-hint">Send to any address</div></div>
+        </div>
+        <div class="quick-action" onclick="registerAgentFromDashboard()">
+          <span class="qa-icon">&#x1F916;</span>
+          <div><div class="qa-label">Register Agent</div><div class="qa-hint">On-chain identity</div></div>
+        </div>
+        <div class="quick-action" onclick="openFaucet()">
+          <span class="qa-icon">&#x1F6B0;</span>
+          <div><div class="qa-label">Open Faucet</div><div class="qa-hint">Get testnet CLAW</div></div>
+        </div>
+      </div>
     </div>
 
     <div class="panel">
@@ -833,6 +978,20 @@ function buildUiHtml(cfg: PluginConfig): string {
 
   <div class="toast" id="toast"></div>
 
+  <div class="modal-overlay" id="exportModal" onclick="if(event.target===this)closeExportModal()">
+    <div class="modal">
+      <div class="modal-title">Export Private Key</div>
+      <div class="modal-warn">
+        &#x26A0;&#xFE0F; <strong>Never share your private key.</strong> Anyone with this key has full control of your wallet and funds. Only use this to import into your own browser extension or backup.
+      </div>
+      <div class="modal-key" id="exportKeyDisplay">Loading...</div>
+      <div class="modal-actions">
+        <button class="btn primary" onclick="copyExportKey()">Copy Private Key</button>
+        <button class="modal-close" onclick="closeExportModal()">Close</button>
+      </div>
+    </div>
+  </div>
+
   <script>
     const API = '';
     let autoRefresh = null;
@@ -844,10 +1003,167 @@ function buildUiHtml(cfg: PluginConfig): string {
       setTimeout(() => el.classList.remove('show'), 3000);
     }
 
+    let cachedAddress = '';
+    let cachedNetwork = '';
+    let cachedKey = '';
+
     function copyText(text) {
       navigator.clipboard.writeText(text).then(() => toast('Copied!')).catch(() => {});
     }
 
+    function copyAddress() {
+      if (!cachedAddress) { toast('No wallet address'); return; }
+      copyText(cachedAddress);
+      toast('Address copied!');
+    }
+
+    async function showExportKey() {
+      document.getElementById('exportKeyDisplay').textContent = 'Loading...';
+      document.getElementById('exportModal').classList.add('open');
+      try {
+        const res = await fetch(API + '/api/wallet/export');
+        const data = await res.json();
+        if (data.error) { document.getElementById('exportKeyDisplay').textContent = data.error; return; }
+        cachedKey = data.secretKey;
+        document.getElementById('exportKeyDisplay').textContent = data.secretKey;
+      } catch (e) { document.getElementById('exportKeyDisplay').textContent = 'Failed to load'; }
+    }
+
+    function closeExportModal() {
+      document.getElementById('exportModal').classList.remove('open');
+      cachedKey = '';
+      document.getElementById('exportKeyDisplay').textContent = '';
+    }
+
+    function copyExportKey() {
+      if (!cachedKey) return;
+      copyText(cachedKey);
+      toast('Private key copied! Paste into browser extension to import.');
+    }
+
+    function openExplorer() {
+      if (!cachedAddress) { toast('No wallet address'); return; }
+      window.open('https://explorer.clawlabz.xyz/address/' + cachedAddress, '_blank');
+    }
+
+    function openFaucet() {
+      window.open('https://chain.clawlabz.xyz/faucet', '_blank');
+    }
+
+    // Detect ClawNetwork extension provider
+    let hasExtension = false;
+    function checkExtension() {
+      if (window.clawNetwork && window.clawNetwork.isClawNetwork) {
+        hasExtension = true;
+        const el = document.getElementById('qaImportExt');
+        if (el) el.style.display = '';
+      }
+    }
+    // Check immediately and after a short delay (extension injects at document_start)
+    checkExtension();
+    setTimeout(checkExtension, 1000);
+    setTimeout(checkExtension, 3000);
+
+    async function importToExtension() {
+      // Try externally_connectable direct channel first (bypasses page JS context)
+      const extIds = await detectExtensionIds();
+      if (extIds.length > 0) {
+        toast('Connecting to extension (secure channel)...');
+        try {
+          const res = await fetch(API + '/api/wallet/export');
+          const data = await res.json();
+          if (!data.secretKey) { toast('No private key found'); return; }
+          // Direct to background — private key never in page JS event loop
+          const extId = extIds[0];
+          await chromeExtSend(extId, { method: 'claw_requestAccounts' });
+          toast('Approve the import in your extension popup...');
+          await chromeExtSend(extId, { method: 'claw_importAccountKey', params: [data.secretKey, 'ClawNetwork Node'] });
+          toast('Account imported to extension!');
+          return;
+        } catch (e) { /* fall through to provider method */ }
+      }
+      // Fallback: use window.clawNetwork provider
+      if (!window.clawNetwork) { toast('ClawNetwork extension not detected. Install it first.'); return; }
+      toast('Connecting to extension...');
+      try {
+        await window.clawNetwork.request({ method: 'claw_requestAccounts' });
+        const res = await fetch(API + '/api/wallet/export');
+        const data = await res.json();
+        if (!data.secretKey) { toast('No private key found'); return; }
+        toast('Approve the import in your extension popup...');
+        await window.clawNetwork.request({ method: 'claw_importAccountKey', params: [data.secretKey, 'ClawNetwork Node'] });
+        toast('Account imported to extension!');
+      } catch (e) { toast('Import failed: ' + (e.message || e)); }
+    }
+
+    function chromeExtSend(extId, msg) {
+      return new Promise((resolve, reject) => {
+        if (!chrome || !chrome.runtime || !chrome.runtime.sendMessage) { reject(new Error('No chrome.runtime')); return; }
+        chrome.runtime.sendMessage(extId, msg, (response) => {
+          if (chrome.runtime.lastError) { reject(new Error(chrome.runtime.lastError.message)); return; }
+          if (response && response.success === false) { reject(new Error(response.error || 'Failed')); return; }
+          resolve(response);
+        });
+      });
+    }
+
+    async function detectExtensionIds() {
+      // Try known extension IDs or probe for externally_connectable
+      // In production, the extension ID is stable after Chrome Web Store publish
+      // For dev, try to detect via management API or stored ID
+      const ids = [];
+      try {
+        if (chrome && chrome.runtime && chrome.runtime.sendMessage) {
+          // Try sending a ping to see if any extension responds
+          // This requires knowing the extension ID. For now, check localStorage.
+          const stored = localStorage.getItem('clawnetwork_extension_id');
+          if (stored) ids.push(stored);
+        }
+      } catch {}
+      return ids;
+    }
+
+    async function transferFromDashboard() {
+      const to = prompt('Recipient address (64 hex chars):');
+      if (!to) return;
+      const amount = prompt('Amount (CLAW):');
+      if (!amount) return;
+      if (window.clawNetwork) {
+        try {
+          toast('Approve transfer in extension...');
+          await window.clawNetwork.request({ method: 'claw_requestAccounts' });
+          const result = await window.clawNetwork.request({ method: 'claw_transfer', params: [to, amount] });
+          toast('Transfer sent! Hash: ' + (result && result.txHash ? result.txHash.slice(0, 16) + '...' : 'submitted'));
+        } catch (e) { toast('Transfer failed: ' + (e.message || e)); }
+      } else {
+        try {
+          const res = await fetch(API + '/api/transfer', { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify({to, amount}) });
+          const data = await res.json();
+          toast(data.ok ? 'Transfer sent! Hash: ' + (data.txHash || '').slice(0, 16) + '...' : 'Error: ' + data.error);
+        } catch (e) { toast('Transfer failed: ' + e.message); }
+      }
+      setTimeout(fetchStatus, 3000);
+    }
+
+    async function registerAgentFromDashboard() {
+      const name = prompt('Agent name (alphanumeric, max 32 chars):', 'openclaw-agent');
+      if (!name) return;
+      if (window.clawNetwork) {
+        try {
+          toast('Approve registration in extension...');
+          await window.clawNetwork.request({ method: 'claw_requestAccounts' });
+          await window.clawNetwork.request({ method: 'claw_registerAgent', params: [name] });
+          toast('Agent registered!');
+        } catch (e) { toast('Registration failed: ' + (e.message || e)); }
+      } else {
+        try {
+          const res = await fetch(API + '/api/agent/register', { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify({name}) });
+          const data = await res.json();
+          toast(data.ok ? 'Agent registered!' : 'Error: ' + data.error);
+        } catch (e) { toast('Registration failed: ' + e.message); }
+      }
+    }
+
     async function fetchStatus() {
       try {
         const res = await fetch(API + '/api/status');
@@ -874,11 +1190,14 @@ function buildUiHtml(cfg: PluginConfig): string {
       document.getElementById('uptimeValue').textContent = s.uptimeFormatted || '—';
 
       // Wallet
+      cachedAddress = s.walletAddress || '';
+      cachedNetwork = s.network || '';
       const wHtml = s.walletAddress
         ? '<div class="wallet-addr">' + s.walletAddress + ' <button class="copy-btn" onclick="copyText(\\''+s.walletAddress+'\\')">Copy</button></div>' +
           (s.balance ? '<div style="margin-top:8px;font-size:14px;color:var(--green)">' + s.balance + '</div>' : '')
         : '<div style="color:var(--text-dim)">No wallet yet — start the node to generate one</div>';
       document.getElementById('walletInfo').innerHTML = wHtml;
+      document.getElementById('walletActions').style.display = s.walletAddress ? '' : 'none';
 
       // Node info
       const rows = [
@@ -923,152 +1242,366 @@ function buildUiHtml(cfg: PluginConfig): string {
 </html>`
 }
 
-let uiServer: unknown = null
+// ── UI Server (standalone script, forked as background process) ──
 
-function startUiServer(cfg: PluginConfig, api: OpenClawApi): string | null {
-  const http = require('http')
+const UI_SERVER_SCRIPT = `
+const http = require('http');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 
-  if (uiServer) return null
+const PORT = parseInt(process.argv[2] || '19877', 10);
+const RPC_PORT = parseInt(process.argv[3] || '9710', 10);
+const LOG_PATH = process.argv[4] || path.join(os.homedir(), '.openclaw/workspace/clawnetwork/node.log');
+const PORT_FILE = path.join(os.homedir(), '.openclaw/clawnetwork-ui-port');
+const MAX_RETRIES = 10;
 
-  let actualPort = cfg.uiPort
-  const maxRetries = 10
+async function fetchJson(url) {
+  const r = await fetch(url);
+  return r.json();
+}
 
-  const handleRequest = async (req: { method: string; url: string }, res: { writeHead: (s: number, h?: Record<string, string>) => void; end: (data?: string) => void; setHeader: (k: string, v: string) => void }) => {
-    const url = new URL(req.url, `http://localhost:${actualPort}`)
-    const pathname = url.pathname
+async function rpcCall(method, params) {
+  const r = await fetch('http://localhost:' + RPC_PORT, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ jsonrpc: '2.0', method, params: params || [], id: Date.now() }),
+  });
+  const d = await r.json();
+  if (d.error) throw new Error(d.error.message || JSON.stringify(d.error));
+  return d.result;
+}
 
-    res.setHeader('Access-Control-Allow-Origin', '*')
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type')
-    if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return }
+function formatClaw(raw) {
+  const v = BigInt(raw);
+  const ONE = BigInt(1e9);
+  const w = v / ONE;
+  const f = v % ONE;
+  if (f === 0n) return w + ' CLAW';
+  return w + '.' + f.toString().padStart(9, '0').replace(/0+$/, '') + ' CLAW';
+}
 
-    const json = (status: number, data: unknown) => {
-      res.writeHead(status, { 'content-type': 'application/json' })
-      res.end(JSON.stringify(data))
-    }
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    req.on('data', (chunk) => { data += chunk; });
+    req.on('end', () => { try { resolve(JSON.parse(data || '{}')); } catch { resolve({}); } });
+    req.on('error', reject);
+    setTimeout(() => reject(new Error('Body read timeout')), 10000);
+  });
+}
 
-    // Serve dashboard
-    if (pathname === '/' || pathname === '/index.html') {
-      res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' })
-      res.end(buildUiHtml(cfg))
-      return
-    }
+function findNodeBinary() {
+  const binDir = path.join(os.homedir(), '.openclaw/bin');
+  const dataDir = path.join(os.homedir(), '.clawnetwork');
+  const binName = process.platform === 'win32' ? 'claw-node.exe' : 'claw-node';
+  let binary = path.join(binDir, binName);
+  if (fs.existsSync(binary)) return binary;
+  binary = path.join(dataDir, 'bin', 'claw-node');
+  if (fs.existsSync(binary)) return binary;
+  return null;
+}
 
-    // Status API
-    if (pathname === '/api/status' && req.method === 'GET') {
-      const health = await checkHealth(cfg.rpcPort)
-      lastHealth = health
-      const status = buildStatus(cfg)
-      // Enrich with balance
-      let balance = ''
-      const wallet = loadWallet()
-      if (wallet?.address) {
-        try {
-          const raw = await rpcCall(cfg.rpcPort, 'claw_getBalance', [wallet.address])
-          balance = formatClaw(String(raw as string))
-        } catch { /* ok */ }
-      }
-      json(200, { ...status, balance, syncing: health.syncing })
-      return
-    }
+async function handle(req, res) {
+  const url = new URL(req.url, 'http://localhost:' + PORT);
+  const p = url.pathname;
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+  if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
+
+  const json = (s, d) => { res.writeHead(s, { 'content-type': 'application/json' }); res.end(JSON.stringify(d)); };
 
-    // Logs API
-    if (pathname === '/api/logs' && req.method === 'GET') {
+  if (p === '/' || p === '/index.html') {
+    res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+    res.end(HTML);
+    return;
+  }
+  if (p === '/api/status') {
+    try {
+      const h = await fetchJson('http://localhost:' + RPC_PORT + '/health');
+      let balance = '';
       try {
-        if (!fs.existsSync(LOG_PATH)) { json(200, { logs: 'No logs yet' }); return }
-        const content = fs.readFileSync(LOG_PATH, 'utf8')
-        const lines = content.split('\n')
-        json(200, { logs: lines.slice(-80).join('\n') })
-      } catch (e: unknown) {
-        json(500, { error: (e as Error).message })
-      }
-      return
+        const walletPath = path.join(os.homedir(), '.openclaw/workspace/clawnetwork/wallet.json');
+        const w = JSON.parse(fs.readFileSync(walletPath, 'utf8'));
+        if (w.address) { const b = await rpcCall('claw_getBalance', [w.address]); balance = formatClaw(b); }
+      } catch {}
+      json(200, {
+        running: h.status === 'ok',
+        blockHeight: h.height,
+        peerCount: h.peer_count,
+        network: h.chain_id,
+        syncMode: 'light',
+        rpcUrl: 'http://localhost:' + RPC_PORT,
+        walletAddress: (() => { try { return JSON.parse(fs.readFileSync(path.join(os.homedir(), '.openclaw/workspace/clawnetwork/wallet.json'), 'utf8')).address; } catch { return ''; } })(),
+        binaryVersion: h.version,
+        pluginVersion: '0.1.0',
+        uptime: h.uptime_secs,
+        uptimeFormatted: h.uptime_secs < 60 ? h.uptime_secs + 's' : h.uptime_secs < 3600 ? Math.floor(h.uptime_secs/60) + 'm' : Math.floor(h.uptime_secs/3600) + 'h ' + Math.floor((h.uptime_secs%3600)/60) + 'm',
+        restartCount: 0, dataDir: path.join(os.homedir(), '.clawnetwork'), balance, syncing: h.status === 'degraded',
+      });
+    } catch { json(200, { running: false, blockHeight: null, peerCount: null }); }
+    return;
+  }
+  if (p === '/api/logs') {
+    try {
+      if (!fs.existsSync(LOG_PATH)) { json(200, { logs: 'No logs yet' }); return; }
+      const c = fs.readFileSync(LOG_PATH, 'utf8').split('\\n');
+      json(200, { logs: c.slice(-80).join('\\n') });
+    } catch (e) { json(500, { error: e.message }); }
+    return;
+  }
+  if (p === '/api/wallet/export') {
+    // Only allow from localhost (127.0.0.1) — never expose to network
+    const host = req.headers.host || '';
+    if (!host.startsWith('127.0.0.1') && !host.startsWith('localhost')) {
+      json(403, { error: 'Wallet export only available from localhost' });
+      return;
     }
-
-    // Action API
-    if (pathname.startsWith('/api/action/') && req.method === 'POST') {
-      const action = pathname.split('/').pop()
-
-      if (action === 'start') {
-        let binary = findBinary()
-        if (!binary && cfg.autoDownload) {
-          try { binary = await downloadBinary(api) } catch (e: unknown) {
-            json(500, { error: (e as Error).message }); return
-          }
-        }
-        if (!binary) { json(400, { error: 'claw-node binary not found' }); return }
-        if (nodeProcess && !nodeProcess.killed) { json(200, { message: 'Node already running' }); return }
-        initNode(binary, cfg.network, api)
-        startNodeProcess(binary, cfg, api)
-        json(200, { message: 'Node starting...' })
-        return
-      }
-
-      if (action === 'stop') {
-        stopNode(api)
-        json(200, { message: 'Node stopped' })
-        return
-      }
-
-      if (action === 'faucet') {
-        const wallet = loadWallet()
-        if (!wallet?.address) { json(400, { error: 'No wallet' }); return }
+    try {
+      const walletPath = path.join(os.homedir(), '.openclaw/workspace/clawnetwork/wallet.json');
+      const w = JSON.parse(fs.readFileSync(walletPath, 'utf8'));
+      json(200, { address: w.address, secretKey: w.secret_key || w.secretKey || w.private_key || '' });
+    } catch (e) { json(400, { error: 'No wallet found' }); }
+    return;
+  }
+  // ── Business API endpoints (mirrors Gateway methods) ──
+  if (p === '/api/wallet/balance') {
+    try {
+      const walletPath = path.join(os.homedir(), '.openclaw/workspace/clawnetwork/wallet.json');
+      const w = JSON.parse(fs.readFileSync(walletPath, 'utf8'));
+      const address = new URL(req.url, 'http://localhost').searchParams.get('address') || w.address;
+      const b = await rpcCall('claw_getBalance', [address]);
+      json(200, { address, balance: String(b), formatted: formatClaw(b) });
+    } catch (e) { json(400, { error: e.message }); }
+    return;
+  }
+  if (p === '/api/transfer' && req.method === 'POST') {
+    try {
+      const body = await readBody(req);
+      const { to, amount } = body;
+      if (!to || !amount) { json(400, { error: 'Missing params: to, amount' }); return; }
+      if (!/^[0-9a-f]{64}$/i.test(to)) { json(400, { error: 'Invalid address (64 hex chars)' }); return; }
+      if (!/^\\d+(\\.\\d+)?$/.test(amount) || parseFloat(amount) <= 0) { json(400, { error: 'Invalid amount' }); return; }
+      const bin = findNodeBinary();
+      if (!bin) { json(400, { error: 'claw-node binary not found' }); return; }
+      const { execFileSync } = require('child_process');
+      const out = execFileSync(bin, ['transfer', to, amount, '--rpc', 'http://localhost:' + RPC_PORT], { encoding: 'utf8', timeout: 30000, env: { HOME: os.homedir(), PATH: process.env.PATH || '' } });
+      const h = out.match(/[0-9a-f]{64}/i);
+      json(200, { ok: true, txHash: h ? h[0] : '', to, amount });
+    } catch (e) { json(500, { error: e.message }); }
+    return;
+  }
+  if (p === '/api/stake' && req.method === 'POST') {
+    try {
+      const body = await readBody(req);
+      const { amount, action } = body;
+      if (!amount && action !== 'claim') { json(400, { error: 'Missing amount' }); return; }
+      const bin = findNodeBinary();
+      if (!bin) { json(400, { error: 'claw-node binary not found' }); return; }
+      const { execFileSync } = require('child_process');
+      const cmd = action === 'withdraw' ? 'stake withdraw' : action === 'claim' ? 'stake claim' : 'stake deposit';
+      const args = cmd.split(' ').concat(amount ? [amount] : []).concat(['--rpc', 'http://localhost:' + RPC_PORT]);
+      const out = execFileSync(bin, args, { encoding: 'utf8', timeout: 30000, env: { HOME: os.homedir(), PATH: process.env.PATH || '' } });
+      json(200, { ok: true, raw: out.trim() });
+    } catch (e) { json(500, { error: e.message }); }
+    return;
+  }
+  if (p === '/api/agent/register' && req.method === 'POST') {
+    try {
+      const body = await readBody(req);
+      const name = (body.name || 'openclaw-agent-' + Date.now().toString(36)).replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 32);
+      const bin = findNodeBinary();
+      if (!bin) { json(400, { error: 'claw-node binary not found' }); return; }
+      const { execFileSync } = require('child_process');
+      const out = execFileSync(bin, ['agent', 'register', '--name', name, '--rpc', 'http://localhost:' + RPC_PORT], { encoding: 'utf8', timeout: 30000, env: { HOME: os.homedir(), PATH: process.env.PATH || '' } });
+      const h = out.match(/[0-9a-f]{64}/i);
+      json(200, { ok: true, txHash: h ? h[0] : '', name });
+    } catch (e) { json(500, { error: e.message }); }
+    return;
+  }
+  if (p === '/api/service/register' && req.method === 'POST') {
+    try {
+      const body = await readBody(req);
+      const { serviceType, endpoint, description, priceAmount } = body;
+      if (!serviceType || !endpoint) { json(400, { error: 'Missing: serviceType, endpoint' }); return; }
+      const bin = findNodeBinary();
+      if (!bin) { json(400, { error: 'claw-node binary not found' }); return; }
+      const { execFileSync } = require('child_process');
+      const out = execFileSync(bin, ['service', 'register', '--type', serviceType, '--endpoint', endpoint, '--description', description || '', '--price', priceAmount || '0', '--rpc', 'http://localhost:' + RPC_PORT], { encoding: 'utf8', timeout: 30000, env: { HOME: os.homedir(), PATH: process.env.PATH || '' } });
+      json(200, { ok: true, raw: out.trim() });
+    } catch (e) { json(500, { error: e.message }); }
+    return;
+  }
+  if (p === '/api/service/search') {
+    try {
+      const t = new URL(req.url, 'http://localhost').searchParams.get('type');
+      const result = await rpcCall('claw_getServices', t ? [t] : []);
+      json(200, { services: result });
+    } catch (e) { json(500, { error: e.message }); }
+    return;
+  }
+  if (p === '/api/node/config') {
+    try {
+      const cfgPath = path.join(os.homedir(), '.openclaw/workspace/clawnetwork/config.json');
+      const cfg = fs.existsSync(cfgPath) ? JSON.parse(fs.readFileSync(cfgPath, 'utf8')) : {};
+      json(200, { ...cfg, rpcPort: RPC_PORT, uiPort: PORT });
+    } catch (e) { json(200, { rpcPort: RPC_PORT, uiPort: PORT }); }
+    return;
+  }
+  if (p.startsWith('/api/action/') && req.method === 'POST') {
+    const a = p.split('/').pop();
+    if (a === 'faucet') {
+      try {
+        const w = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.openclaw/workspace/clawnetwork/wallet.json'), 'utf8'));
+        const r = await rpcCall('claw_faucet', [w.address]);
+        json(200, { message: 'Faucet success', ...r });
+      } catch (e) { json(400, { error: e.message }); }
+      return;
+    }
+    if (a === 'start') {
+      try {
+        // Check if already running
+        const pidFile = path.join(os.homedir(), '.openclaw/workspace/clawnetwork/node.pid');
         try {
-          const result = await rpcCall(cfg.rpcPort, 'claw_faucet', [wallet.address])
-          json(200, { message: 'Faucet success', ...(result as Record<string, unknown>) })
-        } catch (e: unknown) {
-          json(400, { error: (e as Error).message, message: 'Faucet only works on testnet/devnet' })
+          const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+          if (pid > 0) { try { process.kill(pid, 0); json(200, { message: 'Node already running', pid }); return; } catch {} }
+        } catch {}
+        // Find binary
+        const binDir = path.join(os.homedir(), '.openclaw/bin');
+        const dataDir = path.join(os.homedir(), '.clawnetwork');
+        const binName = process.platform === 'win32' ? 'claw-node.exe' : 'claw-node';
+        let binary = path.join(binDir, binName);
+        if (!fs.existsSync(binary)) { binary = path.join(dataDir, 'bin', 'claw-node'); }
+        if (!fs.existsSync(binary)) { json(400, { error: 'claw-node binary not found. Run: openclaw clawnetwork:download' }); return; }
+        // Read config for network/ports
+        const cfgPath = path.join(os.homedir(), '.openclaw/workspace/clawnetwork/config.json');
+        let network = 'mainnet', p2pPort = 9711, syncMode = 'light', extraPeers = [];
+        try {
+          const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+          if (cfg.network) network = cfg.network;
+          if (cfg.p2pPort) p2pPort = cfg.p2pPort;
+          if (cfg.syncMode) syncMode = cfg.syncMode;
+          if (cfg.extraBootstrapPeers) extraPeers = cfg.extraBootstrapPeers;
+        } catch {}
+        const bootstrapPeers = { mainnet: ['/ip4/178.156.162.162/tcp/9711'], testnet: ['/ip4/178.156.162.162/tcp/9721'], devnet: [] };
+        const peers = [...(bootstrapPeers[network] || []), ...extraPeers];
+        const args = ['start', '--network', network, '--rpc-port', String(RPC_PORT), '--p2p-port', String(p2pPort), '--sync-mode', syncMode, '--allow-genesis'];
+        for (const peer of peers) { args.push('--bootstrap', peer); }
+        // Spawn detached
+        const logPath = path.join(os.homedir(), '.openclaw/workspace/clawnetwork/node.log');
+        const logFd = fs.openSync(logPath, 'a');
+        const { spawn: nodeSpawn } = require('child_process');
+        const child = nodeSpawn(binary, args, {
+          stdio: ['ignore', logFd, logFd],
+          detached: true,
+          env: { HOME: os.homedir(), PATH: process.env.PATH || '/usr/local/bin:/usr/bin:/bin', RUST_LOG: process.env.RUST_LOG || 'claw=info' },
+        });
+        child.unref();
+        fs.closeSync(logFd);
+        fs.writeFileSync(pidFile, String(child.pid));
+        // Remove stop signal if exists
+        const stopFile = path.join(os.homedir(), '.openclaw/workspace/clawnetwork/stop.signal');
+        try { fs.unlinkSync(stopFile); } catch {}
+        json(200, { message: 'Node started', pid: child.pid });
+      } catch (e) { json(500, { error: e.message }); }
+      return;
+    }
+    if (a === 'stop') {
+      try {
+        const pidFile = path.join(os.homedir(), '.openclaw/workspace/clawnetwork/node.pid');
+        let pid = null;
+        try { pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10); } catch {}
+        if (pid && pid > 0) {
+          try { process.kill(pid, 'SIGTERM'); } catch {}
         }
-        return
-      }
-
-      json(404, { error: 'Unknown action' })
-      return
+        // Write stop signal for restart loop
+        const stopFile = path.join(os.homedir(), '.openclaw/workspace/clawnetwork/stop.signal');
+        try { fs.writeFileSync(stopFile, String(Date.now())); } catch {}
+        // Also kill by name (covers orphans)
+        try { require('child_process').execFileSync('pkill', ['-f', 'claw-node start'], { timeout: 3000 }); } catch {}
+        try { fs.unlinkSync(pidFile); } catch {}
+        json(200, { message: 'Node stopped' });
+      } catch (e) { json(500, { error: e.message }); }
+      return;
     }
-
-    json(404, { error: 'Not found' })
+    if (a === 'restart') {
+      json(200, { message: 'Use Stop then Start to restart the node' });
+      return;
+    }
+    json(400, { error: 'Unknown action: ' + a });
+    return;
   }
+  json(404, { error: 'Not found' });
+}
 
-  // Try ports with fallback
-  for (let attempt = 0; attempt < maxRetries; attempt++) {
-    const tryPort = cfg.uiPort + attempt
-    try {
-      const server = http.createServer((req: unknown, res: unknown) => {
-        handleRequest(req as any, res as any).catch((err: Error) => {
-          try { (res as any).writeHead(500); (res as any).end(JSON.stringify({ error: err.message })) } catch { /* ok */ }
-        })
-      })
+function tryListen(attempt) {
+  if (attempt >= MAX_RETRIES) { console.error('Failed to bind UI server'); process.exit(1); }
+  const port = PORT + attempt;
+  const srv = http.createServer((req, res) => handle(req, res).catch(e => { try { res.writeHead(500); res.end(e.message); } catch {} }));
+  srv.on('error', () => tryListen(attempt + 1));
+  srv.listen(port, '127.0.0.1', () => {
+    fs.mkdirSync(path.dirname(PORT_FILE), { recursive: true });
+    fs.writeFileSync(PORT_FILE, JSON.stringify({ port, pid: process.pid, startedAt: new Date().toISOString() }));
+    console.log('ClawNetwork Dashboard: http://127.0.0.1:' + port);
+    process.on('SIGINT', () => { try { fs.unlinkSync(PORT_FILE); } catch {} process.exit(0); });
+    process.on('SIGTERM', () => { try { fs.unlinkSync(PORT_FILE); } catch {} process.exit(0); });
+  });
+}
+tryListen(0);
+`
+
+function startUiServer(cfg: PluginConfig, api: OpenClawApi): string | null {
+  // Check if already running
+  const existing = getDashboardUrl()
+  if (existing) {
+    api.logger?.info?.(`[clawnetwork] dashboard already running: ${existing}`)
+    return existing
+  }
 
-      // Synchronous-ish listen check
-      let bound = false
-      server.listen(tryPort, '127.0.0.1')
-      server.on('listening', () => { bound = true })
-      server.on('error', () => { /* handled below */ })
+  // Write the standalone UI server script to a temp file and fork it
+  const scriptPath = path.join(WORKSPACE_DIR, 'ui-server.js')
+  ensureDir(WORKSPACE_DIR)
 
-      // Give it a moment
-      actualPort = tryPort
-      uiServer = server
+  // Write HTML to a separate file, script reads it at startup
+  const htmlPath = path.join(WORKSPACE_DIR, 'ui-dashboard.html')
+  fs.writeFileSync(htmlPath, buildUiHtml(cfg))
 
-      // Write port file for discovery
-      ensureDir(path.dirname(UI_PORT_FILE))
-      fs.writeFileSync(UI_PORT_FILE, JSON.stringify({ port: tryPort, pid: process.pid, startedAt: new Date().toISOString() }))
+  // Inject HTML path into script (read from file, no template escaping issues)
+  const fullScript = `const HTML_PATH = ${JSON.stringify(htmlPath)};\nconst HTML = require('fs').readFileSync(HTML_PATH, 'utf8');\n${UI_SERVER_SCRIPT}`
+  fs.writeFileSync(scriptPath, fullScript)
 
-      api.logger?.info?.(`[clawnetwork] dashboard: http://127.0.0.1:${tryPort}`)
-      return `http://127.0.0.1:${tryPort}`
-    } catch {
-      continue
+  try {
+    const child = fork(scriptPath, [String(cfg.uiPort), String(cfg.rpcPort), LOG_PATH], {
+      detached: true,
+      stdio: 'ignore',
+    })
+    child.unref()
+    api.logger?.info?.(`[clawnetwork] dashboard starting on http://127.0.0.1:${cfg.uiPort}`)
+
+    // Wait briefly for port file
+    for (let i = 0; i < 10; i++) {
+      const url = getDashboardUrl()
+      if (url) return url
+      // Busy-wait 200ms (can't use async sleep here)
+      const start = Date.now()
+      while (Date.now() - start < 200) { /* spin */ }
     }
+    return `http://127.0.0.1:${cfg.uiPort}`
+  } catch (e: unknown) {
+    api.logger?.warn?.(`[clawnetwork] failed to start dashboard: ${(e as Error).message}`)
+    return null
   }
-
-  api.logger?.warn?.('[clawnetwork] failed to start dashboard UI server')
-  return null
 }
 
 function stopUiServer(): void {
-  if (uiServer) {
-    try { uiServer.close() } catch { /* ok */ }
-    uiServer = null
-  }
+  try {
+    const raw = fs.readFileSync(UI_PORT_FILE, 'utf8')
+    const info = JSON.parse(raw)
+    if (info.pid) {
+      try { process.kill(info.pid, 'SIGTERM') } catch { /* ok */ }
+    }
+  } catch { /* no file */ }
   try { fs.unlinkSync(UI_PORT_FILE) } catch { /* ok */ }
 }
 
@@ -1266,11 +1799,15 @@ export default function register(api: OpenClawApi) {
       }
       initNode(binary, cfg.network, api)
       startNodeProcess(binary, cfg, api)
-      out({ message: 'Node started', pid: nodeProcess?.pid, network: cfg.network, rpc: `http://localhost:${cfg.rpcPort}` })
+      // Start UI dashboard
+      const dashUrl = startUiServer(cfg, api)
+      out({ message: 'Node started', pid: nodeProcess?.pid, network: cfg.network, rpc: `http://localhost:${cfg.rpcPort}`, dashboard: dashUrl || `http://127.0.0.1:${cfg.uiPort}` })
     }
 
     const handleStop = () => {
+      stopMinerHeartbeatLoop()
       stopNode(api)
+      stopUiServer()
       out({ message: 'Node stopped' })
     }
 
@@ -1521,16 +2058,23 @@ export default function register(api: OpenClawApi) {
           // Step 3: Wallet
           const wallet = ensureWallet(cfg.network, api)
 
-          // Step 4: Start node
+          // Step 4: Save config for UI server to read
+          const cfgPath = path.join(WORKSPACE_DIR, 'config.json')
+          fs.writeFileSync(cfgPath, JSON.stringify({ network: cfg.network, rpcPort: cfg.rpcPort, p2pPort: cfg.p2pPort, syncMode: cfg.syncMode, extraBootstrapPeers: cfg.extraBootstrapPeers }))
+
+          // Step 5: Start node
           startNodeProcess(binary, cfg, api)
 
-          // Step 5: Start UI dashboard
+          // Step 6: Start UI dashboard
           startUiServer(cfg, api)
 
-          // Step 6: Auto-register agent (wait for node to sync)
+          // Step 7: Wait for node to sync, then auto-register
           await sleep(15_000)
           await autoRegisterAgent(cfg, wallet, api)
 
+          // Step 8: Auto-register as miner + start heartbeat loop
+          await autoRegisterMiner(cfg, wallet, api)
+
         } catch (err: unknown) {
           api.logger?.error?.(`[clawnetwork] startup failed: ${(err as Error).message}`)
         }
@@ -1538,6 +2082,7 @@ export default function register(api: OpenClawApi) {
     },
     stop: () => {
       api.logger?.info?.('[clawnetwork] shutting down...')
+      stopMinerHeartbeatLoop()
       stopNode(api)
       stopUiServer()
     },

package/openclaw.plugin.json

@@ -35,7 +35,7 @@
       "syncMode": {
         "type": "string",
         "enum": ["full", "fast", "light"],
-        "default": "full"
+        "default": "light"
       },
       "healthCheckSeconds": {
         "type": "number",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawlabz/clawnetwork",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Run a ClawNetwork blockchain node inside OpenClaw. Every agent is a blockchain node.",
   "type": "module",
   "license": "MIT",
@@ -42,6 +42,12 @@
     "install": {
       "npmSpec": "@clawlabz/clawnetwork",
       "defaultChoice": "npm"
+    },
+    "compat": {
+      "pluginApi": ">=2026.3.24"
+    },
+    "build": {
+      "openclawVersion": "2026.3.28"
     }
   },
   "publishConfig": {