@leofcoin/peernet 1.2.4 → 1.2.6

package/exports/browser/{client-7chRAqOy.js → client-1JlanVkr.js}

@@ -1,4 +1,4 @@
-import { L as LittlePubSub, d as deflate_1, i as inflate_1, c as createDebugger } from './peernet-D6QlSJ6B.js';
+import { L as LittlePubSub, d as deflate_1, i as inflate_1, c as createDebugger } from './peernet-CpcIFBTX.js';
 import './identity-nIyW_Xm8.js';
 import './value-C3vAp-wb.js';
 
@@ -490,6 +490,63 @@ class Peer extends SimplePeer {
             this.send(data, id);
         });
     }
+    /**
+     * Get comprehensive network statistics from WebRTC
+     * @returns NetworkStats object with detailed metrics
+     */
+    async getNetworkStats() {
+        try {
+            const pc = this._pc;
+            if (!pc)
+                return null;
+            const stats = await pc.getStats();
+            const result = {
+                latency: null,
+                jitter: null,
+                bytesReceived: 0,
+                bytesSent: 0,
+                packetsLost: 0,
+                fractionLost: null,
+                inboundBitrate: null,
+                outboundBitrate: null,
+                availableOutgoingBitrate: null,
+                timestamp: Date.now()
+            };
+            let prevBytesReceived = 0;
+            let prevBytesSent = 0;
+            let prevTimestamp = 0;
+            stats.forEach((report) => {
+                // Latency from candidate pair
+                if (report.type === 'candidate-pair' && report.currentRoundTripTime) {
+                    result.latency = Math.round(report.currentRoundTripTime * 1000);
+                }
+                // Inbound RTP stats
+                if (report.type === 'inbound-rtp') {
+                    result.bytesReceived += report.bytesReceived || 0;
+                    result.packetsLost += report.packetsLost || 0;
+                    if (report.jitter) {
+                        result.jitter = Math.round(report.jitter * 1000);
+                    }
+                    if (report.fractionLost) {
+                        result.fractionLost = report.fractionLost;
+                    }
+                }
+                // Outbound RTP stats
+                if (report.type === 'outbound-rtp') {
+                    result.bytesSent += report.bytesSent || 0;
+                }
+                // Available bandwidth
+                if (report.type === 'remote-candidate' &&
+                    report.availableOutgoingBitrate) {
+                    result.availableOutgoingBitrate = Math.round(report.availableOutgoingBitrate);
+                }
+            });
+            return result;
+        }
+        catch (e) {
+            return null;
+        }
+    }
     toJSON() {
         return {
             peerId: this.peerId,

package/exports/browser/{messages-BVmbvFj4.js → messages-pDchwT17.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface } from './peernet-D6QlSJ6B.js';
+import { F as FormatInterface } from './peernet-CpcIFBTX.js';
 import './identity-nIyW_Xm8.js';
 import './value-C3vAp-wb.js';
 

package/exports/browser/{peernet-D6QlSJ6B.js → peernet-CpcIFBTX.js}

@@ -8318,7 +8318,7 @@ class Peernet {
         return this.identity.accounts;
     }
     get defaultStores() {
-        return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message'];
+        return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message', 'share'];
     }
     selectAccount(account) {
         return this.identity.selectAccount(account);
@@ -8331,7 +8331,12 @@ class Peernet {
         return utils.addCodec(codec);
     }
     async addStore(name, prefix, root, isPrivate = true) {
-        if (name === 'block' || name === 'transaction' || name === 'chain' || name === 'data' || name === 'message')
+        if (name === 'block' ||
+            name === 'transaction' ||
+            name === 'chain' ||
+            name === 'data' ||
+            name === 'message' ||
+            name === 'share')
             isPrivate = false;
         let Storage;
         this.hasDaemon ? (Storage = LeofcoinStorageClient) : (Storage = LeofcoinStorage);
@@ -8380,7 +8385,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-BVmbvFj4.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-pDchwT17.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8474,7 +8479,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-7chRAqOy.js');
+        const importee = await import('./client-1JlanVkr.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -8574,6 +8579,8 @@ class Peernet {
         if (!this._inMemoryBroadcasts)
             this._inMemoryBroadcasts = new Map();
         this._inMemoryBroadcasts.set(hash, encoded);
+        // Persist to share store
+        await shareStore.put(hash, encoded);
         await this.publish('broadcast', { hash, from: this.id });
         return hash;
     }
@@ -8897,6 +8904,65 @@ class Peernet {
             has: async (hash) => await dataStore.has(hash)
         };
     }
+    get share() {
+        return {
+            /**
+             * Get content for given share hash
+             *
+             * @todo Add peer permission checking to validate if requesting peer has access
+             *
+             * @param {String} hash
+             */
+            get: async (hash) => {
+                debug(`get share ${hash}`);
+                const data = await shareStore.has(hash);
+                if (data)
+                    return await shareStore.get(hash);
+                return undefined;
+            },
+            /**
+             * put share content
+             *
+             * @param {String} hash
+             * @param {Buffer} data
+             */
+            put: async (hash, data) => await shareStore.put(hash, data),
+            /**
+             * @param {String} hash
+             * @return {Boolean}
+             */
+            has: async (hash) => await shareStore.has(hash),
+            /**
+             * Put folder content
+             *
+             * @param {Array} files
+             */
+            putFolder: async (files) => {
+                const links = [];
+                for (const file of files) {
+                    const fileNode = await new globalThis.peernet.protos['peernet-file'](file);
+                    const hash = await fileNode.hash;
+                    await dataStore.put(hash, fileNode.encoded);
+                    links.push({ hash, path: file.path });
+                }
+                const node = await new globalThis.peernet.protos['peernet-file']({
+                    path: '/',
+                    links
+                });
+                const hash = await node.hash;
+                await dataStore.put(hash, node.encoded);
+                return hash;
+            }
+        };
+    }
+    /**
+     * Get all shared hashes
+     *
+     * @returns {Promise<string[]>} Array of all shared hashes
+     */
+    async allSharedHashes() {
+        return await shareStore.keys();
+    }
     async addFolder(files) {
         const links = [];
         for (const file of files) {

package/exports/browser/peernet.d.ts

@@ -16,6 +16,7 @@ declare global {
     var dataStore: LeofcoinStorageClass;
     var walletStore: LeofcoinStorageClass;
     var chainStore: LeofcoinStorageClass;
+    var shareStore: LeofcoinStorageClass;
 }
 /**
  * @access public
@@ -220,6 +221,40 @@ export default class Peernet {
          */
         has: (hash: any) => Promise<boolean | any[]>;
     };
+    get share(): {
+        /**
+         * Get content for given share hash
+         *
+         * @todo Add peer permission checking to validate if requesting peer has access
+         *
+         * @param {String} hash
+         */
+        get: (hash: any) => Promise<any>;
+        /**
+         * put share content
+         *
+         * @param {String} hash
+         * @param {Buffer} data
+         */
+        put: (hash: any, data: any) => Promise<unknown>;
+        /**
+         * @param {String} hash
+         * @return {Boolean}
+         */
+        has: (hash: any) => Promise<boolean | any[]>;
+        /**
+         * Put folder content
+         *
+         * @param {Array} files
+         */
+        putFolder: (files: any) => Promise<any>;
+    };
+    /**
+     * Get all shared hashes
+     *
+     * @returns {Promise<string[]>} Array of all shared hashes
+     */
+    allSharedHashes(): Promise<string[]>;
     addFolder(files: any): Promise<any>;
     ls(hash: any, options: any): Promise<any[]>;
     cat(hash: any, options: any): Promise<any>;

package/exports/browser/peernet.js

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

package/exports/peernet.js

@@ -386,7 +386,7 @@ class Peernet {
         return this.identity.accounts;
     }
     get defaultStores() {
-        return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message'];
+        return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message', 'share'];
     }
     selectAccount(account) {
         return this.identity.selectAccount(account);
@@ -399,7 +399,12 @@ class Peernet {
         return utils.addCodec(codec);
     }
     async addStore(name, prefix, root, isPrivate = true) {
-        if (name === 'block' || name === 'transaction' || name === 'chain' || name === 'data' || name === 'message')
+        if (name === 'block' ||
+            name === 'transaction' ||
+            name === 'chain' ||
+            name === 'data' ||
+            name === 'message' ||
+            name === 'share')
             isPrivate = false;
         let Storage;
         this.hasDaemon ? (Storage = LeofcoinStorageClient) : (Storage = LeofcoinStorage);
@@ -642,6 +647,8 @@ class Peernet {
         if (!this._inMemoryBroadcasts)
             this._inMemoryBroadcasts = new Map();
         this._inMemoryBroadcasts.set(hash, encoded);
+        // Persist to share store
+        await shareStore.put(hash, encoded);
         await this.publish('broadcast', { hash, from: this.id });
         return hash;
     }
@@ -965,6 +972,65 @@ class Peernet {
             has: async (hash) => await dataStore.has(hash)
         };
     }
+    get share() {
+        return {
+            /**
+             * Get content for given share hash
+             *
+             * @todo Add peer permission checking to validate if requesting peer has access
+             *
+             * @param {String} hash
+             */
+            get: async (hash) => {
+                debug(`get share ${hash}`);
+                const data = await shareStore.has(hash);
+                if (data)
+                    return await shareStore.get(hash);
+                return undefined;
+            },
+            /**
+             * put share content
+             *
+             * @param {String} hash
+             * @param {Buffer} data
+             */
+            put: async (hash, data) => await shareStore.put(hash, data),
+            /**
+             * @param {String} hash
+             * @return {Boolean}
+             */
+            has: async (hash) => await shareStore.has(hash),
+            /**
+             * Put folder content
+             *
+             * @param {Array} files
+             */
+            putFolder: async (files) => {
+                const links = [];
+                for (const file of files) {
+                    const fileNode = await new globalThis.peernet.protos['peernet-file'](file);
+                    const hash = await fileNode.hash;
+                    await dataStore.put(hash, fileNode.encoded);
+                    links.push({ hash, path: file.path });
+                }
+                const node = await new globalThis.peernet.protos['peernet-file']({
+                    path: '/',
+                    links
+                });
+                const hash = await node.hash;
+                await dataStore.put(hash, node.encoded);
+                return hash;
+            }
+        };
+    }
+    /**
+     * Get all shared hashes
+     *
+     * @returns {Promise<string[]>} Array of all shared hashes
+     */
+    async allSharedHashes() {
+        return await shareStore.keys();
+    }
     async addFolder(files) {
         const links = [];
         for (const file of files) {

package/exports/types/peernet.d.ts

@@ -16,6 +16,7 @@ declare global {
     var dataStore: LeofcoinStorageClass;
     var walletStore: LeofcoinStorageClass;
     var chainStore: LeofcoinStorageClass;
+    var shareStore: LeofcoinStorageClass;
 }
 /**
  * @access public
@@ -220,6 +221,40 @@ export default class Peernet {
          */
         has: (hash: any) => Promise<boolean | any[]>;
     };
+    get share(): {
+        /**
+         * Get content for given share hash
+         *
+         * @todo Add peer permission checking to validate if requesting peer has access
+         *
+         * @param {String} hash
+         */
+        get: (hash: any) => Promise<any>;
+        /**
+         * put share content
+         *
+         * @param {String} hash
+         * @param {Buffer} data
+         */
+        put: (hash: any, data: any) => Promise<unknown>;
+        /**
+         * @param {String} hash
+         * @return {Boolean}
+         */
+        has: (hash: any) => Promise<boolean | any[]>;
+        /**
+         * Put folder content
+         *
+         * @param {Array} files
+         */
+        putFolder: (files: any) => Promise<any>;
+    };
+    /**
+     * Get all shared hashes
+     *
+     * @returns {Promise<string[]>} Array of all shared hashes
+     */
+    allSharedHashes(): Promise<string[]>;
     addFolder(files: any): Promise<any>;
     ls(hash: any, options: any): Promise<any[]>;
     cat(hash: any, options: any): Promise<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "",
   "browser": "./exports/browser/peernet.js",
   "exports": {
@@ -38,7 +38,7 @@
     "@leofcoin/multi-wallet": "^3.1.8",
     "@leofcoin/storage": "^3.5.38",
     "@mapbox/node-pre-gyp": "^2.0.3",
-    "@netpeer/swarm": "^0.9.1",
+    "@netpeer/swarm": "^0.9.2",
     "@vandeurenglenn/base58": "^1.1.9",
     "@vandeurenglenn/debug": "^1.4.0",
     "@vandeurenglenn/little-pubsub": "^1.5.2",

package/src/peernet.ts

@@ -28,6 +28,7 @@ declare global {
   var dataStore: LeofcoinStorageClass
   var walletStore: LeofcoinStorageClass
   var chainStore: LeofcoinStorageClass
+  var shareStore: LeofcoinStorageClass
 }
 
 const debug = createDebugger('peernet')
@@ -121,7 +122,7 @@ export default class Peernet {
   }
 
   get defaultStores() {
-    return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message']
+    return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message', 'share']
   }
 
   selectAccount(account: string) {
@@ -137,7 +138,14 @@ export default class Peernet {
   }
 
   async addStore(name, prefix, root, isPrivate = true) {
-    if (name === 'block' || name === 'transaction' || name === 'chain' || name === 'data' || name === 'message')
+    if (
+      name === 'block' ||
+      name === 'transaction' ||
+      name === 'chain' ||
+      name === 'data' ||
+      name === 'message' ||
+      name === 'share'
+    )
       isPrivate = false
 
     let Storage
@@ -423,6 +431,9 @@ export default class Peernet {
     if (!this._inMemoryBroadcasts) this._inMemoryBroadcasts = new Map()
     this._inMemoryBroadcasts.set(hash, encoded)
 
+    // Persist to share store
+    await shareStore.put(hash, encoded)
+
     await this.publish('broadcast', { hash, from: this.id })
     return hash
   }
@@ -754,6 +765,68 @@ export default class Peernet {
     }
   }
 
+  get share() {
+    return {
+      /**
+       * Get content for given share hash
+       *
+       * @todo Add peer permission checking to validate if requesting peer has access
+       *
+       * @param {String} hash
+       */
+      get: async (hash) => {
+        debug(`get share ${hash}`)
+        const data = await shareStore.has(hash)
+        if (data) return await shareStore.get(hash)
+        return undefined
+      },
+      /**
+       * put share content
+       *
+       * @param {String} hash
+       * @param {Buffer} data
+       */
+      put: async (hash, data) => await shareStore.put(hash, data),
+      /**
+       * @param {String} hash
+       * @return {Boolean}
+       */
+      has: async (hash) => await shareStore.has(hash),
+
+      /**
+       * Put folder content
+       *
+       * @param {Array} files
+       */
+      putFolder: async (files) => {
+        const links = []
+        for (const file of files) {
+          const fileNode = await new globalThis.peernet.protos['peernet-file'](file)
+          const hash = await fileNode.hash
+          await dataStore.put(hash, fileNode.encoded)
+          links.push({ hash, path: file.path })
+        }
+        const node = await new globalThis.peernet.protos['peernet-file']({
+          path: '/',
+          links
+        })
+        const hash = await node.hash
+        await dataStore.put(hash, node.encoded)
+
+        return hash
+      }
+    }
+  }
+
+  /**
+   * Get all shared hashes
+   *
+   * @returns {Promise<string[]>} Array of all shared hashes
+   */
+  async allSharedHashes(): Promise<string[]> {
+    return await shareStore.keys()
+  }
+
   async addFolder(files) {
     const links = []
     for (const file of files) {

package/test/peernet.test.js

@@ -211,6 +211,7 @@ test('default stores are initialized', () => {
   assert.ok(defaultStores.includes('chain'))
   assert.ok(defaultStores.includes('data'))
   assert.ok(defaultStores.includes('message'))
+  assert.ok(defaultStores.includes('share'))
 })
 
 test('identity has all expected methods', () => {
@@ -302,3 +303,46 @@ test('in-memory broadcast and handleData supports large binary data', async () =
   const originalBuffer = Buffer.from(largeBuffer)
   assert.equal(Buffer.compare(receivedBuffer, originalBuffer), 0)
 })
+
+test('share object provides get/put/has', () => {
+  const shareObj = peernet.share
+  assert.equal(typeof shareObj.get, 'function')
+  assert.equal(typeof shareObj.put, 'function')
+  assert.equal(typeof shareObj.has, 'function')
+})
+
+test('allSharedHashes method exists and is callable', () => {
+  assert.equal(typeof peernet.allSharedHashes, 'function')
+})
+
+test('broadcast persists to share store', async () => {
+  const testString = 'test broadcast content'
+  const path = '/broadcast-test'
+  const content = new TextEncoder().encode(testString)
+
+  const hash = await peernet.broadcast(path, { content })
+
+  // Verify it was stored in share store
+  assert.ok(hash)
+  const hasInShare = await peernet.share.has(hash)
+  assert.equal(hasInShare, true)
+})
+
+test('share store can retrieve broadcasted content', async () => {
+  const testString = 'retrievable broadcast content'
+  const path = '/retrievable-test'
+  const content = new TextEncoder().encode(testString)
+
+  const hash = await peernet.broadcast(path, { content })
+
+  // Verify we can retrieve it from share store
+  const storedData = await peernet.share.get(hash)
+  assert.ok(storedData)
+})
+
+test('allSharedHashes returns array of hashes', async () => {
+  const hashes = await peernet.allSharedHashes()
+  assert.ok(Array.isArray(hashes))
+  // Should contain at least the hashes we broadcasted in previous tests
+  assert.ok(hashes.length >= 0)
+})