@leofcoin/peernet 1.1.46 → 1.1.48

package/exports/peernet.js

@@ -1,7 +1,7 @@
 import '@vandeurenglenn/debug';
 import PubSub from '@vandeurenglenn/little-pubsub';
 import { Codec } from '@leofcoin/codec-format-interface';
-import LeofcoinStorage from '@leofcoin/storage';
+import LeofcoinStorageClass from '@leofcoin/storage';
 import { utils } from '@leofcoin/codecs';
 import MultiWallet from '@leofcoin/multi-wallet';
 import base58 from '@vandeurenglenn/base58';
@@ -10,55 +10,54 @@ import QrScanner from 'qr-scanner';
 import qrcode from 'qrcode';
 
 const BufferToUint8Array = data => {
-    if (data.type === 'Buffer') {
-        data = new Uint8Array(data.data);
-    }
-    return data;
+  if (data.type === 'Buffer') {
+    data = new Uint8Array(data.data);
+  }
+  return data
 };
+
 const protoFor = (message) => {
-    const codec = new Codec(message);
-    if (!codec.name)
-        throw new Error('proto not found');
-    const Proto = globalThis.peernet.protos[codec.name];
-    if (!Proto)
-        throw (new Error(`No proto defined for ${codec.name}`));
-    return new Proto(message);
+  const codec = new Codec(message);
+  if (!codec.name) throw new Error('proto not found')
+  const Proto = globalThis.peernet.protos[codec.name];
+  if (!Proto) throw (new Error(`No proto defined for ${codec.name}`))
+  return new Proto(message)
 };
+
 /**
  * wether or not a peernet daemon is active
  * @return {Boolean}
  */
 const hasDaemon = async () => {
-    try {
-        let response = await fetch('http://127.0.0.1:1000/api/version');
-        response = await response.json();
-        return Boolean(response.client === '@peernet/api/http');
-    }
-    catch (e) {
-        return false;
-    }
+  try {
+    let response = await fetch('http://127.0.0.1:1000/api/version');
+    response = await response.json();
+    return Boolean(response.client === '@peernet/api/http')
+  } catch (e) {
+    return false
+  }
 };
+
 const https = () => {
-    if (!globalThis.location)
-        return false;
-    return Boolean(globalThis.location.protocol === 'https:');
+  if (!globalThis.location) return false;
+  return Boolean(globalThis.location.protocol === 'https:')
 };
+
 /**
  * Get current environment
  * @return {String} current environment [node, electron, browser]
  */
 const environment = () => {
-    const _navigator = globalThis.navigator;
-    if (!_navigator) {
-        return 'node';
-    }
-    else if (_navigator && /electron/i.test(_navigator.userAgent)) {
-        return 'electron';
-    }
-    else {
-        return 'browser';
-    }
+  const _navigator = globalThis.navigator;
+  if (!_navigator) {
+    return 'node'
+  } else if (_navigator && /electron/i.test(_navigator.userAgent)) {
+    return 'electron'
+  } else {
+    return 'browser'
+  }
 };
+
 /**
  * * Get current environment
  * @return {Object} result
@@ -66,84 +65,84 @@ const environment = () => {
  * @property {Boolean} reult.environment Current environment
  */
 const target = async () => {
-    let daemon = false;
-    if (!https())
-        daemon = await hasDaemon();
-    return { daemon, environment: environment() };
+  let daemon = false;
+  if (!https()) daemon = await hasDaemon();
+
+  return {daemon, environment: environment()}
 };
 
 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;
+  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 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 })));
+  }
+
+  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);
         }
-        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);
-                }
-            }
+      }
+      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);
         }
+      }
     }
