@leofcoin/peernet 0.9.5 → 0.9.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "",
   "main": "dist/commonjs/peernet.js",
   "module": "dist/module/peernet.js",

package/src/client.js

@@ -0,0 +1,71 @@
+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:7575',
+      '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
+      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

@@ -0,0 +1,139 @@
+import bs32 from 'bs32';
+import bs58 from 'bs58';
+import isHex from 'is-hex';
+import Codec from './codec';
+import Hash from './../hash/hash'
+
+export default class FormatInterface {
+  /**
+   * @param {Buffer|String|Object} buffer -
+   * @param {Object} proto - {encode, decode}
+   * @param {Object} options - {hashFormat, name}
+   */
+  constructor(buffer, proto, options = {}) {
+    this.protoEncode = proto.encode
+    this.protoDecode = proto.decode
+    if (options.name) this.name = options.name
+    this.hashFormat = options.hashFormat || 'bs32'
+    if (Buffer.isBuffer(buffer)) {
+      const codec = new Codec(buffer)
+      if (codec.name) {
+        this.fromEncoded(buffer)
+      } else {
+        this.create(buffer)
+      }
+    } else {
+      if (typeof buffer === 'string') {
+        if (isHex(buffer)) this.fromHex(buffer)
+        else if (bs32.test(buffer)) this.fromBs32(buffer)
+        else this.fromBs58(buffer)
+      } else if (typeof buffer === 'object' && !Array.isArray(buffer)) {
+        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.toString('hex'))
+    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)
+    this.encoded = Buffer.concat([codec.codecBuffer, this.protoEncode(decoded)])
+    return this.encoded
+  }
+
+  /**
+   * @param {Buffer} encoded
+   */
+  fromEncoded(encoded) {
+    const codec = new Codec(encoded)
+    this.name = codec.name
+    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) {
+    this.decoded = data
+    this.encode(data)
+  }
+}

package/src/codec/codec.js

@@ -0,0 +1,114 @@
+import varint from 'varint';
+import bs32 from 'bs32';
+import bs58 from 'bs58';
+import isHex from 'is-hex';
+import codecs from './codecs'
+
+export default class PeernetCodec {
+  get codecs() {
+    return {...globalThis.peernet.codecs, ...codecs}
+  }
+  constructor(buffer) {
+    if (buffer) {
+      if (Buffer.isBuffer(buffer)) {
+        const codec = varint.decode(buffer);
+        const name = this.getCodecName(codec)
+
+        if (name) {
+          this.name = name
+          this.encoded = buffer
+          this.decode(buffer)
+        } else {
+          this.encode(buffer)
+        }
+      }
+      if (typeof buffer === 'string') {
+        if (this.codecs[buffer]) this.fromName(buffer)
+        else if (isHex(buffer)) this.fromHex(buffer)
+        else if (bs32.test(buffer)) this.fromBs32(buffer)
+        else this.fromBs58(buffer)
+      }
+      if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer)
+    }
+  }
+
+  fromEncoded(encoded) {
+    const codec = varint.decode(encoded);
+    const name = this.getCodecName(codec)
+    this.name = name
+    this.encoded = encoded
+    this.decode(encoded)
+  }
+
+  fromHex(hex) {
+    this.encoded = Buffer.from(hex, 'hex')
+    this.decode()
+  }
+
+  fromBs32(input) {
+    this.encoded = bs32.decode(input)
+    this.decode()
+  }
+
+  fromBs58(input) {
+    this.encoded = bs58.decode(input)
+    this.decode()
+  }
+
+  getCodec(name) {
+    return this.codecs[name].codec
+  }
+
+  getCodecName(codec) {
+    return Object.keys(this.codecs).reduce((p, c) => {
+      if (parseInt(Buffer.from(`${this.getCodec(c)}`, 'hex').toString('hex'), 16) === codec) return c;
+      else return p;
+    }, undefined)
+  }
+
+  getHashAlg(name) {
+    return this.codecs[name].hashAlg
+  }
+
+  fromCodec(codec) {
+    this.name = this.getCodecName(codec)
+    this.hashAlg = this.getHashAlg(this.name)
+
+    this.codec = this.getCodec(this.name)
+    this.codecBuffer = Buffer.from(varint.encode(parseInt(Buffer.from(`${this.codec}`, 'hex').toString('hex'), 16)), 'hex');
+  }
+
+  fromName(name) {
+    const codec = this.getCodec(name)
+    this.name = name
+    this.codec = codec
+    this.hashAlg = this.getHashAlg(name)
+    this.codecBuffer = Buffer.from(varint.encode(parseInt(Buffer.from(`${codec}`, 'hex').toString('hex'), 16)), 'hex');
+  }
+
+  toBs32() {
+    this.encode()
+    return bs32.encode(this.encoded)
+  }
+
+  toBs58() {
+    this.encode()
+    return bs58.encode(this.encoded)
+  }
+
+  toHex() {
+    return this.encoded.toString('hex')
+  }
+
+  decode() {
+    const codec = varint.decode(this.encoded);
+    this.fromCodec(codec)
+    this.name = this.getCodecName(codec)
+  }
+
+  encode() {
+    const codec = Buffer.from(varint.encode(parseInt(Buffer.from(`${this.codec}`, 'hex').toString('hex'), 16)), 'hex');
+    this.encoded = codec
+    return this.encoded
+  }
+}

