@leofcoin/peernet 0.10.7 → 0.11.1

package/src/discovery/peer-discovery.js

@@ -1,75 +1,75 @@
-import { protoFor } from './../utils/utils.js'
-
-export default 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]
-      }
-    }
-  }
-
-  async discover(peer) {
-    let id = this._getPeerId(peer.id)
-    if (id) return id
-    const data = 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 = protoFor(response)
-    response = 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)
-      }
-    }
-    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 = 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)
-        }
-      }
-    }
-  }
-}
+import { protoFor } from './../utils/utils.js'
+
+export default 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]
+      }
+    }
+  }
+
+  async discover(peer) {
+    let id = this._getPeerId(peer.id)
+    if (id) return id
+    const data = 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 = protoFor(response)
+    response = 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)
+      }
+    }
+    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 = 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)
+        }
+      }
+    }
+  }
+}

package/src/handlers/message.js

@@ -1,52 +1,52 @@
-import MultiWallet from '@leofcoin/multi-wallet'
-import Hash from './../hash/hash.js'
-import PeernetMessage from './../messages/peernet-message.js'
-
-export default 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 signature
-   */
-  async hashAndSignMessage(message) {
-    const hasher = new Hash(message, {name: 'peernet-message'})
-    const identity = await walletStore.get('identity')
-
-    const wallet = new MultiWallet(this.network)
-    wallet.import(identity.multiWIF)
-    return wallet.sign(hasher.hash.slice(0, 32))
-  }
-
-  /**
-   * @param {String} from - peer id
-   * @param {String} to - peer id
-   * @param {String|PeernetMessage} data - data encoded message string
-   * or the messageNode itself
-   */
-  async prepareMessage(from, to, data) {
-    if (!Buffer.isBuffer(from)) from = new Buffer.from(from)
-    if (!Buffer.isBuffer(to)) to = new Buffer.from(to)
-    if (data.encoded) data = data.encoded
-
-    const message = {
-      from,
-      to,
-      data,
-    }
-    const signature = await this.hashAndSignMessage(message)
-    const node = new PeernetMessage({
-      ...message,
-      signature,
-    })
-
-    return node
-  }
-}
+import MultiWallet from './../../node_modules/@leofcoin/multi-wallet/src/index'
+import Hash from './../hash/hash.js'
+import PeernetMessage from './../messages/peernet-message.js'
+
+export default 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 signature
+   */
+  async hashAndSignMessage(message) {
+    const hasher = new Hash(message, {name: 'peernet-message'})
+    const identity = await walletStore.get('identity')
+
+    const wallet = new MultiWallet(this.network)
+    wallet.import(identity.multiWIF)
+    return wallet.sign(hasher.hash.slice(0, 32))
+  }
+
+  /**
+   * @param {String} from - peer id
+   * @param {String} to - peer id
+   * @param {String|PeernetMessage} data - data encoded message string
+   * or the messageNode itself
+   */
+  async prepareMessage(from, to, data, id) {
+    if (!Buffer.isBuffer(from)) from = new Buffer.from(from)
+    if (!Buffer.isBuffer(to)) to = new Buffer.from(to)
+    if (data.encoded) data = data.encoded
+
+    const message = {
+      from,
+      to,
+      data,
+    }
+    const signature = await this.hashAndSignMessage(message)
+    const node = new PeernetMessage({
+      ...message,
+      signature,
+    })
+
+    return node
+  }
+}

package/src/hash/hash.js

