holepunch-hop 0.3.3 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holepunch-hop",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "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,61 @@ 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)
+    console.log('save peer over---------')
+    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
@@ -722,8 +761,6 @@ class HyperBee extends EventEmitter {
 
   }
 
-
-
   /**
    * delete nxp ref contract public
    * @method deleteRefcontPubliclibrary
@@ -750,7 +787,6 @@ class HyperBee extends EventEmitter {
     return deleteInfo
   }
 
-
   /**
    * repicate the publiclibrary peer to peer
    * @method replicatePubliclibrary
@@ -880,10 +916,10 @@ class HyperBee extends EventEmitter {
 
   /**
    * repicate the publiclibrary peer to peer
-   * @method replicatePubliclibraryOLD
+   * @method ryOLD
    *
   */
-  replicatePubliclibraryOLD = async function (key) {
+  ryOLD = async function (key) {
     // key = '3ec0f3b78a0cfe574c4be89b1d703a65f018c0b73ad77e52ac65645d8f51676a'
     const store = this.client.corestore('peerspace-hyperbeetemp')
     const core = this.store.get(key)
@@ -936,9 +972,6 @@ class HyperBee extends EventEmitter {
 
     await this.client.replicate(beeResults.feed) // fetch from the network
     await beeResults.ready()
-    // console.log('value for key ie results dataPrint')
-    // console.log(await beeResults.get('005ad9c1c29b6b730b6e9f73dd108f8c716a6075'))
-    // console.log('after get uuid')
     let rs = beeResults.createReadStream() // anything >=a and <=d
 
     for await (const { key, value } of rs) {

package/src/index.js

@@ -34,7 +34,9 @@ class HolepunchWorker extends EventEmitter {
     this.core3 = {}
     this.discKeypeer = ''
     this.readcore = null
-    this.warmPeers = []
+    this.warmPeers = [] // ikeep track of live incoming sharing
+    this.codenameUpdates = []
+    this.topicExhange = []
     this.startHolepunch()
     this.networkListeners()
   }
@@ -48,7 +50,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 +99,89 @@ 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-reconnect-topic', async (data) => {
+      data.prime = false
+      this.emit('peer-topic-update', data)    
+    })
+    // peer reconnection topic ie. able to reconnect again
+    this.Peers.on('topic-formed-save', (data) => {
+      // put data into holder await for codename  matching over
+      this.topicExhange.push(data)
+    })
+    // codename matching
+    this.Peers.on('peer-codename-match', (data) => {
+      // put in holding and then complete once save first complete
+      this.codenameUpdates.push(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)
+      // check if bentoboxN1 included?
+      if (data.data.content.bbn1.publicN1contracts.length > 0) {
+        for (let n1Cont of data.data.content.bbn1.publicN1contracts) {
+          this.BeeData.replicatePubliclibrary({ data: n1Cont })
+        }
+      }
     })
     // 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) => {
+      // check re establishing peer to peer of first time connection?
+      let peerInfoName = 'not-matched' //this.Peers.peerHolder[data]
+      // check role and match codename
+      if (data.roletaken === 'server') {
+        // not unique info to match on yet.
+      } else {
+        let peerRole = this.Peers.matchCodename(data.publickey)
+        if (peerRole.name.length > 0) {
+          // receiving peer
+          peerInfoName = peerRole.name
+        }
+      }
+      // setup template for relationship
       let peerId = {}
-      peerId.name = 'new-peer'
-      peerId.publickey = data
-      peerId.datastore = ''
+      peerId.name = peerInfoName
+      peerId.publickey = data.publickey
+      peerId.roletaken = data.roletaken
+      peerId.longterm = true
+      peerId.settopic = false
+      peerId.topic = ''
+      peerId.live = false
+      peerId.livePeerkey = ''
       this.warmPeers.push(peerId)
-      this.emit('peer-incoming', peerId)
+      this.emit('peer-incoming-save', peerId)
     })
+    // peer live on network?
+    this.Peers.on('peer-live-network', (data) => {
+      let peerLive = {}
+      peerLive.publickey = data
+      this.emit('peer-live-notify', peerLive)
+    })
+    // drive listener
     this.DriveFiles.on('largefile-save', (data) => {
       this.emit('drive-save-large', data)
     })
