@leofcoin/peernet 0.16.6 → 0.17.0

package/exports/browser/peernet.js

@@ -0,0 +1,2 @@
+export { P as default } from './peernet-379769d5.js';
+import './value-40634404.js';

package/exports/browser/value-40634404.js

@@ -0,0 +1,64 @@
+// 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}`)
+};
+
+class KeyValue {
+
+  /**
+   * @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 KeyValue) {
+      this.uint8Array = input.uint8Array;
+    } else {
+      throw new Error('Invalid KeyValue, should be a String, Uint8Array or KeyValue')
+    }
+  }
+
+  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(this.uint8Array)
+  }
+
+}
+
+export { KeyValue as K };

package/{dist/module → 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/src/storage';
+import { Codec, codecs } from '@leofcoin/codec-format-interface';
+import LeofcoinStorage from '@leofcoin/storage';
 
 const BufferToUint8Array = data => {
   if (data.type === 'Buffer') {
@@ -259,94 +259,6 @@ class DhtEarth {
   }
 }
 
-var codecs = {
-  // just a hash
-  'disco-hash': {
-    codec: parseInt('30', 16),
-    hashAlg: 'dbl-keccak-256', // ,
-    // testnet: 'olivia'
-  },
-  'peernet-peer-response': {
-    codec: parseInt('707072', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-peer': {
-    codec: parseInt('7070', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-dht': {
-    codec: parseInt('706468', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-dht-response': {
-    codec: parseInt('706472', 16),
-    hashAlg: 'keccak-256',
-  },
-  // data
-  'peernet-data': {
-    codec: parseInt('706461', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-data-response': {
-    codec: parseInt('70646172', 16),
-    hashAlg: 'keccak-256',
-  },
-  // message
-  'peernet-message': {
-    codec: parseInt('706d65', 16),
-    hashAlg: 'keccak-256',
-  },
-  // pubsub
-  'peernet-ps': {
-    codec: parseInt('707073', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-response': {
-    codec: parseInt('7072', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-request': {
-    codec: parseInt('707271', 16),
-    hashAlg: 'keccak-256',
-  },
-  // normal block
-  'leofcoin-block': {
-    codec: parseInt('6c62', 16),
-    hashAlg: 'dbl-keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  'leofcoin-tx': {
-    codec: parseInt('6c74', 16),
-    hashAlg: 'dbl-keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  // itx
-  'leofcoin-itx': {
-    codec: parseInt('6c69', 16),
-    hashAlg: 'keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  // peer reputation
-  'leofcoin-pr': {
-    codec: parseInt('6c70', 16),
-    hashAlg: 'keccak-256', // ,
-    // testnet: 'olivia'
-  },
-  // chat message
-  'chat-message': {
-    codec: parseInt('70636d', 16),
-    hashAlg: 'dbl-keccak-256',
-  },
-  'peernet-file' : {
-    codec: parseInt('7066', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-file-response' : {
-    codec: parseInt('706672', 16),
-    hashAlg: 'keccak-256',
-  }
-};
-
 class MessageHandler {
   constructor(network) {
     this.network = network;
@@ -381,7 +293,7 @@ class MessageHandler {
    * or the messageNode itself
    */
   async prepareMessage(message) {    
-    if (message.keys.indexOf('signature') !== -1) {
+    if (message.keys.includes('signature')) {
       message = await this.hashAndSignMessage(message);
     }
 
@@ -440,13 +352,12 @@ class Peernet {
     this.network = options.network || 'leofcoin';
     this.stars = options.stars;
     const parts = this.network.split(':');
-    this.networkVersion = options.networkVersion ? options.networkVersion : parts.length > 1 ? parts[1] : 'mainnet';
+    this.networkVersion = options.networkVersion || parts.length > 1 ? parts[1] : 'mainnet';
 
     if (!options.storePrefix) options.storePrefix = 'lfc';
     if (!options.port) options.port = 2000;
     if (!options.root) {
-      if (parts[1]) options.root = `.${parts[0]}/${parts[1]}`;
-      else options.root = `.${this.network}`;
+      parts[1] ? options.root = `.${parts[0]}/${parts[1]}` : options.root = `.${this.network}`;
     }
     
     globalThis.peernet = this;
@@ -461,10 +372,6 @@ class Peernet {
     return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message']
   }
 
-  get codecs() {
-    return codecs
-  }
-
   addProto(name, proto) {
     if (!globalThis.peernet.protos[name]) globalThis.peernet.protos[name] = proto;
   }
@@ -478,13 +385,13 @@ class Peernet {
         name === 'data' || name === 'message') isPrivate = false;
 
     let Storage;
-    if (this.hasDaemon) {
-      Storage = LeofcoinStorageClient;
-    } else {
-      Storage = LeofcoinStorage;
+    
+    this.hasDaemon ? Storage = LeofcoinStorageClient : Storage = LeofcoinStorage;
+    
+    if (!globalThis[`${name}Store`]) {
+      globalThis[`${name}Store`] = new Storage(name, root);
+      await globalThis[`${name}Store`].init();
     }
-    globalThis[`${name}Store`] = globalThis[`${name}Store`] ||
-      await new Storage(name, root);
 
     globalThis[`${name}Store`].private = isPrivate;
     if (!isPrivate) this.stores.push(name);
@@ -542,6 +449,7 @@ class Peernet {
      * @property {Object} peer Instance of Peer
      */
     this.stores = [];
+    this.codecs = {...codecs};
     this.requestProtos = {};
     this.storePrefix = options.storePrefix;
     this.root = options.root;
@@ -560,7 +468,7 @@ class Peernet {
       ChatMessage,
       PeernetFile
       // FolderMessageResponse
-    } = await import(/* webpackChunkName: "messages" */ './messages-bce1b91d.js');
+    } = await import(/* webpackChunkName: "messages" */ './messages-796c4d5c.js');
 
     /**
      * proto Object containing protos
@@ -591,7 +499,7 @@ class Peernet {
 
     const {daemon, environment} = await target();
     this.hasDaemon = daemon;
-
+    
     for (const store of this.defaultStores) {
       await this.addStore(store, options.storePrefix, options.root);
     }
@@ -609,7 +517,7 @@ class Peernet {
       // TODO: remove when on mainnet
       try {
         this.accounts = JSON.parse(accounts);
-      } catch (e) {
+      } catch {
         this.accounts = [accounts.split(',')];
       }
     } else {
@@ -648,13 +556,13 @@ class Peernet {
     pubsub.subscribe('peer:data', dataHandler);
 
 
-    const importee = await import(/* webpackChunkName: "peernet-swarm" */ '@leofcoin/peernet-swarm');
+    const importee = await import(/* webpackChunkName: "peernet-swarm" */ '@leofcoin/peernet-swarm/client');
     /**
      * @access public
      * @type {PeernetClient}
      */
     this.client = new importee.default(this.id, this.networkVersion, this.stars);
-    if (globalThis.onbeforeunload) {
+    if (globalThis.navigator) {
       globalThis.addEventListener('beforeunload', async () => this.client.close());
     } else {
       process.on('SIGTERM', async () => {
@@ -678,6 +586,49 @@ class Peernet {
 
   }
 
+  async handleDHT(peer, id, proto) {
+    let { hash, store } = proto.decoded;
+    let has;
+
+    if (store) {
+      store = globalThis[`${store}Store`];
+      has = store.private ? false : await store.has(hash);
+    } else {
+      has = await this.has(hash);
+    }
+
+    const data = await new globalThis.peernet.protos['peernet-dht-response']({hash, has});
+    const node = await this.prepareMessage(data);
+
+    this.sendMessage(peer, id, node.encoded);
+  }
+
+  async handleData(peer, id, proto) {
+    let { hash, store } = proto.decoded;
+    let data;
+    store = globalThis[`${store}Store`] || await this.whichStore([...this.stores], hash);
+    
+    if (store && !store.private) {
+      data = await store.get(hash);
+
+      if (data) {
+        data = await new globalThis.peernet.protos['peernet-data-response']({hash, data});
+
+        const node = await this.prepareMessage(data);
+        this.sendMessage(peer, id, node.encoded);
+      }
+    }
+  }
+
+  async handleRequest(peer, id, proto) {
+    const method = this.requestProtos[proto.decoded.request];
+    if (method) {
+      const data = await method();
+      const node = await this.prepareMessage(data);
+      this.sendMessage(peer, id, node.encoded);
+    }
+  }
+
   /**
    * @private
    *
@@ -685,54 +636,25 @@ class Peernet {
    * @param {PeernetPeer} peer - peernet peer
    */
   async _protoHandler(message, peer, from) {
-
     const {id, proto} = message;
     this.bw.down += proto.encoded.length;
-      if (proto.name === 'peernet-dht') {
-        let { hash, store } = proto.decoded;
-        let has;
-
-        if (!store) {
-          has = await this.has(hash);
-        } else {
-          store = globalThis[`${store}Store`];
-          if (store.private) has = false;
-          else has = await store.has(hash);
-        }
-        const data = await new globalThis.peernet.protos['peernet-dht-response']({hash, has});
-        const node = await this.prepareMessage(data);
-
-        this.sendMessage(peer, id, node.encoded);
-      } else if (proto.name === 'peernet-data') {
-        let { hash, store } = proto.decoded;
-        let data;
-        if (!store) {
-          store = await this.whichStore([...this.stores], hash);
-        } else {
-          store = globalThis[`${store}Store`];
-        }
-        if (store && !store.private) {
-          data = await store.get(hash);
-
-          if (data) {
-            data = await new globalThis.peernet.protos['peernet-data-response']({hash, data});
-
-            const node = await this.prepareMessage(data);
-            this.sendMessage(peer, id, node.encoded);
-          }
-        }
+    switch(proto.name) {
+      case 'peernet-dht': {
+        this.handleDHT(peer, id, proto);
+        break
+      }
+      case 'peenet-data': {
+        this.handleData(peer, id, proto);
+        break
+      }
+      case 'peernet-request': {
+        this.handleRequest(peer, id, proto);
+      }
 
-      } else if (proto.name === 'peernet-request') {
-        const method = this.requestProtos[proto.decoded.request];
-        if (method) {
-          const data = await method();
-          const node = await this.prepareMessage(data);
-          this.sendMessage(peer, id, node.encoded);
-        }
-      } else if (proto.name === 'peernet-ps' && peer.peerId !== this.id) {
-        globalSub.publish(proto.decoded.topic, proto.decoded.data);
+      case 'peernet-ps': {
+        if (peer.peerId !== this.id) globalSub.publish(proto.decoded.topic, proto.decoded.data);
       }
-    // }
+    }
   }
 
   /**
@@ -839,7 +761,7 @@ class Peernet {
     // get closest peer on earth
     const closestPeer = await this.dht.closestPeer(providers);
     // get peer instance by id
-    if (!closestPeer || !closestPeer.id) return this.requestData(hash, store?.name ? store?.name : store)
+    if (!closestPeer || !closestPeer.id) return this.requestData(hash, store?.name || store)
 
     const id = closestPeer.id;
     if (this.connections) {
@@ -847,7 +769,7 @@ class Peernet {
         if (peer.peerId === id) return peer
       });
 
-      let data = await new globalThis.peernet.protos['peernet-data']({hash, store: store?.name ? store?.name : store});
+      let data = await new globalThis.peernet.protos['peernet-data']({hash, store: store?.name || store});
 
       const node = await this.prepareMessage(data);
       if (closest[0]) data = await closest[0].request(node.encoded);
@@ -864,7 +786,7 @@ class Peernet {
 
       // this.put(hash, proto.decoded.data)
     }
-    return null
+    return
   }
 
 
@@ -970,8 +892,7 @@ class Peernet {
   async ls(hash, options) {
     let data;
     const has = await dataStore.has(hash);
-    if (has) data = await dataStore.get(hash);
-    else data = await this.requestData(hash, 'data');
+    data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
 
     const node = await new peernet.protos['peernet-file'](data);
     await node.decode();
@@ -988,8 +909,7 @@ class Peernet {
   async cat(hash, options) {
     let data;
     const has = await dataStore.has(hash);
-    if (has) data = await dataStore.get(hash);
-    else data = await this.requestData(hash, 'data');
+    data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
     const node = await new peernet.protos['peernet-file'](data);
 
     if (node.decoded?.links.length > 0) throw new Error(`${hash} is a directory`)
@@ -1009,7 +929,7 @@ class Peernet {
       const has = await store.has(hash);
       if (has) return store
       if (stores.length > 0) return this.whichStore(stores, hash)
-    } else return null
+    } else return
   }
 
   /**
@@ -1026,7 +946,7 @@ class Peernet {
     if (store && await store.has(hash)) data = await store.get(hash);
     if (data) return data
 
-    return this.requestData(hash, store?.name ? store.name : store)
+    return this.requestData(hash, store?.name || store)
   }
 
   /**
@@ -1048,8 +968,7 @@ class Peernet {
   async has(hash) {
     const store = await this.whichStore([...this.stores], hash);
     if (store) {
-      if (store.private) return false
-      else return true
+      return store.private ? false : true
     }
     return false
   }
@@ -1081,9 +1000,9 @@ class Peernet {
    * @param {String} topic
    * @param {Method} cb
    */
-  async subscribe(topic, cb) {
+  async subscribe(topic, callback) {
     // TODO: if peer subscribed
-    globalSub.subscribe(topic, cb);
+    globalSub.subscribe(topic, callback);
   }
 
   async removePeer(peer) {

package/exports/store.js

@@ -0,0 +1,225 @@
+import { join } from 'path';
+import { homedir, platform } from 'os';
+import { readdirSync } from 'fs';
+import { execSync } from 'child_process';
+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 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}`)
+};
+
+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')
+    }
+  }
+
+  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)
+  }
+
+}
+
+const mkdirp = path => execSync(`mkdir "${platform() === 'win32' ? path.replace(/\//g, '\\') : path}"`);
+
+const init = (root, home = true) => {
+  let _root;
+  if (home) _root = join(homedir(), root);
+    if (readdirSync) try {
+      readdirSync(_root);
+    } catch (e) {
+      mkdirp(_root);
+    }
+
+    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('base32')
+  }
+  
+  toKeyValue(value) {
+    if (!value.isKeyValue()) value = new KeyValue(value);
+    return value.uint8Array
+  }
+
+  async get(key) {
+    return 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(value);
+    }
+    return values
+  }
+
+  async keys(limit = -1) {
+    const keys = [];
+    for await (const key of this.db.keys({limit})) {
+      keys.push(key);
+    }
+    return keys
+  }
+
+    /**
+     * 
+     * @param {object} options {  limit, gt, lt, reverse }
+     * @returns 
+     */
+  iterate(options) {
+    return this.db.iterator(options)
+  }
+
+}
+
+export { Store as default };