@relay-federation/bridge 0.3.11 → 0.3.12

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.11",
+  "version": "0.3.12",
   "description": "Bridge server — WebSocket peering, header sync, tx relay, CLI",
   "type": "module",
   "bin": {