+  }
 }
 
 /**
@@ -256,52 +255,55 @@ class DhtEarth {
 }
 
 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;
+  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
+  }
 }
 
-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);
+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);
 };
 
 const dhtError = (proto) => {
-    const text = `Received proto ${proto.name} expected peernet-dht-response`;
-    return new Error(`Routing error: ${text}`);
+  const text = `Received proto ${proto.name} expected peernet-dht-response`;
+  return new Error(`Routing error: ${text}`)
 };
+
 const nothingFoundError = (hash) => {
-    return new Error(`nothing found for ${hash}`);
+  return new Error(`nothing found for ${hash}`)
 };
 
 class Identity {
@@ -379,10 +381,10 @@ class Identity {
     }
 }
 
-globalThis.LeofcoinStorage = LeofcoinStorage;
+globalThis.LeofcoinStorage = LeofcoinStorageClass;
 globalThis.leofcoin = globalThis.leofcoin || {};
-globalThis.pubsub = globalThis.pubsub || new PubSub();
-globalThis.globalSub = globalThis.globalSub || new PubSub();
+pubsub = pubsub || new PubSub();
+globalSub = globalSub || new PubSub();
 /**
  * @access public
  * @example
@@ -402,11 +404,14 @@ class Peernet {
     stars;
     networkVersion;
     bw;
+    hasDaemon = false;
     autoStart = true;
     #starting = false;
     #started = false;
     #connections = {};
     requestProtos = {};
+    _messageHandler;
+    protos;
     /**
      * @access public
      * @param {Object} options
@@ -436,7 +441,7 @@ class Peernet {
         if (!options.root) {
             parts[1] ? options.root = `.${parts[0]}/${parts[1]}` : options.root = `.${this.network}`;
         }
-        globalThis.peernet = this;
+        peernet = this;
         this.bw = {
             up: 0,
             down: 0,
@@ -512,7 +517,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-6645d42e.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-dc960cb3.js');
         /**
          * proto Object containing protos
          * @type {Object}

package/exports/types/peernet.d.ts

@@ -0,0 +1,233 @@
+/// <reference types="node" />
+import '@vandeurenglenn/debug';
+import PubSub from '@vandeurenglenn/little-pubsub';
+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;
+}
+/**
+ * @access public
+ * @example
+ * const peernet = new Peernet();
+ */
+export default class Peernet {
+    #private;
+    identity: Identity;
+    stores: string[];
+    /**
+     * @type {Object}
+     * @property {Object} peer Instance of Peer
+     */
+    dht: DHT;
+    /** @leofcoin/peernet-swarm/client */
+    client: {
+        connections: [];
+        id: string;
+        removePeer: (peer: string) => {};
+        close: () => {};
+    };
+    network: string;
+    stars: string[];
+    networkVersion: string;
+    bw: {
+        up: number;
+        down: number;
+    };
+    hasDaemon: boolean;
+    autoStart: boolean;
+    requestProtos: {};
+    _messageHandler: MessageHandler;
+    protos: {};
+    /**
+     * @access public
+     * @param {Object} options
+     * @param {String} options.network - desired network
+     * @param {String} options.stars - star list for selected network (these should match, don't mix networks)
+     * @param {String} options.root - path to root directory
+     * @param {String} options.storePrefix - prefix for datatores (lfc)
+     *
+     * @return {Promise} instance of Peernet
+     *
+     * @example
+     * const peernet = new Peernet({network: 'leofcoin', root: '.leofcoin'});
+     */
+    constructor(options: any, password: any);
+    get id(): string;
+    get accounts(): Promise<[[name: string, externalAddress: string, internalAddress: string]]>;
+    get defaultStores(): string[];
+    addProto(name: any, proto: any): void;
+    addCodec(codec: any): void;
+    addStore(name: any, prefix: any, root: any, isPrivate?: boolean): Promise<void>;
+    /**
+     * @see MessageHandler
+     */
+    prepareMessage(data: any): Promise<any>;
+    /**
+     * @access public
+     *
+     * @return {Array} peerId
+     */
+    get peers(): [string, unknown][];
+    get connections(): unknown[];
+    get peerEntries(): unknown[];
+    /**
+     * @return {String} id - peerId
+     */
+    getConnection(id: any): never;
+    /**
+     * @private
+     *
+     * @param {Object} options
+     * @param {String} options.root - path to root directory
+     *
+     * @return {Promise} instance of Peernet
+     */
+    _init(options: any, password: any): Peernet;
+    start(): Promise<void>;
+    addRequestHandler(name: any, method: any): void;
+    sendMessage(peer: any, id: any, data: any): Promise<void>;
+    handleDHT(peer: any, id: any, proto: any): Promise<void>;
+    handleData(peer: any, id: any, proto: any): Promise<void>;
+    handleRequest(peer: any, id: any, proto: any): Promise<void>;
+    /**
+     * @private
+     *
+     * @param {Buffer} message - peernet message
+     * @param {PeernetPeer} peer - peernet peer
+     */
+    _protoHandler(message: any, peer: any, from: any): Promise<void>;
+    /**
+     * performs a walk and resolves first encounter
+     *
+     * @param {String} hash
+     */
+    walk(hash: any): Promise<any[]>;
+    /**
+     * Override DHT behavior, try's finding the content three times
+     *
+     * @param {String} hash
+     */
+    providersFor(hash: string, store?: undefined): Promise<Set<string>>;
+    get block(): {
+        get: (hash: any) => Promise<any>;
+        put: (hash: any, data: any) => Promise<any>;
+        has: (hash: any) => Promise<any>;
+    };
+    get transaction(): {
+        get: (hash: any) => Promise<any>;
+        put: (hash: any, data: any) => Promise<any>;
+        has: (hash: any) => Promise<any>;
+    };
+    requestData(hash: any, store: any): any;
+    get message(): {
+        /**
+         * Get content for given message hash
+         *
+         * @param {String} hash
+         */
+        get: (hash: any) => Promise<any>;
+        /**
+         * put message content
+         *
+         * @param {String} hash
+         * @param {Buffer} message
+         */
+        put: (hash: any, message: any) => Promise<any>;
+        /**
+         * @param {String} hash
+         * @return {Boolean}
+         */
+        has: (hash: any) => Promise<any>;
+    };
+    get data(): {
+        /**
+         * Get content for given data hash
+         *
+         * @param {String} hash
+         */
+        get: (hash: any) => Promise<any>;
+        /**
+         * put data content
+         *
+         * @param {String} hash
+         * @param {Buffer} data
+         */
+        put: (hash: any, data: any) => Promise<any>;
+        /**
+         * @param {String} hash
+         * @return {Boolean}
+         */
+        has: (hash: any) => Promise<any>;
+    };
+    get folder(): {
+        /**
+         * Get content for given data hash
+         *
+         * @param {String} hash
+         */
+        get: (hash: any) => Promise<any>;
+        /**
+         * put data content
+         *
+         * @param {String} hash
+         * @param {Buffer} data
+         */
+        put: (hash: any, data: any) => Promise<any>;
+        /**
+         * @param {String} hash
+         * @return {Boolean}
+         */
+        has: (hash: any) => Promise<any>;
+    };
+    addFolder(files: any): Promise<any>;
+    ls(hash: any, options: any): Promise<any[]>;
+    cat(hash: any, options: any): Promise<any>;
+    /**
+     * goes trough given stores and tries to find data for given hash
+     * @param {Array} stores
+     * @param {string} hash
+     */
+    whichStore(stores: any, hash: any): any;
+    /**
+     * Get content for given hash
+     *
+     * @param {String} hash - the hash of the wanted data
+     * @param {String} store - storeName to access
+     */
+    get(hash: any, store: any): Promise<any>;
+    /**
+     * put content
+     *
+     * @param {String} hash
+     * @param {Buffer} data
+     * @param {String} store - storeName to access
+     */
+    put(hash: any, data: any, store?: string): Promise<any>;
+    /**
+     * @param {String} hash
+     * @return {Boolean}
+     */
+    has(hash: any): Promise<boolean>;
+    /**
+     *
+     * @param {String} topic
+     * @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>;
+    removePeer(peer: any): Promise<any>;
+    get Buffer(): BufferConstructor;
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.1.46",
+  "version": "1.1.48",
   "description": "",
   "main": "src/peernet.js",
   "exports": {
     ".": {
       "import": "./exports/peernet.js",
-      "require": "./exports/commonjs/peernet.js"
+      "require": "./exports/commonjs/peernet.js",
+      "types": "./exports/types/peernet.d.ts"
     },
     "./browser": "./exports/browser/peernet.js"
   },

package/rollup.config.js

@@ -34,7 +34,7 @@ export default [{
       mainFields: ['browser', 'module', 'main']
     }),
     
-    typescript({...tsconfig, outDir: './exports/browser'})
+    typescript({ compilerOptions: { outDir: './exports/browser'} })
   ],
   external: [
     './prompts/password.js'
@@ -49,7 +49,7 @@ export default [{
     modify({
       "@netpeer/p2pt-swarm": '@netpeer/p2pt-swarm'
     }),
-    typescript({...tsconfig, outDir: './exports'})
+    typescript({ compilerOptions: { outDir: './exports', declarationDir: './exports/types'} })
   ],
   external: [
     './prompts/password.js'