@@ -1,145 +1,155 @@
-import createKeccakHash from 'keccak';
-import varint from 'varint';
-import bs32 from 'bs32';
-import bs58 from 'bs58';
-import isHex from 'is-hex';
-import Codec from './../codec/codec';
-
-export default class PeernetHash {
-  constructor(buffer, options = {}) {
-    if (options.name) this.name = options.name
-    else this.name = 'disco-hash'
-    if (options.codecs) this.codecs = options.codecs
-    if (buffer) {
-      if (Buffer.isBuffer(buffer)) {
-        this.discoCodec = new Codec(buffer, this.codecs)
-        const name = this.discoCodec.name
-
-        if (name) {
-          this.name = name
-          this.decode(buffer)
-        } else {
-          this.encode(buffer)
-        }
-      }
-
-      if (typeof buffer === 'string') {
-        if (isHex(buffer)) this.fromHex(buffer)
-        if (bs32.test(buffer)) this.fromBs32(buffer)
-        else this.fromBs58(buffer)
-      } else if (typeof buffer === 'object') this.fromJSON(buffer)
-    }
-  }
-
-  get prefix() {
-    return Buffer.concat([this.discoCodec.codecBuffer, this.length])
-  }
-
-  get length() {
-    return Buffer.from(varint.encode(this.size))
-  }
-
-  get buffer() {
-    return this.hash
-  }
-
-  toHex() {
-    return this.hash.toString('hex')
-  }
-
-  fromHex(hex) {
-    return this.decode(Buffer.from(hex, 'hex'))
-  }
-
-  fromJSON(json) {
-    return this.encode(Buffer.from(JSON.stringify(json)))
-  }
-
-  toBs32() {
-    return bs32.encode(this.hash)
-  }
-
-  fromBs32(bs) {
-    return this.decode(bs32.decode(bs))
-  }
-
-  toBs58() {
-    return bs58.encode(this.hash)
-  }
-
-  fromBs58(bs) {
-    return this.decode(bs58.decode(bs))
-  }
-
-  toString(encoding = 'utf8') {
-    return this.hash.toString(encoding)
-  }
-
-  encode(buffer, name) {
-    if (!this.name && name) this.name = name;
-    if (!buffer) buffer = this.buffer;
-    this.discoCodec = new Codec(this.name, this.codecs)
-    this.discoCodec.fromName(this.name)
-    let hashAlg = this.discoCodec.hashAlg
-    if (hashAlg.includes('dbl')) {
-      hashAlg = hashAlg.replace('dbl-', '')
-      buffer = createKeccakHash(hashAlg.replace('-', '')).update(buffer).digest()
-    }
-    this.digest = createKeccakHash(hashAlg.replace('-', '')).update(buffer).digest()
-    this.size = this.digest.length
-
-    this.codec = this.discoCodec.encode();
-    this.codec = this.discoCodec.codecBuffer
-    this.hash = Buffer.concat([
-      this.prefix,
-      this.digest,
-    ])
-
-    return this.hash
-  }
-
-  validate(buffer) {
-    if (Buffer.isBuffer(buffer)) {
-      const codec = varint.decode(buffer);
-      if (this.codecs[codec]) {
-        this.decode(buffer)
-      } else {
-        this.encode(buffer)
-      }
-    }
-    if (typeof buffer === 'string') {
-      if (isHex(buffer)) this.fromHex(buffer)
-      if (bs32.test(buffer)) this.fromBs32(buffer)
-    }
-    if (typeof buffer === 'object') this.fromJSON(buffer)
-  }
-
-  decode(buffer) {
-    this.hash = buffer
-    const codec = varint.decode(buffer);
-
-    this.discoCodec = new Codec(codec, this.codecs)
-    // TODO: validate codec
-    buffer = buffer.slice(varint.decode.bytes);
-    this.size = varint.decode(buffer);
-    this.digest = buffer.slice(varint.decode.bytes);
-    if (this.digest.length !== this.size) {
-      throw new Error(`hash length inconsistent: 0x${this.hash.toString('hex')}`)
-    }
-
-    // const discoCodec = new Codec(codec, this.codecs)
-
-    this.name = this.discoCodec.name
-
-
-    this.size = this.digest.length
-
-    return {
-      codec: this.codec,
-      name: this.name,
-      size: this.size,
-      length: this.length,
-      digest: this.digest,
-    }
-  }
-}
+import createKeccakHash from 'keccak';
+import varint from 'varint';
+import bs32 from '@vandeurenglenn/base32';
+import bs58 from '@vandeurenglenn/base58';
+import isHex from '@vandeurenglenn/is-hex';
+import Codec from './../codec/codec';
+
+export default class PeernetHash {
+  constructor(buffer, options = {}) {
+    if (options.name) this.name = options.name
+    else this.name = 'disco-hash'
+    if (options.codecs) this.codecs = options.codecs
+    if (buffer) {
+      if (Buffer.isBuffer(buffer)) {
+        this.discoCodec = new Codec(buffer, this.codecs)
+        const name = this.discoCodec.name
+
+        if (name) {
+          this.name = name
+          this.decode(buffer)
+        } else {
+          this.encode(buffer)
+        }
+      }
+
+      if (typeof buffer === 'string') {
+        if (isHex(buffer)) this.fromHex(buffer)
+        if (bs32.isBase32(buffer)) this.fromBs32(buffer)
+        else if (bs58.isBase58(buffer)) this.fromBs58(buffer)
+        else throw new Error(`unsupported string ${buffer}`)
+      } else if (typeof buffer === 'object') this.fromJSON(buffer)
+    }
+  }
+
+  get prefix() {
+    const length = this.length
+    const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length)
+    for (let i = 0; i < this.discoCodec.codecBuffer.length; i++) {
+      uint8Array[i] = this.discoCodec.codecBuffer[i]
+    }
+
+    for (let i = uint8Array.length - 1; i < length.length; i++) {
+      uint8Array[i] = length[i]
+    }
+    return uint8Array
+  }
+
+  get length() {
+    return varint.encode(this.size)
+  }
+
+  get buffer() {
+    return this.hash
+  }
+
+  toHex() {
+    return this.hash.toString('hex')
+  }
+
+  fromHex(hex) {
+    return this.decode(Buffer.from(hex, 'hex'))
+  }
+
+  fromJSON(json) {
+    return this.encode(Buffer.from(JSON.stringify(json)))
+  }
+
+  toBs32() {
+    return bs32.encode(this.hash)
+  }
+
+  fromBs32(bs) {
+    return this.decode(bs32.decode(bs))
+  }
+
+  toBs58() {
+    return bs58.encode(this.hash)
+  }
+
+  fromBs58(bs) {
+    return this.decode(bs58.decode(bs))
+  }
+
+  toString(encoding = 'utf8') {
+    return this.hash.toString(encoding)
+  }
+
+  encode(buffer, name) {
+    if (!this.name && name) this.name = name;
+    if (!buffer) buffer = this.buffer;
+    this.discoCodec = new Codec(this.name, this.codecs)
+    this.discoCodec.fromName(this.name)
+    let hashAlg = this.discoCodec.hashAlg
+    if (hashAlg.includes('dbl')) {
+      hashAlg = hashAlg.replace('dbl-', '')
+      buffer = createKeccakHash(hashAlg.replace('-', '')).update(buffer).digest()
+    }
+    this.digest = createKeccakHash(hashAlg.replace('-', '')).update(buffer).digest()
+    this.size = this.digest.length
+
+    this.codec = this.discoCodec.encode();
+    this.codec = this.discoCodec.codecBuffer
+    this.hash = Buffer.concat([
+      this.prefix,
+      this.digest,
+    ])
+
+    return this.hash
+  }
+
+  validate(buffer) {
+    if (Buffer.isBuffer(buffer)) {
+      const codec = varint.decode(buffer);
+      if (this.codecs[codec]) {
+        this.decode(buffer)
+      } else {
+        this.encode(buffer)
+      }
+    }
+    if (typeof buffer === 'string') {
+      if (isHex(buffer)) this.fromHex(buffer)
+      if (bs32.test(buffer)) this.fromBs32(buffer)
+    }
+    if (typeof buffer === 'object') this.fromJSON(buffer)
+  }
+
+  decode(buffer) {
+    this.hash = buffer
+    const codec = varint.decode(buffer);
+
+    this.discoCodec = new Codec(codec, this.codecs)
+    // TODO: validate codec
+    buffer = buffer.slice(varint.decode.bytes);
+    this.size = varint.decode(buffer);
+    this.digest = buffer.slice(varint.decode.bytes);
+    if (this.digest.length !== this.size) {
+      throw new Error(`hash length inconsistent: 0x${this.hash.toString('hex')}`)
+    }
+
+    // const discoCodec = new Codec(codec, this.codecs)
+
+    this.name = this.discoCodec.name
+
+
+    this.size = this.digest.length
+
+    return {
+      codec: this.codec,
+      name: this.name,
+      size: this.size,
+      length: this.length,
+      digest: this.digest,
+    }
+  }
+}

