holepunch-hop 0.4.5 → 0.4.8

package/src/{peers.js → network/peers.js}

@@ -1,4 +1,5 @@
 'use strict'
+
 /**
 *  Manage Peers connections
 *
@@ -12,7 +13,6 @@ import EventEmitter from 'events'
 import crypto from 'crypto'
 
 class NetworkPeers extends EventEmitter {
-
   constructor(store, swarm) {
     super()
     this.hello = 'hyperpeers'
@@ -28,6 +28,7 @@ class NetworkPeers extends EventEmitter {
     this.sendTopicHolder = []
     this.peersRole = []
     this.discoveryList = []
+    this.peerSwitchLiveID = []
   }
 
   /**
@@ -92,6 +93,17 @@ class NetworkPeers extends EventEmitter {
     }
   }
 
+  /**
+   * when new update or refresh peer network to get latest peers
+   * @method latestPeerNetwork
+   *
+  */
+  latestPeerNetwork = function (peerNetwork) {
+    // Use concat to merge arrays while preserving existing elements
+    this.peerNetwork = [...this.peerNetwork, ...peerNetwork]
+  }
+
+
   /**
    * incoming establsihed information
    * @method setRestablished
@@ -101,155 +113,180 @@ class NetworkPeers extends EventEmitter {
     this.peerEstContext[pubKey] = established
   }
 
-  /**
-   * connection listen
-   * @method listenNetwork
-   *
-  */
-  listenNetwork = function  () {
+  /*
+   * Listen for network connections
+  *
+  **/
+  listenNetwork = function () {
     this.swarm.on('connection', (conn, info) => {
-      // save peer connection instance for ongoing communication
-      // 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')
+      const publicKey = info.publicKey.toString('hex')
+      this.peerConnect[publicKey] = conn
+      const connectionInfo = this.prepareConnectionInfo(info, publicKey)
+      // Determine which path to take
+      if (connectionInfo.discoveryTopicInfo.firstTime === false) {
+        this.handleReconnection(conn, info, connectionInfo)
+      } else if (connectionInfo.discoveryTopicInfo.firstTime === true) {
+        this.handleFirstTimeConnection(conn, info, connectionInfo)
       } 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')
-        }
+        // need to differenciate between first time and reconnect
+        this.peerSwitchLiveID.push({ publicKey: publicKey, discoveryTopicInfo: connectionInfo })
       }
+      
+      // Common setup
+      this.store.replicate(conn);
 
       // process network message
       conn.on('data', data =>
         // assess data
-        this.assessData(publicKeylive, data)
+        this.assessData(publicKey, data)
       )
 
       conn.on('error', data => {
         let connectLivekeys = Object.keys(this.peerConnect)
-        for (let peer of this.peerNetwork) {
-          for (let pconn of connectLivekeys) {
-            if (peer.value.livePeerkey === pconn) {
-              // check if connect is close?
-              let keysNoise = Object.keys(this.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed'])
-              // console.log(this.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed'])
-              let closeStatus = this.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed']
-              if (closeStatus === true) {
-                // remove peer & inform beebee
-                this.emit('peer-disconnect', { publickey: peer.key })
+        if (connectLivekeys.length > 0) {
+          for (let peer of this.peerNetwork) {
+            for (let pconn of connectLivekeys) {
+              if (peer.value.livePeerkey.length > 0) {
+                if (peer.value.livePeerkey === pconn) {
+                  // check if connect is close?
+                  // let keysNoise = Object.keys(this.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed'])
+                  // console.log(this.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed'])
+                  let closeStatus = this.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed']
+                  if (closeStatus === true) {
+                    // remove peer & inform beebee
+                    this.emit('peer-disconnect', { publickey: peer.key })
+                  }
+                }
+               } else {
+                // assume first time and use key
+                if (peer.key === pconn) {
+                  // check if connect is close?
+                  let closeStatus = this.peerConnect[pconn]['noiseStream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['_writableState']['stream']['rawStream']['_closed']
+                  if (closeStatus === true) {
+                    // remove peer & inform beebee
+                    this.emit('peer-disconnect', { publickey: peer.key })
+                  }
+                }
               }
             }
           }
         }
       })
-
-      // conn.end()
     })
   }
 
+  // Connection preparation methods
+  prepareConnectionInfo =  function(info, publicKey) {
+    const topicKeylive = info.topics
+    const roleTaken = info.client
+    let discoveryTopicInfo = {}
+    if (topicKeylive.length === 0) {
+      if (roleTaken === false) {
+        discoveryTopicInfo = this.checkDisoveryStatus('server', publicKey, topicKeylive)
+      } else if (roleTaken === true) {
+        discoveryTopicInfo = this.checkDisoveryStatus('client', publicKey, topicKeylive)
+      }
+      if (discoveryTopicInfo === undefined) {
+        discoveryTopicInfo = { firstTime: false, topic: ''}
+      }
+    } else {
+      discoveryTopicInfo = { firstTime: false, topic: ''}
+    }
+       
+    return {
+      topicKeylive,
+      roleTaken,
+      discoveryTopicInfo
+    };
+  }
+
+  handleFirstTimeConnection = function(conn, info, connectionInfo) {
+    const { publicKey } = info
+    const { topicKeylive } = connectionInfo
+    let publicKeylive = publicKey.toString('hex')
+    // First establish the connection
+    let roleTaken = info.client
+    // check status of topic  first time no topic
+    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.dataFlowCheck(publicKeylive, 'first')
+      this.emit('connect-warm-first', roleContext)
+    }
+}
+
+  /**
+   *  Reconnection handler
+   * 
+   */
+  handleReconnection = function(conn, info, connectionInfo) {
+    const { publicKey } = info;
+    const { topicKeylive, discoveryTopicInfo, serverStatus } = connectionInfo
+    // Reconnection logic
+    let topic = topicKeylive[0].toString('hex')
+    // match topic to topic holder list to get original pub key ID
+    let originalKey = ''
+    for (let savePeer of this.peerNetwork) {
+      if (savePeer.value.topic === topic) {
+         originalKey = savePeer.value.publickey
+        break;
+      }
+    }
+    if (topic.length > 0) {
+      // Handle topic-based reconnection
+      const topicMatch = this.topicHolder[topic]
+      if (topicMatch && Object.keys(topicMatch).length > 0) {
+        topicMatch.currentPubkey = publicKey.toString('hex')
+        this.topicHolder[topic] = topicMatch
+        this.dataFlowCheck(topic, 'client')
+        this.updatePeerStatus(topic, publicKey.toString('hex'))
+        // inform other peer of peerkey id
+        this.writeTopicReconnect(originalKey, topicMatch)
+      }
+      // Handle non-topic reconnection
+      this.dataFlowCheck(publicKey.toString('hex'), 'server')
+    }
+  }
+
+  /*
+   * Update peer status
+  *
+  **/
+  updatePeerStatus = function(topic, publicKey) {
+    let originalKey = '';
+    for (let savePeer of this.peerNetwork) {
+      if (savePeer.value.topic === topic) {
+        originalKey = savePeer.value.publickey;
+        break;
+      }
+    }
+
+    const updatePeerStatus = this.peerNetwork.map(savePeer => {
+      if (savePeer.key === originalKey) {
+        return {
+          ...savePeer,
+          value: {
+            ...savePeer.value,
+            live: true,
+            livePeerkey: publicKey
+          }
+        };
+      }
+      return savePeer;
+    });
+    this.peerNetwork = updatePeerStatus;
+    this.emit('peer-live-network', originalKey)
+  }
+
   /**
    * 
    * @method updateListen
@@ -301,6 +338,9 @@ class NetworkPeers extends EventEmitter {
             dataShareIn.settopic = false
             this.emit('peer-reconnect-topic', dataShareIn)
           }
+        } else if (dataShareIn.type === 'topic-reconnect-id') {
+          // update status of livepeer public key
+          this.emit('peer-reconnect-topic-id', peer, dataShareIn.data)
         }
       } catch (e) {
           return console.error('ignore err')
@@ -369,6 +409,27 @@ class NetworkPeers extends EventEmitter {
     return ptopStatus
   }
 
+  /**
+  *  match to first time invite code
+  *  @method matchInviteFirst
+  * 
+  */
+  matchInviteFirst = function (data) {
+    let roleMatch = false
+    for(let peerRole of this.peersRole ) {
+      if (peerRole.invite.codename === data.data.inviteCode) {
+        roleMatch = true
+        break
+      }
+    }
+    if (roleMatch === true) {
+      let roleContext = {}
+      roleContext.publickey = data.data.peerkey
+      roleContext.roletaken = 'server'
+      this.emit('connect-warm-first', roleContext)
+    }
+  }
+
   /**
   *  match codename to peer name
   *  @method matchCodename
@@ -434,11 +495,25 @@ class NetworkPeers extends EventEmitter {
         discoverySettings = savePeer.discovery
       }
     }
-    // now refresh
-    discoverySettings.refresh()
     return true
   }
 
+  /**
+  *  match topic live public key
+  *  @method topicPublicKeyMatch
+  * 
+  */
+  topicPublicKeyMatch = function (topic) {
+    // first match live pubkey to topic and then use topic to get original
+    let topicSettings = {}
+    for (let livePeer of this.peerSwitchLiveID) {
+      if (livePeer.connectionInfo.topic === topic) {
+        topicSettings = livePeer.publicKey
+      }
+    }
+    return topicSettings
+  }
+
   /**
   *  match current publickey to peer id i.e. estbalshed on first connect and maps to 'peername' in UX
   *  @method peerMatchbase
@@ -460,6 +535,22 @@ class NetworkPeers extends EventEmitter {
     }
   }
 
+  /**
+  *  match peer to topic live
+  *  @method matchPeerTopic
+  * 
+  */
+  matchPeerTopic = function (topic) {
+    // first match live pubkey to topic and then use topic to get original
+    let peerSettings = {}
+    for (let savePeer of this.peerNetwork) {
+      if (savePeer.value.topic === topic) {
+        peerSettings = savePeer
+      }
+    }
+    return peerSettings
+  }
+
   /**
   *  split invte code string
   *  @method inviteDecoded
@@ -560,35 +651,271 @@ class NetworkPeers extends EventEmitter {
     } 
   }
 
+  /* 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) {
+  checkDisoveryStatus = function (nodeRole, publicKey, topic) {
     let topicList = []
     if (nodeRole === 'server') {
       topicList = this.sendTopicHolder
     } else if (nodeRole === 'client') {
       topicList = this.topicHolder
     }
+    // previous info at hand 
+    let firstTime = false
+    let emptyHolder = false
+
+    // we get public key --  discovery process to match to topic, has that topic been set before, then match live key to peerKey ie. the pubkey used an id from first time connection??
+    // scenerios
+    // 1. first time connection both client and server -- no save peers
+    // 2. first time connection client -- with saved peers
+    // 3. first time connection server -- with saved peers
+    // 4. reconnect with only one options
+    // 5. reconnect client with saved peers
+    // 6. reconnect server with saved peers
+    // 7  mix of peers acting as clients and server
+    let checkDiscoveryInfo = {}
+    // any existing peers
+    if (this.peerNetwork.length === 0) {
+      firstTime = true
+    } else {
+      // check if current publickey matches
+      let keyMatchTopic = false
+      if (topicList.length > 0) {
+        for (let topicE of topicList) {
+          if (topicE.livePubkey === publicKey) {
+            keyMatchTopic = true
+          }
+        }
+      } else {
+        keyMatchTopic = false
+      }
+      // need to also check if histic topic set?   
+      if (keyMatchTopic === false) {
+        // check in client or Server roles
+        // client will have topic if returning peer
+        if (nodeRole === 'client') {
+          // check if topic in peerInfo on connect
+          if (topic.length === 0) {
+            firstTime = true
+          }
+        } else if (nodeRole === 'server') {
+          if (topicList.length === 0) {
+            firstTime = true
+          } else {
+            // could be first time connect
+            // check if public key in network
+            let existingPeerCheck = false
+            for (let peer of this.peerNetwork) {
+              if (peer.key === publicKey) {
+                existingPeerCheck = true
+              } else {
+                existingPeerCheck = false
+              }
+            }
+            // can rule out reconnection?  not enough info at this time, peer if reconnect topic will send id to match direct
+            if (existingPeerCheck === false && keyMatchTopic === false) {
+              firstTime = 'wait-topic-confirm'
+            } else if (existingPeerCheck === false && keyMatchTopic === true) {
+              firstTime = 'wait-topic-confirm'
+            } else {
+              firstTime = false
+            }
+          }
+        }
+      }
+    }
+
+
+    checkDiscoveryInfo.firstTime = firstTime
+    checkDiscoveryInfo.emptyHolder = emptyHolder
+    checkDiscoveryInfo.role = nodeRole
+    checkDiscoveryInfo.server = ''
+    checkDiscoveryInfo.client = ''
+    checkDiscoveryInfo.topic = ''
+    return checkDiscoveryInfo
+
+
+    /*
+    if (this.peerNetwork.length > 0) {
+      emptyHolder = true
+      // match pubkey to peer to get set topic
+      let matchTopic = ''
+      for (let peer of this.peerNetwork) {
+        if (peer.key === publicKey) {
+          matchTopic = peer.value.topic
+        } else {
+        }
+      }
+      // now use match topic to see if topic set as server or client roles?
+      let sendLogic = []
+      let holderLogic = []
+      for (let sendPeerT of this.sendTopicHolder) {
+        if (sendPeerT.topic === matchTopic) {
+          sendLogic.push(sendPeerT)
+        } else {
+        }
+      }
+      let matchHolderKeys = Object.keys(this.topicHolder)
+      for (let topicH of matchHolderKeys) {
+        if (this.topicHolder[topicH].topic === matchTopic) {
+          holderLogic.push(this.topicHolder[topicH])
+        } else {
+        }
+      }
+      console.log('match topic')
+      console.log(matchTopic)
+      console.log('send logic')
+      console.log(sendLogic)
+      console.log('holder logic')
+      console.log(holderLogic)
+      if (nodeRole === 'client') {
+        console.log('extra workk for client')
+        if (matchTopic.length > 0 && sendLogic.length === 0 && holderLogic.length === 0) {
+          firstTime = true
+        } else {
+          firstTime = true
+        }
+      } else if (nodeRole === 'server') {
+        console.log('extra workk for server')
+        // check if public key match any exsting keyids?
+        /* for (let peer of this.peerNetwork) {
+          if (peer.key === publicKey) {
+            firstTime = false
+          } else {
+            firstTime = true
+          }
+        } 
+      }
+ 
+    } else {
+      firstTime = true
+    }
+    
+    // has a topic already been sent to this peer, if not must be first time
+    let beforeSendTopic = false
+    for (let topicS of this.sendTopicHolder) {
+      if (topicS.livePubkey === publicKey) {
+        beforeSendTopic = true
+      }
+    }
     let checkDiscoveryTopic = {}
+    checkDiscoveryTopic.firstTime = firstTime  // should this be set???
     if (topicList.length > 0) {
       for (let topicH of topicList) {
         const noisePublicKey = Buffer.from(topicH.topic, 'hex')
         let discovery = this.swarm.status(noisePublicKey)
+        console.log('discovery000000000000000000000000')
+        console.log(discovery.topic.toString('hex'))
         let discoverTopic = discovery.topic.toString('hex')
         if (discoverTopic === topicH.topic) {
           // do the peerid match?
           discovery.swarm.connections.forEach((value, key) => {
+            console.log('value looooop')
             checkDiscoveryTopic.server = value.publicKey.toString('hex')
             checkDiscoveryTopic.client = value.remotePublicKey.toString('hex')
             checkDiscoveryTopic.topic = discoverTopic
           })
           if (checkDiscoveryTopic.client === topicH.peerKey) {
+            console.log('retrun rrrr1111')
+            checkDiscoveryTopic.firstTime = false
+            console.log(checkDiscoveryTopic)
             return checkDiscoveryTopic
           } else {
             if (checkDiscoveryTopic.topic === topicH.topic) {
+              // now check if returning
+              if (firstTime === false && emptyHolder === true) {
+                // match current public key to original key uses a permanent key
+                let permKeyID = ''
+                let topicSet = ''
+                if (checkDiscoveryTopic.client === publicKey) {
+                  permKeyID = checkDiscoveryTopic.client
+                  topicSet = checkDiscoveryTopic.topic
+                }
+                // now use this id to check if peer has been invited
+                let beforeTopicCheck = this.checkTopicModes(topicSet)
+                console.log('beftopicchchc-------------------')
+                console.log(beforeTopicCheck)
+                checkDiscoveryTopic.firstTime = beforeTopicCheck.firstTime
+              } else {
+                checkDiscoveryTopic.firstTime = true
+              }
+              console.log('return rrrr2222')
+              console.log(checkDiscoveryTopic)
               return checkDiscoveryTopic
             } else {
               checkDiscoveryTopic.topic = ''
@@ -602,10 +929,41 @@ class NetworkPeers extends EventEmitter {
       checkDiscoveryTopic.server = '' 
       checkDiscoveryTopic.client = ''
       checkDiscoveryTopic.topic = ''
+      console.log('return rrrr3333')
+      return checkDiscoveryTopic
     }
-    return checkDiscoveryTopic
+*/   
   }
 
+  /**
+   * match topics already set send and holder modes
+   * @method checkTopicModes
+   *
+  */
+  checkTopicModes = function (matchTopic) {
+    // now use match topic to see if topic set as server or client roles?
+    let sendLogic = []
+    let holderLogic = []
+    for (let sendPeerT of this.sendTopicHolder) {
+      if (sendPeerT.topic === matchTopic) {
+        sendLogic.push(sendPeerT)
+      } else {
+      }
+    }
+    let matchHolderKeys = Object.keys(this.topicHolder)
+    for (let topicH of matchHolderKeys) {
+      if (this.topicHolder[topicH].topic === matchTopic) {
+        holderLogic.push(this.topicHolder[topicH])
+      } else {
+      }
+    }
+    let firstTime = false
+    if (sendLogic.length === 0 && holderLogic.length === 0) {
+      firstTime = true
+    }
+
+    return { firstTime: firstTime }
+  }
 
   /**
    * where to route data share
@@ -666,6 +1024,19 @@ class NetworkPeers extends EventEmitter {
       this.peerConnect[publickey].write(JSON.stringify(topicShare))
   }
 
+  /**
+   * write message to topic reconnect peer to inform of id
+   * @method writeTopicReconnect
+   *
+  */
+  writeTopicReconnect = function (publickey, topicInfo) {
+    let topicReconnectMessage = {}
+    topicReconnectMessage.type = 'topic-reconnect-id'
+    topicReconnectMessage.data = { topic: topicInfo.topic, peerKey: topicInfo.peerKey }
+    this.peerConnect[topicInfo.currentPubkey].write(JSON.stringify(topicReconnectMessage))
+  }
+
+
   /**
    * write message to network
    * @method writeTonetworkData
@@ -786,7 +1157,7 @@ class NetworkPeers extends EventEmitter {
    *
   */
   topicListen = async function (topic, peerKey) {
-    // const noisePublicKey = Buffer.alloc(32).fill(topic) // A topic must be 32 bytes
+     // 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) {