package/src/codec/codecs.js

@@ -0,0 +1,79 @@
+export default {
+  // just a hash
+  'disco-hash': {
+    codec: '30',
+    hashAlg: 'dbl-keccak-512', // ,
+    // testnet: 'olivia'
+  },
+  'peernet-peer-response': {
+    codec: '707072',
+    hashAlg: 'keccak-256',
+  },
+  'peernet-peer': {
+    codec: '7070',
+    hashAlg: 'keccak-256',
+  },
+  'peernet-dht': {
+    codec: '706468',
+    hashAlg: 'keccak-256',
+  },
+  'peernet-dht-response': {
+    codec: '706472',
+    hashAlg: 'keccak-256',
+  },
+  // data
+  'peernet-data': {
+    codec: '706461',
+    hashAlg: 'keccak-256',
+  },
+  'peernet-data-response': {
+    codec: '70646172',
+    hashAlg: 'keccak-256',
+  },
+  // message
+  'peernet-message': {
+    codec: '706d65',
+    hashAlg: 'keccak-512',
+  },
+  // pubsub
+  'peernet-ps': {
+    codec: '707073',
+    hashAlg: 'keccak-256',
+  },
+  'peernet-response': {
+    codec: '7072',
+    hashAlg: 'keccak-256',
+  },
+  'peernet-request': {
+    codec: '707271',
+    hashAlg: 'keccak-256',
+  },
+  // normal block
+  'leofcoin-block': {
+    codec: '6c62',
+    hashAlg: 'dbl-keccak-512', // ,
+    // testnet: 'olivia'
+  },
+  'leofcoin-tx': {
+    codec: '6c74',
+    hashAlg: 'dbl-keccak-512', // ,
+    // testnet: 'olivia'
+  },
+  // itx
+  'leofcoin-itx': {
+    codec: '6c69',
+    hashAlg: 'keccak-512', // ,
+    // testnet: 'olivia'
+  },
+  // peer reputation
+  'leofcoin-pr': {
+    codec: '6c70',
+    hashAlg: 'keccak-256', // ,
+    // testnet: 'olivia'
+  },
+  // chat message
+  'chat-message': {
+    codec: '636d',
+    hashAlg: 'dbl-keccak-512',
+  },
+}

package/src/dht/dht.js

