holepunch-hop 0.3.4 → 0.3.6

package/package.json

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

package/src/bees.js

@@ -422,6 +422,7 @@ class HyperBee extends EventEmitter {
   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
   }
 
@@ -760,8 +761,6 @@ class HyperBee extends EventEmitter {
 
   }
 
-
-
   /**
    * delete nxp ref contract public
    * @method deleteRefcontPubliclibrary
@@ -788,7 +787,6 @@ class HyperBee extends EventEmitter {
     return deleteInfo
   }
 
-
   /**
    * repicate the publiclibrary peer to peer
    * @method replicatePubliclibrary
@@ -918,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)
@@ -974,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()
   }
@@ -110,12 +112,19 @@ class HolepunchWorker extends EventEmitter {
       this.wsocket.send(JSON.stringify(peerFail))
     })
     // save peer topic
-    this.Peers.on('peer-topic-save', async (data) => {
-      await this.emit('peer-topic-save', data)    
+    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('peer-reconnect-topic', (data) => {
-      this.emit('peer-reconnect-topic', data)
+    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) => {
@@ -124,6 +133,12 @@ class HolepunchWorker extends EventEmitter {
     // cue space share
     this.Peers.on('cuespace-notification', (data) => {
       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) => {
@@ -135,21 +150,37 @@ class HolepunchWorker extends EventEmitter {
     })
     // new warm incoming peer
     this.Peers.on('connect-warm-first', (data) => {
-      let peerInfo = this.Peers.peerHolder[data]
-      if (peerInfo === undefined) {
-        // receiving peer
-        peerInfo = { name: 'peernew'}
+      // 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 = peerInfo.name
-      peerId.publickey = data
+      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-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)
@@ -163,78 +194,132 @@ 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-share-invite') {
-        // keep track of role, reciving or extended invite
-        this.Peers.setRole(message.data.publickey)
-        if (peerMatch === true) {
+        // 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.peerAlreadyJoinSetData(message.data)
-          // this.Peers.writeTonetwork(message.data.publickey)
-          this.warmPeerPrepare(message.data.publickey, true)
+          this.Peers.peerJoin(message.data)
         } 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.peerAlreadyJoinSetData(message.data)
-          this.Peers.peerJoin(message.data)
+          // 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-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)
+      } 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') {
+          // first time or turning
+        if (Object.keys(reEstablishShort.peer).length === 0) {
+          this.Peers.peerAlreadyJoinSetData(message.data)
+          let peerActionData = this.Peers.peerHolder[message.data.publickey]
+          this.Peers.routeDataPath(message.data.publickey, peerActionData.data)
         } else {
-          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)
+          let peerActionData = this.Peers.peerHolder[message.data.publickey]
+          this.Peers.routeDataPath(reEstablishShort.peer.value.livePeerkey, peerActionData.data)
         }
-      } else if (message.task = 'cue-space') {
-        if (peerMatch === true) {
+      } else if (message.task === 'public-n1-experiment') {
+        if (Object.keys(reEstablishShort.peer).length === 0) {
           this.Peers.peerAlreadyJoinSetData(message.data)
-          this.Peers.writeToCueSpace(message.data.publickey)
+          let peerActionData = this.Peers.peerHolder[message.data.publickey]
+          this.Peers.routeDataPath(message.data.publickey, peerActionData.data)
         } else {
-          this.warmPeers.push(message.data)
-          this.Peers.peerJoin(message.data)
-          // this.Peers.peerAlreadyJoinSetData(message.data)
-          // this.Peers.writeToCueSpace(message.data.publickey)
+          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 === 'peer-write') {
-        this.emit('peer-write', message.data)
-      } else if (message.task === 'topic') {
-        // this.Peers.peerTopic(message.data.topic)
       }
     }
   }
 
-
   /**
    * 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) {
-      let peerRole = this.Peers.peersRole[data]
-      if (peerRole === undefined) {
-        this.Peers.writeTonetworkTopic(data)
-      } else {
-        console.log(' this peer set the topic')
+      // 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)
@@ -248,8 +333,54 @@ class HolepunchWorker extends EventEmitter {
           // simpole text message
           this.Peers.writeTonetwork(data)
         }
+      } */
+    }
+  }
+
+  /**
+   * 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,7 +9,7 @@
 * @version    $Id$
 */
 import EventEmitter from 'events'
