holepunch-hop 0.3.2 → 0.3.4

package/package.json

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

package/src/bees.js

@@ -2,8 +2,8 @@
 /**
 *  Manage HyperBee  key store datastore
 *
-* @class HypBee
-* @package    HypBee
+* @class HyperBee
+* @package    HyperBee
 * @copyright  Copyright (c) 2024 James Littlejohn
 * @license    http://www.gnu.org/licenses/old-licenses/gpl-3.0.html
 * @version    $Id$
@@ -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
@@ -96,6 +95,60 @@ class HyperBee extends EventEmitter {
     await this.dbKBledger.ready()
     // this.client.replicate(this.dbKBledger.feed)
     beePubkeys.push({store:'kbledger', pubkey: b4a.toString(core5.key, 'hex')})
+    // stores of cues, media, research, markers, products/treatments
+
+    const core7 = this.store.get({ name: 'bentocues' })
+    this.dbBentocues = new Hyperbee(core7, {
+      keyEncoding: 'utf-8', // can be set to undefined (binary), utf-8, ascii or and abstract-encoding
+      valueEncoding: 'json' // same options as above
+    })
+    await this.dbBentocues.ready()
+    beePubkeys.push({store:'bentocues', pubkey: b4a.toString(core7.key, 'hex')})
+
+
+    const core8 = this.store.get({ name: 'bentodecisions' })
+    this.dbBentodecisions = new Hyperbee(core8, {
+      keyEncoding: 'utf-8', // can be set to undefined (binary), utf-8, ascii or and abstract-encoding
+      valueEncoding: 'json' // same options as above
+    })
+    await this.dbBentodecisions.ready()
+    beePubkeys.push({store:'bentodecisions', pubkey: b4a.toString(core8.key, 'hex')})
+
+
+    const core9 = this.store.get({ name: 'bentomarkers' })
+    this.dbBentomarkers = new Hyperbee(core9, {
+      keyEncoding: 'utf-8', // can be set to undefined (binary), utf-8, ascii or and abstract-encoding
+      valueEncoding: 'json' // same options as above
+    })
+    await this.dbBentomarkers.ready()
+    beePubkeys.push({store:'bentomarkers', pubkey: b4a.toString(core9.key, 'hex')})
+
+
+    const core10 = this.store.get({ name: 'research' })
+    this.dbBentoresearch = new Hyperbee(core10, {
+      keyEncoding: 'utf-8', // can be set to undefined (binary), utf-8, ascii or and abstract-encoding
+      valueEncoding: 'json' // same options as above
+    })
+    await this.dbBentoresearch.ready()
+    beePubkeys.push({store:'research', pubkey: b4a.toString(core10.key, 'hex')})
+
+
+    const core11 = this.store.get({ name: 'bentoproducts' })
+    this.dbBentoproducts = new Hyperbee(core11, {
+      keyEncoding: 'utf-8', // can be set to undefined (binary), utf-8, ascii or and abstract-encoding
+      valueEncoding: 'json' // same options as above
+    })
+    await this.dbBentoproducts.ready()
+    beePubkeys.push({store:'bentoproducts', pubkey: b4a.toString(core11.key, 'hex')})
+
+    const core12 = this.store.get({ name: 'bentomedia' })
+    this.dbBentomedia = new Hyperbee(core12, {
+      keyEncoding: 'utf-8', // can be set to undefined (binary), utf-8, ascii or and abstract-encoding
+      valueEncoding: 'json' // same options as above
+    })
+    await this.dbBentomedia.ready()
+    beePubkeys.push({store:'bentomedia', pubkey: b4a.toString(core12.key, 'hex')})
+    
     this.emit('hbee-live')
     // return beePubkeys
     let startBeePubkey = {}
@@ -212,8 +265,8 @@ class HyperBee extends EventEmitter {
    *
   */
   saveSpaceHistory = async function (spaceContract) {
-    await this.dbBentospaces.put(spaceContract.space.spaceid, spaceContract)
-    let checkSave = await this.getBentospace(spaceContract.space.spaceid)
+    await this.dbBentospaces.put(spaceContract.space.cueid, spaceContract)
+    let checkSave = await this.getBentospace(spaceContract.space.cueid)
     return checkSave
   }
 
