@leofcoin/peernet 1.1.57 → 1.1.58

package/src/dht/dht.ts

@@ -1,141 +1,141 @@
-export declare type DHTProvider = {
-  address: string,
-  id: string
-}
-
-export declare type DHTProviderDistanceResult = {
-  provider: DHTProvider,
-  /**
-   * distance on earth between peers in km
-   */
-  distance: number
-}
-
-export declare type DHTProviderMapValue = {[index: string]: DHTProvider}
-
-declare type Coordinates = {
-  longitude: number,
-  latitude: number
-}
-
-/**
- * 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 fetchedCoordinates = {}
-
-const getAddress = async () => {
-  const {address} = lastFetched
-  if (address) {
-    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 {
-  providerMap = new Map<string, DHTProviderMapValue>
-
-  /**
-   *
-   */
-  constructor() {
-    this.providerMap = new Map();
-  }
-
-  async getCoordinates(address: string): Promise<Coordinates> {
-    if (!fetchedCoordinates[address]) {
-      const request = `https://whereis.leofcoin.org/?ip=${address}`
-      let response = await fetch(request)
-      const {lat, lon} = await response.json() as { lat: number, lon: number}
-      fetchedCoordinates[address] = {latitude: lat, longitude: lon}
-    }
-    return fetchedCoordinates[address]
-  }
-
-  /**
-   * @param {Object} peer
-   * @param {Object} provider
-   * @return {Object} {provider, distance}
-   */
-  async getDistance(peer: { latitude: number, longitude: number } , provider: DHTProvider): Promise<DHTProviderDistanceResult> {
-    const {latitude, longitude} = await this.getCoordinates(provider.address)
-    return {provider, distance: distanceInKmBetweenEarthCoordinates(peer.latitude, peer.longitude, latitude, longitude)}
-  }
-
-  async closestPeer(providers: Array<any>): Promise<DHTProvider> {
-    let all = []
-    const address = await getAddress();
-    const peerLoc = await this.getCoordinates(address)
-
-    for (const provider of providers) {
-      if (provider.address === '127.0.0.1' || provider.address === '::1') all.push({provider, distance: 0})
-      else all.push(this.getDistance(peerLoc, provider))
-    }
-
-    // todo queue
-    all = await Promise.all(all);
-    all = all.sort((previous, current) => previous.distance - current.distance)
-    return all[0].provider;
-  }
-
-  hasProvider(hash: string): boolean {
-    return this.providerMap.has(hash)
-  }
-
-  providersFor(hash: string): DHTProviderMapValue {
-    let providers:  DHTProviderMapValue
-    if (this.providerMap.has(hash)) providers = this.providerMap.get(hash)
-    return providers
-  }
-
-  addProvider(provider: DHTProvider, hash: string) {
-    let providers: DHTProviderMapValue = {}
-    if (this.providerMap.has(hash)) {
-      providers = this.providerMap.get(hash)
-    }
-    providers[provider.address] = provider
-    this.providerMap.set(hash, providers)
-  }
-
-  removeProvider(address: string, hash: string){
-    if (this.providerMap.has(hash)) {
-      const providers = this.providerMap.get(hash)
-      delete providers[address]
-      this.providerMap.set(hash, providers)
-    }
-  }
-}
+export declare type DHTProvider = {
+  address: string,
+  id: string
+}
+
+export declare type DHTProviderDistanceResult = {
+  provider: DHTProvider,
+  /**
+   * distance on earth between peers in km
+   */
+  distance: number
+}
+
+export declare type DHTProviderMapValue = {[index: string]: DHTProvider}
+
+declare type Coordinates = {
+  longitude: number,
+  latitude: number
+}
+
+/**
+ * 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 fetchedCoordinates = {}
+
+const getAddress = async () => {
+  const {address} = lastFetched
+  if (address) {
+    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 {
+  providerMap = new Map<string, DHTProviderMapValue>
+
+  /**
+   *
+   */
+  constructor() {
+    this.providerMap = new Map();
+  }
+
+  async getCoordinates(address: string): Promise<Coordinates> {
+    if (!fetchedCoordinates[address]) {
+      const request = `https://whereis.leofcoin.org/?ip=${address}`
+      let response = await fetch(request)
+      const {lat, lon} = await response.json() as { lat: number, lon: number}
+      fetchedCoordinates[address] = {latitude: lat, longitude: lon}
+    }
+    return fetchedCoordinates[address]
+  }
+
+  /**
+   * @param {Object} peer
+   * @param {Object} provider
+   * @return {Object} {provider, distance}
+   */
+  async getDistance(peer: { latitude: number, longitude: number } , provider: DHTProvider): Promise<DHTProviderDistanceResult> {
+    const {latitude, longitude} = await this.getCoordinates(provider.address)
+    return {provider, distance: distanceInKmBetweenEarthCoordinates(peer.latitude, peer.longitude, latitude, longitude)}
+  }
+
+  async closestPeer(providers: Array<any>): Promise<DHTProvider> {
+    let all = []
+    const address = await getAddress();
+    const peerLoc = await this.getCoordinates(address)
+
+    for (const provider of providers) {
+      if (provider.address === '127.0.0.1' || provider.address === '::1') all.push({provider, distance: 0})
+      else all.push(this.getDistance(peerLoc, provider))
+    }
+
+    // todo queue
+    all = await Promise.all(all);
+    all = all.sort((previous, current) => previous.distance - current.distance)
+    return all[0].provider;
+  }
+
+  hasProvider(hash: string): boolean {
+    return this.providerMap.has(hash)
+  }
+
+  providersFor(hash: string): DHTProviderMapValue {
+    let providers:  DHTProviderMapValue
+    if (this.providerMap.has(hash)) providers = this.providerMap.get(hash)
+    return providers
+  }
+
+  addProvider(provider: DHTProvider, hash: string) {
+    let providers: DHTProviderMapValue = {}
+    if (this.providerMap.has(hash)) {
+      providers = this.providerMap.get(hash)
+    }
+    providers[provider.address] = provider
+    this.providerMap.set(hash, providers)
+  }
+
+  removeProvider(address: string, hash: string){
+    if (this.providerMap.has(hash)) {
+      const providers = this.providerMap.get(hash)
+      delete providers[address]
+      this.providerMap.set(hash, providers)
+    }
+  }
+}

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 = 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)
-      }
-    }
-    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)
-        }
-      }
-    }
-  }
-}
+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 = 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)
+      }
+    }
+    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)
+        }
+      }
+    }
+  }
+}

package/src/errors/errors.js

@@ -1,12 +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}`)
-}
+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/data.js

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

package/src/handlers/message.js

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