@cero-base/core 1.3.0 → 1.5.0

package/src/network/index.js

@@ -1,15 +1,18 @@
-import Hyperswarm from 'hyperswarm'
 import NoiseSecretStream from '@hyperswarm/secret-stream'
 import BlindPairing from 'blind-pairing'
+import BlindPeering from 'blind-peering'
 import ProtomuxWakeup from 'protomux-wakeup'
 import ReadyResource from 'ready-resource'
 import safetyCatch from 'safety-catch'
+import { decode as decodeKey } from 'hypercore-id-encoding'
 import b4a from 'b4a'
-import { hash } from 'hypercore-crypto'
 
 import { ACTIVE, PASSIVE } from '../lib/constants.js'
 import { CeroError } from '../lib/errors.js'
 import { Discovery } from './discovery.js'
+import { DHTTransport, channelTopic } from './transports/dht.js'
+
+export { channelTopic }
 
 /**
  * @typedef {object} NetworkOpts
@@ -18,6 +21,8 @@ import { Discovery } from './discovery.js'
  * @property {(remotePublicKey: Uint8Array, payload: any) => boolean} [firewall]  Incoming-connection filter.
  * @property {Uint8Array[]} [relayThrough]                          Relay public keys to tunnel through.
  * @property {string} [channel]                                     Optional network-isolation label; only same-channel peers meet.
+ * @property {any} [store]                                          Corestore; required for mirrors (blind peers replicate its cores).
+ * @property {Array<string | Uint8Array>} [mirrors]                Blind-peer public keys; each attached room/blob core is mirrored through them for offline sync.
  *
  * @typedef {{ replicate: (stream: any) => any }} Replicable
  */