-
+import crypto from 'crypto'
 
 class NetworkPeers extends EventEmitter {
 
@@ -19,9 +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.peersRole = {}
+    this.topicHolder = {}
+    this.sendTopicHolder = []
+    this.peersRole = []
   }
 
   /**
@@ -31,16 +36,21 @@ 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) => {
+    /*
+    this.swarm._discovery.forEach((value, key) => {
       console.log('key')
       console.log(key)
-      console.log('-----------swarm discovery IN-------------------')
+      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 = {}
@@ -52,6 +62,46 @@ 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) {
+    this.peerNetwork = peerNetwork
+    for (let sPeer of this.peerNetwork) {
+      // sPeer.value.key = publicKeylive
+      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
@@ -60,11 +110,119 @@ class NetworkPeers extends EventEmitter {
   listenNetwork = function  () {
     this.swarm.on('connection', (conn, info) => {
       // save peer connection instance for ongoing communication
-      let publicKeylive = info.publicKey.toString('hex')
-      this.peerConnect[publicKeylive] = conn
-      this.emit('connect-warm-first', publicKeylive)
       // listen for replication  NEED UPTATED LOGIC
       this.store.replicate(conn)
+      // assess if token is present to match to exsing peer account ID?
+      let publicKeylive = info.publicKey.toString('hex')
+      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
+          // update livePeerkey to true?? 
+          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
@@ -74,16 +232,7 @@ 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
    *
@@ -103,9 +252,24 @@ class NetworkPeers extends EventEmitter {
         } 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
-          this.emit('peer-reconnect-topic', dataShareIn)      
+          // 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)
+          }
         }
       } catch (e) {
           return console.error('ignore err')
@@ -113,6 +277,253 @@ class NetworkPeers extends EventEmitter {
     }
   }
 
+  /**
+   * 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
@@ -129,15 +540,21 @@ class NetworkPeers extends EventEmitter {
    * @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 })
+  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))
   }
@@ -151,25 +568,17 @@ class NetworkPeers extends EventEmitter {
     this.peerConnect[publickey].write(JSON.stringify(dataShare))
   }
 
-
   /**
    * write message connect public library
    * @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')
-    }
   }
 
   /**
@@ -177,19 +586,10 @@ 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]
-      this.peerConnect[publickey].write(JSON.stringify(libraryData))
-    } 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 direct private (server)
    * @method peerJoin
@@ -197,11 +597,11 @@ class NetworkPeers extends EventEmitter {
   */
   peerJoin = function (peerContext) {
     // set timeer to inform if not connection can be established
-    this. checkTimerConnection(peerContext.publickey)
+    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 })
     }
   }
 
@@ -246,7 +646,6 @@ class NetworkPeers extends EventEmitter {
     return true
   }
 
-
   /**
    * join peer to peer private (client)
    * @method peerJoinClient
@@ -262,20 +661,34 @@ class NetworkPeers extends EventEmitter {
    *
   */
   topicConnect = async function (topic) {
-    const noisePublicKey = Buffer.alloc(32).fill(topic) // A topic must be 32 bytes
-    const peerConnect = this.swarm.join(noisePublicKey, { server: true, client: false })
-    await peerConnect.flushed() // Waits for the topic to be fully announced on the DHT
-  }
+    // 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
+    }
+   }
 
   /**
    * out message topics as a client
    * @method topicListen
    *
   */
-  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
+  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')
+    }
   }
 
   /**