@relay-federation/bridge 0.3.10 → 0.3.12

package/cli.js

@@ -11,6 +11,112 @@ import { StatusServer } from './lib/status-server.js'
 
 const command = process.argv[2]
 
+/**
+ * Scan historical beacon registrations on startup.
+ * Fetches beacon address history from WhatsOnChain and parses each tx
+ * to populate the registeredPubkeys Set with all valid registrations.
+ *
+ * @param {Set<string>} registeredPubkeys - Set to populate with registered pubkeys
+ * @param {string} selfPubkey - Our own pubkey (skip self-registration)
+ */
+async function backfillBeaconRegistry (registeredPubkeys, selfPubkey) {
+  const { BEACON_ADDRESS, PROTOCOL_PREFIX } = await import('@relay-federation/common/protocol')
+  const { extractOpReturnData, decodePayload } = await import('@relay-federation/registry/lib/cbor.js')
+  const { Transaction } = await import('@bsv/sdk')
+
+  console.log(`  Beacon backfill: scanning ${BEACON_ADDRESS}...`)
+
+  try {
+    // Fetch confirmed history (registrations should be confirmed)
+    const historyResp = await fetch(
+      `https://api.whatsonchain.com/v1/bsv/main/address/${BEACON_ADDRESS}/confirmed/history`,
+      { signal: AbortSignal.timeout(30000) }
+    )
+    if (!historyResp.ok) {
+      console.log(`  Beacon backfill: WoC returned ${historyResp.status}, skipping`)
+      return
+    }
+
+    const data = await historyResp.json()
+    const history = Array.isArray(data) ? data : (data.result || [])
+    if (history.length === 0) {
+      console.log(`  Beacon backfill: no history found`)
+      return
+    }
+
+    console.log(`  Beacon backfill: found ${history.length} transactions`)
+
+    // Track registrations and deregistrations to handle order correctly
+    // Process oldest first (history is typically newest-first from WoC)
+    const sortedHistory = [...history].sort((a, b) => (a.height || 0) - (b.height || 0))
+
+    let registered = 0
+    let deregistered = 0
+    let skipped = 0
+
+    for (const item of sortedHistory) {
+      const txid = item.tx_hash
+      if (!txid) continue
+
+      try {
+        // Rate limit to avoid WoC throttling
+        await new Promise(r => setTimeout(r, 100))
+
+        const txResp = await fetch(
+          `https://api.whatsonchain.com/v1/bsv/main/tx/${txid}/hex`,
+          { signal: AbortSignal.timeout(10000) }
+        )
+        if (!txResp.ok) {
+          skipped++
+          continue
+        }
+
+        const rawHex = await txResp.text()
+        const tx = Transaction.fromHex(rawHex)
+
+        // Find OP_RETURN output
+        const opReturnOutput = tx.outputs.find(out =>
+          out.satoshis === 0 && out.lockingScript.toHex().startsWith('006a')
+        )
+        if (!opReturnOutput) {
+          skipped++
+          continue
+        }
+
+        const { prefix, cborBytes } = extractOpReturnData(opReturnOutput.lockingScript)
+        if (prefix !== PROTOCOL_PREFIX) {
+          skipped++
+          continue
+        }
+
+        const entry = decodePayload(cborBytes)
+        if (!entry || !entry.pubkey) {
+          skipped++
+          continue
+        }
+
+        const pubHex = Buffer.from(entry.pubkey).toString('hex')
+        if (pubHex === selfPubkey) continue // skip self
+
+        if (entry.action === 'register') {
+          registeredPubkeys.add(pubHex)
+          registered++
+        } else if (entry.action === 'deregister') {
+          registeredPubkeys.delete(pubHex)
+          deregistered++
+        }
+      } catch {
+        skipped++
+      }
+    }
+
+    console.log(`  Beacon backfill: +${registered} registered, -${deregistered} deregistered, ${skipped} skipped`)
+    console.log(`  Registry: ${registeredPubkeys.size} trusted pubkeys after backfill`)
+  } catch (err) {
+    console.log(`  Beacon backfill failed: ${err.message}`)
+  }
+}
+
 switch (command) {
   case 'init':
     await cmdInit()
@@ -434,6 +540,9 @@ async function cmdStart () {
   }
   console.log(`  Registry: ${registeredPubkeys.size} trusted pubkeys (self + seeds)`)
 
+  // ── 4a-2. Beacon backfill — scan historical registrations on startup ──
+  await backfillBeaconRegistry(registeredPubkeys, config.pubkeyHex)
+
   // ── 4b. Beacon address watcher — detect on-chain registrations ──
   const { extractOpReturnData, decodePayload, PROTOCOL_PREFIX } = await import('@relay-federation/registry/lib/cbor.js')
   const { Transaction: BsvTx } = await import('@bsv/sdk')

package/lib/address-scanner.js

@@ -25,14 +25,15 @@ export async function scanAddress (address, store, onProgress = () => {}) {
   // Phase 1: Fetch tx history from WhatsOnChain
   onProgress({ phase: 'discovery', current: 0, total: 0, message: 'Fetching transaction history...' })
 
-  const historyUrl = `${WOC_BASE}/address/${address}/history`
+  const historyUrl = `${WOC_BASE}/address/${address}/confirmed/history`
   const histRes = await fetchWithRetry(historyUrl)
   if (!histRes.ok) {
     throw new Error(`WhatsOnChain returned ${histRes.status} for address history`)
   }
-  const history = await histRes.json()
+  const data = await histRes.json()
+  const history = Array.isArray(data) ? data : (data.result || [])
 
-  if (!Array.isArray(history) || history.length === 0) {
+  if (history.length === 0) {
     onProgress({ phase: 'done', current: 0, total: 0, message: 'No transactions found for this address' })
     return { address, txsScanned: 0, inscriptionsFound: 0, errors: 0 }
   }

package/lib/status-server.js

@@ -415,7 +415,7 @@ export class StatusServer {
                 isP2PKH: o.isP2PKH,
                 hash160: o.hash160,
                 type: o.type,
-                data: o.data,
+                data: o.data ? o.data.map(d => d.length > 128 ? d.slice(0, 128) + '...' : d) : o.data,
                 protocol: o.protocol,
                 parsed: o.parsed
               }))
@@ -804,9 +804,10 @@ export class StatusServer {
         return
       }
       try {
-        const resp = await fetch('https://api.whatsonchain.com/v1/bsv/main/address/' + addr + '/history', { signal: AbortSignal.timeout(10000) })
+        const resp = await fetch('https://api.whatsonchain.com/v1/bsv/main/address/' + addr + '/confirmed/history', { signal: AbortSignal.timeout(10000) })
         if (!resp.ok) throw new Error('WoC returned ' + resp.status)
-        const history = await resp.json()
+        const data = await resp.json()
+        const history = Array.isArray(data) ? data : (data.result || [])
         this._addressCache.set(addr, { data: history, time: Date.now() })
         // Prune cache if it grows too large
         if (this._addressCache.size > 100) {
@@ -1092,6 +1093,176 @@ export class StatusServer {
       return
     }
 
+    // GET /health — MCP/CLI compatibility
+    if (req.method === 'GET' && path === '/health') {
+      const status = await this.getStatus()
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({
+        status: 'ok',
+        headerHeight: status.headers.bestHeight,
+        connectedPeers: status.bsvNode.peers,
+        synced: status.headers.bestHeight > 0
+      }))
+      return
+    }
+
+    // GET /api/address/:addr/unspent — UTXO lookup via GorillaPool ordinals
+    const unspentMatch = path.match(/^\/api\/address\/([13][a-km-zA-HJ-NP-Z1-9]{24,33})\/unspent$/)
+    if (req.method === 'GET' && unspentMatch) {
+      const addr = unspentMatch[1]
+      try {
+        const resp = await fetch(
+          `https://ordinals.gorillapool.io/api/txos/address/${addr}/unspent`,
+          { signal: AbortSignal.timeout(10000) }
+        )
+        if (!resp.ok) throw new Error(`GorillaPool ${resp.status}`)
+        const data = await resp.json()
+        // Transform GorillaPool format → WoC format
+        const utxos = data.map(u => ({
+          tx_hash: u.txid,
+          tx_pos: u.vout,
+          value: u.satoshis
+        }))
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify(utxos))
+      } catch (err) {
+        res.writeHead(502, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ error: 'UTXO fetch failed: ' + err.message }))
+      }
+      return
+    }
+
+    // GET /api/tx/:txid/hex — raw transaction hex
+    const hexMatch = path.match(/^\/api\/tx\/([0-9a-f]{64})\/hex$/)
+    if (req.method === 'GET' && hexMatch) {
+      const txid = hexMatch[1]
+      let rawHex = null
+      // Mempool first
+      if (this._txRelay && this._txRelay.mempool.has(txid)) {
+        rawHex = this._txRelay.mempool.get(txid)
+      }
+      // P2P second
+      if (!rawHex && this._bsvNodeClient) {
+        try {
+          const result = await this._bsvNodeClient.getTx(txid, 5000)
+          rawHex = result.rawHex
+        } catch {}
+      }
+      // WoC fallback
+      if (!rawHex) {
+        try {
+          const resp = await fetch(`https://api.whatsonchain.com/v1/bsv/main/tx/${txid}/hex`)
+          if (resp.ok) rawHex = await resp.text()
+        } catch {}
+      }
+      if (rawHex) {
+        res.writeHead(200, { 'Content-Type': 'text/plain' })
+        res.end(rawHex)
+      } else {
+        res.writeHead(404, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ error: 'tx not found' }))
+      }
+      return
+    }
+
+    // POST /api/broadcast — MCP/CLI compatibility (accepts { rawTx } key)
+    if (req.method === 'POST' && path === '/api/broadcast') {
+      const body = await this._readBody(req)
+      const rawHex = body.rawTx || body.rawHex
+      if (!rawHex || typeof rawHex !== 'string') {
+        res.writeHead(400, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ error: 'rawTx or rawHex required' }))
+        return
+      }
+      if (!/^[0-9a-fA-F]+$/.test(rawHex) || rawHex.length % 2 !== 0) {
+        res.writeHead(400, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ error: 'Invalid hex string' }))
+        return
+      }
+      const buf = Buffer.from(rawHex, 'hex')
+      const hash = createHash('sha256').update(createHash('sha256').update(buf).digest()).digest()
+      const txid = Buffer.from(hash).reverse().toString('hex')
+      const sent = this._txRelay ? this._txRelay.broadcastTx(txid, rawHex) : 0
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({ txid, peers: sent }))
+      return
+    }
+
+    // GET /api/address/:addr/history — proxy to WoC confirmed/history (web app compat)
+    const apiHistMatch = path.match(/^\/api\/address\/([13][a-km-zA-HJ-NP-Z1-9]{24,33})\/history$/)
+    if (req.method === 'GET' && apiHistMatch) {
+      const addr = apiHistMatch[1]
+      const cached = this._addressCache.get(addr)
+      if (cached && Date.now() - cached.time < 60000) {
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify(cached.data))
+        return
+      }
+      try {
+        const resp = await fetch('https://api.whatsonchain.com/v1/bsv/main/address/' + addr + '/confirmed/history', { signal: AbortSignal.timeout(10000) })
+        if (!resp.ok) throw new Error('WoC returned ' + resp.status)
+        const data = await resp.json()
+        const history = Array.isArray(data) ? data : (data.result || [])
+        this._addressCache.set(addr, { data: history, time: Date.now() })
+        if (this._addressCache.size > 100) {
+          const oldest = this._addressCache.keys().next().value
+          this._addressCache.delete(oldest)
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify(history))
+      } catch (err) {
+        res.writeHead(502, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ error: 'Failed to fetch address history: ' + err.message }))
+      }
+      return
+    }
+
+    // GET /api/address/:addr/balance — sum UTXOs from GorillaPool (web app compat)
+    const apiBalMatch = path.match(/^\/api\/address\/([13][a-km-zA-HJ-NP-Z1-9]{24,33})\/balance$/)
+    if (req.method === 'GET' && apiBalMatch) {
+      const addr = apiBalMatch[1]
+      try {
+        const resp = await fetch(
+          `https://ordinals.gorillapool.io/api/txos/address/${addr}/unspent`,
+          { signal: AbortSignal.timeout(10000) }
+        )
+        if (!resp.ok) throw new Error(`GorillaPool ${resp.status}`)
+        const data = await resp.json()
+        const confirmed = data.reduce((sum, u) => sum + (u.satoshis || 0), 0)
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ confirmed, unconfirmed: 0 }))
+      } catch (err) {
+        res.writeHead(502, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ error: 'Balance fetch failed: ' + err.message }))
+      }
+      return
+    }
+
+    // GET /api/tx/:txid — full tx JSON via WoC (web app compat)
+    const apiTxMatch = path.match(/^\/api\/tx\/([0-9a-f]{64})$/)
+    if (req.method === 'GET' && apiTxMatch) {
+      const txid = apiTxMatch[1]
+      try {
+        const resp = await fetch(`https://api.whatsonchain.com/v1/bsv/main/tx/${txid}`, { signal: AbortSignal.timeout(10000) })
+        if (!resp.ok) throw new Error('WoC returned ' + resp.status)
+        const data = await resp.json()
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify(data))
+      } catch (err) {
+        res.writeHead(502, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ error: 'tx fetch failed: ' + err.message }))
+      }
+      return
+    }
+
+    // GET /api/mesh/status — alias for /status (web app compat)
+    if (req.method === 'GET' && path === '/api/mesh/status') {
+      const status = await this.getStatus({ authenticated })
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify(status))
+      return
+    }
+
     res.writeHead(404)
     res.end('Not Found')
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relay-federation/bridge",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "description": "Bridge server — WebSocket peering, header sync, tx relay, CLI",
   "type": "module",
   "bin": {