@leofcoin/peernet 1.1.58 → 1.1.60

package/exports/types/peernet.d.ts

@@ -1,13 +1,12 @@
 /// <reference types="node" resolution-mode="require"/>
-import "@vandeurenglenn/debug";
-import PubSub from "@vandeurenglenn/little-pubsub";
-import PeerDiscovery from "./discovery/peer-discovery.js";
-import DHT from "./dht/dht.js";
-import MessageHandler from "./handlers/message.js";
-import LeofcoinStorageClass from "@leofcoin/storage";
-import Identity from "./identity.js";
-import swarm from "@netpeer/p2pt-swarm";
-import P2PTPeer from "@netpeer/p2pt-swarm/peer";
+import '@vandeurenglenn/debug';
+import PubSub from '@vandeurenglenn/little-pubsub';
+import PeerDiscovery from './discovery/peer-discovery.js';
+import DHT from './dht/dht.js';
+import MessageHandler from './handlers/message.js';
+import { Storage as LeofcoinStorageClass } from '@leofcoin/storage';
+import Identity from './identity.js';
+import swarm from '@netpeer/p2pt-swarm';
 declare global {
     var LeofcoinStorage: typeof LeofcoinStorageClass;
     var peernet: Peernet;
@@ -68,9 +67,7 @@ export default class Peernet {
     constructor(options: any, password: any);
     get id(): string;
     get selectedAccount(): string;
-    get accounts(): Promise<[
-        [name: string, externalAddress: string, internalAddress: string]
-    ]>;
+    get accounts(): Promise<[[name: string, externalAddress: string, internalAddress: string]]>;
     get defaultStores(): string[];
     selectAccount(account: string): Promise<void> | Promise<IDBValidKey> | Promise<any[]>;
     addProto(name: any, proto: any): void;
@@ -85,13 +82,13 @@ export default class Peernet {
      *
      * @return {Array} peerId
      */
-    get peers(): [string, P2PTPeer][];
-    get connections(): P2PTPeer[];
-    get peerEntries(): P2PTPeer[];
+    get peers(): [string, unknown][];
+    get connections(): unknown[];
+    get peerEntries(): unknown[];
     /**
      * @return {String} id - peerId
      */
-    getConnection(id: any): P2PTPeer;
+    getConnection(id: any): unknown;
     /**
      * @private
      *

package/exports/types/types.d.ts

@@ -1,7 +1,7 @@
 import '@vandeurenglenn/debug';
 import PubSub from '@vandeurenglenn/little-pubsub';
 import Peernet from './peernet.js';
-import { LeofcoinStorage as LeofcoinStorageClass } from '@leofcoin/storage';
+import { Storage as LeofcoinStorageClass } from '@leofcoin/storage';
 declare global {
     var debug: (message: any) => string;
     var globalSub: PubSub;
@@ -9,8 +9,8 @@ declare global {
     var peernet: Peernet;
     var LeofcoinStorage: typeof LeofcoinStorageClass;
     var LeofcoinStorageClient: any;
-    var messageStore: typeof LeofcoinStorage;
-    var dataStore: typeof LeofcoinStorage;
-    var transactionStore: typeof LeofcoinStorage;
-    var blockStore: typeof LeofcoinStorage;
+    var messageStore: LeofcoinStorageClass;
+    var dataStore: LeofcoinStorageClass;
+    var transactionStore: LeofcoinStorageClass;
+    var blockStore: LeofcoinStorageClass;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.1.58",
+  "version": "1.1.60",
   "description": "",
   "main": "src/peernet.js",
   "exports": {

package/src/dht/dht.ts

@@ -1,20 +1,20 @@
 export declare type DHTProvider = {
-  address: string,
+  address: string
   id: string
 }
 
 export declare type DHTProviderDistanceResult = {
-  provider: DHTProvider,
+  provider: DHTProvider
   /**
    * distance on earth between peers in km
    */
   distance: number
 }
 
-export declare type DHTProviderMapValue = {[index: string]: DHTProvider}
+export declare type DHTProviderMapValue = { [index: string]: DHTProvider }
 
 declare type Coordinates = {
-  longitude: number,
+  longitude: number
   latitude: number
 }
 
@@ -26,62 +26,62 @@ declare type Coordinates = {
 const lastFetched = {
   address: {
     value: undefined,
-    timestamp: 0,
+    timestamp: 0
   },
   ptr: {
     value: undefined,
-    timestamp: 0,
-  },
+    timestamp: 0
+  }
 }
 
 const fetchedCoordinates = {}
 
 const getAddress = async () => {
-  const {address} = lastFetched
+  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;
+    address.timestamp = Math.round(new Date().getTime() / 1000)
+    lastFetched.address = address
   }
 
   return address.value
 }
 
 const degreesToRadians = (degrees) => {
-  return degrees * Math.PI / 180;
+  return (degrees * Math.PI) / 180
 }
 
 const distanceInKmBetweenEarthCoordinates = (lat1, lon1, lat2, lon2) => {
-  const earthRadiusKm = 6371;
+  const earthRadiusKm = 6371
 
-  const dLat = degreesToRadians(lat2-lat1);
-  const dLon = degreesToRadians(lon2-lon1);
+  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;
+  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>
+  providerMap = new Map<string, DHTProviderMapValue>()
 
   /**
    *
    */
   constructor() {
-    this.providerMap = new Map();
+    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}
+      const { lat, lon } = (await response.json()) as { lat: number; lon: number }
+      fetchedCoordinates[address] = { latitude: lat, longitude: lon }
     }
     return fetchedCoordinates[address]
   }