@@ -28,21 +33,29 @@ import { Discovery } from './discovery.js'
  */
 export class Network extends ReadyResource {
   /** @param {NetworkOpts} [opts] */
-  constructor({ identity, bootstrap, firewall, relayThrough, channel } = {}) {
+  constructor({ identity, bootstrap, firewall, relayThrough, channel, store, mirrors } = {}) {
     super()
     this.identity = identity || null
     this.bootstrap = bootstrap || null
     this.firewall = firewall || null
     this.relayThrough = relayThrough || null
     this.channel = channel || null
+    this.store = store || null
+    this.mirrors = (mirrors || []).map((k) => (typeof k === 'string' ? decodeKey(k) : k))
 
-    this.swarm = null
+    this._dht = null
     this.wakeup = new ProtomuxWakeup()
 
     this._replicateables = new Set()
     this._discoveries = new Set()
     this._injected = new Set()
     this._blind = null
+    this._blindPeering = null
+  }
+
+  /** @returns {any} The underlying hyperswarm, or null before ready / after close. */
+  get swarm() {
+    return this._dht ? this._dht.swarm : null
   }
 
   /**
@@ -143,24 +156,18 @@ export class Network extends ReadyResource {
   }
 
   async _open() {
-    const opts = {}
-    if (this.identity)
-      opts.keyPair = { publicKey: this.identity.publicKey, secretKey: this.identity.secretKey }
-    if (this.bootstrap) opts.bootstrap = this.bootstrap
-    if (this.firewall) opts.firewall = this.firewall
-    if (this.relayThrough) opts.relayThrough = this.relayThrough
-
-    this.swarm = new Hyperswarm(opts)
-
-    if (this.channel) {
-      const channel = this.channel
-      const join = this.swarm.join.bind(this.swarm)
-      const leave = this.swarm.leave.bind(this.swarm)
-      this.swarm.join = (topic, opts) => join(channelTopic(topic, channel), opts)
-      this.swarm.leave = (topic) => leave(channelTopic(topic, channel))
-    }
+    this._dht = new DHTTransport({
+      identity: this.identity,
+      bootstrap: this.bootstrap,
+      firewall: this.firewall,
+      relayThrough: this.relayThrough,
+      channel: this.channel
+    })
 
-    this.swarm.on('connection', (stream, info) => {
+    // DHTTransport owns the swarm's lifecycle; Network subscribes to its events
+    // because the handlers touch Network state (wakeup, replicateables, emit).
+    const swarm = this._dht.swarm
+    swarm.on('connection', (stream, info) => {
       if (this.closing || this.closed) {
         stream.destroy()
         return
@@ -169,8 +176,16 @@ export class Network extends ReadyResource {
       for (const r of this._replicateables) replicateInto(r, stream)
       this.emit('connection', stream, info)
     })
-    this.swarm.on('peer-add', (peer) => this.emit('peer-add', peer))
-    this.swarm.on('peer-remove', (peer) => this.emit('peer-remove', peer))
+    swarm.on('peer-add', (peer) => this.emit('peer-add', peer))
+    swarm.on('peer-remove', (peer) => this.emit('peer-remove', peer))
+
+    if (this.store && this.mirrors.length) {
+      this._blindPeering = new BlindPeering(swarm.dht, this.store, {
+        keys: this.mirrors,
+        wakeup: this.wakeup,
+        pick: 2
+      })
+    }
   }
 
   /**
@@ -179,9 +194,8 @@ export class Network extends ReadyResource {
    * @param {{ timeout?: number }} [opts]
    * @returns {Promise<void>}
    */
-  async flush({ timeout = 500 } = {}) {
-    if (!this.swarm) return
-    await Promise.race([this.swarm.flush(), new Promise((r) => setTimeout(r, timeout))])
+  async flush(opts) {
+    await this._dht?.flush(opts)
   }
 
   /**
@@ -190,13 +204,9 @@ export class Network extends ReadyResource {
    * @returns {Promise<void>}
    */
   async suspend() {
-    if (!this.swarm || this.closing || this.closed) return
-    if (this.swarm.suspended) return
-    try {
-      await this.swarm.suspend()
-    } catch (err) {
-      safetyCatch(err)
-    }
+    if (this.closing || this.closed) return
+    await this._blindPeering?.suspend()
+    await this._dht?.suspend()
   }
 
   /**
@@ -205,13 +215,9 @@ export class Network extends ReadyResource {
    * @returns {Promise<void>}
    */
   async resume() {
-    if (!this.swarm || this.closing || this.closed) return
-    if (!this.swarm.suspended) return
-    try {
-      await this.swarm.resume()
-    } catch (err) {
-      safetyCatch(err)
-    }
+    if (this.closing || this.closed) return
+    await this._dht?.resume()
+    await this._blindPeering?.resume()
   }
 
   async _close() {
@@ -232,27 +238,31 @@ export class Network extends ReadyResource {
       }
     }
 
-    if (this._blind) {
+    if (this._blindPeering) {
       try {
-        await (await this._blind).close()
+        await this._blindPeering.close()
       } catch (err) {
         safetyCatch(err)
       }
-      this._blind = null
+      this._blindPeering = null
     }
 
-    if (this.swarm) {
+    if (this._blind) {
       try {
-        await this.flush()
+        await (await this._blind).close()
       } catch (err) {
         safetyCatch(err)
       }
+      this._blind = null
+    }
+
+    if (this._dht) {
       try {
-        await this.swarm.destroy()
+        await this._dht.destroy()
       } catch (err) {
         safetyCatch(err)
       }
-      this.swarm = null
+      this._dht = null
     }
 
     if (this.wakeup) {
@@ -300,6 +310,12 @@ export class Network extends ReadyResource {
     if (!core) throw CeroError.REQUIRED('core')
     this._replicateables.add(core)
     for (const stream of this.connections) replicateInto(core, stream)
+    // mirror the core so it stays available when its writers are offline —
+    // autobees announce their whole writer set, plain cores (blobs) just themselves
+    if (this._blindPeering) {
+      if (core.wakeupCapability) this._blindPeering.addAutobaseBackground(core)
+      else this._blindPeering.addCoreBackground(core)
+    }
   }
 
   /**
@@ -350,12 +366,6 @@ function replicateInto(core, stream) {
   }
 }
 
-// A channel re-namespaces every swarm topic so only same-channel peers meet.
-// No channel → identity (unchanged, back-compat).
-export function channelTopic(topic, channel) {
-  return channel ? hash([topic, b4a.from(channel)]) : topic
-}
-
 function isTopic(x) {
   return b4a.isBuffer(x) && x.length === 32
 }