@leofcoin/chain 1.7.109 → 1.7.111

package/exports/browser/{client-UwSHOtRi-BsddY8I0.js → client-DgmVTCEc-WVRX01s7.js}

@@ -1,4 +1,4 @@
-import { L as LittlePubSub } from './node-browser-DPfaEz6Y.js';
+import { L as LittlePubSub } from './node-browser-Dk2CzshW.js';
 import './identity-Cn0iQbY3-CeW0giQS.js';
 import './index-DUfUgiQY.js';
 
@@ -132,10 +132,9 @@ class Api {
                     throw e;
                 }
             },
-            peers: async (params) => {
+            peers: async () => {
                 try {
-                    params.peers = true;
-                    const requested = { url: 'peernet', params };
+                    const requested = { url: 'peernet', params: { peers: true } };
                     const { result, id, handler } = await this.request(client, requested);
                     this.unsubscribe(id, handler);
                     return result;
@@ -206,7 +205,7 @@ class SocketRequestClient {
     clientConnection;
     #tries = 0;
     #retry = false;
-    #timeout = 10000;
+    #timeout = 10_000;
     #times = 10;
     #options;
     #protocol;
@@ -673,7 +672,7 @@ class Client {
         }
         this.#createRTCPeerConnection(peerId, star, this.version, initiator);
     }
-    reconnect(peerId, star, initiator = true) {
+    reconnect(peerId, star, initiator = false) {
         delete this.#connections[peerId];
         debug(`reconnecting to peer ${peerId}`);
         return this.connect(peerId, star, initiator);
@@ -728,6 +727,7 @@ class Client {
             // // // Create a new peer connection with the correct configuration
             // this.#createRTCPeerConnection(from, star, version, false)
             // peer = this.#connections[from]
+            return;
         }
         peer.signal(signal);
     };

package/exports/browser/messages-Bx4w-Pqo-DSXPMvjy.js

@@ -0,0 +1,206 @@
+import { F as FormatInterface } from './node-browser-Dk2CzshW.js';
+import './identity-Cn0iQbY3-CeW0giQS.js';
+import './index-DUfUgiQY.js';
+
+var proto$b = {
+    data: new Uint8Array(),
+    signature: new Uint8Array(),
+    'from?': String(),
+    'to?': String(),
+    'id?': String()
+};
+
+class PeernetMessage extends FormatInterface {
+    get messageName() {
+        return 'PeernetMessage';
+    }
+    constructor(buffer) {
+        const name = 'peernet-message';
+        super(buffer, proto$b, { name });
+    }
+}
+
+var proto$a = {
+    hash: String(),
+    'store?': String()
+};
+
+/**
+ * @example `
+   new DHTMessage(hash, store)
+   // store = optional if not set, peernet checks every store
+   let message = new DHTMessage('hashmvbs124xcfd...', 'transaction')
+   message = new DHTMessage('hashmvbs124xcfd...', 'block')
+ `
+ */
+class DHTMessage extends FormatInterface {
+    get messageName() {
+        return 'PeernetDHTMessage';
+    }
+    constructor(data) {
+        const name = 'peernet-dht';
+        super(data, proto$a, { name });
+    }
+}
+
+var proto$9 = {
+    hash: String(),
+    has: Boolean()
+};
+
+class DHTMessageResponse extends FormatInterface {
+    get messageName() {
+        return 'PeernetDHTMessageResponse';
+    }
+    constructor(data) {
+        const name = 'peernet-dht-response';
+        super(data, proto$9, { name });
+    }
+}
+
+var proto$8 = {
+    hash: String(),
+    'store?': String()
+};
+
+/**
+ * @extends {CodecFormat}
+ */
+class DataMessage extends FormatInterface {
+    get messageName() {
+        return 'PeernetDataMessage';
+    }
+    /**
+     * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
+     */
+    constructor(data) {
+        super(data, proto$8, { name: 'peernet-data' });
+    }
+}
+
+var proto$7 = {
+    data: new Uint8Array(),
+    topic: new Uint8Array()
+};
+
+class PsMessage extends FormatInterface {
+    get messageName() {
+        return 'PsMessage';
+    }
+    constructor(buffer) {
+        const name = 'peernet-ps';
+        super(buffer, proto$7, { name });
+    }
+}
+
+var proto$6 = {
+    id: String()
+};
+
+class PeerMessage extends FormatInterface {
+    get messageName() {
+        return 'PeernetPeerMessage';
+    }
+    constructor(data) {
+        const name = 'peernet-peer';
+        super(data, proto$6, { name });
+    }
+}
+
+var proto$5 = {
+    request: String(),
+    'requested?': new Uint8Array()
+};
+
+class RequestMessage extends FormatInterface {
+    get messageName() {
+        return 'PeernetRequestMessage';
+    }
+    constructor(data) {
+        const name = 'peernet-request';
+        super(data, proto$5, { name });
+    }
+}
+
+var proto$4 = {
+    response: {}
+};
+
+class ResponseMessage extends FormatInterface {
+    get messageName() {
+        return 'PeernetResponseMessage';
+    }
+    constructor(data) {
+        const name = 'peernet-response';
+        super(data, proto$4, { name });
+    }
+}
+
+var proto$3 = {
+    id: String()
+};
+
+class PeerMessageResponse extends FormatInterface {
+    get messageName() {
+        return 'PeernetPeerMessageResponse';
+    }
+    constructor(data) {
+        const name = 'peernet-peer-response';
+        super(data, proto$3, { name });
+    }
+}
+
+var proto$2 = {
+    hash: String(),
+    data: new Uint8Array()
+};
+
+class DataMessageResponse extends FormatInterface {
+    get messageName() {
+        return 'PeernetDataMessageResponse';
+    }
+    constructor(data) {
+        const name = 'peernet-data-response';
+        super(data, proto$2, { name });
+    }
+}
+
+var proto$1 = {
+    value: String(),
+    author: String(),
+    timestamp: Number(),
+    files: [String()]
+};
+
+class ChatMessage extends FormatInterface {
+    get messageName() {
+        return 'ChatMessage';
+    }
+    constructor(buffer) {
+        const name = 'chat-message';
+        super(buffer, proto$1, { name });
+    }
+}
+
+var proto = {
+    path: String(),
+    'content?': '',
+    'links?': []
+};
+
+/**
+ * @extends {CodecFormat}
+ */
+class PeernetFile extends FormatInterface {
+    get messageName() {
+        return 'PeernetFile';
+    }
+    /**
+     * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
+     */
+    constructor(data) {
+        super(data, proto, { name: 'peernet-file' });
+    }
+}
+
+export { ChatMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PeerMessage, PeerMessageResponse, PeernetFile, PeernetMessage, PsMessage, RequestMessage, ResponseMessage };

package/exports/browser/{node-browser-DPfaEz6Y.js → node-browser-Dk2CzshW.js}

@@ -7944,54 +7944,55 @@ const FormatInterface = FormatInterface$1;
 const Codec = Codec$1;
 
 const BufferToUint8Array = (data) => {
-  if (data.type === 'Buffer') {
-    data = new Uint8Array(data.data);
-  }
-  return data
+    if (data.type === 'Buffer') {
+        data = new Uint8Array(data.data);
+    }
+    return data;
 };
-
 const protoFor = (message) => {
-  const codec = new Codec(message);
-  if (!codec.name) throw new Error(`proto not found ${message}`)
-  const Proto = globalThis.peernet.protos[codec.name];
-  if (!Proto) throw new Error(`No proto defined for ${codec.name}`)
-  return new Proto(message)
+    const codec = new Codec(message);
+    if (!codec.name)
+        throw new Error(`proto not found ${message}`);
+    const Proto = globalThis.peernet.protos[codec.name];
+    if (!Proto)
+        throw new Error(`No proto defined for ${codec.name}`);
+    return new Proto(message);
 };
-
 /**
  * wether or not a peernet daemon is active
  * @return {Boolean}
  */
 const hasDaemon = async () => {
-  try {
-    let response = await fetch('http://127.0.0.1:1000/api/version');
-    response = await response.json();
-    return Boolean(response.client === '@peernet/api/http')
-  } catch (e) {
-    return false
-  }
+    try {
+        let response = await fetch('http://127.0.0.1:1000/api/version');
+        response = await response.json();
+        return Boolean(response.client === '@peernet/api/http');
+    }
+    catch (e) {
+        return false;
+    }
 };
-
 const https = () => {
-  if (!globalThis.location) return false
-  return Boolean(globalThis.location.protocol === 'https:')
+    if (!globalThis.location)
+        return false;
+    return Boolean(globalThis.location.protocol === 'https:');
 };
-
 /**
  * Get current environment
  * @return {String} current environment [node, electron, browser]
  */
 const environment = () => {
-  const _navigator = globalThis.navigator;
-  if (!_navigator) {
-    return 'node'
-  } else if (_navigator && /electron/i.test(_navigator.userAgent)) {
-    return 'electron'
-  } else {
-    return 'browser'
-  }
+    const _navigator = globalThis.navigator;
+    if (!_navigator) {
+        return 'node';
+    }
+    else if (_navigator && /electron/i.test(_navigator.userAgent)) {
+        return 'electron';
+    }
+    else {
+        return 'browser';
+    }
 };
-
 /**
  * * Get current environment
  * @return {Object} result
@@ -7999,84 +8000,84 @@ const environment = () => {
  * @property {Boolean} reult.environment Current environment
  */
 const target = async () => {
-  let daemon = false;
-  if (!https()) daemon = await hasDaemon();
-
-  return { daemon, environment: environment() }
+    let daemon = false;
+    if (!https())
+        daemon = await hasDaemon();
+    return { daemon, environment: environment() };
 };
 
 class PeerDiscovery {
-  constructor(id) {
-    this.id = id;
-  }
-
-  _getPeerId(id) {
-    if (!peernet.peerMap || (peernet.peerMap && peernet.peerMap.size === 0)) return false
-
-    for (const entry of [...peernet.peerMap.entries()]) {
-      for (const _id of entry[1]) {
-        if (_id === id) return entry[0]
-      }
+    constructor(id) {
+        this.id = id;
     }
-  }
-
-  async discover(peer) {
-    let id = this._getPeerId(peer.id);
-    if (id) return id
-    const data = await new peernet.protos['peernet-peer']({ id: this.id });
-    const node = await peernet.prepareMessage(peer.id, data.encoded);
-
-    let response = await peer.request(node.encoded);
-    response = await protoFor(response);
-    response = await new peernet.protos['peernet-peer-response'](response.decoded.data);
-
-    id = response.decoded.id;
-    if (id === this.id) return
-
-    if (!peernet.peerMap.has(id)) peernet.peerMap.set(id, [peer.id]);
-    else {
-      const connections = peernet.peerMap.get(id);
-      if (connections.indexOf(peer.id) === -1) {
-        connections.push(peer.id);
-        peernet.peerMap.set(peer.id, connections);
-      }
+    _getPeerId(id) {
+        if (!peernet.peerMap || (peernet.peerMap && peernet.peerMap.size === 0))
+            return false;
+        for (const entry of [...peernet.peerMap.entries()]) {
+            for (const _id of entry[1]) {
+                if (_id === id)
+                    return entry[0];
+            }
+        }
     }
-    return id
-  }
-
-  async discoverHandler(message, peer) {
-    const { id, proto } = message;
-    // if (typeof message.data === 'string') message.data = Buffer.from(message.data)
-    if (proto.name === 'peernet-peer') {
-      const from = proto.decoded.id;
-      if (from === this.id) return
-
-      if (!peernet.peerMap.has(from)) peernet.peerMap.set(from, [peer.id]);
-      else {
-        const connections = peernet.peerMap.get(from);
-        if (connections.indexOf(peer.id) === -1) {
-          connections.push(peer.id);
-          peernet.peerMap.set(from, connections);
+    async discover(peer) {
+        let id = this._getPeerId(peer.id);
+        if (id)
+            return id;
+        const data = await new peernet.protos['peernet-peer']({ id: this.id });
+        const node = await peernet.prepareMessage(peer.id, data.encoded);
+        let response = await peer.request(node.encoded);
+        response = await protoFor(response);
+        response = await new peernet.protos['peernet-peer-response'](response.decoded.data);
+        id = response.decoded.id;
+        if (id === this.id)
+            return;
+        if (!peernet.peerMap.has(id))
+            peernet.peerMap.set(id, [peer.id]);
+        else {
+            const connections = peernet.peerMap.get(id);
+            if (connections.indexOf(peer.id) === -1) {
+                connections.push(peer.id);
+                peernet.peerMap.set(peer.id, connections);
+            }
         }
-      }
-      const data = await new peernet.protos['peernet-peer-response']({ id: this.id });
-      const node = await peernet.prepareMessage(from, data.encoded);
-
-      peer.write(Buffer.from(JSON.stringify({ id, data: node.encoded })));
-    } else if (proto.name === 'peernet-peer-response') {
-      const from = proto.decoded.id;
-      if (from === this.id) return
-
-      if (!peernet.peerMap.has(from)) peernet.peerMap.set(from, [peer.id]);
-      else {
-        const connections = peernet.peerMap.get(from);
-        if (connections.indexOf(peer.id) === -1) {
-          connections.push(peer.id);
-          peernet.peerMap.set(from, connections);
+        return id;
+    }
+    async discoverHandler(message, peer) {
+        const { id, proto } = message;
+        // if (typeof message.data === 'string') message.data = Buffer.from(message.data)
+        if (proto.name === 'peernet-peer') {
+            const from = proto.decoded.id;
+            if (from === this.id)
+                return;
+            if (!peernet.peerMap.has(from))
+                peernet.peerMap.set(from, [peer.id]);
+            else {
+                const connections = peernet.peerMap.get(from);
+                if (connections.indexOf(peer.id) === -1) {
+                    connections.push(peer.id);
+                    peernet.peerMap.set(from, connections);
+                }
+            }
+            const data = await new peernet.protos['peernet-peer-response']({ id: this.id });
+            const node = await peernet.prepareMessage(from, data.encoded);
+            peer.write(Buffer.from(JSON.stringify({ id, data: node.encoded })));
+        }
+        else if (proto.name === 'peernet-peer-response') {
+            const from = proto.decoded.id;
+            if (from === this.id)
+                return;
+            if (!peernet.peerMap.has(from))
+                peernet.peerMap.set(from, [peer.id]);
+            else {
+                const connections = peernet.peerMap.get(from);
+                if (connections.indexOf(peer.id) === -1) {
+                    connections.push(peer.id);
+                    peernet.peerMap.set(from, connections);
+                }
+            }
         }
-      }
     }
-  }
 }
 
 /**
@@ -8178,59 +8179,57 @@ class DhtEarth {
 }
 
 class MessageHandler {
-  constructor(network) {
-    this.network = network;
-  }
-  /**
-   * hash and sign message
-   *
-   * @param {object} message
-   * @param {Buffer} message.from peer id
-   * @param {Buffer} message.to peer id
-   * @param {string} message.data Peernet message
-   * (PeernetMessage excluded) encoded as a string
-   * @return message
-   */
-  async hashAndSignMessage(message) {
-    const hash = await message.peernetHash;
-    message.decoded.signature = globalThis.identity.sign(hash.buffer);
-    return message
-  }
-
-  /**
-   * @param {String} from - peer id
-   * @param {String} to - peer id
-   * @param {String|PeernetMessage} data - data encoded message string
-   * or the messageNode itself
-   */
-  async prepareMessage(message) {
-    if (message.keys.includes('signature')) {
-      message = await this.hashAndSignMessage(message);
+    constructor(network) {
+        this.network = network;
+    }
+    /**
+     * hash and sign message
+     *
+     * @param {object} message
+     * @param {Buffer} message.from peer id
+     * @param {Buffer} message.to peer id
+     * @param {string} message.data Peernet message
+     * (PeernetMessage excluded) encoded as a string
+     * @return message
+     */
+    async hashAndSignMessage(message) {
+        const hash = await message.peernetHash;
+        message.decoded.signature = globalThis.identity.sign(hash.buffer);
+        return message;
+    }
+    /**
+     * @param {String} from - peer id
+     * @param {String} to - peer id
+     * @param {String|PeernetMessage} data - data encoded message string
+     * or the messageNode itself
+     */
+    async prepareMessage(message) {
+        if (message.keys.includes('signature')) {
+            message = await this.hashAndSignMessage(message);
+        }
+        return message;
     }
-
-    return message
-  }
 }
 
 const dataHandler = async (message) => {
-  if (!message) return
-
-  try {
-    const { data, id, from, peer } = message;
-    const proto = await protoFor(data);
-    peernet._protoHandler({ id, proto }, peernet.connections[from] || peer, from);
-  } catch (error) {
-    console.error(error);
-  }
+    if (!message)
+        return;
+    try {
+        const { data, id, from, peer } = message;
+        const proto = await protoFor(data);
+        peernet._protoHandler({ id, proto }, peernet.connections[from] || peer, from);
+    }
+    catch (error) {
+        console.error(error);
+    }
 };
 
 const dhtError = (proto) => {
-  const text = `Received proto ${proto.name} expected peernet-dht-response`;
-  return new Error(`Routing error: ${text}`)
+    const text = `Received proto ${proto.name} expected peernet-dht-response`;
+    return new Error(`Routing error: ${text}`);
 };
-
 const nothingFoundError = (hash) => {
-  return new Error(`nothing found for ${hash}`)
+    return new Error(`nothing found for ${hash}`);
 };
 
 const isBrowser = globalThis.process?.versions?.node ? false : true;
@@ -8491,7 +8490,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-CFqwXbrQ-D0JHZ5TG.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-Bx4w-Pqo-DSXPMvjy.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8585,7 +8584,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-UwSHOtRi-BsddY8I0.js');
+        const importee = await import('./client-DgmVTCEc-WVRX01s7.js');
         /**
          * @access public
          * @type {PeernetClient}

package/exports/browser/node-browser.js

@@ -1,3 +1,3 @@
-export { N as default } from './node-browser-DPfaEz6Y.js';
+export { N as default } from './node-browser-Dk2CzshW.js';
 import './identity-Cn0iQbY3-CeW0giQS.js';
 import './index-DUfUgiQY.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.7.109",
+  "version": "1.7.111",
   "description": "Official javascript implementation",
   "private": false,
   "exports": {
@@ -52,10 +52,10 @@
     "@rollup/plugin-commonjs": "^28.0.8",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@rollup/plugin-typescript": "^12.1.4",
+    "@rollup/plugin-typescript": "^12.3.0",
     "@types/semver": "^7.7.1",
     "@vandeurenglenn/debug": "^1.2.6",
-    "rollup": "^4.52.4",
+    "rollup": "^4.52.5",
     "rollup-plugin-modify": "^3.0.0",
     "tape": "^5.9.0",
     "tslib": "^2.8.1"
@@ -69,7 +69,7 @@
     "@leofcoin/messages": "^1.4.40",
     "@leofcoin/multi-wallet": "^3.1.8",
     "@leofcoin/networks": "^1.1.25",
-    "@leofcoin/peernet": "^1.1.98",
+    "@leofcoin/peernet": "^1.1.100",
     "@leofcoin/storage": "^3.5.38",
     "@leofcoin/utils": "^1.1.40",
     "@leofcoin/workers": "^1.5.27",

package/exports/browser/messages-CFqwXbrQ-D0JHZ5TG.js

@@ -1,216 +0,0 @@
-import { F as FormatInterface } from './node-browser-DPfaEz6Y.js';
-import './identity-Cn0iQbY3-CeW0giQS.js';
-import './index-DUfUgiQY.js';
-
-var proto$b = {
-  data: new Uint8Array(),
-  signature: new Uint8Array(),
-  'from?': String(),
-  'to?': String(),
-  'id?': String()
-};
-
-class PeernetMessage extends FormatInterface {
-  get messageName() {
-    return 'PeernetMessage'
-  }
-
-  constructor(buffer) {
-    const name = 'peernet-message';
-    super(buffer, proto$b, { name });
-  }
-}
-
-var proto$a = {
-  hash: String(),
-  'store?': String()
-};
-
-/**
- * @example `
-   new DHTMessage(hash, store)
-   // store = optional if not set, peernet checks every store
-   let message = new DHTMessage('hashmvbs124xcfd...', 'transaction')
-   message = new DHTMessage('hashmvbs124xcfd...', 'block')
- `
- */
-class DHTMessage extends FormatInterface {
-  get messageName() {
-    return 'PeernetDHTMessage'
-  }
-
-  constructor(data) {
-    const name = 'peernet-dht';
-    super(data, proto$a, { name });
-  }
-}
-
-var proto$9 = {
-  hash: String(),
-  has: Boolean()
-};
-
-class DHTMessageResponse extends FormatInterface {
-  get messageName() {
-    return 'PeernetDHTMessageResponse'
-  }
-
-  constructor(data) {
-    const name = 'peernet-dht-response';
-    super(data, proto$9, { name });
-  }
-}
-
-var proto$8 = {
-  hash: String(),
-  'store?': String()
-};
-
-/**
- * @extends {CodecFormat}
- */
-class DataMessage extends FormatInterface {
-  get messageName() {
-    return 'PeernetDataMessage'
-  }
-  /**
-   * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
-   */
-  constructor(data) {
-    super(data, proto$8, { name: 'peernet-data' });
-  }
-}
-
-var proto$7 = {
-  data: new Uint8Array(),
-  topic: new Uint8Array()
-};
-
-class PsMessage extends FormatInterface {
-  get messageName() {
-    return 'PsMessage'
-  }
-
-  constructor(buffer) {
-    const name = 'peernet-ps';
-    super(buffer, proto$7, { name });
-  }
-}
-
-var proto$6 = {
-  id: String()
-};
-
-class PeerMessage extends FormatInterface {
-  get messageName() {
-    return 'PeernetPeerMessage'
-  }
-
-  constructor(data) {
-    const name = 'peernet-peer';
-    super(data, proto$6, { name });
-  }
-}
-
-var proto$5 = {
-  request: String(),
-  'requested?': new Uint8Array()
-};
-
-class RequestMessage extends FormatInterface {
-  get messageName() {
-    return 'PeernetRequestMessage'
-  }
-
-  constructor(data) {
-    const name = 'peernet-request';
-    super(data, proto$5, { name });
-  }
-}
-
-var proto$4 = {
-  response: {}
-};
-
-class ResponseMessage extends FormatInterface {
-  get messageName() {
-    return 'PeernetResponseMessage'
-  }
-
-  constructor(data) {
-    const name = 'peernet-response';
-    super(data, proto$4, { name });
-  }
-}
-
-var proto$3 = {
-  id: String()
-};
-
-class PeerMessageResponse extends FormatInterface {
-  get messageName() {
-    return 'PeernetPeerMessageResponse'
-  }
-
-  constructor(data) {
-    const name = 'peernet-peer-response';
-    super(data, proto$3, { name });
-  }
-}
-
-var proto$2 = {
-  hash: String(),
-  data: new Uint8Array()
-};
-
-class DataMessageResponse extends FormatInterface {
-  get messageName() {
-    return 'PeernetDataMessageResponse'
-  }
-
-  constructor(data) {
-    const name = 'peernet-data-response';
-    super(data, proto$2, { name });
-  }
-}
-
-var proto$1 = {
-  value: String(),
-  author: String(),
-  timestamp: Number(),
-  files: [String()]
-};
-
-class ChatMessage extends FormatInterface {
-  get messageName() {
-    return 'ChatMessage'
-  }
-
-  constructor(buffer) {
-    const name = 'chat-message';
-    super(buffer, proto$1, { name });
-  }
-}
-
-var proto = {
-  path: String(),
-  'content?': '',
-  'links?': []
-};
-
-/**
- * @extends {CodecFormat}
- */
-class PeernetFile extends FormatInterface {
-  get messageName() {
-    return 'PeernetFile'
-  }
-  /**
-   * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
-   */
-  constructor(data) {
-    super(data, proto, { name: 'peernet-file' });
-  }
-}
-
-export { ChatMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PeerMessage, PeerMessageResponse, PeernetFile, PeernetMessage, PsMessage, RequestMessage, ResponseMessage };