@relay-federation/bridge 0.3.0 → 0.3.2

package/cli.js

@@ -63,18 +63,19 @@ async function cmdInit () {
   const config = await initConfig(dir)
 
   console.log('Bridge initialized!\n')
-  console.log(`  Config:  ${dir}/config.json`)
-  console.log(`  Pubkey:  ${config.pubkeyHex}`)
-  console.log(`  Address: ${config.address}`)
-  console.log(`  Secret:  ${config.statusSecret}`)
+  console.log(`  Name:     ${config.name}`)
+  console.log(`  Config:   ${dir}/config.json`)
+  console.log(`  Endpoint: ${config.endpoint}`)
+  console.log(`  Pubkey:   ${config.pubkeyHex}`)
+  console.log(`  Address:  ${config.address}`)
+  console.log(`  Secret:   ${config.statusSecret}`)
   console.log('')
   console.log('  Save your operator secret! You need it to log into the dashboard.')
   console.log('')
   console.log('Next steps:')
-  console.log(`  1. Edit config.json — set your WSS endpoint`)
-  console.log(`  2. Fund your bridge: send BSV to ${config.address}`)
-  console.log('  3. Import the funding tx: relay-bridge fund <rawTxHex>')
-  console.log('  4. Run: relay-bridge register')
+  console.log(`  1. Fund your bridge: send BSV to ${config.address}`)
+  console.log('  2. Import the funding tx: relay-bridge fund <rawTxHex>')
+  console.log('  3. Run: relay-bridge register')
 }
 
 async function cmdSecret () {
@@ -319,9 +320,10 @@ async function cmdStart () {
   })
 
   // Wire peer health tracking
