@leofcoin/peernet 0.11.0 → 0.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "",
   "main": "dist/commonjs/peernet.js",
   "module": "dist/module/peernet.js",
@@ -29,26 +29,12 @@
     "@leofcoin/storage": "^2.1.2",
     "@vandeurenglenn/base32": "^1.1.0",
     "@vandeurenglenn/base58": "^1.1.0",
+    "@vandeurenglenn/is-hex": "^1.0.0",
     "@vandeurenglenn/little-pubsub": "^1.3.1",
-    "acorn-class-fields": "^1.0.0",
-    "acorn-node": "^2.0.1",
-    "acorn-private-class-elements": "^1.0.0",
-    "acorn-private-methods": "^1.0.0",
-    "acorn-stage3": "^4.0.0",
-    "async_hooks": "^1.0.0",
-    "bittorrent-tracker": "^9.18.5",
-    "bs32": "^0.1.6",
-    "bs58": "^4.0.1",
-    "bs58check": "^2.1.2",
-    "is-hex": "^1.1.3",
     "keccak": "^3.0.1",
     "koa": "^2.13.1",
-    "multiformats": "^9.6.4",
     "node-fetch": "^2.6.1",
-    "on-finished": "^2.4.1",
-    "p2pt": "^1.5.0",
     "protons": "^2.0.1",
-    "simple-peer": "^9.11.1",
     "socket-request-client": "^1.5.0",
     "socket-request-server": "^1.5.0",
     "stream-browserify": "^3.0.0",
@@ -60,8 +46,6 @@
     "@rollup/plugin-eslint": "^8.0.1",
     "@rollup/plugin-json": "^4.1.0",
     "@rollup/plugin-node-resolve": "^13.0.4",
-    "acorn": "^8.7.0",
-    "browserify": "^17.0.0",
     "coveralls": "^3.1.1",
     "esdoc": "^1.1.0",
     "esdoc-ecmascript-proposal-plugin": "^1.0.0",

package/src/client.js

