@leofcoin/peernet 1.2.0 → 1.2.2

package/README.md

@@ -1,72 +1,171 @@
 # peernet
 
+Peer-to-peer networking for Leofcoin and distributed applications.
+
+## Features
+- Decentralized peer discovery and messaging
+- Pluggable request handlers
+- File and data sharing
+- Works in Node.js, browser, and Electron
+
+## Installation
+
+```sh
+npm install @leofcoin/peernet
+```
+
 ## Usage
+
 ```js
 import Peernet from '@leofcoin/peernet'
 
-
 const config = {
   network: 'leofcoin:peach',
   networkVersion: 'peach',
   stars: ['wss://peach.leofcoin.org']
 }
 
-const node = await new Peernet(config)
-// ... setup some things
+// If your identity is password-protected, prompt for password:
+import passwordPrompt from '@leofcoin/peernet/src/prompts/password/node.js';
+const password = await passwordPrompt();
+
+const node = await new Peernet(config, password)
 await node.start()
 
 console.log(globalThis.peernet)
 ```
 
-
-
 ## API
-#### addRequestHandler
 
-examples
+### addRequestHandler
+Register a handler for custom requests:
+
 ```js
-peernet.addRequestHandler('lastBlock', () => {
-  let response;
+peernet.addRequestHandler('lastBlock', async () => {
   const height = await chainStore.get('localIndex')
   const hash = await chainStore.get('localBlock')
-  response = JSON.stringify({ height: height.toString(), hash: hash.toString() })
+  const response = JSON.stringify({ height: height.toString(), hash: hash.toString() })
   return new ResponseMessage({ response })
   // or
-  return new peernet.protos['peernet-response']({ response })
+  // return new peernet.protos['peernet-response']({ response })
 })
-```
 
-```js
 peernet.addRequestHandler('hello', () => {
   return new ResponseMessage({ response: 'hi' })
-  // or
-  return new peernet.protos['peernet-response']({ response: 'hi' })
 })
-```
-#### add version to peer
-```js
+
 peernet.addRequestHandler('version', () => {
-  return new ResponseMessage({ response: {version: 1} })
+  return new ResponseMessage({ response: { version: 1 } })
 })
 ```
 
-## Development
+### Password Prompt
+For password-protected identities, use the provided prompt:
 
-`note: you need to install jsproject`
-```sh
-npm i -g @vandeurenglenn/project
+- **Node.js:** `import passwordPrompt from '@leofcoin/peernet/src/prompts/password/node.js'`
+- **Browser:** `import passwordPrompt from '@leofcoin/peernet/src/prompts/password/browser.js'`
+
+```js
+const password = await passwordPrompt();
+const node = await new Peernet(config, password);
 ```
 
-### watch
-```sh
-npm run w
+## In-Memory Broadcasts
+
+Peernet supports in-memory data sharing for fast, temporary distribution of files or data objects between peers. This feature allows you to broadcast a file or data object, which is then available for retrieval by other peers (or yourself) until the process is restarted or the in-memory cache is cleared.
+
+### Usage Example
+
+```js
+// Broadcast a file or data object in-memory
+const fileObj = {
+  path: '/example',
+  content: new TextEncoder().encode('hello world'),
+  links: []
+};
+const hash = await peernet.broadcast(fileObj);
+
+// Another peer can request the data by hash
+// (handled internally by peernet.handleData)
 ```
-### compile
-```sh
-npm run c
+
+### Detailed Example
+
+```js
+// 1. Broadcast a file object in-memory
+const fileObj = {
+  path: '/example',
+  content: new TextEncoder().encode('Hello Peernet!'),
+  links: []
+};
+const hash = await peernet.broadcast(fileObj);
+console.log('Broadcasted hash:', hash);
+
+// 2. Simulate a peer requesting the data by hash
+const mockPeer = {
+  connected: true,
+  send: async (data, id) => {
+    // Handle the received data (for demo/testing)
+    const DataResponseProto = globalThis.peernet.protos['peernet-data-response'];
+    const decodedProto = await new DataResponseProto(data);
+    await decodedProto.decode();
+    const decodedContent = new TextDecoder().decode(decodedProto.decoded.data);
+    console.log('Received content:', decodedContent);
+  }
+};
+const proto = { decoded: { hash } };
+await peernet.handleData(mockPeer, 'test-id', proto);
+```
+
+### Data Flow Diagram
+
+```
+[You/Peer] --(broadcast)--> [Peernet Node: In-Memory Map]
+     ^                                 |
+     |                                 |
+     +------(handleData request)--------+
 ```
-### serve html
+
+- `broadcast()` stores the data in-memory and returns a hash.
+- `handleData()` retrieves the data by hash and sends it to the requesting peer.
+
+- The broadcasted data is stored in-memory and is not persisted to disk.
+- Retrieval is by hash, matching the value returned from `broadcast()`.
+- The feature is useful for ephemeral data, rapid prototyping, or testing.
+- If the process restarts, the in-memory data is lost.
+
+### Testing
+
+Automated tests verify that broadcasting and retrieving in-memory data works as expected, including content integrity and hash matching.
+
+## Development
+
+> **Note:** You need to install [jsproject](https://www.npmjs.com/package/@vandeurenglenn/project)
+
 ```sh
