@leofcoin/peernet 1.1.80 → 1.1.82

package/rollup.config.js

@@ -1,63 +1,63 @@
-import resolve from '@rollup/plugin-node-resolve'
-import commonjs from '@rollup/plugin-commonjs'
-import json from '@rollup/plugin-json'
-import wasm from '@rollup/plugin-wasm'
-import rimraf from 'rimraf'
-import typescript from '@rollup/plugin-typescript'
-
-rimraf.sync('./exports/**')
-
-export default [
-  {
-    input: ['./src/peernet.ts', './src/identity.ts', './node_modules/@leofcoin/storage/exports/browser-store.js'],
-    output: {
-      format: 'es',
-      dir: './exports/browser'
-    },
-    plugins: [
-      json(),
-      wasm(),
-      resolve({
-        browser: true,
-        preferBuiltins: false,
-        mainFields: ['browser', 'module', 'main']
-      }),
-      commonjs({
-        mainFields: ['browser', 'module', 'main']
-      }),
-
-      typescript({ compilerOptions: { outDir: './exports/browser' } })
-    ],
-    external: ['./prompts/password.js']
-  },
-  {
-    input: ['./src/peernet.ts', './src/identity.ts', './node_modules/@leofcoin/storage/exports/store.js'],
-    output: {
-      format: 'es',
-      dir: './exports'
-    },
-    plugins: [
-      typescript({
-        compilerOptions: {
-          outDir: './exports',
-          declarationDir: './exports/types'
-        }
-      })
-    ],
-    external: ['./prompts/password.js']
-  },
-  {
-    input: ['./src/prompts/password/browser.js'],
-    output: {
-      format: 'es',
-      file: './exports/browser/src/prompts/password.js'
-    }
-  },
-  {
-    input: ['./src/prompts/password/node.js'],
-    output: {
-      format: 'es',
-      file: './exports/src/prompts/password.js'
-    }
-  }
-]
+import resolve from '@rollup/plugin-node-resolve'
+import commonjs from '@rollup/plugin-commonjs'
+import json from '@rollup/plugin-json'
+import wasm from '@rollup/plugin-wasm'
+import rimraf from 'rimraf'
+import typescript from '@rollup/plugin-typescript'
+
+rimraf.sync('./exports/**')
+
+export default [
+  {
+    input: ['./src/peernet.ts', './src/identity.ts', './node_modules/@leofcoin/storage/exports/browser-store.js'],
+    output: {
+      format: 'es',
+      dir: './exports/browser'
+    },
+    plugins: [
+      json(),
+      wasm(),
+      resolve({
+        browser: true,
+        preferBuiltins: false,
+        mainFields: ['browser', 'module', 'main']
+      }),
+      commonjs({
+        mainFields: ['browser', 'module', 'main']
+      }),
+
+      typescript({ compilerOptions: { outDir: './exports/browser' } })
+    ],
+    external: ['./prompts/password.js']
+  },
+  {
+    input: ['./src/peernet.ts', './src/identity.ts', './node_modules/@leofcoin/storage/exports/store.js'],
+    output: {
+      format: 'es',
+      dir: './exports'
+    },
+    plugins: [
+      typescript({
+        compilerOptions: {
+          outDir: './exports',
+          declarationDir: './exports/types'
+        }
+      })
+    ],
+    external: ['./prompts/password.js']
+  },
+  {
+    input: ['./src/prompts/password/browser.js'],
+    output: {
+      format: 'es',
+      file: './exports/browser/src/prompts/password.js'
+    }
+  },
+  {
+    input: ['./src/prompts/password/node.js'],
+    output: {
+      format: 'es',
+      file: './exports/src/prompts/password.js'
+    }
+  }
+]

package/src/dht/dht.ts

@@ -1,147 +1,147 @@
-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,15 +1,15 @@
-import { protoFor } from './../utils/utils.js'
-
-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)
-  }
-}
-
-export default dataHandler
+import { protoFor } from './../utils/utils.js'
+
+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)
+  }
+}
+
+export default dataHandler