@@ -1,75 +1,75 @@
-import Pubsub from '@vandeurenglenn/little-pubsub'
-import PeernetPeer from './peer.js'
-import sha256 from 'crypto-js/sha256'
-
-import P2P from 'p2pt'
-
-
-/**
- * Array of peers
- * @type {Array}
- * @property {PeernetPeer} peer Instance of Peer
- */
-globalThis.connections = new Map()
-globalThis.recentConnections = new Map()
-globalThis.pubsub = globalThis.pubsub || new Pubsub({verbose: false})
-
-export default class PeernetClient {
-  constructor(options = {}) {
-    if (!options.id) options.id = Buffer.from('00000000000000000000000000000000')
-    if (!options.networkVersion) options.networkVersion = 'v0.1.0'
-    if (!options.networkName) options.networkName = 'peernet'
-    this.id = options.id
-
-    this.topic = Buffer.from(sha256(`${options.networkName}-${options.networkVersion}`).toString())
-
-    const trackers = [
-      'wss://star.leofcoin.org',
-      'wss://tracker.openwebtorrent.com',
-      // 'wss://tracker.sloppyta.co:443/announce',
-    ]
-    this.p2p = new P2P(trackers, this.topic.slice(0, 20))
-    this.p2p.on('peerconnect', (peer) => {
-      peer = new PeernetPeer(peer.id, peer)
-      connections.set(peer.id, peer)
-      pubsub.publish('peer:discovered', peer)
-    })
-
-    this.p2p.on('peerclose', (peer) => {
-      // TODO: close peernetPeer
-      const peernetPeer = connections.get(peer.id)
-      if (peernetPeer) {
-        peernetPeer.close()
-      }
-      connections.delete(peer.id)
-      pubsub.publish('peer:disconnected', peer)
-    })
-
-    this.p2p.start()
-
-    if (globalThis.process) {
-      process.on('SIGINT', async () => {
-        console.log('Caught interrupt signal')
-        this.close()
-        setTimeout(async () => {
-          process.exit();
-        }, 100);
-      })
-    } else {
-      globalThis.onbeforeunload = () => {
-        this.close()
-      }
-    }
-    //
-    // this.sw.on('close', () => {
-    // })
-  }
-
-  close() {
-    return this.p2p.destroy()
-  }
-
-  _peers() {
-    return this.p2p.getPeers()
-  }
-}
+import Pubsub from '@vandeurenglenn/little-pubsub'
+import PeernetPeer from './peer.js'
+import sha256 from 'crypto-js/sha256'
+
+import P2P from 'p2pt'
+
+
+/**
+ * Array of peers
+ * @type {Array}
+ * @property {PeernetPeer} peer Instance of Peer
+ */
+globalThis.connections = new Map()
+globalThis.recentConnections = new Map()
+globalThis.pubsub = globalThis.pubsub || new Pubsub({verbose: false})
+
+export default class PeernetClient {
+  constructor(options = {}) {
+    if (!options.id) options.id = Buffer.from('00000000000000000000000000000000')
+    if (!options.networkVersion) options.networkVersion = 'v0.1.0'
+    if (!options.networkName) options.networkName = 'peernet'
+    this.id = options.id
+
+    this.topic = Buffer.from(sha256(`${options.networkName}-${options.networkVersion}`).toString())
+
+    const trackers = [
+      'wss://star.leofcoin.org',
+      'wss://tracker.openwebtorrent.com',
+      // 'wss://tracker.sloppyta.co:443/announce',
+    ]
+    this.p2p = new P2P(trackers, this.topic.slice(0, 20))
+    this.p2p.on('peerconnect', (peer) => {
+      peer = new PeernetPeer(peer.id, peer)
+      connections.set(peer.id, peer)
+      pubsub.publish('peer:discovered', peer)
+    })
+
+    this.p2p.on('peerclose', (peer) => {
+      // TODO: close peernetPeer
+      const peernetPeer = connections.get(peer.id)
+      if (peernetPeer) {
+        peernetPeer.close()
+      }
+      connections.delete(peer.id)
+      pubsub.publish('peer:disconnected', peer)
+    })
+
+    this.p2p.start()
+
+    if (globalThis.process) {
+      process.on('SIGINT', async () => {
+        console.log('Caught interrupt signal')
+        this.close()
+        setTimeout(async () => {
+          process.exit();
+        }, 100);
+      })
+    } else {
+      globalThis.onbeforeunload = () => {
+        this.close()
+      }
+    }
+    //
+    // this.sw.on('close', () => {
+    // })
+  }
+
+  close() {
+    return this.p2p.destroy()
+  }
+
+  _peers() {
+    return this.p2p.getPeers()
+  }
+}

package/src/codec/codec-format-interface.js