@@ -91,25 +91,31 @@ export default class DhtEarth {
    * @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 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 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})
+      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 = await Promise.all(all)
     all = all.sort((previous, current) => previous.distance - current.distance)
-    return all[0].provider;
+    return all[0].provider
   }
 
   hasProvider(hash: string): boolean {
@@ -117,7 +123,7 @@ export default class DhtEarth {
   }
 
   providersFor(hash: string): DHTProviderMapValue {
-    let providers:  DHTProviderMapValue
+    let providers: DHTProviderMapValue
     if (this.providerMap.has(hash)) providers = this.providerMap.get(hash)
     return providers
   }
@@ -131,7 +137,7 @@ export default class DhtEarth {
     this.providerMap.set(hash, providers)
   }
 
-  removeProvider(address: string, hash: string){
+  removeProvider(address: string, hash: string) {
     if (this.providerMap.has(hash)) {
       const providers = this.providerMap.get(hash)
       delete providers[address]

package/src/discovery/peer-discovery.js

@@ -6,7 +6,7 @@ export default class PeerDiscovery {
   }
 
   _getPeerId(id) {
-    if (!peernet.peerMap || peernet.peerMap && peernet.peerMap.size === 0) return false
+    if (!peernet.peerMap || (peernet.peerMap && peernet.peerMap.size === 0)) return false
 
     for (const entry of [...peernet.peerMap.entries()]) {
       for (const _id of entry[1]) {
@@ -18,7 +18,7 @@ export default class PeerDiscovery {
   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 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)
@@ -26,7 +26,7 @@ export default class PeerDiscovery {
     response = await new peernet.protos['peernet-peer-response'](response.decoded.data)
 
     id = response.decoded.id
-    if (id === this.id) return;
+    if (id === this.id) return
 
     if (!peernet.peerMap.has(id)) peernet.peerMap.set(id, [peer.id])
     else {
@@ -40,11 +40,11 @@ export default class PeerDiscovery {
   }
 
   async discoverHandler(message, peer) {
-    const {id, proto} = message
+    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 (from === this.id) return
 
       if (!peernet.peerMap.has(from)) peernet.peerMap.set(from, [peer.id])
       else {
@@ -54,13 +54,13 @@ export default class PeerDiscovery {
           peernet.peerMap.set(from, connections)
         }
       }
-      const data = await new peernet.protos['peernet-peer-response']({id: this.id})
+      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})))
+      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 (from === this.id) return
 
       if (!peernet.peerMap.has(from)) peernet.peerMap.set(from, [peer.id])
       else {

package/src/handlers/data.js

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

package/src/handlers/message.js

@@ -24,7 +24,7 @@ export default class MessageHandler {
    * @param {String|PeernetMessage} data - data encoded message string
    * or the messageNode itself
    */
-  async prepareMessage(message) {    
+  async prepareMessage(message) {
     if (message.keys.includes('signature')) {
       message = await this.hashAndSignMessage(message)
     }

package/src/identity.ts

@@ -1,6 +1,6 @@
 import MultiWallet from '@leofcoin/multi-wallet'
 import base58 from '@vandeurenglenn/base58'
-import {encrypt, decrypt} from '@leofcoin/identity-utils'
+import { encrypt, decrypt } from '@leofcoin/identity-utils'
 import QrScanner from 'qr-scanner'
 import qrcode from 'qrcode'
 
@@ -26,31 +26,30 @@ export default class Identity {
 
   async load(password?: string): Promise<void> {
     if (password && password.includes('.txt')) {
-
       const { readFile } = await import('fs/promises')
       try {
         password = (await readFile(password)).toString()
       } catch (error) {
         console.error(error)
       }
-    } 
+    }
     if (!password) {
       // @ts-ignore
       const importee: { default: () => Promise<string> } = await import('./prompts/password.js')
       password = await importee.default()
     }
-    
+
     const accountExists = await globalThis.accountStore.has('public')
     if (accountExists) {
       const pub = await globalThis.accountStore.get('public')
-      this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
+      this.id = JSON.parse(new TextDecoder().decode(pub)).walletId
       const selected = await globalThis.walletStore.get('selected-account')
       this.selectedAccount = new TextDecoder().decode(selected)
     } else {
       const importee = await import(/* webpackChunkName: "generate-account" */ '@leofcoin/generate-account')
-      const {identity, accounts} = await importee.default(password, this.network)
-      await globalThis.accountStore.put('public', JSON.stringify({walletId: identity.walletId}));
-      
+      const { identity, accounts } = await importee.default(password, this.network)
+      await globalThis.accountStore.put('public', JSON.stringify({ walletId: identity.walletId }))
+
       await globalThis.walletStore.put('version', String(1))
       await globalThis.walletStore.put('accounts', JSON.stringify(accounts))
       await globalThis.walletStore.put('selected-account', accounts[0][1])
@@ -92,11 +91,13 @@ export default class Identity {
 
   async exportQR(password: string) {
     const exported = await this.export(password)
-    return globalThis.navigator ? await qrcode.toDataURL(exported) : await qrcode.toString(exported, {type: 'terminal'})
+    return globalThis.navigator
+      ? await qrcode.toDataURL(exported)
+      : await qrcode.toString(exported, { type: 'terminal' })
   }
 
-  async importQR(image: File | Blob , password: string) {
+  async importQR(image: File | Blob, password: string) {
     const multiWIF = await QrScanner.default.scanImage(image)
     return this.import(password, multiWIF)
   }
-}
+}

package/src/messages/chat.js

@@ -2,13 +2,12 @@ import proto from './../proto/chat-message.proto.js'
 import { FormatInterface } from '@leofcoin/codec-format-interface'
 
 export default class ChatMessage extends FormatInterface {
-
   get messageName() {
     return 'ChatMessage'
   }
 
   constructor(buffer) {
     const name = 'chat-message'
-    super(buffer, proto, {name})
+    super(buffer, proto, { name })
   }
 }

package/src/messages/data-response.js

@@ -2,13 +2,12 @@ import proto from './../proto/data-response.proto.js'
 import { FormatInterface } from '@leofcoin/codec-format-interface'
 
 export default class DataMessageResponse extends FormatInterface {
-
   get messageName() {
     return 'PeernetDataMessageResponse'
   }
 
   constructor(data) {
     const name = 'peernet-data-response'
-    super(data, proto, {name})
+    super(data, proto, { name })
   }
 }

package/src/messages/data.js

@@ -5,7 +5,6 @@ import { FormatInterface } from '@leofcoin/codec-format-interface'
  * @extends {CodecFormat}
  */
 export default class DataMessage extends FormatInterface {
-
   get messageName() {
     return 'PeernetDataMessage'
   }
@@ -13,6 +12,6 @@ export default class DataMessage extends FormatInterface {
    * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
    */
   constructor(data) {
-    super(data, proto, {name: 'peernet-data'})
+    super(data, proto, { name: 'peernet-data' })
   }
 }

package/src/messages/dht-response.js

@@ -2,13 +2,12 @@ import proto from './../proto/dht-response.proto.js'
 import { FormatInterface } from '@leofcoin/codec-format-interface'
 
 export default class DHTMessageResponse extends FormatInterface {
-
   get messageName() {
     return 'PeernetDHTMessageResponse'
   }
 
   constructor(data) {
     const name = 'peernet-dht-response'
-    super(data, proto, {name})
+    super(data, proto, { name })
   }
 }

package/src/messages/dht.js

@@ -10,13 +10,12 @@ import { FormatInterface } from '@leofcoin/codec-format-interface'
  `
  */
 export default class DHTMessage extends FormatInterface {
-
   get messageName() {
     return 'PeernetDHTMessage'
   }
 
   constructor(data) {
     const name = 'peernet-dht'
-    super(data, proto, {name})
+    super(data, proto, { name })
   }
 }

package/src/messages/file-link.js

@@ -5,7 +5,6 @@ import { FormatInterface } from '@leofcoin/codec-format-interface'
  * @extends {CodecFormat}
  */
 export default class PeernetFileLink extends FormatInterface {
-
   get messageName() {
     return 'PeernetFileLink'
   }
@@ -13,6 +12,6 @@ export default class PeernetFileLink extends FormatInterface {
    * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
    */
   constructor(data) {
-    super(data, proto, {name: 'peernet-file-link'})
+    super(data, proto, { name: 'peernet-file-link' })
   }
 }

package/src/messages/file.js

@@ -5,7 +5,6 @@ import { FormatInterface } from '@leofcoin/codec-format-interface'
  * @extends {CodecFormat}
  */
 export default class PeernetFile extends FormatInterface {
-
   get messageName() {
     return 'PeernetFile'
   }
@@ -13,6 +12,6 @@ export default class PeernetFile extends FormatInterface {
    * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
    */
   constructor(data) {
-    super(data, proto, {name: 'peernet-file'})
+    super(data, proto, { name: 'peernet-file' })
   }
 }

package/src/messages/peer-response.js

@@ -2,13 +2,12 @@ import proto from './../proto/peer-response.proto.js'
 import { FormatInterface } from '@leofcoin/codec-format-interface'
 
 export default class PeerMessageResponse extends FormatInterface {
-
   get messageName() {
     return 'PeernetPeerMessageResponse'
   }
 
   constructor(data) {
     const name = 'peernet-peer-response'
-    super(data, proto, {name})
+    super(data, proto, { name })
   }
 }

package/src/messages/peer.js

@@ -8,6 +8,6 @@ export default class PeerMessage extends FormatInterface {
 
   constructor(data) {
     const name = 'peernet-peer'
-    super(data, proto, {name})
+    super(data, proto, { name })
   }
 }

package/src/messages/peernet.js

@@ -2,13 +2,12 @@ import proto from './../proto/peernet.proto.js'
 import { FormatInterface } from '@leofcoin/codec-format-interface'
 
 export default class PeernetMessage extends FormatInterface {
-
   get messageName() {
     return 'PeernetMessage'
   }
 
   constructor(buffer) {
     const name = 'peernet-message'
-    super(buffer, proto, {name})
+    super(buffer, proto, { name })
   }
 }

package/src/messages/ps.js

@@ -8,6 +8,6 @@ export default class PsMessage extends FormatInterface {
 
   constructor(buffer) {
     const name = 'peernet-ps'
-    super(buffer, proto, {name})
+    super(buffer, proto, { name })
   }
 }

package/src/messages/request.js

@@ -2,13 +2,12 @@ import proto from './../proto/request.proto.js'
 import { FormatInterface } from '@leofcoin/codec-format-interface'
 
 export default class RequestMessage extends FormatInterface {
-
   get messageName() {
     return 'PeernetRequestMessage'
   }
 
   constructor(data) {
     const name = 'peernet-request'
-    super(data, proto, {name})
+    super(data, proto, { name })
   }
 }

package/src/messages/response.js

@@ -2,13 +2,12 @@ import proto from './../proto/response.proto.js'
 import { FormatInterface } from '@leofcoin/codec-format-interface'
 
 export default class ResponseMessage extends FormatInterface {
-
   get messageName() {
     return 'PeernetResponseMessage'
   }
 
   constructor(data) {
     const name = 'peernet-response'
-    super(data, proto, {name})
+    super(data, proto, { name })
   }
 }