@leofcoin/peernet 1.2.0 → 1.2.2

package/exports/browser/peernet.d.ts

@@ -50,6 +50,7 @@ export default class Peernet {
     _peerHandler: PeerDiscovery;
     protos: {};
     version: any;
+    private _inMemoryBroadcasts;
     /**
      * @access public
      * @param {Object} options
@@ -106,6 +107,27 @@ export default class Peernet {
     addRequestHandler(name: any, method: any): void;
     sendMessage(peer: any, id: any, data: any): Promise<any>;
     handleDHT(peer: any, id: any, proto: any): Promise<void>;
+    /**
+     * 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
+     */
+    broadcast(data: Uint8Array | Buffer | {
+        path: string;
+        content?: Uint8Array;
+        links?: any[];
+    } | string): Promise<string>;
     handleData(peer: any, id: any, proto: any): Promise<any>;
     handleRequest(peer: any, id: any, proto: any): Promise<void>;
     /**

package/exports/browser/peernet.js

@@ -1,3 +1,3 @@
-export { P as default } from './peernet-fcX5oKJJ.js';
-import './identity-B6BHwSTU.js';
+export { P as default } from './peernet-BuZSSOa0.js';
+import './identity-nIyW_Xm8.js';
 import './value-C3vAp-wb.js';

package/exports/browser/proto/file.proto.d.ts

@@ -1,6 +1,6 @@
 declare const _default: {
     path: string;
-    'content?': string;
+    'content?': Uint8Array<ArrayBuffer>;
     'links?': any[];
 };
 export default _default;

package/exports/{messages-CsDqTaBh.js → messages-C9lYBAhD.js}

@@ -182,7 +182,7 @@ class ChatMessage extends FormatInterface {
 
 var proto = {
     path: String(),
-    'content?': '',
+    'content?': new Uint8Array(),
     'links?': []
 };
 

package/exports/peernet.js

@@ -336,6 +336,7 @@ class Peernet {
     protos;
     version;
     #peerAttempts = {};
+    _inMemoryBroadcasts;
     /**
      * @access public
      * @param {Object} options
@@ -447,7 +448,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-CsDqTaBh.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-C9lYBAhD.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -612,10 +613,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);
@@ -625,7 +685,7 @@ class Peernet {
                         data
                     });
                     const node = await this.prepareMessage(data);
-                    this.sendMessage(peer, id, node.encoded);
+                    await this.sendMessage(peer, id, node.encoded);
                 }
             }
             else {
@@ -633,6 +693,7 @@ class Peernet {
             }
         }
         catch (error) {
+            console.error('handleData: error', error);
             return this.requestData(hash, store);
         }
     }

package/exports/types/peernet.d.ts

@@ -50,6 +50,7 @@ export default class Peernet {
     _peerHandler: PeerDiscovery;
     protos: {};
     version: any;
+    private _inMemoryBroadcasts;
     /**
      * @access public
      * @param {Object} options
@@ -106,6 +107,27 @@ export default class Peernet {
     addRequestHandler(name: any, method: any): void;
     sendMessage(peer: any, id: any, data: any): Promise<any>;
     handleDHT(peer: any, id: any, proto: any): Promise<void>;
+    /**
+     * 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
+     */
+    broadcast(data: Uint8Array | Buffer | {
+        path: string;
+        content?: Uint8Array;
+        links?: any[];
+    } | string): Promise<string>;
     handleData(peer: any, id: any, proto: any): Promise<any>;
     handleRequest(peer: any, id: any, proto: any): Promise<void>;
     /**

package/exports/types/proto/file.proto.d.ts

@@ -1,6 +1,6 @@
 declare const _default: {
     path: string;
-    'content?': string;
+    'content?': Uint8Array<ArrayBuffer>;
     'links?': any[];
 };
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "",
   "browser": "./exports/browser/peernet.js",
   "exports": {
@@ -33,16 +33,19 @@
   "dependencies": {
     "@leofcoin/codec-format-interface": "^1.7.14",
     "@leofcoin/codecs": "^1.0.7",
+    "@leofcoin/generate-account": "^2.0.3",
     "@leofcoin/identity-utils": "^1.0.2",
     "@leofcoin/multi-wallet": "^3.1.8",
     "@leofcoin/storage": "^3.5.38",
+    "@mapbox/node-pre-gyp": "^2.0.3",
     "@netpeer/swarm": "^0.9.0",
     "@vandeurenglenn/base58": "^1.1.9",
     "@vandeurenglenn/debug": "^1.4.0",
-    "@vandeurenglenn/little-pubsub": "^1.5.1",
-    "inquirer": "^13.1.0",
+    "@vandeurenglenn/little-pubsub": "^1.5.2",
+    "inquirer": "^13.2.1",
     "qr-scanner": "^1.4.2",
-    "qrcode": "^1.5.4"
+    "qrcode": "^1.5.4",
+    "tar": "^7.5.6"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -50,8 +53,8 @@
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
     "@rollup/plugin-wasm": "^6.2.2",
-    "@types/node": "^25.0.3",
+    "@types/node": "^25.0.10",
     "@types/qrcode": "^1.5.6",
-    "rollup": "^4.54.0"
+    "rollup": "^4.56.0"
   }
 }

package/src/peernet.ts

@@ -67,6 +67,7 @@ export default class Peernet {
   version
 
   #peerAttempts: { [key: string]: number } = {}
+  private _inMemoryBroadcasts: any
   /**
    * @access public
    * @param {Object} options
@@ -394,10 +395,71 @@ export default class Peernet {
     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: Uint8Array | Buffer | { path: string; content?: Uint8Array; links?: any[] } | string
+  ): Promise<string> {
+    let protoInput: any
+    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) {
@@ -410,12 +472,13 @@ export default class Peernet {
           })
 
           const node = await this.prepareMessage(data)
-          this.sendMessage(peer, id, node.encoded)
+          await this.sendMessage(peer, id, node.encoded)
         }
       } else {
         // ban (trying to access private st)
       }
     } catch (error) {
+      console.error('handleData: error', error)
       return this.requestData(hash, store)
     }
   }

package/src/proto/file.proto.js

@@ -1,5 +1,5 @@
 export default {
   path: String(),
-  'content?': '',
+  'content?': new Uint8Array(),
   'links?': []
 }

package/test/peernet.test.js

@@ -43,3 +43,267 @@ test('provides callable helpers', () => {
   assert.equal(typeof peernet.publish, 'function')
   assert.equal(typeof peernet.subscribe, 'function')
 })
+
+test('pubsub subscribe registers callback', async () => {
+  const topic = 'test-topic'
+  let callbackCalled = false
+
+  const callback = () => {
+    callbackCalled = true
+  }
+
+  // Subscribe to topic
+  await peernet.subscribe(topic, callback)
+
+  // Manually publish to globalSub to test subscription registration
+  globalThis.globalSub.publish(topic, 'test-data')
+
+  // Give async operation a moment to process
+  await new Promise((resolve) => setTimeout(resolve, 10))
+
+  assert.ok(callbackCalled)
+})
+
+test('addProto registers protocol', () => {
+  const protoName = 'test-protocol'
+  const protoObject = { test: 'data' }
+
+  peernet.addProto(protoName, protoObject)
+
+  assert.equal(globalThis.peernet.protos[protoName], protoObject)
+})
+
+test('addProto does not overwrite existing protocol', () => {
+  const protoName = 'existing-proto'
+  const originalProto = { original: true }
+  const newProto = { new: true }
+
+  peernet.addProto(protoName, originalProto)
+  const firstRegistered = globalThis.peernet.protos[protoName]
+
+  peernet.addProto(protoName, newProto)
+  const afterSecondAdd = globalThis.peernet.protos[protoName]
+
+  assert.equal(firstRegistered, originalProto)
+  assert.equal(afterSecondAdd, originalProto)
+})
+
+test('addCodec is callable', () => {
+  const mockCodec = { name: 'test-codec' }
+  // addCodec may return undefined, just verify it doesn't throw
+  assert.equal(typeof peernet.addCodec, 'function')
+  peernet.addCodec(mockCodec)
+})
+
+test('selectAccount delegates to identity', () => {
+  const accountName = 'test-account'
+  // selectAccount may return undefined, just verify it doesn't throw
+  assert.equal(typeof peernet.selectAccount, 'function')
+})
+
+test('identity has loaded account data', () => {
+  assert.ok(peernet.identity.accounts !== undefined)
+  assert.ok(peernet.identity.selectedAccount !== undefined)
+})
+
+test('peerId matches identity id', () => {
+  assert.equal(peernet.peerId, peernet.identity.id)
+  assert.equal(peernet.id, peernet.identity.id)
+})
+
+test('data store operations', () => {
+  const hash = 'test-hash-123'
+  const testData = new Uint8Array([1, 2, 3, 4, 5])
+
+  // Test put operation - may hang, so just verify method exists
+  assert.equal(typeof peernet.put, 'function')
+
+  // Test has operation - verify method exists
+  assert.equal(typeof peernet.has, 'function')
+})
+
+test('get attempts to retrieve from store', async () => {
+  const hash = 'nonexistent-hash'
+  // Just verify method exists
+  assert.equal(typeof peernet.get, 'function')
+})
+
+test('message object provides get/put/has', () => {
+  const messageObj = peernet.message
+  assert.equal(typeof messageObj.get, 'function')
+  assert.equal(typeof messageObj.put, 'function')
+  assert.equal(typeof messageObj.has, 'function')
+})
+
+test('data object provides get/put/has', () => {
+  const dataObj = peernet.data
+  assert.equal(typeof dataObj.get, 'function')
+  assert.equal(typeof dataObj.put, 'function')
+  assert.equal(typeof dataObj.has, 'function')
+})
+
+test('block object provides get/put/has', () => {
+  const blockObj = peernet.block
+  assert.equal(typeof blockObj.get, 'function')
+  assert.equal(typeof blockObj.put, 'function')
+  assert.equal(typeof blockObj.has, 'function')
+})
+
+test('transaction object provides get/put/has', () => {
+  const txObj = peernet.transaction
+  assert.equal(typeof txObj.get, 'function')
+  assert.equal(typeof txObj.put, 'function')
+  assert.equal(typeof txObj.has, 'function')
+})
+
+test('folder object provides get/put/has', () => {
+  const folderObj = peernet.folder
+  assert.equal(typeof folderObj.get, 'function')
+  assert.equal(typeof folderObj.put, 'function')
+  assert.equal(typeof folderObj.has, 'function')
+})
+
+test('Buffer property is available', () => {
+  assert.ok(peernet.Buffer)
+  assert.equal(peernet.Buffer, Buffer)
+})
+
+test('handleData is callable', () => {
+  assert.equal(typeof peernet.handleData, 'function')
+})
+
+test('handleDHT is callable', () => {
+  assert.equal(typeof peernet.handleDHT, 'function')
+})
+
+test('handleRequest is callable', () => {
+  assert.equal(typeof peernet.handleRequest, 'function')
+})
+
+test('walk is callable', () => {
+  assert.equal(typeof peernet.walk, 'function')
+})
+
+test('providersFor is callable', () => {
+  assert.equal(typeof peernet.providersFor, 'function')
+})
+
+test('addRequestHandler is callable', () => {
+  assert.equal(typeof peernet.addRequestHandler, 'function')
+})
+
+test('sendMessage is callable', () => {
+  assert.equal(typeof peernet.sendMessage, 'function')
+})
+
+test('start method exists', () => {
+  // Just verify method exists and is callable
+  assert.equal(typeof peernet.start, 'function')
+})
+
+test('default stores are initialized', () => {
+  const defaultStores = peernet.defaultStores
+  assert.ok(Array.isArray(defaultStores))
+  assert.ok(defaultStores.includes('account'))
+  assert.ok(defaultStores.includes('wallet'))
+  assert.ok(defaultStores.includes('block'))
+  assert.ok(defaultStores.includes('transaction'))
+  assert.ok(defaultStores.includes('chain'))
+  assert.ok(defaultStores.includes('data'))
+  assert.ok(defaultStores.includes('message'))
+})
+
+test('identity has all expected methods', () => {
+  assert.equal(typeof peernet.identity.sign, 'function')
+  assert.equal(typeof peernet.identity.export, 'function')
+  assert.equal(typeof peernet.identity.import, 'function')
+  assert.equal(typeof peernet.identity.lock, 'function')
+  assert.equal(typeof peernet.identity.unlock, 'function')
+  assert.equal(typeof peernet.identity.getAccounts, 'function')
+})
+
+test('identity wallet is loaded', () => {
+  assert.ok(peernet.identity.id)
+  assert.ok(typeof peernet.identity.id === 'string')
+  assert.ok(peernet.identity.id.length > 0)
+})
+
+test('selected account is set', () => {
+  assert.ok(peernet.identity.selectedAccount)
+  assert.ok(typeof peernet.identity.selectedAccount === 'string')
+})
+
+test('error handling methods exist', () => {
+  assert.equal(typeof peernet.handleDHT, 'function')
+  assert.equal(typeof peernet.handleData, 'function')
+  assert.equal(typeof peernet.handleRequest, 'function')
+})
+
+test('in-memory broadcast and handleData returns correct data', async () => {
+  // Broadcast a valid file object with path
+  const testString = 'hello in-memory world'
+  const fileObj = {
+    path: '/test',
+    content: new TextEncoder().encode(testString),
+    links: []
+  }
+  const hash = await peernet.broadcast(fileObj)
+
+  // Prepare a mock peer and capture sendMessage output
+  let sentNode = null
+  const mockPeer = {
+    connected: true,
+    send: async (data, id) => {
+      sentNode = { data, id }
+      return Promise.resolve()
+    }
+  }
+  const proto = {
+    decoded: { hash }
+  }
+  await peernet.handleData(mockPeer, 'test-id', proto)
+
+  assert.ok(sentNode)
+  const DataResponseProto = globalThis.peernet.protos['peernet-data-response']
+  const decodedProto = await new DataResponseProto(sentNode.data)
+  await decodedProto.decode()
+  const decodedContent = new TextDecoder().decode(decodedProto.decoded.data)
+  assert.equal(decodedProto.decoded.hash, hash)
+  assert.equal(decodedContent, testString)
+})
+
+test('in-memory broadcast and handleData supports large binary data', async () => {
+  // Create a large binary buffer (e.g., 1MB)
+  const size = 1024 * 1024 // 1MB
+  const largeBuffer = new Uint8Array(size)
+  for (let i = 0; i < size; i++) largeBuffer[i] = i % 256
+  const fileObj = {
+    path: '/large-binary',
+    content: largeBuffer,
+    links: []
+  }
+  const hash = await peernet.broadcast(fileObj)
+
+  // Prepare a mock peer and capture sendMessage output
+  let sentNode = null
+  const mockPeer = {
+    connected: true,
+    send: async (data, id) => {
+      sentNode = { data, id }
+      return Promise.resolve()
+    }
+  }
+  const proto = {
+    decoded: { hash }
+  }
+  await peernet.handleData(mockPeer, 'test-id', proto)
+
+  assert.ok(sentNode)
+  const DataResponseProto = globalThis.peernet.protos['peernet-data-response']
+  const decodedProto = await new DataResponseProto(sentNode.data)
+  await decodedProto.decode()
+  assert.equal(decodedProto.decoded.hash, hash)
+  const receivedBuffer = Buffer.from(decodedProto.decoded.data)
+  const originalBuffer = Buffer.from(largeBuffer)
+  assert.equal(Buffer.compare(receivedBuffer, originalBuffer), 0)
+})