-npm run demo
+npm i -g @vandeurenglenn/project
 ```
 
+### Scripts
+
+- **Watch:**
+  ```sh
+  npm run watch
+  ```
+- **Build:**
+  ```sh
+  npm run build
+  ```
+- **Test:**
+  ```sh
+  npm test
+  ```
+- **Serve HTML Demo:**
+  ```sh
+  npm run demo
+  ```
+
+## License
+
+MIT
+

package/exports/browser/{browser-DQlwTLRn.js → browser-CWWW0kSj.js}

@@ -1,4 +1,19 @@
-import { g as getDefaultExportFromCjs } from './identity-B6BHwSTU.js';
+import { g as getDefaultExportFromCjs } from './identity-nIyW_Xm8.js';
+
+function _mergeNamespaces(n, m) {
+	m.forEach(function (e) {
+		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+			if (k !== 'default' && !(k in n)) {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	});
+	return Object.freeze(n);
+}
 
 var global;
 var hasRequiredGlobal;
@@ -124,9 +139,9 @@ function requireBrowser () {
 var browserExports = requireBrowser();
 var browser = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
-var browser$1 = /*#__PURE__*/Object.freeze({
+var browser$1 = /*#__PURE__*/_mergeNamespaces({
 	__proto__: null,
 	default: browser
-});
+}, [browserExports]);
 
 export { browser$1 as b };

package/exports/browser/{browser-BHbuEZJu.js → browser-DMVbMScf.js}

@@ -1,4 +1,19 @@
-import { g as getDefaultExportFromCjs } from './identity-B6BHwSTU.js';
+import { g as getDefaultExportFromCjs } from './identity-nIyW_Xm8.js';
+
+function _mergeNamespaces(n, m) {
+	m.forEach(function (e) {
+		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+			if (k !== 'default' && !(k in n)) {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	});
+	return Object.freeze(n);
+}
 
 var browser$2 = {};
 
@@ -30,9 +45,9 @@ function requireBrowser () {
 var browserExports = requireBrowser();
 var browser = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
-var browser$1 = /*#__PURE__*/Object.freeze({
+var browser$1 = /*#__PURE__*/_mergeNamespaces({
 	__proto__: null,
 	default: browser
-});
+}, [browserExports]);
 
 export { browser$1 as b };

package/exports/browser/{client-DCeU_UX5.js → client-BqvqxCzm.js}

@@ -1,5 +1,5 @@
-import { L as LittlePubSub, d as deflate_1, c as createDebugger, i as inflate_1 } from './peernet-fcX5oKJJ.js';
-import './identity-B6BHwSTU.js';
+import { L as LittlePubSub, d as deflate_1, i as inflate_1, c as createDebugger } from './peernet-BuZSSOa0.js';
+import './identity-nIyW_Xm8.js';
 import './value-C3vAp-wb.js';
 
 class Api {
@@ -231,7 +231,7 @@ class SocketRequestClient {
             const init = async () => {
                 // @ts-ignore
                 if (!globalThis.WebSocket && !this.#experimentalWebsocket)
-                    globalThis.WebSocket = (await import('./browser-DQlwTLRn.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                    globalThis.WebSocket = (await import('./browser-CWWW0kSj.js').then(function (n) { return n.b; })).default.w3cwebsocket;
                 const client = new WebSocket(this.#url, this.#protocol);
                 if (this.#experimentalWebsocket) {
                     client.addEventListener('error', this.onerror);
@@ -346,7 +346,7 @@ const iceServers = [
         credential: 'openrelayproject'
     }
 ];
-const SimplePeer = (await import('./index-DYdP5D9L.js').then(function (n) { return n.i; })).default;
+const SimplePeer = (await import('./index-BoQ4uWm2.js').then(function (n) { return n.i; })).default;
 class Peer extends SimplePeer {
     peerId;
     channelName;
@@ -616,7 +616,7 @@ class Client {
     }
     async _init() {
         if (!globalThis.RTCPeerConnection)
-            globalThis.wrtc = (await import('./browser-BHbuEZJu.js').then(function (n) { return n.b; })).default;
+            globalThis.wrtc = (await import('./browser-DMVbMScf.js').then(function (n) { return n.b; })).default;
         for (const star of this.starsConfig) {
             try {
                 await this.setupStar(star);

package/exports/browser/{identity-B6BHwSTU.js → identity-nIyW_Xm8.js}

@@ -17150,7 +17150,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ '@leofcoin/generate-account');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-ChRjMyiM.js');
             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));
@@ -17196,4 +17196,4 @@ class Identity {
     }
 }
 
-export { Identity as I, base58$1 as a, base$1 as b, index$3 as c, index$2 as d, index$4 as e, commonjsGlobal as f, getDefaultExportFromCjs as g, requireInherits_browser as h, index$5 as i, require$$3 as r };
+export { Identity as I, MultiWallet as M, base58$1 as a, base$1 as b, index$3 as c, index$2 as d, index$4 as e, encrypt as f, getDefaultExportFromCjs as g, commonjsGlobal as h, index$5 as i, requireInherits_browser as j, require$$3 as r };

package/exports/browser/identity.js

@@ -1 +1 @@
-export { I as default } from './identity-B6BHwSTU.js';
+export { I as default } from './identity-nIyW_Xm8.js';

package/exports/browser/{index-DYdP5D9L.js → index-BoQ4uWm2.js}

@@ -1,6 +1,21 @@
-import { f as commonjsGlobal, r as require$$3, h as requireInherits_browser, g as getDefaultExportFromCjs } from './identity-B6BHwSTU.js';
+import { h as commonjsGlobal, r as require$$3, j as requireInherits_browser, g as getDefaultExportFromCjs } from './identity-nIyW_Xm8.js';
 import require$$0 from 'events';
 
+function _mergeNamespaces(n, m) {
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+
 var browser$2 = {exports: {}};
 
 /**
@@ -7572,9 +7587,9 @@ function requireSimplePeer () {
 var simplePeerExports = requireSimplePeer();
 var index = /*@__PURE__*/getDefaultExportFromCjs(simplePeerExports);
 
-var index$1 = /*#__PURE__*/Object.freeze({
+var index$1 = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
   default: index
-});
+}, [simplePeerExports]);
 
 export { index$1 as i };

package/exports/browser/index-ChRjMyiM.js

@@ -0,0 +1,36 @@
+import { M as MultiWallet, f as encrypt, a as base58$1 } from './identity-nIyW_Xm8.js';
+
+/**
+ * @params {String} network
+ * @return {object} { identity, accounts, config }
+ */
+var index = async (password, network) => {
+    if (!password)
+        throw new Error('wallets need to be password protected.');
+    let wallet = new MultiWallet(network);
+    /**
+     * @type {string}
+     */
+    let mnemonic = await wallet.generate(password);
+    wallet = new MultiWallet(network);
+    await wallet.recover(mnemonic, password, network);
+    mnemonic = new Uint8Array(await encrypt(password, mnemonic));
+    const multiWIF = new Uint8Array(await encrypt(password, await wallet.multiWIF));
+    /**
+     * @type {object}
+     */
+    const external = await wallet.account(1).external(1);
+    const externalAddress = await external.address;
+    const internal = await wallet.account(1).internal(1);
+    const internalAddress = await internal.address;
+    return {
+        identity: {
+            mnemonic: base58$1.encode(mnemonic),
+            multiWIF: base58$1.encode(multiWIF),
+            walletId: await external.id
+        },
+        accounts: [['main account', externalAddress, internalAddress]]
+    };
+};
+
+export { index as default };

package/exports/browser/{messages-CiR1YiV5.js → messages-C-z7iw3I.js}

@@ -1,5 +1,5 @@
-import { F as FormatInterface } from './peernet-fcX5oKJJ.js';
-import './identity-B6BHwSTU.js';
+import { F as FormatInterface } from './peernet-BuZSSOa0.js';
+import './identity-nIyW_Xm8.js';
 import './value-C3vAp-wb.js';
 
 var proto$b = {
@@ -184,7 +184,7 @@ class ChatMessage extends FormatInterface {
 
 var proto = {
     path: String(),
-    'content?': '',
+    'content?': new Uint8Array(),
     'links?': []
 };
 

package/exports/browser/{peernet-fcX5oKJJ.js → peernet-BuZSSOa0.js}

@@ -1,4 +1,4 @@
-import { b as base, a as base58$1, i as index$2, c as index$3, d as index$4, e as index$5, I as Identity } from './identity-B6BHwSTU.js';
+import { b as base, a as base58$1, i as index$2, c as index$3, d as index$4, e as index$5, I as Identity } from './identity-nIyW_Xm8.js';
 import { K as KeyPath, a as KeyValue } from './value-C3vAp-wb.js';
 
 const getTargets = () => Array.from([]);
@@ -27,58 +27,73 @@ const createDebugger = (target) => {
 };
 
 class LittlePubSub {
-    subscribers = {};
+    subscribers = new Map();
     verbose;
     constructor(verbose) {
-        this.verbose = verbose;
-    }
-    _handleContext(handler, context) {
-        if (typeof context === 'undefined') {
-            context = handler;
-        }
-        return context;
+        this.verbose = verbose ?? false;
     }
     hasSubscribers(event) {
-        return this.subscribers[event] ? true : false;
+        return this.subscribers.has(event);
+    }
+    subscriberCount(event) {
+        return this.subscribers.get(event)?.handlers.length ?? 0;
+    }
+    clear() {
+        this.subscribers.clear();
     }
     getValue(event) {
-        if (this.subscribers[event])
-            return this.subscribers[event].value;
-        return undefined;
+        return this.subscribers.get(event)?.value;
     }
     subscribe(event, handler, options) {
-        if (!this.hasSubscribers(event))
-            this.subscribers[event] = { handlers: [], value: undefined };
-        const context = this._handleContext(handler, options?.context);
-        const _handler = handler.bind(context);
-        this.subscribers[event].handlers.push(_handler);
-        if (this.subscribers[event].value !== undefined)
-            _handler(this.subscribers[event].value, undefined);
+        let subscriber = this.subscribers.get(event);
+        if (subscriber === undefined) {
+            subscriber = { handlers: [], value: undefined };
+            this.subscribers.set(event, subscriber);
+        }
+        // Only bind if context is provided
+        const context = options?.context;
+        const boundHandler = context
+            ? handler.bind(context)
+            : handler;
+        subscriber.handlers.push({ original: handler, bound: boundHandler });
+        // Call handler immediately if value already exists
+        if (subscriber.value !== undefined) {
+            boundHandler(subscriber.value, undefined);
+        }
+        // Return unsubscribe function
+        return () => this.unsubscribe(event, handler, options);
     }
     unsubscribe(event, handler, options) {
-        if (!options)
-            options = { keepValue: false };
-        if (!this.hasSubscribers(event))
+        const subscriber = this.subscribers.get(event);
+        if (subscriber === undefined)
             return;
-        const context = this._handleContext(handler, options.context);
-        const index = this.subscribers[event].handlers.indexOf(handler.bind(context));
-        this.subscribers[event].handlers.splice(index);
-        // delete event if no handlers left but supports keeping value for later use
-        // (like when unsubscribing from a value that is still needed because others might subscibe to it)
-        if (this.subscribers[event].handlers.length === 0 && !options.keepValue)
-            delete this.subscribers[event];
+        const handlers = subscriber.handlers;
+        // Find and remove handler by original reference
+        for (let i = 0, len = handlers.length; i < len; i++) {
+            if (handlers[i].original === handler) {
+                handlers.splice(i, 1);
+                break;
+            }
+        }
+        // Delete event if no handlers left (unless keepValue is true)
+        if (handlers.length === 0 && !options?.keepValue) {
+            this.subscribers.delete(event);
+        }
     }
     publish(event, value, verbose) {
-        // always set value even when having no subscribers
-        if (!this.hasSubscribers(event))
-            this.subscribers[event] = {
-                handlers: []
-            };
-        const oldValue = this.subscribers[event]?.value;
+        let subscriber = this.subscribers.get(event);
+        if (subscriber === undefined) {
+            subscriber = { handlers: [], value: undefined };
+            this.subscribers.set(event, subscriber);
+        }
+        const oldValue = subscriber.value;
+        // Only trigger handlers if verbose or value changed
         if (this.verbose || verbose || oldValue !== value) {
-            this.subscribers[event].value = value;
-            for (const handler of this.subscribers[event].handlers) {
-                handler(value, oldValue);
+            subscriber.value = value;
+            const handlers = subscriber.handlers;
+            const len = handlers.length;
+            for (let i = 0; i < len; i++) {
+                handlers[i].bound(value, oldValue);
             }
         }
     }
@@ -86,12 +101,21 @@ class LittlePubSub {
         this.publish(event, value, true);
     }
     once(event, options) {
-        return new Promise((resolve) => {
-            const cb = (value) => {
+        return new Promise((resolve, reject) => {
+            let timeoutId;
+            const handler = (value) => {
+                if (timeoutId !== undefined)
+                    clearTimeout(timeoutId);
                 resolve(value);
-                this.unsubscribe(event, cb, options);
+                this.unsubscribe(event, handler, options);
             };
-            this.subscribe(event, cb, options);
+            this.subscribe(event, handler, options);
+            if (options?.timeout !== undefined) {
+                timeoutId = setTimeout(() => {
+                    this.unsubscribe(event, handler, options);
+                    reject(new Error(`Timeout waiting for event "${event}"`));
+                }, options.timeout);
+            }
         });
     }
 }
@@ -8244,6 +8268,7 @@ class Peernet {
     protos;
     version;
     #peerAttempts = {};
+    _inMemoryBroadcasts;
     /**
      * @access public
      * @param {Object} options
@@ -8355,7 +8380,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-CiR1YiV5.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-C-z7iw3I.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8449,7 +8474,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-DCeU_UX5.js');
+        const importee = await import('./client-BqvqxCzm.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -8520,10 +8545,69 @@ class Peernet {
         const node = await this.prepareMessage(data);
         this.sendMessage(peer, id, node.encoded);
     }
+    /**
+     * Broadcasts data to the network and returns a hash that can be used by another peer
+     * to directly connect and download the data from the broadcasting peer.
+     *
+     * @param {Uint8Array|Buffer|Object|string} data - The data to broadcast
+     * @param {string} [storeName='data'] - The store to use for storing the data
+     * @returns {Promise<string>} The hash that can be shared for direct download
+     */
+    /**
+     * Broadcasts data to the network and returns a hash that can be used by another peer
+     * to directly connect and download the data from the broadcasting peer.
+     * The data is kept in memory only and not persisted to storage.
+     *
+     * @param {Uint8Array|Buffer|Object|string} data - The data to broadcast
+     * @returns {Promise<string>} The hash that can be shared for direct download
+     */
+    async broadcast(data) {
+        let protoInput;
+        if (typeof data === 'string') {
+            protoInput = { path: '/', content: new TextEncoder().encode(data) };
+        }
+        else if (data instanceof Uint8Array || data instanceof Buffer) {
+            protoInput = { path: '/', content: data };
+        }
+        else if (typeof data === 'object' && data.path) {
+            protoInput = data;
+        }
+        else {
+            // fallback: treat as JSON string
+            protoInput = { path: '/', content: new TextEncoder().encode(JSON.stringify(data)) };
+        }
+        const protoNode = await new globalThis.peernet.protos['peernet-file'](protoInput);
+        const hash = await protoNode.hash();
+        const encoded = await protoNode.encoded;
+        if (!this._inMemoryBroadcasts)
+            this._inMemoryBroadcasts = new Map();
+        this._inMemoryBroadcasts.set(hash, encoded);
+        await this.publish('broadcast', { hash, from: this.id });
+        return hash;
+    }
     async handleData(peer, id, proto) {
         let { hash, store } = proto.decoded;
         let data;
         try {
+            if (this._inMemoryBroadcasts && this._inMemoryBroadcasts.has(hash)) {
+                data = this._inMemoryBroadcasts.get(hash);
+                let resolvedHash = hash;
+                if (typeof hash === 'function') {
+                    resolvedHash = await hash();
+                }
+                // Decode the stored proto to extract the content
+                const FileProto = globalThis.peernet.protos['peernet-file'];
+                const fileProto = await new FileProto(data);
+                await fileProto.decode();
+                const fileContent = fileProto.decoded.content;
+                data = await new globalThis.peernet.protos['peernet-data-response']({
+                    hash: resolvedHash,
+                    data: fileContent
+                });
+                const node = await this.prepareMessage(data);
+                await this.sendMessage(peer, id, node.encoded);
+                return;
+            }
             store = globalThis[`${store}Store`] || (await this.whichStore([...this.stores], hash));
             if (store && !store.private) {
                 data = await store.get(hash);
@@ -8533,7 +8617,7 @@ class Peernet {
                         data
                     });
                     const node = await this.prepareMessage(data);
-                    this.sendMessage(peer, id, node.encoded);
+                    await this.sendMessage(peer, id, node.encoded);
                 }
             }
             else {
@@ -8541,6 +8625,7 @@ class Peernet {
             }
         }
         catch (error) {
+            console.error('handleData: error', error);
             return this.requestData(hash, store);
         }
     }