@leofcoin/peernet 0.11.18 → 0.11.21

package/dist/browser/peernet.js

@@ -287,6 +287,8 @@ const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry
   });
 };
 
+const messageQue = {};
+
 class Peer {
   #connection
   #ready = false
@@ -305,6 +307,7 @@ class Peer {
   #iceCompleteTimer
   #channel
   #peerId
+  #chunkSize = 16384
 
   get connection() {
     return this.#connection
@@ -322,7 +325,7 @@ class Peer {
  * @params {Object} options
  * @params {string} options.channelName - this peerid : otherpeer id
  */
-constructor(options = {}) {
+ constructor(options = {}) {
     this._in = this._in.bind(this);
     this.offerOptions = options.offerOptions;
     this.initiator = options.initiator;
@@ -356,29 +359,51 @@ constructor(options = {}) {
      return this._socketClient
    }
 
-   send(message) {
-     switch (this.channel?.readyState) {
-       case 'open':
-        this.bw.up += message.length || message.byteLength;
-        this.channel.send(message);
-       break;
-       case 'closed':
-       case 'closing':
-        debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
-       break;
-       case undefined:
-       debug(`trying to send before a channel is created`);
-       break;
-     }
+   splitMessage(message) {
+     const chunks = [];
+     const size = message.byteLength || message.length;
+     let offset = 0;
+     return new Promise((resolve, reject) => {
+       const splitMessage = () => {
+         const chunk = message.slice(offset, offset + this.#chunkSize > size ? size : offset + this.#chunkSize);
+         offset += offset + this.#chunkSize;
+         chunks.push(chunk);
+         if (offset < size) return splitMessage()
+         else resolve({chunks, size});
+       };
+
+       splitMessage();
+     })
+   }
+
+   async send(message, id) {
+     const { chunks, size } = await this.splitMessage(message);
+     let offset = 0;
+     for (const chunk of chunks) {
+        const start = offset;
+        const end = offset + chunk.length;
+        const message = new TextEncoder().encode(JSON.stringify({ size, id, chunk, start, end }));
+        switch (this.channel?.readyState) {
+          case 'open':
+           this.bw.up += message.length || message.byteLength;
+           this.channel.send(message);
+          break;
+          case 'closed':
+          case 'closing':
+           debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
+          break;
+          case undefined:
+          debug(`trying to send before a channel is created`);
+          break;
+        }
+      }
    }
 
    request(data) {
     return new Promise((resolve, reject) => {
       const id = Math.random().toString(36).slice(-12);
-      // TODO: get rid of JSON
-      data = new TextEncoder().encode(JSON.stringify({id, data}));
+
       const _onData = message => {
-        message = JSON.parse(new TextDecoder().decode(message.data));
         if (message.id === id) {
           resolve(message.data);
           pubsub.unsubscribe(`peer:data`, _onData);
@@ -392,8 +417,8 @@ constructor(options = {}) {
       //   pubsub.unsubscribe(`peer:data-request-${id}`, _onData)
       // }, 5000);
 
-      this.send(data);
-    });
+      this.send(data, id);
+    })
   }
 
    async #init() {
@@ -403,6 +428,7 @@ constructor(options = {}) {
        }];
 
        this.#connection = new wrtc.RTCPeerConnection();
+
        this.#connection.onicecandidate = ({ candidate }) => {
          if (candidate) {
            this.address = candidate.address;
@@ -422,10 +448,7 @@ constructor(options = {}) {
          message.channel.onclose = () => this.close.bind(this);
 
          message.channel.onmessage = (message) => {
-           pubsub.publish('peer:data', message);
-           debug(`incoming message from ${this.id}`);
-           debug(message);
-           this.bw.down += message.length || message.byteLength;
+           this._handleMessage(this.id, message);
          };
          this.channel = message.channel;
        };
@@ -440,23 +463,41 @@ constructor(options = {}) {
         this.channel.onclose = () => this.close.bind(this);
 
         this.channel.onmessage = (message) => {
-          pubsub.publish('peer:data', message);
-          debug(`incoming message from ${this.peerId}`);
-          this.bw.down += message.length || message.byteLength;
+          this._handleMessage(this.peerId, message);
         };
 
        const offer = await this.#connection.createOffer();
        await this.#connection.setLocalDescription(offer);
 
        this._sendMessage({'sdp': this.#connection.localDescription});
-      }
-       // }
-
+     }
      } catch (e) {
        console.log(e);
      }
    }
 
+   _handleMessage(peerId, message) {
+     debug(`incoming message from ${peerId}`);
+
+     message = JSON.parse(new TextDecoder().decode(message.data));
+     // allow sharding (multiple peers share data)
+     pubsub.publish('peernet:shard', message);
+     if (!messageQue[message.id]) messageQue[message.id] = [];
+
+     if (message.size > messageQue[message.id].length || message.size === messageQue[message.id].length) {
+       for (const value of Object.values(message.chunk)) {
+         messageQue[message.id].push(value);
+       }
+     }
+
+     if (message.size === messageQue[message.id].length) {
+       pubsub.publish('peer:data', {id: message.id, data: new Uint8Array(Object.values(messageQue[message.id]))});
+       delete messageQue[message.id];
+     }
+     this.bw.down += message.byteLength || message.length;
+
+   }
+
    _sendMessage(message) {
      this.socketClient.send({url: 'signal', params: {
        to: this.to,
@@ -618,7 +659,8 @@ class Client {
     debug(`star ${id} left`);
   }
 
-  peerLeft(id) {
+  peerLeft(peer) {
+    const id = peer.peerId || peer;
     if (this.#connections[id]) {
       this.#connections[id].close();
       delete this.#connections[id];
@@ -626,7 +668,8 @@ class Client {
     debug(`peer ${id} left`);
   }
 
-  peerJoined(id, signal) {
+  peerJoined(peer, signal) {
+    const id = peer.peerId || peer;
     if (this.#connections[id]) {
       if (this.#connections[id].connected) this.#connections[id].close();
       delete this.#connections[id];
@@ -2259,6 +2302,18 @@ class MessageHandler {
   }
 }
 
+const dataHandler = async message => {
+  if (!message) return
+
+  const {data, id} = message;
+
+  message = protoFor(data);
+  const proto = protoFor(message.decoded.data);
+  const from = message.decoded.from;
+
+  peernet._protoHandler({id, proto}, peernet.client.connections[from], from);
+};
+
 const encapsulatedError = () => {
   return new Error('Nodes/Data should be send encapsulated by peernet-message')
 };
@@ -2468,19 +2523,11 @@ class Peernet {
       // })
     });
 
-    pubsub.subscribe('peer:data', async message => {
-      if (!message.data) return
-      const {id, data} = JSON.parse(new TextDecoder().decode(message.data));
-      const uint8Array = new Uint8Array(Object.keys(data).length);
-      for (var i = 0; i < Object.keys(data).length; i++) {
-        uint8Array[i] = data[i];
-      }
-      message = new PeernetMessage(uint8Array);
-      const proto = protoFor(message.decoded.data);
-
-      const from = message.decoded.from;
-      this._protoHandler({id, proto}, this.client.connections[from], from);
-    });
+    /**
+     * converts data -> message -> proto
+     * @see DataHandler
+     */
+    pubsub.subscribe('peer:data', dataHandler);
 
     /**
      * @access public
@@ -2499,11 +2546,9 @@ class Peernet {
 
   sendMessage(peer, id, data) {
     if (peer.readyState === 'open') {
-      peer.send(new TextEncoder().encode(JSON.stringify({id, data})));
+      peer.send(data, id);
       this.bw.up += data.length;
-    } else if (peer.readyState === 'closed') {
-      this.removePeer(peer);
-    }
+    } else if (peer.readyState === 'closed') ;
 
   }
 

package/dist/commonjs/{http-6c848a1e.js → http-62c5b155.js}

@@ -10,7 +10,7 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var PubSub__default = /*#__PURE__*/_interopDefaultLegacy(PubSub);
 var Koa__default = /*#__PURE__*/_interopDefaultLegacy(Koa);
 
-var version = "0.11.17";
+var version = "0.11.19";
 
 var api$1 = {
   version: ({send}) => send({client: '@peernet/api/http', version}),

package/dist/commonjs/peernet.js

@@ -285,6 +285,8 @@ const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry
   });
 };
 
+const messageQue = {};
+
 class Peer {
   #connection
   #ready = false
@@ -303,6 +305,7 @@ class Peer {
   #iceCompleteTimer
   #channel
   #peerId
+  #chunkSize = 16384
 
   get connection() {
     return this.#connection
@@ -320,7 +323,7 @@ class Peer {
  * @params {Object} options
  * @params {string} options.channelName - this peerid : otherpeer id
  */
-constructor(options = {}) {
+ constructor(options = {}) {
     this._in = this._in.bind(this);
     this.offerOptions = options.offerOptions;
     this.initiator = options.initiator;
@@ -354,29 +357,51 @@ constructor(options = {}) {
      return this._socketClient
    }
 
-   send(message) {
-     switch (this.channel?.readyState) {
-       case 'open':
-        this.bw.up += message.length || message.byteLength;
-        this.channel.send(message);
-       break;
-       case 'closed':
-       case 'closing':
-        debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
-       break;
-       case undefined:
-       debug(`trying to send before a channel is created`);
-       break;
-     }
+   splitMessage(message) {
+     const chunks = [];
+     const size = message.byteLength || message.length;
+     let offset = 0;
+     return new Promise((resolve, reject) => {
+       const splitMessage = () => {
+         const chunk = message.slice(offset, offset + this.#chunkSize > size ? size : offset + this.#chunkSize);
+         offset += offset + this.#chunkSize;
+         chunks.push(chunk);
+         if (offset < size) return splitMessage()
+         else resolve({chunks, size});
+       };
+
+       splitMessage();
+     })
+   }
+
+   async send(message, id) {
+     const { chunks, size } = await this.splitMessage(message);
+     let offset = 0;
+     for (const chunk of chunks) {
+        const start = offset;
+        const end = offset + chunk.length;
+        const message = new TextEncoder().encode(JSON.stringify({ size, id, chunk, start, end }));
+        switch (this.channel?.readyState) {
+          case 'open':
+           this.bw.up += message.length || message.byteLength;
+           this.channel.send(message);
+          break;
+          case 'closed':
+          case 'closing':
+           debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
+          break;
+          case undefined:
+          debug(`trying to send before a channel is created`);
+          break;
+        }
+      }
    }
 
    request(data) {
     return new Promise((resolve, reject) => {
       const id = Math.random().toString(36).slice(-12);
-      // TODO: get rid of JSON
-      data = new TextEncoder().encode(JSON.stringify({id, data}));
+
       const _onData = message => {
-        message = JSON.parse(new TextDecoder().decode(message.data));
         if (message.id === id) {
           resolve(message.data);
           pubsub.unsubscribe(`peer:data`, _onData);
@@ -390,8 +415,8 @@ constructor(options = {}) {
       //   pubsub.unsubscribe(`peer:data-request-${id}`, _onData)
       // }, 5000);
 
-      this.send(data);
-    });
+      this.send(data, id);
+    })
   }
 
    async #init() {
@@ -401,6 +426,7 @@ constructor(options = {}) {
        }];
 
        this.#connection = new wrtc.RTCPeerConnection();
+
        this.#connection.onicecandidate = ({ candidate }) => {
          if (candidate) {
            this.address = candidate.address;
@@ -420,10 +446,7 @@ constructor(options = {}) {
          message.channel.onclose = () => this.close.bind(this);
 
          message.channel.onmessage = (message) => {
-           pubsub.publish('peer:data', message);
-           debug(`incoming message from ${this.id}`);
-           debug(message);
-           this.bw.down += message.length || message.byteLength;
+           this._handleMessage(this.id, message);
          };
          this.channel = message.channel;
        };
@@ -438,23 +461,41 @@ constructor(options = {}) {
         this.channel.onclose = () => this.close.bind(this);
 
         this.channel.onmessage = (message) => {
-          pubsub.publish('peer:data', message);
-          debug(`incoming message from ${this.peerId}`);
-          this.bw.down += message.length || message.byteLength;
+          this._handleMessage(this.peerId, message);
         };
 
        const offer = await this.#connection.createOffer();
        await this.#connection.setLocalDescription(offer);
 
        this._sendMessage({'sdp': this.#connection.localDescription});
-      }
-       // }
-
+     }
      } catch (e) {
        console.log(e);
      }
    }
 
+   _handleMessage(peerId, message) {
+     debug(`incoming message from ${peerId}`);
+
+     message = JSON.parse(new TextDecoder().decode(message.data));
+     // allow sharding (multiple peers share data)
+     pubsub.publish('peernet:shard', message);
+     if (!messageQue[message.id]) messageQue[message.id] = [];
+
+     if (message.size > messageQue[message.id].length || message.size === messageQue[message.id].length) {
+       for (const value of Object.values(message.chunk)) {
+         messageQue[message.id].push(value);
+       }
+     }
+
+     if (message.size === messageQue[message.id].length) {
+       pubsub.publish('peer:data', {id: message.id, data: new Uint8Array(Object.values(messageQue[message.id]))});
+       delete messageQue[message.id];
+     }
+     this.bw.down += message.byteLength || message.length;
+
+   }
+
    _sendMessage(message) {
      this.socketClient.send({url: 'signal', params: {
        to: this.to,
@@ -616,7 +657,8 @@ class Client {
     debug(`star ${id} left`);
   }
 
-  peerLeft(id) {
+  peerLeft(peer) {
+    const id = peer.peerId || peer;
     if (this.#connections[id]) {
       this.#connections[id].close();
       delete this.#connections[id];
@@ -624,7 +666,8 @@ class Client {
     debug(`peer ${id} left`);
   }
 
-  peerJoined(id, signal) {
+  peerJoined(peer, signal) {
+    const id = peer.peerId || peer;
     if (this.#connections[id]) {
       if (this.#connections[id].connected) this.#connections[id].close();
       delete this.#connections[id];
@@ -1617,6 +1660,18 @@ class MessageHandler {
   }
 }
 
+const dataHandler = async message => {
+  if (!message) return
+
+  const {data, id} = message;
+
+  message = protoFor(data);
+  const proto = protoFor(message.decoded.data);
+  const from = message.decoded.from;
+
+  peernet._protoHandler({id, proto}, peernet.client.connections[from], from);
+};
+
 const encapsulatedError = () => {
   return new Error('Nodes/Data should be send encapsulated by peernet-message')
 };
@@ -1795,7 +1850,7 @@ class Peernet {
 					protocol: 'peernet-v0.1.0', host: '127.0.0.1', port: options.port
 				});
 			} else {
-				const http = await Promise.resolve().then(function () { return require('./http-6c848a1e.js'); });
+				const http = await Promise.resolve().then(function () { return require('./http-62c5b155.js'); });
 	      if (environment !== 'browser') http.default(options);
 	    }
 
@@ -1834,19 +1889,11 @@ class Peernet {
       // })
     });
 
-    pubsub.subscribe('peer:data', async message => {
-      if (!message.data) return
-      const {id, data} = JSON.parse(new TextDecoder().decode(message.data));
-      const uint8Array = new Uint8Array(Object.keys(data).length);
-      for (var i = 0; i < Object.keys(data).length; i++) {
-        uint8Array[i] = data[i];
-      }
-      message = new peernetMessage(uint8Array);
-      const proto = protoFor(message.decoded.data);
-
-      const from = message.decoded.from;
-      this._protoHandler({id, proto}, this.client.connections[from], from);
-    });
+    /**
+     * converts data -> message -> proto
+     * @see DataHandler
+     */
+    pubsub.subscribe('peer:data', dataHandler);
 
     /**
      * @access public
@@ -1865,11 +1912,9 @@ class Peernet {
 
   sendMessage(peer, id, data) {
     if (peer.readyState === 'open') {
-      peer.send(new TextEncoder().encode(JSON.stringify({id, data})));
+      peer.send(data, id);
       this.bw.up += data.length;
-    } else if (peer.readyState === 'closed') {
-      this.removePeer(peer);
-    }
+    } else if (peer.readyState === 'closed') ;
 
   }
 

package/dist/module/peernet.js

@@ -241,6 +241,8 @@ const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry
   });
 };
 
+const messageQue = {};
+
 class Peer {
   #connection
   #ready = false
@@ -259,6 +261,7 @@ class Peer {
   #iceCompleteTimer
   #channel
   #peerId
+  #chunkSize = 16384
 
   get connection() {
     return this.#connection
@@ -276,7 +279,7 @@ class Peer {
  * @params {Object} options
  * @params {string} options.channelName - this peerid : otherpeer id
  */
-constructor(options = {}) {
+ constructor(options = {}) {
     this._in = this._in.bind(this);
     this.offerOptions = options.offerOptions;
     this.initiator = options.initiator;
@@ -310,29 +313,51 @@ constructor(options = {}) {
      return this._socketClient
    }
 
-   send(message) {
-     switch (this.channel?.readyState) {
-       case 'open':
-        this.bw.up += message.length || message.byteLength;
-        this.channel.send(message);
-       break;
-       case 'closed':
-       case 'closing':
-        debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
-       break;
-       case undefined:
-       debug(`trying to send before a channel is created`);
-       break;
-     }
+   splitMessage(message) {
+     const chunks = [];
+     const size = message.byteLength || message.length;
+     let offset = 0;
+     return new Promise((resolve, reject) => {
+       const splitMessage = () => {
+         const chunk = message.slice(offset, offset + this.#chunkSize > size ? size : offset + this.#chunkSize);
+         offset += offset + this.#chunkSize;
+         chunks.push(chunk);
+         if (offset < size) return splitMessage()
+         else resolve({chunks, size});
+       };
+
+       splitMessage();
+     })
+   }
+
+   async send(message, id) {
+     const { chunks, size } = await this.splitMessage(message);
+     let offset = 0;
+     for (const chunk of chunks) {
+        const start = offset;
+        const end = offset + chunk.length;
+        const message = new TextEncoder().encode(JSON.stringify({ size, id, chunk, start, end }));
+        switch (this.channel?.readyState) {
+          case 'open':
+           this.bw.up += message.length || message.byteLength;
+           this.channel.send(message);
+          break;
+          case 'closed':
+          case 'closing':
+           debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
+          break;
+          case undefined:
+          debug(`trying to send before a channel is created`);
+          break;
+        }
+      }
    }
 
    request(data) {
     return new Promise((resolve, reject) => {
       const id = Math.random().toString(36).slice(-12);
-      // TODO: get rid of JSON
-      data = new TextEncoder().encode(JSON.stringify({id, data}));
+
       const _onData = message => {
-        message = JSON.parse(new TextDecoder().decode(message.data));
         if (message.id === id) {
           resolve(message.data);
           pubsub.unsubscribe(`peer:data`, _onData);
@@ -346,8 +371,8 @@ constructor(options = {}) {
       //   pubsub.unsubscribe(`peer:data-request-${id}`, _onData)
       // }, 5000);
 
-      this.send(data);
-    });
+      this.send(data, id);
+    })
   }
 
    async #init() {
@@ -357,6 +382,7 @@ constructor(options = {}) {
        }];
 
        this.#connection = new wrtc.RTCPeerConnection();
+
        this.#connection.onicecandidate = ({ candidate }) => {
          if (candidate) {
            this.address = candidate.address;
@@ -376,10 +402,7 @@ constructor(options = {}) {
          message.channel.onclose = () => this.close.bind(this);
 
          message.channel.onmessage = (message) => {
-           pubsub.publish('peer:data', message);
-           debug(`incoming message from ${this.id}`);
-           debug(message);
-           this.bw.down += message.length || message.byteLength;
+           this._handleMessage(this.id, message);
          };
          this.channel = message.channel;
        };
@@ -394,23 +417,41 @@ constructor(options = {}) {
         this.channel.onclose = () => this.close.bind(this);
 
         this.channel.onmessage = (message) => {
-          pubsub.publish('peer:data', message);
-          debug(`incoming message from ${this.peerId}`);
-          this.bw.down += message.length || message.byteLength;
+          this._handleMessage(this.peerId, message);
         };
 
        const offer = await this.#connection.createOffer();
        await this.#connection.setLocalDescription(offer);
 
        this._sendMessage({'sdp': this.#connection.localDescription});
-      }
-       // }
-
+     }
      } catch (e) {
        console.log(e);
      }
    }
 
+   _handleMessage(peerId, message) {
+     debug(`incoming message from ${peerId}`);
+
+     message = JSON.parse(new TextDecoder().decode(message.data));
+     // allow sharding (multiple peers share data)
+     pubsub.publish('peernet:shard', message);
+     if (!messageQue[message.id]) messageQue[message.id] = [];
+
+     if (message.size > messageQue[message.id].length || message.size === messageQue[message.id].length) {
+       for (const value of Object.values(message.chunk)) {
+         messageQue[message.id].push(value);
+       }
+     }
+
+     if (message.size === messageQue[message.id].length) {
+       pubsub.publish('peer:data', {id: message.id, data: new Uint8Array(Object.values(messageQue[message.id]))});
+       delete messageQue[message.id];
+     }
+     this.bw.down += message.byteLength || message.length;
+
+   }
+
    _sendMessage(message) {
      this.socketClient.send({url: 'signal', params: {
        to: this.to,
@@ -572,7 +613,8 @@ class Client {
     debug(`star ${id} left`);
   }
 
-  peerLeft(id) {
+  peerLeft(peer) {
+    const id = peer.peerId || peer;
     if (this.#connections[id]) {
       this.#connections[id].close();
       delete this.#connections[id];
@@ -580,7 +622,8 @@ class Client {
     debug(`peer ${id} left`);
   }
 
-  peerJoined(id, signal) {
+  peerJoined(peer, signal) {
+    const id = peer.peerId || peer;
     if (this.#connections[id]) {
       if (this.#connections[id].connected) this.#connections[id].close();
       delete this.#connections[id];
@@ -2213,6 +2256,18 @@ class MessageHandler {
   }
 }
 
+const dataHandler = async message => {
+  if (!message) return
+
+  const {data, id} = message;
+
+  message = protoFor(data);
+  const proto = protoFor(message.decoded.data);
+  const from = message.decoded.from;
+
+  peernet._protoHandler({id, proto}, peernet.client.connections[from], from);
+};
+
 const encapsulatedError = () => {
   return new Error('Nodes/Data should be send encapsulated by peernet-message')
 };
@@ -2422,19 +2477,11 @@ class Peernet {
       // })
     });
 
-    pubsub.subscribe('peer:data', async message => {
-      if (!message.data) return
-      const {id, data} = JSON.parse(new TextDecoder().decode(message.data));
-      const uint8Array = new Uint8Array(Object.keys(data).length);
-      for (var i = 0; i < Object.keys(data).length; i++) {
-        uint8Array[i] = data[i];
-      }
-      message = new PeernetMessage(uint8Array);
-      const proto = protoFor(message.decoded.data);
-
-      const from = message.decoded.from;
-      this._protoHandler({id, proto}, this.client.connections[from], from);
-    });
+    /**
+     * converts data -> message -> proto
+     * @see DataHandler
+     */
+    pubsub.subscribe('peer:data', dataHandler);
 
     /**
      * @access public
@@ -2453,11 +2500,9 @@ class Peernet {
 
   sendMessage(peer, id, data) {
     if (peer.readyState === 'open') {
-      peer.send(new TextEncoder().encode(JSON.stringify({id, data})));
+      peer.send(data, id);
       this.bw.up += data.length;
-    } else if (peer.readyState === 'closed') {
-      this.removePeer(peer);
-    }
+    } else if (peer.readyState === 'closed') ;
 
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "0.11.18",
+  "version": "0.11.21",
   "description": "",
   "main": "dist/commonjs/peernet.js",
   "module": "dist/module/peernet.js",
@@ -25,7 +25,7 @@
   "dependencies": {
     "@leofcoin/generate-account": "^1.0.2",
     "@leofcoin/multi-wallet": "^2.1.2",
-    "@leofcoin/peernet-swarm": "^0.1.17",
+    "@leofcoin/peernet-swarm": "^0.1.21",
     "@leofcoin/storage": "^2.3.0",
     "@vandeurenglenn/base32": "^1.1.0",
     "@vandeurenglenn/base58": "^1.1.0",

package/src/handlers/data.js

@@ -0,0 +1,15 @@
+import { protoFor } from './../utils/utils.js'
+
+const dataHandler = async message => {
+  if (!message) return
+
+  const {data, id} = message
+
+  message = protoFor(data)
+  const proto = protoFor(message.decoded.data)
+  const from = message.decoded.from
+
+  peernet._protoHandler({id, proto}, peernet.client.connections[from], from)
+}
+
+export default dataHandler

package/src/peernet.js

@@ -20,6 +20,7 @@ import codecs from './codec/codecs'
 import { protoFor, target } from './utils/utils.js'
 import generateAccount from './../node_modules/@leofcoin/generate-account/dist/module/generate-account'
 import MessageHandler from './handlers/message.js'
+import dataHandler from './handlers/data.js'
 import { encapsulatedError, dhtError,
   nothingFoundError } from './errors/errors.js'
 
@@ -220,19 +221,11 @@ export default class Peernet {
       // })
     })
 
-    pubsub.subscribe('peer:data', async message => {
-      if (!message.data) return
-      const {id, data} = JSON.parse(new TextDecoder().decode(message.data))
-      const uint8Array = new Uint8Array(Object.keys(data).length)
-      for (var i = 0; i < Object.keys(data).length; i++) {
-        uint8Array[i] = data[i]
-      }
-      message = new PeernetMessage(uint8Array)
-      const proto = protoFor(message.decoded.data)
-
-      const from = message.decoded.from
-      this._protoHandler({id, proto}, this.client.connections[from], from)
-    })
+    /**
+     * converts data -> message -> proto
+     * @see DataHandler
+     */
+    pubsub.subscribe('peer:data', dataHandler)
 
     /**
      * @access public
@@ -251,10 +244,10 @@ export default class Peernet {
 
   sendMessage(peer, id, data) {
     if (peer.readyState === 'open') {
-      peer.send(new TextEncoder().encode(JSON.stringify({id, data})))
+      peer.send(data, id)
       this.bw.up += data.length
     } else if (peer.readyState === 'closed') {
-      this.removePeer(peer)
+      // this.removePeer(peer)
     }
 
   }