@@ -1,172 +1,172 @@
-import bs32 from '@vandeurenglenn/base32';
-import bs58 from '@vandeurenglenn/base58';
-import isHex from 'is-hex';
-import Codec from './codec';
-import Hash from './../hash/hash'
-
-export default class FormatInterface {
-  /**
-   * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
-   * @param {Object} proto - {encode, decode}
-   * @param {Object} options - {hashFormat, name}
-   */
-  constructor(buffer, proto, options = {}) {
-    this.protoEncode = proto.encode
-    this.protoDecode = proto.decode
-    this.hashFormat = options.hashFormat || 'bs32'
-    if (options.name) this.name = options.name
-    if (buffer instanceof Uint8Array) return this.fromUint8Array(buffer)
-    else if (buffer instanceof ArrayBuffer) return this.fromArrayBuffer(buffer)
-    else if (buffer.name === options.name) return buffer
-    else if (typeof buffer === 'string') {
-        if (isHex(buffer)) this.fromHex(buffer)
-        else if (bs32.isBase32(buffer)) this.fromBs32(buffer)
-        else if (bs58.isBase58(buffer)) this.fromBs58(buffer)
-        else throw new Error(`unsupported string ${buffer}`)
-    } else {
-      this.create(buffer)
-    }
-  }
-
-  /**
-   * @return {PeernetHash}
-   */
-  get peernetHash() {
-    return new Hash(this.decoded, {name: this.name})
-  }
-
-  /**
-   * @return {peernetHash}
-   */
-  get hash() {
-    const upper = this.hashFormat.charAt(0).toUpperCase()
-    const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`
-    return this.peernetHash[`to${format}`]()
-  }
-
-  /**
-   * @return {Object}
-   */
-  decode() {
-    let encoded = this.encoded;
-    const discoCodec = new Codec(this.encoded)
-    encoded = encoded.slice(discoCodec.codecBuffer.length)
-    this.name = discoCodec.name
-    this.decoded = this.protoDecode(encoded)
-    return this.decoded
-  }
-
-  /**
-   * @return {Buffer}
-   */
-  encode(decoded) {
-    if (!decoded) decoded = this.decoded;
-    const codec = new Codec(this.name)
-    const encoded = this.protoEncode(decoded)
-    const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length)
-    uint8Array.set(codec.codecBuffer)
-    uint8Array.set(encoded, codec.codecBuffer.length)
-    this.encoded = uint8Array
-    return this.encoded
-  }
-
-  hasCodec() {
-    if (!this.encoded) return false
-    const codec = new Codec(this.encoded)
-    if (codec.name) return true
-  }
-
-  fromUint8Array(buffer) {
-    this.encoded = buffer
-    if (!this.hasCodec()) this.create(
-      JSON.parse(new TextDecoder().decode(this.encoded))
-    )
-    else this.decode()
-  }
-
-  fromArrayBuffer(buffer) {
-    this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
-    if (!this.hasCodec()) this.create(
-      JSON.parse(new TextDecoder().decode(this.encoded))
-    )
-    else this.decode()
-  }
-
-  /**
-   * @param {Buffer} encoded
-   */
-  fromEncoded(encoded) {
-    this.encoded = encoded
-    this.decode()
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  fromHex(encoded) {
-    this.encoded = Buffer.from(encoded, 'hex')
-    this.decode()
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  fromBs32(encoded) {
-    this.encoded = bs32.decode(encoded)
-    this.decode()
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  fromBs58(encoded) {
-    this.encoded = bs58.decode(encoded)
-    this.decode()
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toHex() {
-    if (!this.encoded) this.encode()
-    return this.encoded.toString('hex')
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toBs32() {
-    if (!this.encoded) this.encode()
-    return bs32.encode(this.encoded)
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toBs58() {
-    if (!this.encoded) this.encode()
-    return bs58.encode(this.encoded)
-  }
-
-  /**
-   * @param {Object} data
-   */
-  create(data) {
-    const decoded = {}
-    if (this.keys?.length > 0) {
-      for (const key of this.keys) {
-        Object.defineProperties(decoded, {
-          [key]: {
-            enumerable: true,
-            configurable: true,
-            set: (val) => value = data[key],
-            get: () => data[key]
-          }
-        })
-      }
-
-      this.decoded = decoded
-      this.encode()
-    }
-  }
-}
+import bs32 from '@vandeurenglenn/base32';
+import bs58 from '@vandeurenglenn/base58';
+import isHex from '@vandeurenglenn/is-hex';
+import Codec from './codec';
+import Hash from './../hash/hash'
+
+export default class FormatInterface {
+  /**
+   * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
+   * @param {Object} proto - {encode, decode}
+   * @param {Object} options - {hashFormat, name}
+   */
+  constructor(buffer, proto, options = {}) {
+    this.protoEncode = proto.encode
+    this.protoDecode = proto.decode
+    this.hashFormat = options.hashFormat || 'bs32'
+    if (options.name) this.name = options.name
+    if (buffer instanceof Uint8Array) return this.fromUint8Array(buffer)
+    else if (buffer instanceof ArrayBuffer) return this.fromArrayBuffer(buffer)
+    else if (buffer.name === options.name) return buffer
+    else if (typeof buffer === 'string') {
+        if (isHex(buffer)) this.fromHex(buffer)
+        else if (bs32.isBase32(buffer)) this.fromBs32(buffer)
+        else if (bs58.isBase58(buffer)) this.fromBs58(buffer)
+        else throw new Error(`unsupported string ${buffer}`)
+    } else {
+      this.create(buffer)
+    }
+  }
+
+  /**
+   * @return {PeernetHash}
+   */
+  get peernetHash() {
+    return new Hash(this.decoded, {name: this.name})
+  }
+
+  /**
+   * @return {peernetHash}
+   */
+  get hash() {
+    const upper = this.hashFormat.charAt(0).toUpperCase()
+    const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`
+    return this.peernetHash[`to${format}`]()
+  }
+
+  /**
+   * @return {Object}
+   */
+  decode() {
+    let encoded = this.encoded;
+    const discoCodec = new Codec(this.encoded)
+    encoded = encoded.slice(discoCodec.codecBuffer.length)
+    this.name = discoCodec.name
+    this.decoded = this.protoDecode(encoded)
+    return this.decoded
+  }
+
+  /**
+   * @return {Buffer}
+   */
+  encode(decoded) {
+    if (!decoded) decoded = this.decoded;
+    const codec = new Codec(this.name)
+    const encoded = this.protoEncode(decoded)
+    const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length)
+    uint8Array.set(codec.codecBuffer)
+    uint8Array.set(encoded, codec.codecBuffer.length)
+    this.encoded = uint8Array
+    return this.encoded
+  }
+
+  hasCodec() {
+    if (!this.encoded) return false
+    const codec = new Codec(this.encoded)
+    if (codec.name) return true
+  }
+
+  fromUint8Array(buffer) {
+    this.encoded = buffer
+    if (!this.hasCodec()) this.create(
+      JSON.parse(new TextDecoder().decode(this.encoded))
+    )
+    else this.decode()
+  }
+
+  fromArrayBuffer(buffer) {
+    this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
+    if (!this.hasCodec()) this.create(
+      JSON.parse(new TextDecoder().decode(this.encoded))
+    )
+    else this.decode()
+  }
+
+  /**
+   * @param {Buffer} encoded
+   */
+  fromEncoded(encoded) {
+    this.encoded = encoded
+    this.decode()
+  }
+
+  /**
+   * @param {String} encoded
+   */
+  fromHex(encoded) {
+    this.encoded = Buffer.from(encoded, 'hex')
+    this.decode()
+  }
+
+  /**
+   * @param {String} encoded
+   */
+  fromBs32(encoded) {
+    this.encoded = bs32.decode(encoded)
+    this.decode()
+  }
+
+  /**
+   * @param {String} encoded
+   */
+  fromBs58(encoded) {
+    this.encoded = bs58.decode(encoded)
+    this.decode()
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  toHex() {
+    if (!this.encoded) this.encode()
+    return this.encoded.toString('hex')
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  toBs32() {
+    if (!this.encoded) this.encode()
+    return bs32.encode(this.encoded)
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  toBs58() {
+    if (!this.encoded) this.encode()
+    return bs58.encode(this.encoded)
+  }
+
+  /**
+   * @param {Object} data
+   */
+  create(data) {
+    const decoded = {}
+    if (this.keys?.length > 0) {
+      for (const key of this.keys) {
+        Object.defineProperties(decoded, {
+          [key]: {
+            enumerable: true,
+            configurable: true,
+            set: (val) => value = data[key],
+            get: () => data[key]
+          }
+        })
+      }
+
+      this.decoded = decoded
+      this.encode()
+    }
+  }
+}