-  peerManager.on('peer:connect', ({ pubkeyHex }) => {
+  peerManager.on('peer:connect', ({ pubkeyHex, endpoint }) => {
     peerHealth.recordSeen(pubkeyHex)
     scorer.setStakeAge(pubkeyHex, 7)
+    if (endpoint) gossipManager.addSeed({ pubkeyHex, endpoint, meshId: config.meshId })
   })
 
   peerManager.on('peer:disconnect', ({ pubkeyHex }) => {
@@ -429,6 +431,8 @@ async function cmdStart () {
   const { extractOpReturnData, decodePayload, PROTOCOL_PREFIX } = await import('../registry/lib/cbor.js')
   const { Transaction: BsvTx } = await import('@bsv/sdk')
 
+  // Registry bootstrapped via discoverNewPeers() after server start (no WoC dependency)
+
   watcher.on('utxo:received', async ({ txid, hash160 }) => {
     if (hash160 !== beaconHash160) return
 
@@ -640,14 +644,17 @@ async function cmdStart () {
   let gossipStarted = false
 
   // Start gossip after first peer connection completes.
-  // With crypto handshake, peer:connect fires AFTER handshake verification,
-  // so gossip won't race the handshake anymore.
+  // Delay 5s so all seed handshakes finish before gossip broadcasts
+  // (immediate broadcast would send announce/getpeers through connections
+  // whose inbound side is still waiting for verify — breaking the handshake).
   peerManager.on('peer:connect', () => {
     if (!gossipStarted) {
       gossipStarted = true
-      gossipManager.start()
-      gossipManager.requestPeersFromAll()
-      console.log('Gossip started')
+      setTimeout(() => {
+        gossipManager.start()
+        gossipManager.requestPeersFromAll()
+        console.log('Gossip started')
+      }, 5000)
 
       // Periodic peer refresh — re-request peer lists every 10 minutes
       // Catches registrations missed during downtime or initial gossip
@@ -702,6 +709,7 @@ async function cmdStart () {
     // Connect to seed peers (accept both string URLs and {pubkeyHex, endpoint} objects)
     console.log(`Connecting to ${seedPeers.length} seed peer(s)...`)
     for (let i = 0; i < seedPeers.length; i++) {
+      if (i > 0) await new Promise(r => setTimeout(r, 2000)) // stagger to avoid handshake races
       const seed = seedPeers[i]
       const endpoint = typeof seed === 'string' ? seed : seed.endpoint
       const pubkey = typeof seed === 'string' ? `seed_${i}` : seed.pubkeyHex
@@ -769,6 +777,47 @@ async function cmdStart () {
   statusServer.startAppMonitoring()
   console.log(`  Status: http://127.0.0.1:${statusPort}/status`)
 
+  // ── Peer discovery — bootstrap registry from seed peers, then periodic refresh ──
+  const knownEndpoints = new Set()
+  for (const sp of (config.seedPeers || [])) knownEndpoints.add(sp.endpoint)
+  knownEndpoints.add(config.endpoint)
+
+  async function discoverNewPeers () {
+    const peersToQuery = [...(config.seedPeers || [])]
+    for (const [, conn] of peerManager.peers) {
+      if (conn.endpoint && conn.readyState === 1) peersToQuery.push({ endpoint: conn.endpoint })
+    }
+    for (const peer of peersToQuery) {
+      try {
+        const ep = peer.endpoint || ''
+        const u = new URL(ep)
+        const statusUrl = 'http://' + u.hostname + ':' + (parseInt(u.port, 10) + 1000) + '/discover'
+        const res = await fetch(statusUrl, { signal: AbortSignal.timeout(5000) })
+        if (!res.ok) continue
+        const data = await res.json()
+        if (!data.bridges) continue
+        for (const b of data.bridges) {
+          if (!b.endpoint) continue
+          if (b.pubkeyHex) registeredPubkeys.add(b.pubkeyHex)
+          seedEndpoints.add(b.endpoint)
+          if (knownEndpoints.has(b.endpoint)) continue
+          knownEndpoints.add(b.endpoint)
+          const conn = peerManager.connectToPeer({ endpoint: b.endpoint, pubkeyHex: b.pubkeyHex })
+          if (conn) {
+            conn.on('open', () => performOutboundHandshake(conn))
+            const msg = `Discovered new peer: ${b.name || b.pubkeyHex?.slice(0, 16) || b.endpoint}`
+            console.log(msg)
+            statusServer.addLog(msg)
+          }
+        }
+      } catch {}
+    }
+  }
+  await discoverNewPeers()
+  console.log(`  Registry: ${registeredPubkeys.size} trusted pubkeys after peer discovery`)
+  setTimeout(discoverNewPeers, 5000)
+  setInterval(discoverNewPeers, 300000)
+
   // ── 9. Log events (dual: console + status server ring buffer) ──
   peerManager.on('peer:connect', ({ pubkeyHex }) => {
     const msg = `Peer connected: ${pubkeyHex.slice(0, 16)}...`

package/dashboard/index.html

@@ -978,7 +978,7 @@ async function fetchBridge(bridge) {
     const r = await fetch(bridge.url + '/status' + getAuthParam(bridge.url), { signal: AbortSignal.timeout(5000) });
     if (!r.ok) throw new Error('HTTP ' + r.status);
     const data = await r.json();
-    data._name = bridge.name; data._url = bridge.url; data._error = null; data._lastSeen = Date.now();
+    data._name = (data.bridge && data.bridge.name) || bridge.name; data._url = bridge.url; data._error = null; data._lastSeen = Date.now();
     return data;
   } catch (e) {
     return { _name: bridge.name, _url: bridge.url, _error: e.message,
@@ -1009,7 +1009,7 @@ async function discoverBridges() {
         if (!b.statusUrl) continue;
         const base = b.statusUrl.replace(/\/status$/, '');
         if (!known.has(base)) {
-          const name = 'bridge-' + (b.pubkeyHex ? b.pubkeyHex.slice(0, 8) : known.size);
+          const name = b.name || 'bridge-' + (b.pubkeyHex ? b.pubkeyHex.slice(0, 8) : known.size);
           known.set(base, name);
         }
       }

package/lib/config.js

@@ -21,16 +21,29 @@ export function defaultConfigDir () {
  * @param {string} [dir] — Config directory (default: ~/.relay-bridge)
  * @returns {Promise<object>} The generated config
  */
-export async function initConfig (dir = DEFAULT_DIR) {
+export async function initConfig (dir = DEFAULT_DIR, opts = {}) {
   const privKey = PrivateKey.fromRandom()
 
   const address = privKey.toPublicKey().toAddress()
 
+  // Auto-detect public IP
+  let publicIp = opts.ip || null
+  if (!publicIp) {
+    try {
+      const res = await fetch('https://api.ipify.org?format=json', { signal: AbortSignal.timeout(5000) })
+      if (res.ok) publicIp = (await res.json()).ip
+    } catch {}
+  }
+
+  const name = opts.name || (publicIp ? 'bridge-' + publicIp.split('.').pop() : 'bridge-' + privKey.toPublicKey().toString().slice(0, 8))
+  const endpoint = publicIp ? 'ws://' + publicIp + ':8333' : 'ws://your-bridge-ip:8333'
+
   const config = {
+    name,
     wif: privKey.toWif(),
     pubkeyHex: privKey.toPublicKey().toString(),
     address,
-    endpoint: 'wss://your-bridge.example.com:8333',
+    endpoint,
     meshId: '70016',
     capabilities: ['tx_relay', 'header_sync', 'broadcast', 'address_history'],
     spvEndpoint: 'https://relay.indelible.one',

package/lib/peer-manager.js

@@ -169,7 +169,7 @@ export class PeerManager extends EventEmitter {
             // If cryptographic handshake is available, use it
             if (opts.handshake && msg.nonce && Array.isArray(msg.versions)) {
               const isSeed = opts.seedEndpoints && opts.seedEndpoints.has(msg.endpoint)
-              const result = opts.handshake.handleHello(msg, isSeed ? null : (opts.registeredPubkeys || null))
+              const result = opts.handshake.handleHello(msg, null) // cryptographic handshake is the security layer — no whitelist gate
               if (result.error) {
                 ws.send(JSON.stringify({ type: 'error', error: result.error }))
                 ws.close()

package/lib/status-server.js

@@ -112,6 +112,7 @@ export class StatusServer {
 
     const status = {
       bridge: {
+        name: this._config.name || null,
         pubkeyHex: this._config.pubkeyHex || null,
         meshId: this._config.meshId || null,
         uptimeSeconds: Math.floor((Date.now() - this._startedAt) / 1000)
@@ -425,6 +426,7 @@ export class StatusServer {
       const bridges = []
       // Add self
       bridges.push({
+        name: this._config.name || null,
         pubkeyHex: this._config.pubkeyHex || null,
         endpoint: this._config.endpoint || null,
         meshId: this._config.meshId || null,

package/package.json

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