holepunch-hop 0.3.3 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holepunch-hop",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "data interface to HOP",
   "main": "src/index.js",
   "type": "module",

package/src/bees.js

@@ -46,15 +46,14 @@ class HyperBee extends EventEmitter {
       valueEncoding: 'json' // same options as above
     })
     await this.dbPublicLibrary.ready()
-    beePubkeys.push({ store: 'publiclibrary', pubkey: b4a.toString(core.key, 'hex')})
+    beePubkeys.push({ store: 'publiclibrary', pubkey: b4a.toString(this.dbPublicLibrary.key, 'hex')})
     // allow other peer access to public library  (need to check for DDOS ie over asked)
-    // join a topic
+    // join a topic for network 
     const discovery = this.swarm.join(this.dbPublicLibrary.discoveryKey)
     // Only display the key once the Hyperbee has been announced to the DHT
     discovery.flushed().then(() => {
     })
 
-
     const core2 = this.store.get({ name: 'peerlibrary' })
     this.dbPeerLibrary = new Hyperbee(core2, {
       keyEncoding: 'utf-8', // can be set to undefined (binary), utf-8, ascii or and abstract-encoding
@@ -149,12 +148,6 @@ class HyperBee extends EventEmitter {
     })
     await this.dbBentomedia.ready()
     beePubkeys.push({store:'bentomedia', pubkey: b4a.toString(core12.key, 'hex')})
-
-    // await this.deleteBentocue({ cueid: '7da21b8d50c72f94595fd9617bfa2609c90d5d9c'})
-    // await this.deleteBentocue({ cueid: '8220c425a534634a44a69b6f56babaf26edf2a01'})
-    // await this.deleteBentocue({ cueid: 'ec4890f6c0b0d8f4a313136b4e7c9f425b1977a5'})
-    // await this.deleteBentocue({ cueid: 'eea2825cc91a1093594dffa9a953cbce3f77860c'})
-    // await this.deleteBentocue({ cueid: 'eee097d964fae67a6dd39abc02b0e9fd7c5f71bc'})
     
     this.emit('hbee-live')
     // return beePubkeys
@@ -172,8 +165,6 @@ class HyperBee extends EventEmitter {
    *
   */
   savePubliclibrary = async function (refContract) {
-    console.log('savePubliclibrary')
-    console.log(refContract)
     let beeSave = await this.dbPublicLibrary.put(refContract.data.hash, refContract.data.contract)
     // go query the key are return the info. to ensure data save asplanned.
     let saveCheck = await this.getPublicLibrary(refContract.data.hash)
@@ -416,13 +407,60 @@ class HyperBee extends EventEmitter {
    * @method deleteBentomedia
   */
   deleteBentomedia = async function (media) {
-    console.log(media)
     const deleteStatus = await this.dbBentomedia.del(media.id)
     let deleteInfo = {}
     deleteInfo.spaceid = media.id
     return deleteInfo
   }
 
+  /** PEERS */
+  /**
+   * save research
+   * @method savePeer
+   *
+  */
+  savePeer = async function (peerInfo) {
+    await this.dbPeers.put(peerInfo.publickey, peerInfo)
+    let checkSave = await this.getPeer(peerInfo.publickey)
+    return checkSave
+  }
+
+  /**
+   * get one peer by publickey
+   * @method getPeer
+   *
+  */
+  getPeer = async function (key) {
+    const nodeData = await this.dbPeers.get(key)
+    return nodeData
+  }
+
+  /**
+   * get all peers
+   * @method getPeersHistory
+   *
+  */
+  getPeersHistory = async function (key) {
+    const peerHistory = await this.dbPeers.createReadStream()
+    let peerData = []
+    for await (const { key, value } of peerHistory) {
+      peerData.push({ key, value })
+    }    
+    return peerData
+  }
+
+  /**
+   * delete contract
+   * @method deletePeer
+  */
+  deletePeer = async function (pubkey) {
+    const deleteStatus = await this.dbPeers.del(pubkey)
+    let deleteInfo = {}
+    deleteInfo.publickey = pubkey
+    return deleteInfo
+  }
+  
+
   /** RESEARCH */
   /**
    * save research

package/src/index.js

@@ -48,7 +48,7 @@ class HolepunchWorker extends EventEmitter {
     this.store = new Corestore(os.homedir() + '/.hop-storage')
     this.swarm = new Hyperswarm()
     // make replication possible
-    // this.swarm.on('connection', conn => this.store.replicate(conn))
+    this.swarm.on('connection', conn => this.store.replicate(conn))
     goodbye(() => this.swarm.destroy())
     this.BeeData = new BeeWorker(this.store, this.swarm)
     this.DriveFiles = new DriveWorker(this.store, this.swarm)
@@ -97,69 +97,60 @@ class HolepunchWorker extends EventEmitter {
     this.Peers.on('peer-network', (data) => {
       this.wsocket.send(JSON.stringify(data))
     })
-    // peer connection active for first time
+    // peer connection active for first time 
     this.Peers.on('peer-connect', (data) => {
-      let taskCheck = 0
-      let firstCheck = this.Peers.peerHolder[data]
-      if (firstCheck !== undefined) {
-        if (this.Peers.peerHolder[data]?.data?.labels !== undefined) {
-          taskCheck = this.Peers.peerHolder[data].data.labels.length
-        }
-      } else {
-        taskCheck = 0
-      }
-      // if (this.Peers.peerHolder[data].data.boardID !== undefined) {
-      // any existing peers
-      let holderCheck = Object.keys(this.Peers.peerHolder)
-      // now first time, check if any message can be send?
-      if (holderCheck !== 0 && taskCheck === 0) {
-        console.log('HOP--write publis lib???')
-        // switch between 
-        console.log(holderCheck)
-        console.log(taskCheck)
-        let peerFirstID = holderCheck[0]
-        console.log(peerFirstID)
-        console.log(this.Peers.peerHolder)
-        // which direction connection, client or from a peer on the network?
-        if (this.Peers.peerHolder[peerFirstID]?.data !== undefined) {
-          let dataLive = this.Peers.peerHolder[peerFirstID].data.name
-          if (dataLive === 'cue-space') {
-            this.Peers.writeToCueSpace(this.Peers.peerHolder[peerFirstID].publickey)
-          } else {
-          this.Peers.writeToPublicLibrary(data)
-          }
-
-        } else {
-          console.log('write to entwoir on start')
-          this.Peers.writeTonetwork(data)
-        }
-      }
-
+     //this.warmPeerPrepare(data)
+    })
+    // share connection failed
+    this.Peers.on('peer-share-fail', (data) => {
+      let peerFail = {}
+      peerFail.type = 'account'
+      peerFail.action = 'peer-share-fail'
+      peerFail.data = { publickey: data }
+      this.wsocket.send(JSON.stringify(peerFail))
+    })
+    // save peer topic
+    this.Peers.on('peer-topic-save', async (data) => {
+      await this.emit('peer-topic-save', data)    
+    })
+    // peer reconnection topic ie. able to reconnect again
+    this.Peers.on('peer-reconnect-topic', (data) => {
+      this.emit('peer-reconnect-topic', data)
     })
     // data for beebee
     this.Peers.on('beebee-data', (data) => {
       this.emit('peer-topeer', data)
     })
+    // cue space share
     this.Peers.on('cuespace-notification', (data) => {
-      console.log('cue space ntototoo')
       this.emit('peer-cuespace', data)
     })
     // public library notification
     this.Peers.on('publiclibrarynotification', (data) => {
       this.BeeData.replicatePubliclibrary(data)
     })
+    // beebee notifications public
     this.BeeData.on('publibbeebee-notification', (data) => {
       this.emit('beebee-publib-notification', data)
     })
     // new warm incoming peer
-    this.Peers.on('connect-warm', (data) => {
+    this.Peers.on('connect-warm-first', (data) => {
+      let peerInfo = this.Peers.peerHolder[data]
+      if (peerInfo === undefined) {
+        // receiving peer
+        peerInfo = { name: 'peernew'}
+      }
       let peerId = {}
-      peerId.name = 'new-peer'
+      peerId.name = peerInfo.name
       peerId.publickey = data
-      peerId.datastore = ''
+      peerId.longterm = true
+      peerId.settopic = false
+      peerId.topic = ''
+      peerId.live = false
       this.warmPeers.push(peerId)
-      this.emit('peer-incoming', peerId)
+      this.emit('peer-incoming-save', peerId)
     })
+    // drive listener
     this.DriveFiles.on('largefile-save', (data) => {
       this.emit('drive-save-large', data)
     })
@@ -179,31 +170,22 @@ class HolepunchWorker extends EventEmitter {
           peerMatch = true
         }
       }
-      
-      if (message.task === 'peer-join') {
+      if (message.task === 'peer-share-invite') {
+        // keep track of role, reciving or extended invite
+        this.Peers.setRole(message.data.publickey)
         if (peerMatch === true) {
           this.Peers.peerAlreadyJoinSetData(message.data)
-          this.Peers.writeTonetwork(message.data.publickey)
+          // this.Peers.writeTonetwork(message.data.publickey)
+          this.warmPeerPrepare(message.data.publickey, true)
         } else {
           this.warmPeers.push(message.data)
-          this.Peers.peerJoin(message.data)
-        }
-      } else if (message.task = 'cue-space') {
-        console.log('cus space send path')
-        console.log(peerMatch)
-        if (peerMatch === true) {
-          console.log('already connect space')
           this.Peers.peerAlreadyJoinSetData(message.data)
-          this.Peers.writeToCueSpace(message.data.publickey)
-        } else {
-          console.log('first space send')
-          this.warmPeers.push(message.data)
           this.Peers.peerJoin(message.data)
-          // this.Peers.peerAlreadyJoinSetData(message.data)
-          // this.Peers.writeToCueSpace(message.data.publickey)
-          console.log('space suce peepr ot sent')
         }
-      } else if (message.task === 'peer-board') {
+      } else if (message.task === 'peer-share-topic') {
+        // existing peers reconnecting via topic
+        this.Peers.topicConnect(message.data)
+      } else if (message.task === 'public-n1-experiment') {
         if (peerMatch === true) {
          this.Peers.peerAlreadyJoinSetData(message.data)
          this.Peers.writeToPublicLibrary(message.data.publickey)
@@ -214,6 +196,16 @@ class HolepunchWorker extends EventEmitter {
           this.Peers.peerAlreadyJoinSetData(message.data)
           this.Peers.writeToPublicLibrary(message.data.publickey)
         }
+      } else if (message.task = 'cue-space') {
+        if (peerMatch === true) {
+          this.Peers.peerAlreadyJoinSetData(message.data)
+          this.Peers.writeToCueSpace(message.data.publickey)
+        } else {
+          this.warmPeers.push(message.data)
+          this.Peers.peerJoin(message.data)
+          // this.Peers.peerAlreadyJoinSetData(message.data)
+          // this.Peers.writeToCueSpace(message.data.publickey)
+        }
       } else if (message.task === 'peer-write') {
         this.emit('peer-write', message.data)
       } else if (message.task === 'topic') {
@@ -222,6 +214,44 @@ class HolepunchWorker extends EventEmitter {
     }
   }
 
+
+  /**
+   * prepare data to send to a warm peer
+   * @method warmPeerPrepare
+   */
+  warmPeerPrepare = function (data, existing) {
+    // two checks, if topic send to other peer
+    if (existing !== true) {
+      let peerRole = this.Peers.peersRole[data]
+      if (peerRole === undefined) {
+        this.Peers.writeTonetworkTopic(data)
+      } else {
+        console.log(' this peer set the topic')
+      }
+    }
+    // if data within coming then process that
+    let peerDataExist = this.Peers.peerHolder[data]
+    if (peerDataExist === undefined) {
+    } else {
+      // what type of data being shared?
+      // check for data along with new peer?
+      if (peerDataExist.data !== undefined) {
+        if (peerDataExist.data.type === 'private-chart') {
+          this.Peers.writeTonetworkData(data, peerDataExist.data)
+        } else if (peerDataExist.data.type === 'private-cue-space') {
+          this.Peers.writeToCueSpace(this.Peers.peerHolder[peerFirstID].publickey)
+        } else if (peerDataExist.data.type === 'public-n1-experiment') {
+          this.Peers.writeTonetworkData(data, peerDataExist.data)
+        } else if (peerDataExist.data.type === 'public-library') {
+          this.Peers.writeToPublicLibrary(data)
+        } else if (peerDataExist.data.type === 'text-message') {
+          // simpole text message
+          this.Peers.writeTonetwork(data)
+        }
+      }
+    }
+  }
+
   /**
    * corestore test example
    * @method testCorestore

package/src/peers.js

@@ -9,9 +9,6 @@
 * @version    $Id$
 */
 import EventEmitter from 'events'
-// import DHT from '@hyperswarm/dht'
-import goodbye from 'graceful-goodbye'
-import b4a from 'b4a'
 
 
 class NetworkPeers extends EventEmitter {
@@ -24,6 +21,7 @@ class NetworkPeers extends EventEmitter {
     this.drive = {}
     this.peerHolder = {}
     this.peerConnect = {}
+    this.peersRole = {}
   }
 
   /**
@@ -32,6 +30,17 @@ class NetworkPeers extends EventEmitter {
    *
   */
   networkKeys = function () {
+    // console.log('swarm on start')
+    // console.log(this.swarm._discovery) // .toString('hex'))
+
+    /*this.swarm._discovery.forEach((value, key) => {
+      console.log('key')
+      console.log(key)
+      console.log('-----------swarm discovery IN-------------------')
+      console.log(Object.keys(value))
+      console.log(value.topic)
+      console.log(value.topic.toString('hex'))
+    }) */
     let peerNxKeys = {}
     peerNxKeys.publickey = this.swarm.keyPair.publicKey.toString('hex')
     let networkMessage = {}
@@ -48,15 +57,14 @@ class NetworkPeers extends EventEmitter {
    * @method listenNetwork
    *
   */
-  listenNetwork = function () {
+  listenNetwork = function  () {
     this.swarm.on('connection', (conn, info) => {
-      // listen for replication
-      this.store.replicate(conn)
-      // listener to write message to peers or network partial or broadcast
+      // save peer connection instance for ongoing communication
       let publicKeylive = info.publicKey.toString('hex')
-      this.emit('connect-warm', publicKeylive)
       this.peerConnect[publicKeylive] = conn
-      this.emit('peer-connect', publicKeylive)
+      this.emit('connect-warm-first', publicKeylive)
+      // listen for replication  NEED UPTATED LOGIC
+      this.store.replicate(conn)
       // process network message
       conn.on('data', data =>
         // assess data
@@ -66,6 +74,15 @@ class NetworkPeers extends EventEmitter {
     })
   }
 
+  /**
+   * set role in peer to peer relationship,  invte or receive?
+   * @method setRole
+   *
+  */
+  setRole = function (pubKey) {
+    let setRole = { send: 'prime' , invite: pubKey}
+    this.peersRole[pubKey] = setRole
+  }
   /**
    * 
    * @method assessData data and act
@@ -75,21 +92,21 @@ class NetworkPeers extends EventEmitter {
     if (Buffer.isBuffer(data)) {
       try {
         let dataShareIn = JSON.parse(data.toString())
-        console.log('data in listen bubfferr')
-        console.log(dataShareIn.type)
-        if (dataShareIn.type === 'chart') {
+        if (dataShareIn.type === 'private-chart') {
           this.emit('beebee-data', dataShareIn)
           // need to look at NXP,  modules and within for reference contracts.
           // Need to replicate public library for contracts (repliate hyberbee)
           // Need to ask for data source e.g. file (replicate hyberdrive)
           // Lastly put together SafeFlowECS query to produce chart
-        } else if (dataShareIn.type === 'cue-space') {
+        } else if (dataShareIn.type === 'private-cue-space') {
           this.emit('cuespace-notification', dataShareIn)
         } else if (dataShareIn.type === 'public-library') {
           this.emit('publiclibrarynotification', dataShareIn)
         } else if (dataShareIn.type === 'peer') {
+        } else if (dataShareIn.type === 'topic-reconnect') {
+          // peer has share a topic for future reconnect
+          this.emit('peer-reconnect-topic', dataShareIn)      
         }
-        console.log(a)
       } catch (e) {
           return console.error('ignore err')
       }
@@ -101,22 +118,40 @@ class NetworkPeers extends EventEmitter {
    * @method writeTonetwork
    *
   */
-  writeTonetwork = function (publickey) {
+  writeTonetwork = function (data, messType) {
     // check this peer has asked for chart data
-    let connectTrue = publickey in this.peerConnect
-    let chartTrue = publickey in this.peerHolder
-    if (connectTrue === true && chartTrue === true) {
-      let chartData = this.peerHolder[publickey]
-      let dataShare = {}
-      dataShare.hop = chartData.hop
-      dataShare.data = chartData.data
-      dataShare.type = 'chart'
-      this.peerConnect[publickey].write(JSON.stringify(dataShare))
-    } else {
-      console.log('non chart write')
-    }
+    let dataSend = data
+    this.peerConnect[data].write(JSON.stringify(dataSend))
+  }
+
+  /**
+   * write message to network
+   * @method writeTonetworkTopic
+   *
+  */
+  writeTonetworkTopic = function (publickey) {
+      let topicGeneration = 'kprel135811'
+      // need to save the topic initiator of warm peer save relationship
+      this.emit('peer-topic-save', { peerkey: publickey, topic: topicGeneration })
+      // send to other peer topic to allow reconnection in future
+      let topicShare = {}
+      topicShare.type = 'topic-reconnect'
+      topicShare.publickey = this.swarm.keyPair.publicKey.toString('hex')
+      topicShare.data = topicGeneration
+      // inform peer that topic has been created
+      this.peerConnect[publickey].write(JSON.stringify(topicShare))
   }
 
+  /**
+   * write message to network
+   * @method writeTonetworkData
+   *
+  */
+  writeTonetworkData = function (publickey, dataShare) {
+    this.peerConnect[publickey].write(JSON.stringify(dataShare))
+  }
+
+
   /**
    * write message connect public library
    * @method writeToPublicLibrary
@@ -148,10 +183,7 @@ class NetworkPeers extends EventEmitter {
     let spaceTrue = publickey in this.peerHolder
     if (connectTrue === true && spaceTrue === true) {
       let libraryData = this.peerHolder[publickey]
-      let dataShare = {}
-      dataShare.data = libraryData.data
-      dataShare.type = 'cue-space'
-      this.peerConnect[publickey].write(JSON.stringify(dataShare))
+      this.peerConnect[publickey].write(JSON.stringify(libraryData))
     } else {
       console.log('no cuespace to write ie share with a peer')
     }
@@ -159,13 +191,13 @@ class NetworkPeers extends EventEmitter {
 
 
   /**
-   * join peer to peer private (server)
+   * join peer to peer direct private (server)
    * @method peerJoin
    *
   */
   peerJoin = function (peerContext) {
-    console.log('peerJOIn')
-    console.log(peerContext)
+    // set timeer to inform if not connection can be established
+    this. checkTimerConnection(peerContext.publickey)
     this.peerHolder[peerContext.publickey] = peerContext
     const noisePublicKey = Buffer.from(peerContext.publickey, 'hex') //  must be 32 bytes
     if (noisePublicKey.length === 32) {
@@ -173,6 +205,37 @@ class NetworkPeers extends EventEmitter {
     }
   }
 
+  /**
+   * give 2 seconds for connection to establish
+   * @method checkTimerConnection
+   *
+  */
+  checkTimerConnection (key) {
+    // if peerconnect not set the inform beebee  not connection accepted try again
+    let localthis = this
+    // setTimeout(checkPeerState(localthis, key), 2000)
+    setTimeout(() => checkPeerState(localthis, key), 6000)
+
+    function checkPeerState (localthis, publicKeylive) {
+      if (localthis.peerConnect[publicKeylive] === undefined) {
+        // failed peer connection
+        localthis.emit('peer-share-fail', publicKeylive)
+      } else {
+        // connnection established
+      }
+    }
+  }
+
+  /**
+   * leave a direct peer connection
+   * @method peerLeave
+   *
+  */
+  peerLeave = function (peerLeaveKey) {
+    this.peerHolder[peerLeaveKey] = {}
+    this.swarm.leavePeer(peerLeaveKey)
+  }
+
   /**
    * already joined but keep track context data
    * @method peerAlreadyJoinSetData
@@ -180,6 +243,7 @@ class NetworkPeers extends EventEmitter {
   */
   peerAlreadyJoinSetData = function (peerContext) {
     this.peerHolder[peerContext.publickey] = peerContext
+    return true
   }
 
 
@@ -193,48 +257,34 @@ class NetworkPeers extends EventEmitter {
   }
 
   /**
-   * listen for topics as a client
-   * @method listenClient
+   * out message topics as a client
+   * @method topicConnect
    *
   */
-  listenClient = async function (topic) {
+  topicConnect = async function (topic) {
     const noisePublicKey = Buffer.alloc(32).fill(topic) // A topic must be 32 bytes
-    const peerConnect = this.swarm.join(noisePublicKey, { server: false, client: true })
+    const peerConnect = this.swarm.join(noisePublicKey, { server: true, client: false })
     await peerConnect.flushed() // Waits for the topic to be fully announced on the DHT
   }
 
   /**
-   * 
-   * @method listen
+   * out message topics as a client
+   * @method topicListen
    *
   */
-  listen = function () {
-    console.log('listen')
+  topicListen = async function (topic) {
+    const noisePublicKey = Buffer.alloc(32).fill(topic) // A topic must be 32 bytes
+    const peerConnect = this.swarm.join(noisePublicKey, { server: false, client: true })
+    await peerConnect.flushed() // Waits for the topic to be fully announced on the DHT
   }
 
   /**
-   * setup peers protocol
-   * @method setupHyerPeers
+   * leave topic
+   * @method leaveTopic
    *
   */
-  setupHyerPeers = function () {
-    /* const dht = new DHT()
-
-    // This keypair is your peer identifier in the DHT
-    const keyPair = DHT.keyPair()
-
-    const server = dht.createServer(conn => {
-      console.log('got connection!')
-      process.stdin.pipe(conn).pipe(process.stdout)
-    })
-
-    server.listen(keyPair).then(() => {
-      console.log('listening on:', b4a.toString(keyPair.publicKey, 'hex'))
-    })
-
-    // Unnannounce the public key before exiting the process
-    // (This is not a requirement, but it helps avoid DHT pollution)
-    goodbye(() => server.close()) */
+  leaveTopic = async function (topic) {
+    await this.swarm.leave(topic)
   }
 
 }