@leofcoin/peernet 1.1.64 → 1.1.66

package/exports/browser/{client-d602421d.js → client-493cbd83.js}

@@ -103,15 +103,18 @@ class LittlePubSub {
         if (this.subscribers[event].handlers.length === 0)
             delete this.subscribers[event];
     }
-    publish(event, change) {
+    publish(event, value) {
+        // always set value even when having no subscribers
         if (!this.hasSubscribers(event))
-            return;
-        if (this.verbose || this.subscribers[event]?.value !== change) {
-            this.subscribers[event].value = change;
-            this.subscribers[event].handlers.forEach((handler) => {
-                handler(change, this.subscribers[event].value);
-            });
-        }
+            this.subscribers[event] = {
+                handlers: []
+            };
+        const oldValue = this.subscribers[event]?.value;
+        this.subscribers[event].value = value;
+        if (this.verbose || oldValue !== value)
+            for (const handler of this.subscribers[event].handlers) {
+                handler(value, oldValue);
+            }
     }
     once(event) {
         return new Promise((resolve) => {
@@ -270,53 +273,61 @@ const base = (ALPHABET) => {
 const ALPHABET$3 = '0123456789ABCDEF';
 base(ALPHABET$3);
 
-const ALPHABET$2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
-const ALPHABET_HEX$1 = '0123456789ABCDEFGHIJKLMNOPQRSTUV';
-base(ALPHABET$2);
+const ALPHABET$2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+const ALPHABET_HEX$1 = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+base(ALPHABET$2);
 base(ALPHABET_HEX$1);
 
-var ALPHABET$1 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-var ALPHABET_HEX = '0123456789ABCDEFGHJKLMNPQRSTUVabcdefghijklmnopqrstuv';
-var base58 = base(ALPHABET$1);
-var base58Hex = base(ALPHABET_HEX);
-var encode = base58.encode;
-var decode = base58.decode;
-var encodeHex = base58Hex.encode;
-var decodeHex = base58Hex.decode;
-var isBase58 = function (string) {
-    try {
-        decode(string);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-};
-var isBase58Hex = function (string) {
-    try {
-        decodeHex(string);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-};
-var whatType = function (string) {
-    try {
-        decode(string);
-        return 'base58';
-    }
-    catch (e) {
-        try {
-            decodeHex(string);
-            return 'base58Hex';
-        }
-        catch (_a) {
-            return;
-        }
-    }
-};
-var base58$1 = { encode: encode, decode: decode, isBase58: isBase58, isBase58Hex: isBase58Hex, encodeHex: encodeHex, decodeHex: decodeHex, whatType: whatType };
+const ALPHABET$1 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const ALPHABET_HEX = "0123456789ABCDEFGHJKLMNPQRSTUVabcdefghijklmnopqrstuv";
+const base58 = base(ALPHABET$1);
+const base58Hex = base(ALPHABET_HEX);
+const encode = base58.encode;
+const decode = base58.decode;
+const encodeHex = base58Hex.encode;
+const decodeHex = base58Hex.decode;
+const isBase58 = (string) => {
+    try {
+        decode(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const isBase58Hex = (string) => {
+    try {
+        decodeHex(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const whatType = (string) => {
+    try {
+        decode(string);
+        return "base58";
+    }
+    catch (e) {
+        try {
+            decodeHex(string);
+            return "base58Hex";
+        }
+        catch {
+            return;
+        }
+    }
+};
+var base58$1 = {
+    encode,
+    decode,
+    isBase58,
+    isBase58Hex,
+    encodeHex,
+    decodeHex,
+    whatType,
+};
 
 const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
 base(ALPHABET);
@@ -467,18 +478,20 @@ let P2PT$1 = class P2PT extends EventEmitter {
     infoHash;
     _infoHashBuffer;
     _infoHashBinary;
+    #maxPeerChannels;
     /**
      *
      * @param array announceURLs List of announce tracker URLs
      * @param string identifierString Identifier used to discover peers in the network
      */
-    constructor(announceURLs = [], identifierString = '', peerId) {
+    constructor(announceURLs = [], identifierString = '', peerId, maxPeerChannels = 5) {
         super();
         this.announceURLs = announceURLs;
         this.trackers = {};
         this.peers = {};
         this.msgChunks = {};
         this.responseWaiting = {};
+        this.#maxPeerChannels = maxPeerChannels;
         if (identifierString) {
             this.setIdentifier(identifierString);
         }
@@ -497,83 +510,94 @@ let P2PT$1 = class P2PT extends EventEmitter {
         this._infoHashBuffer = hex2arr(this.infoHash);
         this._infoHashBinary = hex2bin(this.infoHash);
     }
-    /**
-     * Connect to network and start discovering peers
-     */
-    start() {
-        this.on('peer', peer => {
-            peer.on('connect', () => {
-                let newpeer = false;
-                /**
-                 * peer connected or reconnected
-                 * Sometimes peers reconnect so need to handle the newpeer here
-                 */
-                if (!this.peers[peer.id]) {
-                    newpeer = true;
-                    this.peers[peer.id] = {};
-                    if (!this.responseWaiting[peer.id])
-                        this.responseWaiting[peer.id] = {};
-                }
-                /**
-                 * Multiple data channels to one peer is possible
-                 * The `peer` object actually refers to a peer with a data channel. Even though it may have same `id` (peerID) property, the data channel will be different. Different trackers giving the same "peer" will give the `peer` object with different channels.
-                 * We will store all channels as backups in case any one of them fails
-                 * A peer is removed if all data channels become unavailable
-                 */
-                this.peers[peer.id][peer.channelName] = peer;
-                if (newpeer) {
-                    this.emit('peerconnect', peer);
-                }
-            });
-            peer.on('data', data => {
-                this.emit('data', peer, data);
-                data = data.toString();
-                debug('got a message from ' + peer.id);
-                if (data[0] === JSON_MESSAGE_IDENTIFIER) {
-                    try {
-                        data = JSON.parse(data.slice(1));
-                        // A respond function
-                        peer.respond = this._peerRespond(peer, data.id);
-                        let msg = this._chunkHandler(data);
-                        // msg fully retrieved
-                        if (msg !== false) {
-                            if (data.o) {
-                                msg = JSON.parse(msg);
-                            }
-                            /**
-                             * If there's someone waiting for a response, call them
-                             */
-                            if (this.responseWaiting[peer.id] && this.responseWaiting[peer.id][data.id]) {
-                                this.responseWaiting[peer.id][data.id]([peer, msg]);
-                                delete this.responseWaiting[peer.id][data.id];
-                            }
-                            else {
-                                this.emit('msg', peer, msg, data.id, data.from);
-                            }
-                            this._destroyChunks(data.id);
-                        }
+    #onPeerConnect = (peer) => {
+        let newpeer = false;
+        /**
+         * peer connected or reconnected
+         * Sometimes peers reconnect so need to handle the newpeer here
+         */
+        if (!this.peers[peer.id]) {
+            newpeer = true;
+            this.peers[peer.id] = {};
+            if (!this.responseWaiting[peer.id])
+                this.responseWaiting[peer.id] = {};
+        }
+        /**
+         * Multiple data channels to one peer is possible
+         * The `peer` object actually refers to a peer with a data channel. Even though it may have same `id` (peerID) property, the data channel will be different. Different trackers giving the same "peer" will give the `peer` object with different channels.
+         * We will store all channels as backups in case any one of them fails
+         * A peer is removed if all data channels become unavailable
+         */
+        for (const channelName in this.peers[peer.id]) {
+            if (!this.peers[peer.id][channelName].connected) {
+                this.peers[peer.id][channelName].destroy();
+            }
+        }
+        if (Object.keys(this.peers[peer.id]).length < this.#maxPeerChannels)
+            this.peers[peer.id][peer.channelName] = peer;
+        else
+            peer.destroy();
+        if (newpeer) {
+            this.emit('peerconnect', peer);
+        }
+    };
+    #onPeerData = (peer, data) => {
+        this.emit('data', peer, data);
+        data = data.toString();
+        debug('got a message from ' + peer.id);
+        if (data[0] === JSON_MESSAGE_IDENTIFIER) {
+            try {
+                data = JSON.parse(data.slice(1));
+                // A respond function
+                peer.respond = this._peerRespond(peer, data.id);
+                let msg = this._chunkHandler(data);
+                // msg fully retrieved
+                if (msg !== false) {
+                    if (data.o) {
+                        msg = JSON.parse(msg);
+                    }
+                    /**
+                     * If there's someone waiting for a response, call them
+                     */
+                    if (this.responseWaiting[peer.id] && this.responseWaiting[peer.id][data.id]) {
+                        this.responseWaiting[peer.id][data.id]([peer, msg]);
+                        delete this.responseWaiting[peer.id][data.id];
                     }
-                    catch (e) {
-                        console.log(e);
+                    else {
+                        this.emit('msg', peer, msg, data.id, data.from);
                     }
+                    this._destroyChunks(data.id);
                 }
-            });
-            peer.on('error', err => {
-                this._removePeer(peer);
-                debug('Error in connection : ' + err);
-            });
-            peer.on('close', () => {
-                this._removePeer(peer);
-                debug('Connection closed with ' + peer.id);
-            });
+            }
+            catch (e) {
+                console.log(e);
+            }
+        }
+    };
+    #onPeer = (peer) => {
+        peer.on('connect', () => this.#onPeerConnect(peer));
+        peer.on('data', (data) => this.#onPeerData(peer, data));
+        peer.on('error', (err) => {
+            this._removePeer(peer);
+            debug('Error in connection : ' + err);
         });
+        peer.on('close', () => {
+            this._removePeer(peer);
+            debug('Connection closed with ' + peer.id);
+        });
+    };
+    /**
+     * Connect to network and start discovering peers
+     */
+    start() {
+        this.on('peer', this.#onPeer);
         // Tracker responded to the announce request
-        this.on('update', response => {
+        this.on('update', (response) => {
             const tracker = this.trackers[this.announceURLs.indexOf(response.announce)];
             this.emit('trackerconnect', tracker, this.getTrackerStats());
         });
         // Errors in tracker connection
-        this.on('warning', err => {
+        this.on('warning', (err) => {
             this.emit('trackerwarning', err, this.getTrackerStats());
         });
         this._fetchPeers();
@@ -611,7 +635,10 @@ let P2PT$1 = class P2PT extends EventEmitter {
         if (!this.peers[peer.id]) {
             return false;
         }
-        delete this.peers[peer.id][peer.channelName];
+        if (this.peers[peer.id][peer.channelName]) {
+            this.peers[peer.id][peer.channelName].destroy();
+            delete this.peers[peer.id][peer.channelName];
+        }
         // All data channels are gone. Peer lost
         if (Object.keys(this.peers[peer.id]).length === 0) {
             this.emit('peerclose', peer);
@@ -665,8 +692,13 @@ let P2PT$1 = class P2PT extends EventEmitter {
                  * Array should atleast have one channel, otherwise peer connection is closed
                  */
                 if (!peer.connected) {
-                    for (const index in this.peers[peer.id]) {
+                    for (const index in { ...this.peers[peer.id] }) {
                         peer = this.peers[peer.id][index];
+                        /**
+                         * directly cleanup channels
+                         */
+                        if (!peer.connected)
+                            this._removePeer(peer);
                         if (peer.connected)
                             break;
                     }
@@ -687,7 +719,7 @@ let P2PT$1 = class P2PT extends EventEmitter {
      * Request more peers
      */
     requestMorePeers() {
-        return new Promise(resolve => {
+        return new Promise((resolve) => {
             for (const key in this.trackers) {
                 this.trackers[key].announce(this._defaultAnnounceOpts());
             }
@@ -729,7 +761,7 @@ let P2PT$1 = class P2PT extends EventEmitter {
      * @param integer msgID Message ID
      */
     _peerRespond(peer, msgID) {
-        return msg => {
+        return (msg) => {
             return this.send(peer, msg, msgID);
         };
     }
@@ -763,7 +795,7 @@ let P2PT$1 = class P2PT extends EventEmitter {
      */
     _defaultAnnounceOpts(options = {}) {
         if (options.numwant === undefined)
-            options.numwant = 50;
+            options.numwant = 5;
         if (options.uploaded === undefined)
             options.uploaded = 0;
         if (options.downloaded === undefined)
@@ -1231,7 +1263,7 @@ class WebSocketTracker extends Tracker {
     if (data.complete != null) {
       const response = Object.assign({}, data, {
         announce: this.announceUrl,
-        infoHash: data.info_hash
+        infoHash: common.binaryToHex(data.info_hash)
       });
       this.client.emit('update', response);
     }

package/exports/browser/{index-20ad607b.js → index-34c93510.js}

@@ -1,4 +1,4 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './peernet-8bfe60c5.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './peernet-72528dd9.js';
 import './value-4e80eeeb.js';
 
 /**

package/exports/browser/{messages-29f5675b.js → messages-b7f41cba.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface } from './peernet-8bfe60c5.js';
+import { F as FormatInterface } from './peernet-72528dd9.js';
 import './value-4e80eeeb.js';
 
 var proto$b = {

package/exports/browser/{peernet-8bfe60c5.js → peernet-72528dd9.js}

@@ -11658,25 +11658,23 @@ var pako = {
 };
 
 const { fromString, toString } = index$3;
-const isJson = (type) => type === "object" || "array";
-const isString = (type) => type === "string";
-const isNumber = (type) => type === "number";
-const isBoolean = (type) => type === "boolean";
-const isUint8Array$1 = (type) => type === "uint8Array";
-const isBigNumber = (type) => type === "bigNumber";
+const isJson = (type) => type === 'object' || 'array';
+const isString = (type) => type === 'string';
+const isNumber = (type) => type === 'number';
+const isBoolean = (type) => type === 'boolean';
+const isUint8Array$1 = (type) => type === 'uint8Array';
+const isBigNumber = (type) => type === 'bigNumber';
 const tokenize = (key, value) => {
-    const optional = key.endsWith("?");
+    const optional = key.endsWith('?');
     let type = value === undefined ? key : value;
     if (type instanceof Uint8Array)
-        type = "uint8Array";
+        type = 'uint8Array';
     else if (type instanceof BigNumber)
-        type = "bigNumber";
+        type = 'bigNumber';
     else
-        type = Array.isArray(type) ? "array" : typeof type;
-    const parts = key.split("?");
-    const minimumLength = parts[2]?.includes("min")
-        ? parts[2].split["min:"][1]
-        : 0;
+        type = Array.isArray(type) ? 'array' : typeof type;
+    const parts = key.split('?');
+    const minimumLength = parts[2]?.includes('min') ? parts[2].split['min:'][1] : 0;
     return { type, optional, key: parts[0], minimumLength };
 };
 const toType = (data) => {
@@ -11690,13 +11688,13 @@ const toType = (data) => {
     if (data instanceof BigNumber)
         return new TextEncoder().encode(data._hex || data.toHexString());
     // returns the string as a UintArray
-    if (typeof data === "string")
+    if (typeof data === 'string')
         return new TextEncoder().encode(data);
     // returns the object as a UintArray
-    if (typeof data === "object")
+    if (typeof data === 'object')
         return new TextEncoder().encode(JSON.stringify(data));
     // returns the number as a UintArray
-    if (typeof data === "number" || typeof data === "boolean")
+    if (typeof data === 'number' || typeof data === 'boolean')
         return new TextEncoder().encode(data.toString());
     throw new Error(`unsuported type ${typeof data || data}`);
 };
@@ -11709,17 +11707,14 @@ const encode$3 = (proto, input, compress) => {
         const data = input[token.key];
         if (!token.optional && data === undefined)
             throw new Error(`missing required property: ${token.key}`);
-        if ((token.type === "array" && token.minimumLength > data?.length) ||
-            (token.type === "object" &&
-                token.minimumLength > Object.keys(data).length))
+        if ((token.type === 'array' && token.minimumLength > data?.length) ||
+            (token.type === 'object' && token.minimumLength > Object.keys(data).length))
             throw new Error(`minimumLength for ${token.key} is set to ${token.minimumLength} but got ${data.length}`);
         // always push data to the set.
         // when data is undefined push the default value of the proto
         set.push(toType(data || values[i]));
     }
-    return compress
-        ? pako.deflate(index$7(set))
-        : index$7(set);
+    return compress ? pako.deflate(index$7(set)) : index$7(set);
 };
 const decode$4 = (proto, uint8Array, compressed) => {
     if (compressed)
@@ -11737,7 +11732,7 @@ const decode$4 = (proto, uint8Array, compressed) => {
         else if (isString(token.type))
             output[token.key] = toString(deconcated[i]);
         else if (isBoolean(token.type))
-            output[token.key] = Boolean(new TextDecoder().decode(deconcated[i]));
+            output[token.key] = new TextDecoder().decode(deconcated[i]) === 'true';
         else if (isNumber(token.type))
             output[token.key] = Number(new TextDecoder().decode(deconcated[i]));
         else if (isBigNumber(token.type))
@@ -11755,7 +11750,7 @@ const decode$4 = (proto, uint8Array, compressed) => {
 };
 var index$2 = {
     encode: encode$3,
-    decode: decode$4,
+    decode: decode$4
 };
 
 class BasicInterface {
@@ -12306,6 +12301,13 @@ class CodecHash extends BasicInterface {
 let FormatInterface$1 = class FormatInterface extends BasicInterface {
     hashFormat;
     #hash;
+    #encoded;
+    get encoded() {
+        return this.#encoded || this.encode();
+    }
+    set encoded(value) {
+        this.#encoded = value;
+    }
     init(buffer) {
         if (buffer instanceof FormatInterface && buffer?.name === this.name)
             return buffer;
@@ -12313,7 +12315,7 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
             this.fromUint8Array(buffer);
         else if (buffer instanceof ArrayBuffer)
             this.fromArrayBuffer(buffer);
-        else if (typeof buffer === "string") {
+        else if (typeof buffer === 'string') {
             if (this.isHex(buffer))
                 this.fromHex(buffer);
             else if (this.isBase58(buffer))
@@ -12379,7 +12381,7 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
     constructor(buffer, proto, options) {
         super();
         this.proto = proto;
-        this.hashFormat = options?.hashFormat ? options.hashFormat : "bs32";
+        this.hashFormat = options?.hashFormat ? options.hashFormat : 'bs32';
         if (options?.name)
             this.name = options.name;
         this.init(buffer);
@@ -12388,13 +12390,16 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
         const upper = this.hashFormat.charAt(0).toUpperCase();
         return `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
     }
+    beforeHashing(decoded) {
+        delete decoded.hash;
+        return decoded;
+    }
     /**
      * @return {PeernetHash}
      */
     get peernetHash() {
-        const decoded = this.decoded;
+        const decoded = this.beforeHashing({ ...this.decoded });
         // @ts-ignore
-        delete decoded.hash;
         return new CodecHash(decoded, { name: this.name });
     }
     /**
@@ -27083,7 +27088,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-20ad607b.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-34c93510.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));
@@ -27275,7 +27280,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-29f5675b.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-b7f41cba.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -27366,7 +27371,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-d602421d.js');
+        const importee = await import('./client-493cbd83.js');
         /**
          * @access public
          * @type {PeernetClient}

package/exports/browser/peernet.js

@@ -1,2 +1,2 @@
-export { P as default } from './peernet-8bfe60c5.js';
+export { P as default } from './peernet-72528dd9.js';
 import './value-4e80eeeb.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.1.64",
+  "version": "1.1.66",
   "description": "",
   "main": "src/peernet.js",
   "exports": {
@@ -33,9 +33,10 @@
     "@leofcoin/generate-account": "^2.0.0",
     "@leofcoin/identity-utils": "^1.0.2",
     "@leofcoin/multi-wallet": "^3.1.4",
+    "@leofcoin/p2pt": "^1.7.6",
     "@leofcoin/peernet-swarm": "^1.1.0",
     "@leofcoin/storage": "^3.0.0",
-    "@netpeer/p2pt-swarm": "^1.3.2",
+    "@netpeer/p2pt-swarm": "^1.3.5",
     "@types/node": "^18.11.18",
     "@vandeurenglenn/base32": "^1.1.0",
     "@vandeurenglenn/base58": "^1.1.0",