@@ -0,0 +1,125 @@
+import fetch from 'node-fetch'
+
+/**
+ * Keep history of fetched address and ptr
+ * @property {Object} address
+ * @property {Object} ptr
+ */
+const lastFetched = {
+  address: {
+    value: undefined,
+    timestamp: 0,
+  },
+  ptr: {
+    value: undefined,
+    timestamp: 0,
+  },
+}
+
+const getAddress = async () => {
+  const {address} = lastFetched
+  const now = Math.round(new Date().getTime() / 1000);
+  if (now - address.timestamp > 1200000) {
+    address.value = await fetch('https://icanhazip.com/')
+    address.value = await address.value.text()
+    address.timestamp = Math.round(new Date().getTime() / 1000);
+    lastFetched.address = address;
+  }
+
+  return address.value
+}
+
+const degreesToRadians = (degrees) => {
+  return degrees * Math.PI / 180;
+}
+
+const distanceInKmBetweenEarthCoordinates = (lat1, lon1, lat2, lon2) => {
+  const earthRadiusKm = 6371;
+
+  const dLat = degreesToRadians(lat2-lat1);
+  const dLon = degreesToRadians(lon2-lon1);
+
+  lat1 = degreesToRadians(lat1);
+  lat2 = degreesToRadians(lat2);
+  const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
+          Math.sin(dLon/2) * Math.sin(dLon/2) * Math.cos(lat1) * Math.cos(lat2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
+  return earthRadiusKm * c;
+}
+
+export default class DhtEarth {
+  /**
+   *
+   */
+  constructor() {
+    this.providerMap = new Map();
+  }
+
+  /**
+   * @param {Object} address
+   * @return {Object} {latitude: lat, longitude: lon}
+   */
+  async getCoordinates(address) {
+    // const {address} = parseAddress(provider)
+    const request = `https://whereis.leofcoin.org/?ip=${address}`
+    let response = await fetch(request)
+    response = await response.json()
+    const {lat, lon} = response;
+    return {latitude: lat, longitude: lon}
+  }
+
+  /**
+   * @param {Object} peer
+   * @param {Object} provider
+   * @return {Object} {provider, distance}
+   */
+  async getDistance(peer, provider) {
+    const {latitude, longitude} = await this.getCoordinates(provider.address)
+    return {provider, distance: distanceInKmBetweenEarthCoordinates(peer.latitude, peer.longitude, latitude, longitude)}
+  }
+
+  /**
+   * @param {Array} providers
+   * @return {Object} closestPeer
+   */
+  async closestPeer(providers) {
+    let all = []
+    const address = await getAddress();
+    const peerLoc = await this.getCoordinates(address)
+
+    for (const provider of providers) {
+      all.push(this.getDistance(peerLoc, provider))
+    }
+
+    all = await Promise.all(all)
+
+    const closestPeer = all.reduce((p, c) => {
+      if (!c.distance || c.distance === NaN) c.distance = 0
+      if (c.distance < p || p === 0) return c.provider;
+    }, 0)
+
+    return closestPeer;
+  }
+
+  /**
+   * @param {String} hash
+   * @return {Array} providers
+   */
+  providersFor(hash) {
+    return this.providerMap.get(hash);
+  }
+
+  /**
+   * @param {String} address
+   * @param {String} hash
+   * @return {Array} providers
+   */
+  async addProvider(address, hash) {
+    let providers = [];
+    if (this.providerMap.has(hash)) providers = this.providerMap.get(hash)
+
+    providers = new Set([...providers, address])
+    this.providerMap.set(hash, providers)
+    return providers;
+  }
+}

package/src/discovery/peer-discovery.js

@@ -0,0 +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(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 = 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/errors/errors.js

@@ -0,0 +1,12 @@
+export const encapsulatedError = () => {
+  return new Error('Nodes/Data should be send encapsulated by peernet-message')
+}
+
+export const dhtError = (proto) => {
+  const text = `Received proto ${proto.name} expected peernet-dht-response`
+  return new Error(`Routing error: ${text}`)
+}
+
+export const nothingFoundError = (hash) => {
+  return new Error(`nothing found for ${hash}`)
+}

package/src/handlers/message.js

@@ -0,0 +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
+  }
+}