@leofcoin/peernet 1.1.49 → 1.1.51

package/exports/store.js

@@ -4,67 +4,76 @@ import { readdirSync } from 'fs';
 import { mkdirp } from 'mkdirp';
 import { ClassicLevel } from 'classic-level';
 
-// import base32 from '@vandeurenglenn/base32'
-// import base58 from '@vandeurenglenn/base58'
-
-// export const encodings = {
-//   base58,
-//   base32
-// }
-
-const encode$1 = (string, encoding = 'utf-8') => {
-  if (typeof string === 'string') {
-    let encoded;
-    
-    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
-    encoded = new TextEncoder().encode(string);
-    return encoded
-  }
-  throw Error(`expected typeof String instead got ${string}`)
+const encode = (string) => {
+    if (typeof string === 'string')
+        return new TextEncoder().encode(string);
+    throw Error(`expected typeof String instead got ${string}`);
 };
-
-const decode$1 = (uint8Array, encoding) => {
-  if (uint8Array instanceof Uint8Array) {
-    let decoded;
-    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
-    decoded = new TextDecoder().decode(uint8Array);
-    
-    return decoded
-  }
-  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
+const decode = (uint8Array) => {
+    if (uint8Array instanceof Uint8Array)
+        return new TextDecoder().decode(uint8Array);
+    throw Error(`expected typeof uint8Array instead got ${uint8Array}`);
 };
 
-class KeyValue {
-
-  /**
-   * @param {string | Uint8Array} input
-   */
-  constructor(input) {
-    if (typeof input === 'string') {
-      this.uint8Array = encode$1(input);
-    } else if (input instanceof Uint8Array) {
-      this.uint8Array = input;
-    } else if (input instanceof KeyValue) {
-      this.uint8Array = input.uint8Array;
-    } else {
-      throw new Error('Invalid KeyValue, should be a String, Uint8Array or KeyValue')
+const pathSepS = '/';
+class KeyPath {
+    uint8Array;
+    constructor(input) {
+        if (typeof input === 'string') {
+            this.uint8Array = encode(input);
+        }
+        else if (input instanceof Uint8Array) {
+            this.uint8Array = input;
+        }
+        else if (input instanceof KeyPath) {
+            this.uint8Array = input.uint8Array;
+        }
+        else {
+            throw new Error('Invalid keyPath, should be a String, Uint8Array or KeyPath');
+        }
     }
-  }
-
-  isKeyValue() {
-    return true
-  }
-
-  /**
-   * Convert to the string representation
-   *
-   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
-   * @returns {string}
-   */
-  toString(encoding = 'utf8') {
-    return decode$1(this.uint8Array)
-  }
+    isKeyPath() {
+        return true;
+    }
+    toString() {
+        return decode(this.uint8Array);
+    }
+    /**
+     * Returns the `list` representation of this path.
+     *
+     * @example
+     * ```js
+     * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
+     * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
+     * ```
+     */
+    list() {
+        return this.toString().split(pathSepS).slice(1);
+    }
+}
 
+class KeyValue {
+    uint8Array;
+    constructor(input) {
+        if (typeof input === 'string') {
+            this.uint8Array = encode(input);
+        }
+        else if (input instanceof Uint8Array) {
+            this.uint8Array = input;
+        }
+        else if (input instanceof KeyValue) {
+            this.uint8Array = input.uint8Array;
+        }
+        else {
+            throw new Error('Invalid KeyValue, should be a String, Uint8Array or KeyValue');
+        }
+    }
+    isKeyValue() {
+        return true;
+    }
+    toString() {
+        return decode(this.uint8Array);
+    }
 }
 
 const init = (root, home = true) => {
@@ -79,149 +88,64 @@ const init = (root, home = true) => {
   return _root
 };
 
-// import base32 from '@vandeurenglenn/base32'
-// import base58 from '@vandeurenglenn/base58'
-
-// export const encodings = {
-//   base58,
-//   base32
-// }
-
-const encode = (string, encoding = 'utf-8') => {
-  if (typeof string === 'string') {
-    let encoded;
-    
-    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
-    encoded = new TextEncoder().encode(string);
-    return encoded
-  }
-  throw Error(`expected typeof String instead got ${string}`)
-};
-
-const decode = (uint8Array, encoding) => {
-  if (uint8Array instanceof Uint8Array) {
-    let decoded;
-    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
-    decoded = new TextDecoder().decode(uint8Array);
-    
-    return decoded
-  }
-  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
-};
-
-const pathSepS = '/';
-class KeyPath {
-
-  /**
-   * @param {string | Uint8Array} input
-   */
-  constructor(input) {
-    if (typeof input === 'string') {
-      this.uint8Array = encode(input);
-    } else if (input instanceof Uint8Array) {
-      this.uint8Array = input;
-    } else if (input instanceof KeyPath) {
-      this.uint8Array = input.uint8Array;
-    } else {
-      throw new Error('Invalid keyPath, should be a String, Uint8Array or KeyPath')
-    }
-  }
-  
-  isKeyPath() {
-    return true
-  }
-
-  /**
-   * Convert to the string representation
-   *
-   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
-   * @returns {string}
-   */
-  toString(encoding = 'hex') {
-    return decode(this.uint8Array)
-  }
-
-  /**
-   * Returns the `list` representation of this path.
-   *
-   * @returns string[]
-   *
-   * @example
-   * ```js
-   * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
-   * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
-   * ```
-   */
-  list() {
-    return this.toString().split(pathSepS).slice(1)
-  }
-
-}
-
 class Store {
-  constructor(name = 'storage', root, version = 'v1.0.0') {
-    this.name = name;
-    this.root = init(root);
-    this.version = version;
-
-    this.db = new ClassicLevel(join(this.root, this.name), { valueEncoding: 'view'});
-  }
-
-  toKeyPath(key) {
-    if (!key.isKeyPath()) key = new KeyPath(key);
-    return key.toString()
-  }
-  
-  toKeyValue(value) {
-    if (!value.isKeyValue()) value = new KeyValue(value);
-    return value.uint8Array
-  }
-
-  toUint8Array(buffer) {
-    return Buffer.isBuffer(buffer) ? new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / Uint8Array.BYTES_PER_ELEMENT) : buffer
-  }
-
-  async get(key) {
-    return this.toUint8Array(await this.db.get(this.toKeyPath(key))) 
-  }
-
-  async put(key, value) {
-    return this.db.put(this.toKeyPath(key), this.toKeyValue(value))
-  }
-
-  async delete(key) {
-    return this.db.del(this.toKeyPath(key))
-  }
-
-  async clear() {
-    return this.db.clear()
-  }
-
-  async values(limit = -1) {
-    const values = [];
-    for await (const value of this.db.values({limit})) {
-      values.push(this.toUint8Array(value));
+    db;
+    name;
+    root;
+    version;
+    constructor(name = 'storage', root, version = 'v1.0.0') {
+        this.name = name;
+        this.root = init(root);
+        this.version = version;
+        this.db = new ClassicLevel(join(this.root, this.name), { valueEncoding: 'view' });
     }
-    return values
-  }
-
-  async keys(limit = -1) {
-    const keys = [];
-    for await (const key of this.db.keys({limit})) {
-      keys.push(key);
+    toKeyPath(key) {
+        if (!key.isKeyPath())
+            key = new KeyPath(key);
+        return key.toString();
+    }
+    toKeyValue(value) {
+        if (!value.isKeyValue())
+            value = new KeyValue(value);
+        return value.uint8Array;
+    }
+    toUint8Array(buffer) {
+        return Buffer.isBuffer(buffer) ? new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / Uint8Array.BYTES_PER_ELEMENT) : buffer;
+    }
+    async get(key) {
+        return this.toUint8Array(await this.db.get(this.toKeyPath(key)));
+    }
+    async put(key, value) {
+        return this.db.put(this.toKeyPath(key), this.toKeyValue(value));
+    }
+    async delete(key) {
+        return this.db.del(this.toKeyPath(key));
+    }
+    async clear() {
+        return this.db.clear();
+    }
+    async values(limit = -1) {
+        const values = [];
+        for await (const value of this.db.values({ limit })) {
+            values.push(this.toUint8Array(value));
+        }
+        return values;
+    }
+    async keys(limit = -1) {
+        const keys = [];
+        for await (const key of this.db.keys({ limit })) {
+            keys.push(key);
+        }
+        return keys;
     }
-    return keys
-  }
-
     /**
-     * 
+     *
      * @param {object} options {  limit, gt, lt, reverse }
-     * @returns 
+     * @returns
      */
-  iterate(options) {
-    return this.db.iterator(options)
-  }
-
+    iterate(options) {
+        return this.db.iterator(options);
+    }
 }
 
 export { Store as default };

package/exports/types/dht/dht.d.ts

@@ -1,19 +1,41 @@
+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;
+};
 export default class DhtEarth {
-    providerMap: Map<string, Set<string>>;
+    providerMap: Map<string, DHTProviderMapValue>;
     /**
      *
      */
     constructor();
-    getCoordinates(address: string): Promise<object>;
+    getCoordinates(address: string): Promise<Coordinates>;
     /**
      * @param {Object} peer
      * @param {Object} provider
      * @return {Object} {provider, distance}
      */
-    getDistance(peer: object, provider: object): object;
-    closestPeer(providers: Array<any>): object;
+    getDistance(peer: {
+        latitude: number;
+        longitude: number;
+    }, provider: DHTProvider): Promise<DHTProviderDistanceResult>;
+    closestPeer(providers: Array<any>): Promise<DHTProvider>;
     hasProvider(hash: string): boolean;
-    providersFor(hash: string): Set<string>;
-    addProvider(address: string, hash: string): void;
-    removeProvider(address: string, hash: string): true | undefined;
+    providersFor(hash: string): DHTProviderMapValue;
+    addProvider(provider: DHTProvider, hash: string): void;
+    removeProvider(address: string, hash: string): void;
 }
+export {};

package/exports/types/identity.d.ts

@@ -0,0 +1,15 @@
+import MultiWallet from '@leofcoin/multi-wallet';
+export default class Identity {
+    #private;
+    network: MultiWallet.network;
+    id: string;
+    constructor(network: string);
+    get accounts(): Promise<[[name: string, externalAddress: string, internalAddress: string]]>;
+    getAccounts(): Promise<[[name: string, externalAddress: string, internalAddress: string]]>;
+    load(password?: string): Promise<void>;
+    sign(hash: Uint8Array): any;
+    export(password: string): Promise<string>;
+    import(password: any, encrypted: base58String): Promise<void>;
+    exportQR(password: string): Promise<any>;
+    importQR(image: File | Blob, password: string): Promise<void>;
+}

package/exports/types/peernet.d.ts

@@ -1,17 +1,12 @@
-/// <reference types="node" />
+/// <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';
-declare global {
-    var globalSub: PubSub;
-    var pubsub: PubSub;
-    var peernet: Peernet;
-    var LeofcoinStorage: typeof LeofcoinStorageClass;
-    var LeofcoinStorageClient: any;
-}
+import swarm from '@netpeer/p2pt-swarm';
+import P2PTPeer from '@netpeer/p2pt-swarm/peer';
 /**
  * @access public
  * @example
@@ -19,20 +14,18 @@ declare global {
  */
 export default class Peernet {
     #private;
+    storePrefix: string;
+    root: string;
     identity: Identity;
     stores: string[];
+    peerId: string;
     /**
      * @type {Object}
      * @property {Object} peer Instance of Peer
      */
     dht: DHT;
     /** @leofcoin/peernet-swarm/client */
-    client: {
-        connections: [];
-        id: string;
-        removePeer: (peer: string) => {};
-        close: () => {};
-    };
+    client: swarm;
     network: string;
     stars: string[];
     networkVersion: string;
@@ -44,6 +37,7 @@ export default class Peernet {
     autoStart: boolean;
     requestProtos: {};
     _messageHandler: MessageHandler;
+    _peerHandler: PeerDiscovery;
     protos: {};
     /**
      * @access public
@@ -63,7 +57,7 @@ export default class Peernet {
     get accounts(): Promise<[[name: string, externalAddress: string, internalAddress: string]]>;
     get defaultStores(): string[];
     addProto(name: any, proto: any): void;
-    addCodec(codec: any): void;
+    addCodec(codec: any): any;
     addStore(name: any, prefix: any, root: any, isPrivate?: boolean): Promise<void>;
     /**
      * @see MessageHandler
@@ -74,13 +68,13 @@ export default class Peernet {
      *
      * @return {Array} peerId
      */
-    get peers(): [string, unknown][];
-    get connections(): unknown[];
-    get peerEntries(): unknown[];
+    get peers(): [string, P2PTPeer][];
+    get connections(): P2PTPeer[];
+    get peerEntries(): P2PTPeer[];
     /**
      * @return {String} id - peerId
      */
-    getConnection(id: any): never;
+    getConnection(id: any): any;
     /**
      * @private
      *
@@ -89,7 +83,7 @@ export default class Peernet {
      *
      * @return {Promise} instance of Peernet
      */
-    _init(options: any, password: any): Peernet;
+    _init(options: any, password: any): Promise<Peernet>;
     start(): Promise<void>;
     addRequestHandler(name: any, method: any): void;
     sendMessage(peer: any, id: any, data: any): Promise<void>;
@@ -114,16 +108,16 @@ export default class Peernet {
      *
      * @param {String} hash
      */
-    providersFor(hash: string, store?: undefined): Promise<Set<string>>;
+    providersFor(hash: string, store?: undefined): Promise<import("./dht/dht.js").DHTProviderMapValue>;
     get block(): {
-        get: (hash: any) => Promise<any>;
-        put: (hash: any, data: any) => Promise<any>;
-        has: (hash: any) => Promise<any>;
+        get: (hash: string) => Promise<any>;
+        put: (hash: string, data: Uint8Array) => Promise<any>;
+        has: (hash: string) => Promise<any>;
     };
     get transaction(): {
-        get: (hash: any) => Promise<any>;
-        put: (hash: any, data: any) => Promise<any>;
-        has: (hash: any) => Promise<any>;
+        get: (hash: string) => Promise<any>;
+        put: (hash: string, data: Uint8Array) => Promise<any>;
+        has: (hash: string) => Promise<any>;
     };
     requestData(hash: any, store: any): any;
     get message(): {
@@ -207,9 +201,9 @@ export default class Peernet {
      *
      * @param {String} hash
      * @param {Buffer} data
-     * @param {String} store - storeName to access
+     * @param {String} storeName - storeName to access
      */
-    put(hash: any, data: any, store?: string): Promise<any>;
+    put(hash: string, data: Uint8Array, storeName?: string | LeofcoinStorageClass): Promise<any>;
     /**
      * @param {String} hash
      * @return {Boolean}
@@ -221,13 +215,12 @@ export default class Peernet {
      * @param {String|Object|Array|Boolean|Buffer} data
      */
     publish(topic: any, data: any): Promise<void>;
-    createHash(data: any, name: any): any;
     /**
      *
      * @param {String} topic
      * @param {Method} cb
      */
-    subscribe(topic: any, callback: any): Promise<void>;
+    subscribe(topic: string, callback: Function): Promise<void>;
     removePeer(peer: any): Promise<any>;
     get Buffer(): BufferConstructor;
 }

package/exports/types/types.d.ts

@@ -0,0 +1,16 @@
+import '@vandeurenglenn/debug';
+import PubSub from '@vandeurenglenn/little-pubsub';
+import Peernet from './peernet.js';
+import { LeofcoinStorage as LeofcoinStorageClass } from '@leofcoin/storage';
+declare global {
+    var debug: (message: any) => string;
+    var globalSub: PubSub;
+    var pubsub: PubSub;
+    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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.1.49",
+  "version": "1.1.51",
   "description": "",
   "main": "src/peernet.js",
   "exports": {
@@ -35,7 +35,7 @@
     "@leofcoin/multi-wallet": "^3.0.1",
     "@leofcoin/peernet-swarm": "^1.1.0",
     "@leofcoin/storage": "^3.0.0",
-    "@netpeer/p2pt-swarm": "^1.1.5",
+    "@netpeer/p2pt-swarm": "^1.3.2",
     "@types/node": "^18.11.18",
     "@vandeurenglenn/base32": "^1.1.0",
     "@vandeurenglenn/base58": "^1.1.0",

package/src/dht/dht.ts

@@ -1,3 +1,23 @@
+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
@@ -47,7 +67,7 @@ const distanceInKmBetweenEarthCoordinates = (lat1, lon1, lat2, lon2) => {
 }
 
 export default class DhtEarth {
-  providerMap = new Map<string, Set<string>>
+  providerMap = new Map<string, DHTProviderMapValue>
 
   /**
    *
@@ -55,12 +75,12 @@ export default class DhtEarth {
   constructor() {
     this.providerMap = new Map();
   }
-  async getCoordinates(address: string): Promise<object> {
+
+  async getCoordinates(address: string): Promise<Coordinates> {
     if (!fetchedCoordinates[address]) {
       const request = `https://whereis.leofcoin.org/?ip=${address}`
       let response = await fetch(request)
-      response = await response.json()
-      const {lat, lon} = response;
+      const {lat, lon} = await response.json() as { lat: number, lon: number}
       fetchedCoordinates[address] = {latitude: lat, longitude: lon}
     }
     return fetchedCoordinates[address]
@@ -71,20 +91,22 @@ export default class DhtEarth {
    * @param {Object} provider
    * @return {Object} {provider, distance}
    */
-  async getDistance(peer: object, provider: object): object {
+  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>): object {
+  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;
@@ -94,28 +116,26 @@ export default class DhtEarth {
     return this.providerMap.has(hash)
   }
 
-  providersFor(hash: string): Set<string> {
-    let providers
+  providersFor(hash: string): DHTProviderMapValue {
+    let providers:  DHTProviderMapValue
     if (this.providerMap.has(hash)) providers = this.providerMap.get(hash)
     return providers
   }
 
-  addProvider(address: string, hash: string) {
-    let providers:Set<string> = new Set()
+  addProvider(provider: DHTProvider, hash: string) {
+    let providers: DHTProviderMapValue
     if (this.providerMap.has(hash)) {
       providers = this.providerMap.get(hash)
     }
-    providers.add(address)
+    providers[provider.address] = provider
     this.providerMap.set(hash, providers)
   }
 
-  removeProvider(address: string, hash: string): true | undefined {
-    let deleted = undefined
+  removeProvider(address: string, hash: string){
     if (this.providerMap.has(hash)) {
       const providers = this.providerMap.get(hash)
-      deleted = providers.delete(address) 
-      deleted && this.providerMap.set(hash, providers)
+      delete providers[address]
+      this.providerMap.set(hash, providers)
     }
-    return deleted;
   }
 }