@@ -223,8 +276,8 @@ class HyperBee extends EventEmitter {
    *
   */
   saveBentospace = async function (spaceContract) {
-    await this.dbBentospaces.put(spaceContract.spaceid, spaceContract)
-    let checkSave = await this.getBentospace(spaceContract.spaceid)
+    await this.dbBentospaces.put(spaceContract.cueid, spaceContract)
+    let checkSave = await this.getBentospace(spaceContract.cueid)
     return checkSave
   }
 
@@ -238,15 +291,314 @@ class HyperBee extends EventEmitter {
     return nodeData
   }
 
+  /**
+   * lookup bentospaces all
+   * @method getAllBentospaces
+   *
+  */
+  getAllBentospaces = async function () {
+    const spacesHistory = await this.dbBentospaces.createReadStream()
+    let spacesData = []
+    for await (const { key, value } of spacesHistory) {
+      spacesData.push({ key, value })
+    }    
+    return spacesData
+  }
+
+
   /**
    * delete nxp ref contract from peer library
    * @method deleteBentospace
    *
   */
   deleteBentospace = async function (space) {
-    const deleteStatus = await this.dbBentospaces.del(space.spaceid)
+    const deleteStatus = await this.dbBentospaces.del(space.cueid)
+    let deleteInfo = {}
+    deleteInfo.spaceid = space.cueid
+    return deleteInfo
+  }
+
+  /** CUES */
+  /**
+   * save cues
+   * @method saveCues
+   *
+  */
+  saveCues = async function (cuesInfo) {
+    await this.dbBentocues.put(cuesInfo.cueid, cuesInfo.data)
+    let checkSave = await this.getCues(cuesInfo.cueid)
+    return checkSave
+  }
+
+  /**
+   * get one cue by id
+   * @method getCues
+   *
+  */
+  getCues = async function (key) {
+    const nodeData = await this.dbBentocues.get(key)
+    return nodeData
+  }
+
+  /**
+   * get all cuees
+   * @method getCuesHistory
+   *
+  */
+  getCuesHistory = async function (key) {
+    const cuesHistory = await this.dbBentocues.createReadStream()
+    let cuesData = []
+    for await (const { key, value } of cuesHistory) {
+      cuesData.push({ key, value })
+    }    
+    return cuesData
+  }
+
+  /**
+   * delete nxp ref contract from peer library
+   * @method deleteBentocue
+  */
+  deleteBentocue = async function (cue) {
+    const deleteStatus = await this.dbBentocues.del(cue.cueid)
+    let deleteInfo = {}
+    deleteInfo.spaceid = cue.cueid
+    return deleteInfo
+  }
+
+ /** MEDIA */
+  /**
+   * save media
+   * @method saveMedia
+   *
+  */
+  saveMedia = async function (mediaInfo) {
+    await this.dbBentomedia.put(mediaInfo.cueid, mediaInfo.data)
+    let checkSave = await this.getMedia(mediaInfo.cueid)
+    return checkSave
+  }
+
+  /**
+   * get one cue by id
+   * @method getMedia
+   *
+  */
+  getMedia = async function (key) {
+    const nodeData = await this.dbBentomedia.get(key)
+    return nodeData
+  }
+
+  /**
+   * get all media
+   * @method getMediaHistory
+   *
+  */
+  getMediaHistory = async function (key) {
+    const cuesHistory = await this.dbBentomedia.createReadStream()
+    let cuesData = []
+    for await (const { key, value } of cuesHistory) {
+      cuesData.push({ key, value })
+    }    
+    return cuesData
+  }
+
+
+  /**
+   * delete nxp ref contract from peer library
+   * @method deleteBentomedia
+  */
+  deleteBentomedia = async function (media) {
+    const deleteStatus = await this.dbBentomedia.del(media.id)
+    let deleteInfo = {}
+    deleteInfo.spaceid = media.id
+    return deleteInfo
+  }
+
+  /** PEERS */
+  /**
+   * save research
+   * @method savePeer
+   *
+  */
+  savePeer = async function (peerInfo) {
+    await this.dbPeers.put(peerInfo.publickey, peerInfo)
+    let checkSave = await this.getPeer(peerInfo.publickey)
+    return checkSave
+  }
+
+  /**
+   * get one peer by publickey
+   * @method getPeer
+   *
+  */
+  getPeer = async function (key) {
+    const nodeData = await this.dbPeers.get(key)
+    return nodeData
+  }
+
+  /**
+   * get all peers
+   * @method getPeersHistory
+   *
+  */
+  getPeersHistory = async function (key) {
+    const peerHistory = await this.dbPeers.createReadStream()
+    let peerData = []
+    for await (const { key, value } of peerHistory) {
+      peerData.push({ key, value })
+    }    
+    return peerData
+  }
+
+  /**
+   * delete contract
+   * @method deletePeer
+  */
+  deletePeer = async function (pubkey) {
+    const deleteStatus = await this.dbPeers.del(pubkey)
+    let deleteInfo = {}
+    deleteInfo.publickey = pubkey
+    return deleteInfo
+  }
+  
+
+  /** RESEARCH */
+  /**
+   * save research
+   * @method saveResearch
+   *
+  */
+  saveResearch = async function (cuesInfo) {
+    await this.dbBentoresearch.put(cuesInfo.cueid, cuesInfo.data)
+    let checkSave = await this.getResearch(cuesInfo.cueid)
+    return checkSave
+  }
+
+  /**
+   * get one cue by id
+   * @method getResearch
+   *
+  */
+  getResearch = async function (key) {
+    const nodeData = await this.dbBentoresearch.get(key)
+    return nodeData
+  }
+
+  /**
+   * get all research
+   * @method getResearchHistory
+   *
+  */
+  getResearchHistory = async function (key) {
+    const cuesHistory = await this.dbBentoresearch.createReadStream()
+    let cuesData = []
+    for await (const { key, value } of cuesHistory) {
+      cuesData.push({ key, value })
+    }    
+    return cuesData
+  }
+
+  /**
+   * delete contract
+   * @method deleteBentoResearch
+  */
+  deleteBentoResearch = async function (cue) {
+    const deleteStatus = await this.dbBentoresearch.del(cue.id)
+    let deleteInfo = {}
+    deleteInfo.spaceid = cue.id
+    return deleteInfo
+  }
+
+  /** MARKER */
+  /**
+   * save marker
+   * @method saveMarker
+   *
+  */
+  saveMarker = async function (cuesInfo) {
+    await this.dbBentomarkers.put(cuesInfo.cueid, cuesInfo.data)
+    let checkSave = await this.getMarker(cuesInfo.cueid)
+    return checkSave
+  }
+
+  /**
+   * get one cue by id
+   * @method getMarker
+   *
+  */
+  getMarker = async function (key) {
+    const nodeData = await this.dbBentomarkers.get(key)
+    return nodeData
+  }
+
+  /**
+   * get all research
+   * @method getMarkerHistory
+   *
+  */
+  getMarkerHistory = async function (key) {
+    const cuesHistory = await this.dbBentomarkers.createReadStream()
+    let cuesData = []
+    for await (const { key, value } of cuesHistory) {
+      cuesData.push({ key, value })
+    }    
+    return cuesData
+  }
+
+  /**
+   * delete contract
+   * @method deleteBentoMarker
+  */
+  deleteBentoMarker = async function (cue) {
+    const deleteStatus = await this.dbBentomarkers.del(cue.id)
+    let deleteInfo = {}
+    deleteInfo.spaceid = cue.id
+    return deleteInfo
+  }
+
+  /** Product */
+  /**
+   * save product
+   * @method saveProduct
+   *
+  */
+  saveProduct = async function (cuesInfo) {
+    await this.dbBentoproducts.put(cuesInfo.cueid, cuesInfo.data)
+    let checkSave = await this.getProduct(cuesInfo.cueid)
+    return checkSave
+  }
+
+  /**
+   * get one cue by id
+   * @method getProduct
+   *
+  */
+  getProduct = async function (key) {
+    const nodeData = await this.dbBentoproducts.get(key)
+    return nodeData
+  }
+
+  /**
+   * get all prodcut
+   * @method getProductHistory
+   *
+  */
+  getProductHistory = async function (key) {
+    const cuesHistory = await this.dbBentoproducts.createReadStream()
+    let cuesData = []
+    for await (const { key, value } of cuesHistory) {
+      cuesData.push({ key, value })
+    }
+    return cuesData
+  }
+
+  /**
+   * delete contract
+   * @method deleteBentoProduct
+  */
+  deleteBentoProduct = async function (cue) {
+    const deleteStatus = await this.dbBentoproducts.del(cue.id)
     let deleteInfo = {}
-    deleteInfo.spaceid = space.spaceid
+    deleteInfo.spaceid = cue.id
     return deleteInfo
   }
 

package/src/drive.js

@@ -86,18 +86,9 @@ class HypDrive extends EventEmitter {
    * @method listFilesFolder 
    *
   */
-  listFilesFolder = function (folder) {
-    const stream = this.drive.list('') //  [options])
-    // Handle stream events --> data, end, and error
-    let dataDrive = []
-    stream.on('data', function(chunk) {
-      dataDrive.push(chunk)
-    })
-
-    stream.on('end', function(chunk) {
-      // console.log('stream at end')
-      // console.log(dataDrive)
-    })
+  listFilesFolder = async function (folder) {
+    const stream = await this.drive.list(folder) //  [options])
+    return stream
   }
 
   /**
@@ -222,6 +213,109 @@ class HypDrive extends EventEmitter {
     return hyperdrivePath
   }
 
+
+  /**
+   * save a stream of file ie. large file
+   * @method hyperdriveStreamSave 
+   *
+  */
+  hyperdriveStreamSave = async function (path, data, first) {
+    let ws
+    if (first === true) {
+      // await this.drive.del(path)
+      ws = this.drive.createWriteStream(path)
+      ws.write(data)
+    }
+    // use listener
+    this.on('stream-update', (data) => {
+      ws.write(data)
+    })
+
+    this.on('stream-complete', async (data) => {
+      ws.end()
+      ws.once('close', () => 
+        console.log('stream-close'),
+        await this.checkLargeList(path)
+      )
+    })
+
+  }
+
+  /**
+   * check read the file if save large file
+   * @method checkLargeList
+   *
+  */
+  checkLargeList = async function (path) {
+    let localthis = this
+    let folder = 'test'
+    let folderList = await this.listFilesFolder(folder)
+    let dataDrive = []
+    folderList.on('data', function(chunk) {
+      dataDrive.push(chunk)
+    })
+
+    folderList.on('end', async function() {
+      for (let file of dataDrive) {
+        if (file.key === path) {
+          await localthis.firstLineLargeCSV(path)
+        }
+      }
+    })
+  }
+
+  /**
+   * check read the file if save large file
+   * @method checkLargeSave
+   *
+  */
+  checkLargeSave = async function (path) {
+    const rs = this.drive.createReadStream(path)
+    for await (const chunk of rs) {
+     console.log('rs', chunk.toString()) // => <Buffer ..>
+    }
+  }
+
+  /**
+   * check read the file if save large file
+   * @method firstLineLargeCSV
+   *
+  */
+  firstLineLargeCSV = async function (path) {
+    let readFile = await this.readCSVfileStream(path)
+    let makeString = readFile[0].toString()
+    let csvFormat = makeString.split(/\r?\n/)
+    let headerList = csvFormat[0].split(",");
+    let largeMessage = {}
+    largeMessage.type = 'library'
+    largeMessage.action = 'PUT-stream'
+    largeMessage.task = 'PUT-stream'
+    largeMessage.save = true
+    largeMessage.data = {}
+    largeMessage.data.path = path
+    largeMessage.data.columns = headerList
+    this.emit('largefile-save', largeMessage)
+  }
+
+  /**
+   * stream save update
+   * @method streamSavedata 
+   *
+   */
+  streamSavedata = async function (path, data) {
+    this.emit('stream-update', data)
+  }
+
+  /**
+   * stream save complete
+   * @method streamSaveComplete 
+   *
+   */
+  streamSaveComplete = async function (data) {
+    this.emit('stream-update', data)
+    this.emit('stream-complete', data)
+  }
+
   /**
    * read file nav to folder
    * @method hyperdriveReadfile 
@@ -300,7 +394,6 @@ class HypDrive extends EventEmitter {
   *
   */
   SQLiteQuery = async function (dataInfo) {
-    console.log('HP--DRIVE--sqlite')
      let timestampCol = ''
     // is the sqliite database sill accive?
     // const stream = this.liveDataAPI.DriveFiles.listFilesFolder('sqlite/')
@@ -324,7 +417,6 @@ class HypDrive extends EventEmitter {
       blindData.label = extractLabel
       return blindData
     } else {
-      console.log('no data for that query')
       let blindData = {}
       blindData.data = []
       blindData.label = []
@@ -362,7 +454,7 @@ class HypDrive extends EventEmitter {
     const rs = this.drive.createReadStream(fpath) // 'text/csv/testshed11530500.csv') // '/blob.txt')
     return new Promise((resolve, reject) => {
       const results = []
-      //this.drive.createReadStream(fpath)
+      // this.drive.createReadStream(fpath)
         rs.pipe(csv({ headers: headerSet.headerset, separator: headerSet.delimiter, skipLines: headerSet.dataline }))
         .on('data', (data) => results.push(data))
         .on('end', () => {
@@ -371,6 +463,22 @@ class HypDrive extends EventEmitter {
     })
   }
 
+  /**
+  *  stream out line by line
+  * @method readCSVfileStream
+  *
+  */
+  readCSVfileStream = async function (fpath) {
+    const rs = this.drive.createReadStream(fpath, { start: 0, end: 120 })
+      return new Promise((resolve, reject) => {
+      let results = []
+        rs.on('data', (data) => results.push(data.toString()))
+        rs.on('end', () => {
+          resolve(results)
+        })
+    })
+  }
+
   /**
    * replicate a hyperdrive
    * @method hyperdriveReplicate 

package/src/fileParser.js

@@ -143,7 +143,6 @@ FileParser.prototype.webCSVparse = function (fData) {
 *
 */
 FileParser.prototype.TEMPwebJSONparse = function (fjData) {
-  console.log(fjData)
   let extractLabel = []
   let extractCol = []
   for (let df of fjData.content) {
@@ -315,20 +314,16 @@ FileParser.prototype.convertJSON = function (o, headerSet, results, source, newF
   const datacolumn = o.data[0].info.datename
   const flowList = []
   for (const rs of results) {
-    // console.log(rs)
     let timeLength = 0
     // what length is date number?  Need to make ms time standard to convert
     if (rs[datacolumn].length === 10) {
-      // console.log('not ms time add 000')
       timeLength = rs[datacolumn] * 1000
     } else {
       // console.log('assume ms time ')
       timeLength = rs[datacolumn]
     }
     const dateFormat = new Date(timeLength)
-    // console.log(dateFormat)
     const msDate = dateFormat.getTime()
-    // console.log(msDate)
     rs[datacolumn] = msDate / 1000
     flowList.push(rs)
   }

package/src/index.js

@@ -48,7 +48,7 @@ class HolepunchWorker extends EventEmitter {
     this.store = new Corestore(os.homedir() + '/.hop-storage')
     this.swarm = new Hyperswarm()
     // make replication possible
-    // this.swarm.on('connection', conn => this.store.replicate(conn))
+    this.swarm.on('connection', conn => this.store.replicate(conn))
     goodbye(() => this.swarm.destroy())
     this.BeeData = new BeeWorker(this.store, this.swarm)
     this.DriveFiles = new DriveWorker(this.store, this.swarm)
@@ -76,9 +76,17 @@ class HolepunchWorker extends EventEmitter {
     this.wsocket = ws
     this.BeeData.setWebsocket(ws)
     this.DriveFiles.setWebsocket(ws)
-    this.activateHypercores()
+    // this.activateHypercores()
   }
 
+  /**
+   * active hypercores auth verified
+   * @method startStores
+   *
+  */
+  startStores = function (ws) {
+    this.activateHypercores()
+  }
 
   /**
   * listen for outputs from workers
@@ -89,46 +97,62 @@ class HolepunchWorker extends EventEmitter {
     this.Peers.on('peer-network', (data) => {
       this.wsocket.send(JSON.stringify(data))
     })
-    // peer connection active
+    // 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)
-      if (holderCheck !== 0 && taskCheck === 0) {
-        this.Peers.writeToPublicLibrary(data)
-      } else {
-        this.Peers.writeTonetwork(data)
-      }
-
+     //this.warmPeerPrepare(data)
+    })
+    // share connection failed
+    this.Peers.on('peer-share-fail', (data) => {
+      let peerFail = {}
+      peerFail.type = 'account'
+      peerFail.action = 'peer-share-fail'
+      peerFail.data = { publickey: data }
+      this.wsocket.send(JSON.stringify(peerFail))
+    })
+    // save peer topic
+    this.Peers.on('peer-topic-save', async (data) => {
+      await this.emit('peer-topic-save', data)    
+    })
+    // peer reconnection topic ie. able to reconnect again
+    this.Peers.on('peer-reconnect-topic', (data) => {
+      this.emit('peer-reconnect-topic', data)
     })
     // data for beebee
     this.Peers.on('beebee-data', (data) => {
       this.emit('peer-topeer', data)
     })
+    // cue space share
+    this.Peers.on('cuespace-notification', (data) => {
+      this.emit('peer-cuespace', data)
+    })
     // public library notification
     this.Peers.on('publiclibrarynotification', (data) => {
       this.BeeData.replicatePubliclibrary(data)
     })
+    // beebee notifications public
     this.BeeData.on('publibbeebee-notification', (data) => {
       this.emit('beebee-publib-notification', data)
     })
     // new warm incoming peer
-    this.Peers.on('connect-warm', (data) => {
+    this.Peers.on('connect-warm-first', (data) => {
+      let peerInfo = this.Peers.peerHolder[data]
+      if (peerInfo === undefined) {
+        // receiving peer
+        peerInfo = { name: 'peernew'}
+      }
       let peerId = {}
-      peerId.name = 'new-peer'
+      peerId.name = peerInfo.name
       peerId.publickey = data
-      peerId.datastore = ''
+      peerId.longterm = true
+      peerId.settopic = false
+      peerId.topic = ''
+      peerId.live = false
       this.warmPeers.push(peerId)
-      this.emit('peer-incoming', peerId)
+      this.emit('peer-incoming-save', peerId)
+    })
+    // drive listener
+    this.DriveFiles.on('largefile-save', (data) => {
+      this.emit('drive-save-large', data)
     })
   }
 
@@ -146,16 +170,22 @@ class HolepunchWorker extends EventEmitter {
           peerMatch = true
         }
       }
-      
-      if (message.task === 'peer-join') {
+      if (message.task === 'peer-share-invite') {
+        // keep track of role, reciving or extended invite
+        this.Peers.setRole(message.data.publickey)
         if (peerMatch === true) {
           this.Peers.peerAlreadyJoinSetData(message.data)
-          this.Peers.writeTonetwork(message.data.publickey)
+          // this.Peers.writeTonetwork(message.data.publickey)
+          this.warmPeerPrepare(message.data.publickey, true)
         } else {
           this.warmPeers.push(message.data)
+          this.Peers.peerAlreadyJoinSetData(message.data)
           this.Peers.peerJoin(message.data)
         }
-      } else if (message.task === 'peer-board') {
+      } else if (message.task === 'peer-share-topic') {
+        // existing peers reconnecting via topic
+        this.Peers.topicConnect(message.data)
+      } else if (message.task === 'public-n1-experiment') {
         if (peerMatch === true) {
          this.Peers.peerAlreadyJoinSetData(message.data)
          this.Peers.writeToPublicLibrary(message.data.publickey)
@@ -166,6 +196,16 @@ class HolepunchWorker extends EventEmitter {
           this.Peers.peerAlreadyJoinSetData(message.data)
           this.Peers.writeToPublicLibrary(message.data.publickey)
         }
+      } else if (message.task = 'cue-space') {
+        if (peerMatch === true) {
+          this.Peers.peerAlreadyJoinSetData(message.data)
+          this.Peers.writeToCueSpace(message.data.publickey)
+        } else {
+          this.warmPeers.push(message.data)
+          this.Peers.peerJoin(message.data)
+          // this.Peers.peerAlreadyJoinSetData(message.data)
+          // this.Peers.writeToCueSpace(message.data.publickey)
+        }
       } else if (message.task === 'peer-write') {
         this.emit('peer-write', message.data)
       } else if (message.task === 'topic') {
@@ -174,6 +214,44 @@ class HolepunchWorker extends EventEmitter {
     }
   }
 
+
+  /**
+   * prepare data to send to a warm peer
+   * @method warmPeerPrepare
+   */
+  warmPeerPrepare = function (data, existing) {
+    // two checks, if topic send to other peer
+    if (existing !== true) {
+      let peerRole = this.Peers.peersRole[data]
+      if (peerRole === undefined) {
+        this.Peers.writeTonetworkTopic(data)
+      } else {
+        console.log(' this peer set the topic')
+      }
+    }
+    // if data within coming then process that
+    let peerDataExist = this.Peers.peerHolder[data]
+    if (peerDataExist === undefined) {
+    } else {
+      // what type of data being shared?
+      // check for data along with new peer?
+      if (peerDataExist.data !== undefined) {
+        if (peerDataExist.data.type === 'private-chart') {
+          this.Peers.writeTonetworkData(data, peerDataExist.data)
+        } else if (peerDataExist.data.type === 'private-cue-space') {
+          this.Peers.writeToCueSpace(this.Peers.peerHolder[peerFirstID].publickey)
+        } else if (peerDataExist.data.type === 'public-n1-experiment') {
+          this.Peers.writeTonetworkData(data, peerDataExist.data)
+        } else if (peerDataExist.data.type === 'public-library') {
+          this.Peers.writeToPublicLibrary(data)
+        } else if (peerDataExist.data.type === 'text-message') {
+          // simpole text message
+          this.Peers.writeTonetwork(data)
+        }
+      }
+    }
+  }
+
   /**
    * corestore test example
    * @method testCorestore

package/src/peers.js

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

package/test/large-csv.test.js

@@ -0,0 +1,9 @@
+import assert from 'assert'
+import HolepunchData from '../src/index.js'
+// need helpers prepare input to HP via (mock) HOP
+
+describe('upload a large csv in chunks', function () {
+  it('read in file', async function () {
+    let dataAPI = new HolepunchData()
+  })
+})