package/src/http/client/http-client.js

@@ -1,44 +1,44 @@
-import Client from './../../../node_modules/socket-request-client/src/index.js'
-
-export default class HttpClientApi {
-  constructor(config = {}) {
-    if (!config.apiPath) config.apiPath = 'api'
-
-    const address = `ws://${config.host}:${config.port}`
-
-    this.apiUrl = (url) => `${address}/${url}`;
-    return (async () => {
-      this.client = await Client(address, config.protocol, {pubsub: config.pubsub, retry: 3000})
-      return this
-    })()
-  }
-
-  async get(url, obj) {
-    const headers = {}
-    let body = null
-    let method = 'GET'
-    if (obj) {
-      method = 'POST'
-      headers['Content-Type'] = 'application/json'
-      body = JSON.stringify(obj)
-    }
-    let response = await this.client.request(url, {headers, body, method})
-    const type = response.headers.get('content-type').split(';')[0]
-    if (type==='application/json') response = await response.json()
-    return response
-  }
-
-  async put(url, obj) {
-    const headers = {}
-    let body = {}
-    if (obj) {
-      headers['Content-Type'] = 'application/json'
-      body = JSON.stringify(obj)
-    }
-
-    let response = await fetch(this.apiUrl(url), {method: 'PUT', headers, body})
-    const type = response.headers.get('content-type').split(';')[0]
-    if (type==='application/json') response = await response.json()
-    return response
-  }
-}
+import Client from './../../../node_modules/socket-request-client/dist/es/index'
+
+export default class HttpClientApi {
+  constructor(config = {}) {
+    if (!config.apiPath) config.apiPath = 'api'
+
+    const address = `ws://${config.host}:${config.port}`
+
+    this.apiUrl = (url) => `${address}/${url}`;
+    return (async () => {
+      this.client = await Client(address, config.protocol, {pubsub: config.pubsub, retry: 3000})
+      return this
+    })()
+  }
+
+  async get(url, obj) {
+    const headers = {}
+    let body = null
+    let method = 'GET'
+    if (obj) {
+      method = 'POST'
+      headers['Content-Type'] = 'application/json'
+      body = JSON.stringify(obj)
+    }
+    let response = await this.client.request(url, {headers, body, method})
+    const type = response.headers.get('content-type').split(';')[0]
+    if (type==='application/json') response = await response.json()
+    return response
+  }
+
+  async put(url, obj) {
+    const headers = {}
+    let body = {}
+    if (obj) {
+      headers['Content-Type'] = 'application/json'
+      body = JSON.stringify(obj)
+    }
+
+    let response = await fetch(this.apiUrl(url), {method: 'PUT', headers, body})
+    const type = response.headers.get('content-type').split(';')[0]
+    if (type==='application/json') response = await response.json()
+    return response
+  }
+}