@leofcoin/peernet 1.1.79 → 1.1.81

package/exports/peernet.js

@@ -3,146 +3,147 @@ import PubSub from '@vandeurenglenn/little-pubsub';
 import { Codec } from '@leofcoin/codec-format-interface';
 import { Storage } from '@leofcoin/storage';
 import { utils } from '@leofcoin/codecs';
-import MultiWallet from '@leofcoin/multi-wallet';
-import base58 from '@vandeurenglenn/base58';
-import { decrypt } from '@leofcoin/identity-utils';
-import QrScanner from 'qr-scanner';
-import qrcode from 'qrcode';
+import Identity from './identity.js';
+import '@leofcoin/multi-wallet';
+import '@vandeurenglenn/base58';
+import '@leofcoin/identity-utils';
+import 'qr-scanner';
+import 'qrcode';
 
-const BufferToUint8Array = (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 ${message}`)
-  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
-  }
-};
-
-const 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'
-  }
-};
-
-/**
- * * Get current environment
- * @return {Object} result
- * @property {Boolean} reult.daemon whether or not daemon is running
- * @property {Boolean} reult.environment Current environment
- */
-const target = async () => {
-  let daemon = false;
-  if (!https()) daemon = await hasDaemon();
-
-  return { daemon, environment: environment() }
+const BufferToUint8Array = (data) => {
+  if (data.type === 'Buffer') {
+    data = new Uint8Array(data.data);
+  }
+  return data
 };
 
-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
-  }
-
-  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 })));
-    } 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 protoFor = (message) => {
+  const codec = new Codec(message);
+  if (!codec.name) throw new Error(`proto not found ${message}`)
+  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
+  }
+};
+
+const 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'
+  }
+};
+
+/**
+ * * Get current environment
+ * @return {Object} result
+ * @property {Boolean} reult.daemon whether or not daemon is running
+ * @property {Boolean} reult.environment Current environment
+ */
+const target = async () => {
+  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
+  }
+
+  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 })));
+    } 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);
+        }
+      }
+    }
+  }
 }
 
 /**
@@ -254,146 +255,61 @@ 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
-  }
+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
+  }
 }
 
-const dataHandler = async (message) => {
-  if (!message) return
-
-  try {
-    const { data, id, from, peer } = message;
-    const proto = await protoFor(data);
-    peernet._protoHandler({ id, proto }, peernet.connections[from] || peer, from);
-  } catch (error) {
-    console.error(error);
-  }
+const dataHandler = async (message) => {
+  if (!message) return
+
+  try {
+    const { data, id, from, peer } = message;
+    const proto = await protoFor(data);
+    peernet._protoHandler({ id, proto }, peernet.connections[from] || peer, from);
+  } catch (error) {
+    console.error(error);
+  }
 };
 
-const dhtError = (proto) => {
-  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}`)
+const dhtError = (proto) => {
+  const text = `Received proto ${proto.name} expected peernet-dht-response`;
+  return new Error(`Routing error: ${text}`)
 };
 
-class Identity {
-    #wallet;
-    network;
-    id;
-    selectedAccount;
-    constructor(network) {
-        this.network = network;
-    }
-    get accounts() {
-        return this.getAccounts();
-    }
-    async getAccounts() {
-        let accounts = await globalThis.walletStore.get('accounts');
-        accounts = new TextDecoder().decode(accounts);
-        return JSON.parse(accounts);
-    }
-    async load(password) {
-        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 = await import('./src/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;
-            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 }));
-            await globalThis.walletStore.put('version', String(1));
-            await globalThis.walletStore.put('accounts', JSON.stringify(accounts));
-            await globalThis.walletStore.put('selected-account', accounts[0][1]);
-            await globalThis.walletStore.put('identity', JSON.stringify(identity));
-            this.selectedAccount = accounts[0][1];
-            this.id = identity.walletId;
-        }
-        const identity = JSON.parse(new TextDecoder().decode(await globalThis.walletStore.get('identity')));
-        this.#wallet = new MultiWallet(this.network);
-        const multiWIF = await decrypt(password, base58.decode(identity.multiWIF));
-        await this.#wallet.fromMultiWif(multiWIF);
-    }
-    selectAccount(account) {
-        this.selectedAccount = account;
-        return walletStore.put('selected-account', account);
-    }
-    sign(hash) {
-        return this.#wallet.sign(hash.subarray(0, 32));
-    }
-    lock(password) {
-        this.#wallet.lock(password);
-    }
-    unlock(password) {
-        this.#wallet.unlock(password);
-    }
-    async export(password) {
-        return this.#wallet.export(password);
-    }
-    async import(password, encrypted) {
-        await this.#wallet.import(password, encrypted);
-    }
-    async exportQR(password) {
-        const exported = await this.export(password);
-        return globalThis.navigator
-            ? await qrcode.toDataURL(exported)
-            : await qrcode.toString(exported, { type: 'terminal' });
-    }
-    async importQR(image, password) {
-        const multiWIF = await QrScanner.default.scanImage(image);
-        return this.import(password, multiWIF);
-    }
-}
+const nothingFoundError = (hash) => {
+  return new Error(`nothing found for ${hash}`)
+};
 
 globalThis.LeofcoinStorage = Storage;
 globalThis.leofcoin = globalThis.leofcoin || {};