@@ -172,54 +194,180 @@ class HolepunchWorker extends EventEmitter {
   */
   networkPath = function (message) {
     if (message.action === 'share') {
-      // has the peer joined already?
-      let peerMatch = false
-      for (let wpeer of this.warmPeers) {
-        if (wpeer.publickey = message.data.publickey) {
-          peerMatch = true
+      // check if joined now?
+      let reEstablishShort = this.Peers.checkConnectivityStatus(message, this.warmPeers, 'invite-gen')
+      if (message.task === 'peer-share-invite' || message.task === 'peer-share-topic') {
+        // has the peer joined already?
+        let peerMatch = false
+        for (let wpeer of this.warmPeers) {
+          if (wpeer.publickey = message.data.publickey) {
+            peerMatch = true
+          }
         }
-      }
-      
-      if (message.task === 'peer-join') {
-        if (peerMatch === true) {
-          this.Peers.peerAlreadyJoinSetData(message.data)
-          this.Peers.writeTonetwork(message.data.publickey)
-        } else {
+        // new peer?
+        let peerTopeerState = this.Peers.checkConnectivityStatus(message, this.warmPeers, 'share-path')
+        if (peerTopeerState.live === false && peerTopeerState.existing === false) {
+          // first time
+          this.Peers.setRole({ pubkey: message.data.publickey, codename: message.data.codename, name: message.data.name })
+          // new peer keep track and start join process
           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') {
-        if (peerMatch === true) {
-         this.Peers.peerAlreadyJoinSetData(message.data)
-         this.Peers.writeToPublicLibrary(message.data.publickey)
         } else {
+          // twooptions  peer still online so reconnect,  or both been offline, reconnect via topic, if topic first time or subdquesnt?
+          // try to connect like first time
           this.warmPeers.push(message.data)
-          this.Peers.peerJoin(message.data)
-          // now set data and write to public library info.
           this.Peers.peerAlreadyJoinSetData(message.data)
-          this.Peers.writeToPublicLibrary(message.data.publickey)
+          // this.Peers.peerJoin(message.data)
+
+          this.Peers.setRestablished(message.data.publickey, reEstablishShort)
+          if (reEstablishShort.live === true) {
+            // first time use or returning use?
+            if (Object.keys(reEstablishShort.peer).length === 0) {
+              let peerActionData = this.Peers.peerHolder[message.data.publickey]
+              this.Peers.routeDataPath(message.data.publickey, peerActionData.data)
+            } else {
+              if (reEstablishShort.peer.value?.livePeerkey.length === 0) {
+                let peerActionData = this.Peers.peerHolder[message.data.publickey]
+                this.Peers.routeDataPath(message.data.publickey, peerActionData.data)
+              } else {
+              // returning peer via topic
+              let peerActionData = this.Peers.peerHolder[message.data.publickey]
+              this.Peers.routeDataPath(reEstablishShort.peer.value.livePeerkey, peerActionData.data)
+              }
+            }
+          } else {
+            // one peer server one peer client on topic  based upon who set the topic
+            if (reEstablishShort.peer.value.settopic === true) {
+              this.Peers.topicConnect(reEstablishShort.peer.value.topic)
+            } else {
+              this.Peers.topicListen(reEstablishShort.peer.value.topic, message.data.publickey)
+            }
+          }
+        }
+      } else if (message.task === 'peer-share-codename') {
+        // from peer generating the invite
+        this.Peers.setRole({ pubkey: message.data.publickey, codename: message.data.codename, name: message.data.name })
+      } else if (message.task === 'cue-space') {
+        this.Peers.peerAlreadyJoinSetData(message.data)
+        let peerActionData = this.Peers.peerHolder[message.data.publickey]
+        this.Peers.routeDataPath(reEstablishShort.peer.value.livePeerkey, peerActionData.data)
+      } else if (message.task === 'public-n1-experiment') {
+        this.Peers.peerAlreadyJoinSetData(message.data)
+        let peerActionData = this.Peers.peerHolder[message.data.publickey]
+        this.Peers.routeDataPath(reEstablishShort.peer.value.livePeerkey, peerActionData.data)
+      }
+    }
+  }
+
+  /**
+   * prepare data to send to a warm peer
+   * @method warmPeerPrepare
+   */
+  warmPeerPrepare = function (data, existing) {
+    // check if codename holder has any data to process
+    this.processCodenameMatching(data)
+    // two checks, if topic send to other peer
+    if (existing !== true) {
+      // match publick key to warmpeers
+      let peerMatch = {}
+      for (let wpeer of this.warmPeers) {
+        if (wpeer.publickey === data) {
+          peerMatch = wpeer
+        }
+      }
+      // client of server Role?
+      // let role = this.Peers.getRole(data)
+      if (peerMatch.roletaken === 'client') {
+        let roleStatus = this.Peers.matchCodename(data)
+        let codenameInform = {}
+        codenameInform.type = 'peer-codename-inform'
+        codenameInform.action = 'set'
+        codenameInform.data = { inviteCode: roleStatus.codename , publickey: data, peerkey: this.swarm.keyPair.publicKey.toString('hex') }
+        this.Peers.writeTonetworkData(data, codenameInform) 
+        // inform peer of codename
+      } else if (peerMatch.roletaken === 'server') {
+        // notify beebee peer to live
+        let codeNameInform = {}
+        codeNameInform.type = 'peer-codename-inform'
+        codeNameInform.action = 'set'
+        codeNameInform.data = { inviteCode: '' , publickey: data }
+        // in form beebee 
+        this.emit('invite-live-peer', codeNameInform)
+        // send topic to allow peer to reconnect
+        this.Peers.writeTonetworkTopic(data, codeNameInform)
+      }
+    }
+
+    // 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?
+      this.Peers.routeDataPath(data, peerDataExist)
+      /*
+      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)
         }
-      } else if (message.task === 'peer-write') {
-        this.emit('peer-write', message.data)
-      } else if (message.task === 'topic') {
-        // this.Peers.peerTopic(message.data.topic)
+      } */
+    }
+  }
+
+  /**
+   * process codename  matches after first save has happened.
+   * @method testCorestore
+   *
+  */
+  processCodenameMatching = async function (data) {
+    let updateCodeName = []
+    for (let cname of this.codenameUpdates) {
+      if (cname.data.peerkey === data) {
+        let matchCodename = this.Peers.matchPeersCodename(cname)
+        // need to matchs
+        let warmMatch = {}
+        for (let wpeer of this.warmPeers) {
+          if (wpeer.publickey === cname.data.peerkey) {
+            warmMatch = wpeer
+          }
+        }
+        matchCodename.peerkey = cname.data.peerkey
+        // update save for longterm and inform beebee
+        this.emit('peer-codename-update', matchCodename)
+      } else {
+        updateCodeName.push(cname)
+      }
+    }
+    this.codenameUpdates = updateCodeName
+  }
+
+ /**
+   * inform other peer of token for future connection
+   * @method topicSaveReturn
+   *
+  */
+  topicSaveReturn = function (data) {
+    let updateTopic = []
+    for (let ctopic of this.topicExhange) {
+      if (ctopic.key === data.publickey) {
+        this.emit('peer-reconnect-topic-notify', ctopic)
+        // update saved contract to add topic
+        this.emit('peer-topic-update', ctopic)
+      } else {
+        updateTopic.push(ctopic)
       }
     }
+    this.tpiocSaveReturn = updateTopic
   }
 
   /**

package/src/peers.js

@@ -9,10 +9,7 @@
 * @version    $Id$
 */
 import EventEmitter from 'events'
-// import DHT from '@hyperswarm/dht'
-import goodbye from 'graceful-goodbye'
-import b4a from 'b4a'
-
+import crypto from 'crypto'
 
 class NetworkPeers extends EventEmitter {
 
@@ -22,8 +19,14 @@ class NetworkPeers extends EventEmitter {
     this.store = store
     this.swarm = swarm
     this.drive = {}
+    this.peerPrime = ''
+    this.peerNetwork = [] // set on loading library via HOP
+    this.peerEstContext = {}
     this.peerHolder = {}
     this.peerConnect = {}
+    this.topicHolder = {}
+    this.sendTopicHolder = []
+    this.peersRole = []
   }
 
   /**
@@ -32,6 +35,22 @@ class NetworkPeers extends EventEmitter {
    *
   */
   networkKeys = function () {
+    // console.log('swarm on start')
+    // console.log(this.swarm)
+    // console.log(this.swarm._discovery) // .toString('hex'))
+
+    /*
+    this.swarm._discovery.forEach((value, key) => {
+      console.log('key')
+      console.log(key)
+      this.peerPrime = key
+      console.log(this.peerPrime)
+      console.log('-----------swarm discovery on START-------------------')
+      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 = {}
@@ -43,20 +62,166 @@ class NetworkPeers extends EventEmitter {
     this.peerJoinClient()
   }
 
+  /**
+   * set role in peer to peer relationship,  invte or receive?
+   * @method setRole
+   *
+  */
+  setRole = function (peerData) {
+    let setRole = { send: 'prime' , invite: peerData}
+    this.peersRole.push(setRole)
+  }
+
+  /**
+   * look at role of each peer save and join or listen to network
+   * @method setupConnectionBegin
+   *
+  */
+  setupConnectionBegin = function (peerNetwork) {
+    for (let sPeer of peerNetwork) {
+      if (sPeer.value.settopic === true) {
+        // client role
+        this.topicConnect(sPeer.value.topic)
+      } else {
+        // server role
+        this.topicListen(sPeer.value.topic, sPeer.key)
+      }
+    }
+  }
+
+  /**
+   * incoming establsihed information
+   * @method setRestablished
+   *
+  */
+  setRestablished = function (pubKey, established) {
+    this.peerEstContext[pubKey] = established
+  }
+
+  
+
   /**
    * connection listen
    * @method listenNetwork
    *
   */
-  listenNetwork = function () {
+  listenNetwork = function  () {
     this.swarm.on('connection', (conn, info) => {
-      // listen for replication
+      // console.log('peerinfo FIRST------------')
+      // console.log(info)
+      // save peer connection instance for ongoing communication
+      // listen for replication  NEED UPTATED LOGIC
       this.store.replicate(conn)
-      // listener to write message to peers or network partial or broadcast
+      // assess if token is present to match to exsing peer account ID?
       let publicKeylive = info.publicKey.toString('hex')
-      this.emit('connect-warm', publicKeylive)
-      this.peerConnect[publicKeylive] = conn
-      this.emit('peer-connect', publicKeylive)
+      let topicKeylive = info.topics
+      let roleTaken = info.client
+      // if now topics info then server, pass by
+      let discoveryTopicInfo = {}
+      if (topicKeylive.length === 0) {
+        // check if joined now?
+        discoveryTopicInfo = this.checkDisoveryStatus('server')
+      } else {
+        discoveryTopicInfo = {topic: ''}
+      }
+      let topicServer = this.topicHolder[discoveryTopicInfo.topic]
+      let serverStatus = false
+      if (topicServer !== undefined) {
+        if (Object.keys(topicServer).length > 0) {
+          serverStatus = true
+        }
+      }
+      // check if toppic via matching or being client receiving
+      if (topicKeylive.length > 0 || serverStatus === true) {
+        // keep track of connection
+        this.peerConnect[publicKeylive] = conn
+        if (topicKeylive.length > 0) {
+          let topicIn = topicKeylive[0].toString('hex')
+          let topicMatch = this.topicHolder[topicIn]
+          if (Object.keys(topicMatch).length > 0) {
+            // looks at what needs data needs cshared
+            // match new public key to saved publickey
+            topicMatch.currentPubkey = publicKeylive
+            this.topicHolder[topicIn] = topicMatch
+            this.dataFlowCheck(topicIn, 'client')
+          } else {
+            this.peerConnect[publicKeylive] = conn
+            
+          }
+          // update to live client
+          let originalKey = ''
+          for (let savePeer of this.peerNetwork) {
+            if (savePeer.value.topic === topicIn) {
+              originalKey = savePeer.value.publickey    
+            }
+          }
+          let updatePeerStatus = []
+          for (let savePeer of this.peerNetwork) {
+            if (savePeer.key === originalKey) {
+              let updatetoLive = savePeer
+              updatetoLive.value.live = true
+              updatetoLive.value.livePeerkey = publicKeylive
+              updatePeerStatus.push(updatetoLive)
+              this.emit('peer-live-network', originalKey)
+            } else {
+              updatePeerStatus.push(savePeer)
+            }
+          }
+          this.peerNetwork = updatePeerStatus
+        } else {
+          // keep track of connection
+          this.peerConnect[publicKeylive] = conn
+          this.dataFlowCheck(publicKeylive, 'server')
+        }
+
+        if (serverStatus === true) {
+          // set to live
+          let originalKey = ''
+          for (let savePeer of this.peerNetwork) {
+            if (savePeer.value.topic === topicServer.topic) {
+              originalKey = savePeer.value.publickey    
+            }
+          }
+          // need original connection public key
+          let updatePeerStatus = []
+          for (let savePeer of this.peerNetwork) {
+            if (savePeer.key === originalKey) {
+              let updatetoLive = savePeer
+              updatetoLive.value.live = true
+              updatetoLive.value.livePeerkey = publicKeylive
+              updatePeerStatus.push(updatetoLive)
+              // update beebee
+              this.emit('peer-live-network', originalKey)
+            } else {
+              updatePeerStatus.push(savePeer)
+            }
+          }
+          this.peerNetwork = updatePeerStatus
+        }
+      } else {
+        // first time or from topic reset?
+        // need to check from client and server side
+        if (this.topicHolder[publicKeylive] === undefined) {
+          // is client or server role
+          let roleType = ''
+          if (roleTaken === false) {
+            roleType = 'server'
+          } else {
+            roleType = 'client'
+          }
+          let roleContext = {}
+          roleContext.publickey = publicKeylive
+          roleContext.roletaken = roleType
+          // first time cheeck for data long with it?
+          this.peerConnect[publicKeylive] = conn
+          this.dataFlowCheck(publicKeylive, 'first')
+          this.emit('connect-warm-first', roleContext)
+        } else {
+          this.peerConnect[publicKeylive] = conn
+          this.dataFlowCheck(publicKeylive, 'server')
+        }
+      }
+
       // process network message
       conn.on('data', data =>
         // assess data
@@ -66,7 +231,7 @@ class NetworkPeers extends EventEmitter {
     })
   }
 
-  /**
+    /**
    * 
    * @method assessData data and act
    *
@@ -75,46 +240,331 @@ 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 === 'peer-codename-inform') {
+          // all peer to match publicke to codename then update save and infom beebee
+          this.emit('peer-codename-match', dataShareIn)
+        } else if (dataShareIn.type === 'topic-reconnect') {
+          // peer has share a topic for future reconnect
+          // check if publickey is  topic key if yes, already active do nothing
+          let topicMatch = this.topicHolder[dataShareIn.topic]
+          if (topicMatch !== undefined) {
+            if (topicMatch.currentPubkey === dataShareIn.publickey) {
+            } else {
+              // server set topic in first connect flow
+              this.emit('peer-reconnect-topic', dataShareIn)
+            }
+          } else {
+            // client path
+            dataShareIn.settopic = false
+            this.emit('peer-reconnect-topic', dataShareIn)
+          }
         }
-        console.log(a)
       } catch (e) {
           return console.error('ignore err')
       }
     }
   }
 
+  /**
+   * what is the connectivity between two peers
+   *  @method checkConnectivityStatus
+  */
+  checkConnectivityStatus = function (message, warmPeers, decodePath) {
+    let ptopStatus = {}
+    let savedPtoP = false
+    let livePtoP = false
+    let savedpeerInfo = {}
+    let peerMatch = false
+    // split invite to parts
+    if (decodePath === 'invite-gen') {
+      let parts = this.inviteDecoded(message.data)
+      message.data.publickey = parts[1]
+      message.data.codename = parts[2]
+    } else {
+    }
+    // check saved i.e. exsting known peer
+    for (let exPeer of this.peerNetwork) {
+      if (exPeer.key === message.data.publickey) {
+        savedPtoP = true
+        savedpeerInfo = exPeer
+      }
+    }
+    // check is peer is live
+    let peerLiveStatus = false
+    for (let sPeer of this.peerNetwork) {
+      if (sPeer.key === message.data.publickey) {
+        peerLiveStatus = sPeer.value.live
+      }      
+    }
+    // is first time or ongoing?
+    if (peerLiveStatus === true) {
+      livePtoP = true
+    } else {
+      // first time connection
+      for (let wpeer of warmPeers) {
+        // connection open and live directly between two peers?
+        let openConn = this.peerConnect[message.data.publickey]
+        if (openConn !== undefined) {
+        livePtoP = true 
+        }
+        // peer existing
+        if (wpeer.publickey = message.data.publickey) {
+          peerMatch = true
+        }
+      }
+    }
+    // set the status
+    ptopStatus.peer = savedpeerInfo
+    // settopic
+    ptopStatus.existing = savedPtoP
+    // live
+    ptopStatus.live = livePtoP
+    ptopStatus.role = this.peersRole[message.data.publickey]
+    ptopStatus.data = message.data
+    ptopStatus.action = message.action
+    ptopStatus.task = message.task
+    return ptopStatus
+  }
+
+  /**
+  *  match codename to peer name
+  *  @method matchCodename
+  * 
+  */
+  matchCodename = function (data) {
+    let codeNameInvite = {}
+    let inviteIn = {}
+    for (let roleP of this.peersRole) {
+      if (roleP.invite.pubkey === data) {
+        inviteIn = roleP
+      }
+    }
+    codeNameInvite = { codename: inviteIn.invite.codename, invitePubkey: data , name: inviteIn.invite.name}
+    // match codename to role
+    let roleMatch = { publickey: data, role: inviteIn, codename: codeNameInvite.codename, name: codeNameInvite.name }
+    return roleMatch
+  }
+
+  /**
+  *  match codename to peer codename
+  *  @method matchPeersCodename
+  * 
+  */
+  matchPeersCodename = function (data) {
+    let inviteIn = {}
+    for (let roleP of this.peersRole) {
+      if (roleP.invite.codename === data.data.inviteCode) {
+        inviteIn = roleP
+      }
+    }
+    // match codename to role
+    let roleMatch = { publickey: data, role: inviteIn, codename: inviteIn.invite.codename, name: inviteIn.invite.name }
+    return roleMatch
+  }
+
+  /**
+  *  split invte code string
+  *  @method inviteDecoded
+  * 
+  */
+  inviteDecoded = function (invite) {
+    let splitInvite = invite.publickey.split('-')
+    if (splitInvite.length === 1) {
+      splitInvite = []
+      splitInvite.push('hop')
+      splitInvite.push(invite.publickey)
+      splitInvite.push(invite.codename)
+    } else {
+      // first time split fine
+    }
+    return splitInvite
+  }
+
+  /**
+  *  check if any data actions along with connecting input?
+  *  @method dataFlowCheck
+  * 
+  */
+  dataFlowCheck = function (topicIn, role) {
+    // check if any data connection flow?
+    let peerTopeerState = {}
+    let matchPeer = {}
+    if (role === 'client') {
+      matchPeer = this.topicHolder[topicIn]
+      let peerActionData = this.peerHolder[matchPeer.peerKey]
+      if (peerActionData !== undefined) {  
+        peerTopeerState = peerActionData.data
+      }
+    } else if (role === 'server') {
+      matchPeer.currentPubkey = topicIn
+      // loop over topics and see what info available??
+      let checkDiscoveryTopic = {}
+      for (let topicH of this.sendTopicHolder) {
+        const noisePublicKey = Buffer.from(topicH.topic, 'hex')
+        let discovery = this.swarm.status(noisePublicKey)
+        let discoverTopic = discovery.topic.toString('hex')
+        if (discoverTopic === topicH.topic) {
+          discovery.swarm.connections.forEach((value, key) => {
+            checkDiscoveryTopic.server = value.publicKey.toString('hex')
+            checkDiscoveryTopic.client = value.remotePublicKey.toString('hex')
+            checkDiscoveryTopic.topic = discoverTopic
+          })
+        }
+      }
+      // find out peer publickey first
+      let peerMTopic = {}
+      for (let peerh of this.peerNetwork) {
+       if (peerh.value.topic === checkDiscoveryTopic.topic) {
+          peerMTopic = peerh
+        }
+      }
+      // server from topic or first time direct?
+      if (Object.keys(peerMTopic).length === 0) {
+        //  first time direct connection
+        peerMTopic.key = topicIn  // note this is public key  poor naming  
+      } else {
+      }
+      // check for data
+      let peerActionData = this.peerHolder[peerMTopic.key]
+      if (peerActionData !== undefined) {
+        peerTopeerState = peerActionData.data
+      } else {
+        peerTopeerState = {}
+      }
+      } else if (role === 'first') {
+        let peerActionData = this.peerHolder[topicIn]
+        if (peerActionData === undefined) {
+          peerTopeerState = {}
+        } else {
+          if(peerActionData.data !== undefined) {
+            peerTopeerState = peerActionData.data          
+          } else {
+            peerTopeerState = {}
+          }
+        }
+      }
+    // any data to write to network? NOT USED?
+    let checkDataShare = Object.keys(peerTopeerState).length
+    if (checkDataShare > 0) {
+      if (peerTopeerState.type === 'peer-share-invite') {
+      } else if (peerTopeerState.type === 'private-chart') {  
+        this.writeTonetworkData(matchPeer.currentPubkey, peerTopeerState)
+      } else if (peerTopeerState.type === 'peer-share-topic') {
+      } else if (peerTopeerState.type === 'public-n1-experiment') {
+      } else if (peerTopeerState.type === 'cue-space') {
+      } else if (peerTopeerState.type === 'peer-write') {
+      }
+    } 
+  }
+
+  /**
+   * check discovery status on network
+   * @method checkDisoveryStatus
+   *
+  */
+  checkDisoveryStatus = function (nodeRole) {
+    let topicList = []
+    if (nodeRole === 'server') {
+      topicList = this.sendTopicHolder
+    } else if (nodeRole === 'client') {
+      topicList = this.topicHolder
+    }
+    let checkDiscoveryTopic = {}
+    if (topicList.length > 0) {
+      for (let topicH of topicList) {
+        const noisePublicKey = Buffer.from(topicH.topic, 'hex')
+        let discovery = this.swarm.status(noisePublicKey)
+        let discoverTopic = discovery.topic.toString('hex')
+        if (discoverTopic === topicH.topic) {
+          discovery.swarm.connections.forEach((value, key) => {
+            checkDiscoveryTopic.server = value.publicKey.toString('hex')
+            checkDiscoveryTopic.client = value.remotePublicKey.toString('hex')
+            checkDiscoveryTopic.topic = discoverTopic
+          })
+        }
+      }
+    }
+    return checkDiscoveryTopic
+  }
+
+
+  /**
+   * where to route data share
+   * @method routeDataPath
+   *
+  */
+  routeDataPath = function (livePubkey, peerTopeerState) {
+    // any data to write to network?
+    let checkDataShare = Object.keys(peerTopeerState).length
+    if (checkDataShare > 0) {
+      if (peerTopeerState.type === 'peer-share-invite') {
+      } else if (peerTopeerState.type === 'private-chart') {  
+        this.writeTonetworkData(livePubkey, peerTopeerState)
+      } else if (peerTopeerState.type === 'public-n1-experiment') {
+        this.writeToPublicLibrary(livePubkey, peerTopeerState)
+      } else if (peerTopeerState.type === 'private-cue-space') {
+        this.writeToCueSpace(livePubkey, peerTopeerState)
+      } else if (peerTopeerState.type === 'peer-write') {
+        this.Peers.writeTonetwork(peerTopeerState)
+      } else if (peerTopeerState.type === 'public-library') {
+        this.Peers.writeToPublicLibrary(data)
+      }
+    }
+  }
+
   /**
    * write message to network
    * @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, codeName) {
+    const randomString = crypto.randomBytes(32).toString('hex')
+    // Convert the random string to a buffer
+    const buffer = Buffer.from(randomString, 'hex')
+      let topicGeneration =  randomString
+      // 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.peerkey = this.swarm.keyPair.publicKey.toString('hex')
+      topicShare.prime = true
+      topicShare.topic = topicGeneration
+      topicShare.codename = codeName
+      topicShare.data = topicGeneration
+      this.emit('topic-formed-save', topicShare)
+      // 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))
   }
 
   /**
@@ -122,19 +572,12 @@ class NetworkPeers extends EventEmitter {
    * @method writeToPublicLibrary
    *
   */
-  writeToPublicLibrary = function (publickey) {
+  writeToPublicLibrary = function (publickey, data) {
     // check this peer has asked for chart data
-    let connectTrue = publickey in this.peerConnect
-    let libraryTrue = publickey in this.peerHolder
-    if (connectTrue === true && libraryTrue === true) {
-      let libraryData = this.peerHolder[publickey]
       let dataShare = {}
-      dataShare.data = libraryData.data
+      dataShare.data = data
       dataShare.type = 'public-library'
       this.peerConnect[publickey].write(JSON.stringify(dataShare))
-    } else {
-      console.log('no board to write ie share with a peer')
-    }
   }
 
   /**
@@ -142,37 +585,56 @@ class NetworkPeers extends EventEmitter {
    * @method writeToCueSpace
    *
   */
-  writeToCueSpace = function (publickey) {
-    // check this peer has asked for space data
-    let connectTrue = publickey in this.peerConnect
-    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))
-    } else {
-      console.log('no cuespace to write ie share with a peer')
-    }
+  writeToCueSpace = function (publickey, data) {
+    this.peerConnect[publickey].write(JSON.stringify(data))
   }
 
-
   /**
-   * 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) {
-      const peerConnect = this.swarm.joinPeer(noisePublicKey, { server: true, client: false })
+      this.swarm.joinPeer(noisePublicKey, { server: true, client: false })
     }
   }
 
+  /**
+   * 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,9 +642,9 @@ class NetworkPeers extends EventEmitter {
   */
   peerAlreadyJoinSetData = function (peerContext) {
     this.peerHolder[peerContext.publickey] = peerContext
+    return true
   }
 
-
   /**
    * join peer to peer private (client)
    * @method peerJoinClient
@@ -193,48 +655,48 @@ class NetworkPeers extends EventEmitter {
   }
 
   /**
-   * listen for topics as a client
-   * @method listenClient
+   * out message topics as a client
+   * @method topicConnect
    *
   */
-  listenClient = 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
-  }
+  topicConnect = async function (topic) {
+    // const noisePublicKey = Buffer.alloc(32).fill(topic) // A topic must be 32 bytes
+    const noisePublicKey = Buffer.from(topic, 'hex') //  must be 32 bytes
+    if (noisePublicKey.length === 32) {
+      let topicKeylive = noisePublicKey.toString('hex')
+      this.topicHolder[topic] = { role: 'server', livePubkey: this.swarm.keyPair.publicKey.toString('hex'), topic: topic, key: topicKeylive, timestamp: '' }
+      this.sendTopicHolder.push({ livePubkey: this.swarm.keyPair.publicKey.toString('hex'), topic: topic })
+      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, peerKey) {
+    // const noisePublicKey = Buffer.alloc(32).fill(topic) // A topic must be 32 bytes
+    // let topicKeylive = noisePublicKey.toString('hex')
+    const noisePublicKey = Buffer.from(topic, 'hex') //  must be 32 bytes
+    if (noisePublicKey.length === 32) {
+      let topicKeylive = noisePublicKey.toString('hex')
+      this.topicHolder[topic] = { role: 'client', topic: topic, key: topicKeylive, peerKey: peerKey, timestamp: '' }
+      const peerConnect = this.swarm.join(noisePublicKey, { server: false, client: true })
+      await peerConnect.flushed() // Waits for the topic to be fully announced on the DHT
+    } else {
+      console.log('key lenght issue')
+    }
   }
 
   /**
-   * 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)
   }
 
 }