@leofcoin/peernet 1.1.50 → 1.1.52

package/exports/browser/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/browser/peernet.js

@@ -1,2 +1,2 @@
-export { P as default } from './peernet-a4156bfd.js';
-import './value-157ab062.js';
+export { P as default } from './peernet-bc021698.js';
+import './value-4e80eeeb.js';

package/exports/browser/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/exports/browser/value-4e80eeeb.js

@@ -0,0 +1,73 @@
+const encode = (string) => {
+    if (typeof string === 'string')
+        return new TextEncoder().encode(string);
+    throw Error(`expected typeof String instead got ${string}`);
+};
+const decode = (uint8Array) => {
+    if (uint8Array instanceof Uint8Array)
+        return new TextDecoder().decode(uint8Array);
+    throw Error(`expected typeof uint8Array instead got ${uint8Array}`);
+};
+
+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');
+        }
+    }
+    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);
+    }
+}
+
+export { KeyPath as K, KeyValue as a };

package/exports/peernet.js

@@ -197,8 +197,7 @@ class DhtEarth {
         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();
             fetchedCoordinates[address] = { latitude: lat, longitude: lon };
         }
         return fetchedCoordinates[address];
@@ -222,6 +221,7 @@ class DhtEarth {
             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;
@@ -235,22 +235,20 @@ class DhtEarth {
             providers = this.providerMap.get(hash);
         return providers;
     }
-    addProvider(address, hash) {
-        let providers = new Set();
+    addProvider(provider, hash) {
+        let providers = {};
         if (this.providerMap.has(hash)) {
             providers = this.providerMap.get(hash);
         }
-        providers.add(address);
+        providers[provider.address] = provider;
         this.providerMap.set(hash, providers);
     }
     removeProvider(address, hash) {
-        let deleted = undefined;
         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;
     }
 }
 
@@ -391,8 +389,11 @@ globalThis.globalSub = globalThis.globalSub || new PubSub();
  * const peernet = new Peernet();
  */
 class Peernet {
+    storePrefix;
+    root;
     identity;
     stores = [];
+    peerId;
     /**
      * @type {Object}
      * @property {Object} peer Instance of Peer
@@ -411,6 +412,7 @@ class Peernet {
     #connections = {};
     requestProtos = {};
     _messageHandler;
+    _peerHandler;
     protos;
     /**
      * @access public
@@ -446,6 +448,7 @@ class Peernet {
             up: 0,
             down: 0,
         };
+        // @ts-ignore
         return this._init(options, password);
     }
     get id() {
@@ -584,7 +587,13 @@ class Peernet {
         else {
             process.on('SIGTERM', async () => {
                 process.stdin.resume();
-                await this.client.destroy();
+                try {
+                    await this.client.destroy();
+                }
+                catch (error) {
+                    // @ts-ignore
+                    await this.client.close();
+                }
                 process.exit();
             });
         }
@@ -724,21 +733,13 @@ class Peernet {
      * @param {String} hash
      */
     async providersFor(hash, store) {
-        let providers = await this.dht.providersFor(hash);
+        let providers = this.dht.providersFor(hash);
         // walk the network to find a provider
-        if (!providers || providers.length === 0) {
+        let tries = 0;
+        while (!providers && tries < 3 || Object.keys(providers).length === 0 && tries < 3) {
+            tries += 1;
             await this.walk(hash);
-            providers = await this.dht.providersFor(hash);
-            // second walk the network to find a provider
-            if (!providers || providers.length === 0) {
-                await this.walk(hash);
-                providers = await this.dht.providersFor(hash);
-            }
-            // last walk
-            if (!providers || providers.length === 0) {
-                await this.walk(hash);
-                providers = await this.dht.providersFor(hash);
-            }
+            providers = this.dht.providersFor(hash);
         }
         // undefined if no providers given
         return providers;
@@ -777,11 +778,11 @@ class Peernet {
     }
     async requestData(hash, store) {
         const providers = await this.providersFor(hash);
-        if (!providers || providers.size === 0)
+        if (!providers || Object.keys(providers).length === 0)
             throw nothingFoundError(hash);
         debug(`found ${providers.size} provider(s) for ${hash}`);
         // get closest peer on earth
-        const closestPeer = Array.from(providers)[0];
+        const closestPeer = Object.values(providers)[0];
         // get peer instance by id
         if (!closestPeer || !closestPeer.id)
             return this.requestData(hash, store?.name || store);
@@ -796,7 +797,7 @@ class Peernet {
                 // fallback and try every provider found
                 const promises = [];
                 const providers = await this.providersFor(hash, store);
-                for (const provider of providers) {
+                for (const provider of Object.values(providers)) {
                     const peer = this.#connections[provider.id];
                     if (peer)
                         promises.push(peer.request(node.encoded));
@@ -982,10 +983,10 @@ class Peernet {
      *
      * @param {String} hash
      * @param {Buffer} data
-     * @param {String} store - storeName to access
+     * @param {String} storeName - storeName to access
      */
-    async put(hash, data, store = 'data') {
-        store = globalThis[`${store}Store`];
+    async put(hash, data, storeName = 'data') {
+        const store = globalThis[`${storeName}Store`];
         return store.put(hash, data);
     }
     /**
@@ -1016,9 +1017,9 @@ class Peernet {
             // TODO: if peer subscribed
         }
     }
-    createHash(data, name) {
-        return new CodeHash(data, { name });
-    }
+    // createHash(data, name) {
+    //   return new CodeHash(data, {name})
+    // }
     /**
      *
      * @param {String} topic
@@ -1032,10 +1033,10 @@ class Peernet {
         console.log('removepeer', peer.id);
         const id = peer.id;
         await this.client._removePeer(peer);
-        console.log(this.client.peers[id]);
         if (this.client.peers[id]) {
             for (const connection of Object.keys(this.client.peers[id])) {
-                // if (this.client.peers[id][connection].connected === false) delete this.client.peers[id][connection] 
+                // if (this.client.peers[id][connection].connected === false) delete this.client.peers[id][connection]
+                // @ts-ignore
                 if (this.client.peers[id][connection].connected)
                     return this.client.emit('peerconnect', connection);
             }