@@ -517,7 +433,7 @@ class Peernet {
      * @return {Array} peerId
      */
     get peers() {
-        return Object.entries(this.client?.connections);
+        return Object.entries(this.client?.connections || {});
     }
     get connections() {
         return this.client?.connections || {};
@@ -541,7 +457,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-T3M-Ff1E.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-BmpgEM4y.js');
         /**
          * proto Object containing protos
          * @type {Object}

package/exports/src/prompts/password.js

@@ -1,8 +1,8 @@
 import inquirer from 'inquirer';
 
-var node = async () => {
-  const answers = await inquirer.prompt({ type: 'password', name: 'password', message: 'Enter password' });
-  return answers.password
+var node = async () => {
+  const answers = await inquirer.prompt({ type: 'password', name: 'password', message: 'Enter password' });
+  return answers.password
 };
 
 export { node as default };

package/exports/store.js

@@ -97,9 +97,9 @@ class Store {
     name;
     root;
     version;
-    async init(name, root, version) {
+    async init(name, root, version, inworker, homedir) {
         this.name = name;
-        this.root = await init(root);
+        this.root = await init(root, homedir);
         this.version = version;
         this.db = new ClassicLevel(join(this.root, this.name), { valueEncoding: 'view' });
     }
@@ -153,6 +153,13 @@ class Store {
         }
         return keys;
     }
+    async size() {
+        let size = 0;
+        for await (const [key, value] of this.db.iterator()) {
+            size += value?.length ?? 0;
+        }
+        return size;
+    }
     /**
      *
      * @param {object} options {  limit, gt, lt, reverse }

package/exports/types/identity.d.ts

@@ -8,7 +8,7 @@ export default class Identity {
     get accounts(): Promise<[[name: string, externalAddress: string, internalAddress: string]]>;
     getAccounts(): Promise<[[name: string, externalAddress: string, internalAddress: string]]>;
     load(password?: string): Promise<void>;
-    selectAccount(account: string): Promise<void> | Promise<any[]>;
+    selectAccount(account: string): Promise<unknown>;
     sign(hash: Uint8Array): any;
     lock(password: string): void;
     unlock(password: string): void;

package/exports/types/peernet.d.ts

@@ -71,7 +71,7 @@ export default class Peernet {
     get selectedAccount(): string;
     get accounts(): Promise<[[name: string, externalAddress: string, internalAddress: string]]>;
     get defaultStores(): string[];
-    selectAccount(account: string): Promise<void> | Promise<any[]>;
+    selectAccount(account: string): Promise<unknown>;
     addProto(name: any, proto: any): void;
     addCodec(codec: any): void;
     addStore(name: any, prefix: any, root: any, isPrivate?: boolean): Promise<void>;
@@ -131,12 +131,12 @@ export default class Peernet {
     providersFor(hash: string, store?: undefined): Promise<import("./dht/dht.js").DHTProviderMapValue>;
     get block(): {
         get: (hash: string) => Promise<any>;
-        put: (hash: string, data: Uint8Array) => Promise<void | any[]>;
+        put: (hash: string, data: Uint8Array) => Promise<unknown>;
         has: (hash: string) => Promise<boolean | any[]>;
     };
     get transaction(): {
         get: (hash: string) => Promise<any>;
-        put: (hash: string, data: Uint8Array) => Promise<void | any[]>;
+        put: (hash: string, data: Uint8Array) => Promise<unknown>;
         has: (hash: string) => Promise<boolean | any[]>;
     };
     requestData(hash: any, store: any): any;
@@ -153,7 +153,7 @@ export default class Peernet {
          * @param {String} hash
          * @param {Buffer} message
          */
-        put: (hash: any, message: any) => Promise<void | any[]>;
+        put: (hash: any, message: any) => Promise<unknown>;
         /**
          * @param {String} hash
          * @return {Boolean}
@@ -173,7 +173,7 @@ export default class Peernet {
          * @param {String} hash
          * @param {Buffer} data
          */
-        put: (hash: any, data: any) => Promise<void | any[]>;
+        put: (hash: any, data: any) => Promise<unknown>;
         /**
          * @param {String} hash
          * @return {Boolean}
@@ -193,7 +193,7 @@ export default class Peernet {
          * @param {String} hash
          * @param {Buffer} data
          */
-        put: (hash: any, data: any) => Promise<void | any[]>;
+        put: (hash: any, data: any) => Promise<unknown>;
         /**
          * @param {String} hash
          * @return {Boolean}
@@ -223,7 +223,7 @@ export default class Peernet {
      * @param {Buffer} data
      * @param {String} storeName - storeName to access
      */
-    put(hash: string, data: Uint8Array, storeName?: string | LeofcoinStorageClass): Promise<void | any[]>;
+    put(hash: string, data: Uint8Array, storeName?: string | LeofcoinStorageClass): Promise<unknown>;
     /**
      * @param {String} hash
      * @return {Boolean}

package/index.html

@@ -1,19 +1,19 @@
-<!DOCTYPE html>
-<html lang="en" dir="ltr">
-  <head>
-    <meta charset="utf-8">
-    <title></title>
-  </head>
-  <body>
-    <!-- <script src="./dist/browser/peernet.js">
-    </script> -->
-
-    <script type="module">
-      import './exports/browser/peernet.js';
-      (async () => {
-        const peernet = await new Peernet({network: 'leofcoin:peach', networkVersion: 'peach'})
-        peernet.addRequestHandler('lastBlock', () => new peernet.protos['peernet-response']({response: new TextEncoder().encode(100)}))
-      })()
-    </script>
-  </body>
-</html>
+<!DOCTYPE html>
+<html lang="en" dir="ltr">
+  <head>
+    <meta charset="utf-8">
+    <title></title>
+  </head>
+  <body>
+    <!-- <script src="./dist/browser/peernet.js">
+    </script> -->
+
+    <script type="module">
+      import './exports/browser/peernet.js';
+      (async () => {
+        const peernet = await new Peernet({network: 'leofcoin:peach', networkVersion: 'peach'})
+        peernet.addRequestHandler('lastBlock', () => new peernet.protos['peernet-response']({response: new TextEncoder().encode(100)}))
+      })()
+    </script>
+  </body>
+</html>