@leofcoin/peernet 1.1.104 → 1.2.0

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

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs } from './identity-nIyW_Xm8.js';
+import { g as getDefaultExportFromCjs } from './identity-B6BHwSTU.js';
 
 var browser$2 = {};
 

package/exports/browser/{browser-CfYI-6aD.js → browser-DQlwTLRn.js}

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs } from './identity-nIyW_Xm8.js';
+import { g as getDefaultExportFromCjs } from './identity-B6BHwSTU.js';
 
 var global;
 var hasRequiredGlobal;

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

@@ -1,5 +1,5 @@
-import { L as LittlePubSub } from './peernet-BsnqtUsa.js';
-import './identity-nIyW_Xm8.js';
+import { L as LittlePubSub, d as deflate_1, c as createDebugger, i as inflate_1 } from './peernet-fcX5oKJJ.js';
+import './identity-B6BHwSTU.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-CfYI-6aD.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                    globalThis.WebSocket = (await import('./browser-DQlwTLRn.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);
@@ -317,6 +317,17 @@ const defaultOptions = {
     connectEvent: 'peer:connected'
 };
 
+// Simple CRC32 implementation
+const crc32$1 = (data) => {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc ^= data[i];
+        for (let j = 0; j < 8; j++) {
+            crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+        }
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+};
 const iceServers = [
     {
         urls: 'stun:stun.l.google.com:19302' // Google's public STUN server
@@ -335,37 +346,81 @@ const iceServers = [
         credential: 'openrelayproject'
     }
 ];
-const SimplePeer = (await import('./index-DTbjK0sK.js').then(function (n) { return n.i; })).default;
+const SimplePeer = (await import('./index-DYdP5D9L.js').then(function (n) { return n.i; })).default;
 class Peer extends SimplePeer {
     peerId;
     channelName;
     version;
+    compressionThreshold = 0.98;
     bw = { up: 0, down: 0 };
     get connected() {
         return super.connected;
     }
     constructor(options) {
-        const { from, to, initiator, trickle, config, version } = options;
+        const { from, to, initiator, trickle, config, version, wrtc, compressionThreshold } = options;
         const channelName = initiator ? `${from}:${to}` : `${to}:${from}`;
         super({
             channelName,
             initiator,
-            trickle: trickle || true,
+            trickle: trickle ?? true,
             config: { iceServers, ...config },
-            wrtc: globalThis.wrtc
+            wrtc: wrtc ?? globalThis.wrtc
         });
         this.version = String(version);
         this.peerId = to;
         this.channelName = channelName;
+        if (compressionThreshold !== undefined)
+            this.compressionThreshold = compressionThreshold;
     }
     async #chunkit(data, id) {
         this.bw.up = data.length;
-        const size = data.length;
+        // attempt compression; use compressed only if beneficial
+        let sendData = data;
+        try {
+            const c = deflate_1(data);
+            if (c?.length && c.length < data.length * this.compressionThreshold)
+                sendData = c;
+        }
+        catch (e) {
+            // ignore
+        }
+        const size = sendData.length;
+        const encodeFrame = (idStr, totalSize, index, count, payload, flags) => {
+            const te = new TextEncoder();
+            const idBytes = te.encode(idStr);
+            const crc = crc32$1(payload);
+            const headerLen = 1 + 1 + 4 + 4 + 4 + 4 + 2 + idBytes.length;
+            const buffer = new ArrayBuffer(headerLen + payload.length);
+            const view = new DataView(buffer);
+            const out = new Uint8Array(buffer);
+            let offset = 0;
+            view.setUint8(offset, 1); // version
+            offset += 1;
+            view.setUint8(offset, flags); // flags: bit0 chunked, bit1 compressed
+            offset += 1;
+            view.setUint32(offset, totalSize, true);
+            offset += 4;
+            view.setUint32(offset, index, true);
+            offset += 4;
+            view.setUint32(offset, count, true);
+            offset += 4;
+            view.setUint32(offset, crc, true); // CRC32
+            offset += 4;
+            view.setUint16(offset, idBytes.length, true);
+            offset += 2;
+            out.set(idBytes, offset);
+            offset += idBytes.length;
+            out.set(payload, offset);
+            return out;
+        };
         // no needles chunking, keep it simple, if data is smaller then max size just send it
-        if (data.length <= MAX_MESSAGE_SIZE) {
-            return super.send(JSON.stringify({ chunk: data, id, size: data.length }));
+        if (size <= MAX_MESSAGE_SIZE) {
+            const flags = ((size > MAX_MESSAGE_SIZE ? 1 : 0) << 0) |
+                ((sendData !== data ? 1 : 0) << 1);
+            super.send(encodeFrame(id, size, 0, 1, sendData, flags));
+            return;
         }
-        async function* chunks(data) {
+        function* chunks(data) {
             while (data.length !== 0) {
                 const amountToSlice = data.length >= MAX_MESSAGE_SIZE ? MAX_MESSAGE_SIZE : data.length;
                 const subArray = data.subarray(0, amountToSlice);
@@ -381,8 +436,27 @@ class Peer extends SimplePeer {
         //   data = data.subarray(amountToSlice, data.length)
         //   super.send(JSON.stringify({ chunk: subArray, id, size }))
         // }
-        for await (const chunk of chunks(data)) {
-            super.send(JSON.stringify({ chunk, id, size }));
+        // backpressure-aware send loop with indexed chunks
+        const count = Math.ceil(size / MAX_MESSAGE_SIZE);
+        let index = 0;
+        const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+        const threshold = 4 * 1024 * 1024; // 4MB bufferedAmount threshold
+        const flags = (1 << 0) | ((sendData !== data ? 1 : 0) << 1);
+        for (const chunk of chunks(sendData)) {
+            // wait while channel is congested
+            // eslint-disable-next-line no-await-in-loop
+            while (
+            // @ts-ignore underlying channel is not part of public types
+            this._channel?.bufferedAmount > threshold) {
+                // if connection closed, abort
+                // eslint-disable-next-line no-await-in-loop
+                if (!this.connected)
+                    return;
+                // eslint-disable-next-line no-await-in-loop
+                await sleep(10);
+            }
+            super.send(encodeFrame(id, size, index, count, chunk, flags));
+            index += 1;
         }
     }
     /**
@@ -402,12 +476,16 @@ class Peer extends SimplePeer {
      */
     request(data, id = crypto.randomUUID()) {
         return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => reject(`request for ${id} timed out`), 30_000);
+            let timeout;
             const onrequest = ({ data }) => {
                 clearTimeout(timeout);
                 resolve(data);
                 globalThis.pubsub.unsubscribe(id, onrequest);
             };
+            timeout = setTimeout(() => {
+                globalThis.pubsub.unsubscribe(id, onrequest);
+                reject(`request for ${id} timed out`);
+            }, 30_000);
             globalThis.pubsub.subscribe(id, onrequest);
             this.send(data, id);
         });
@@ -422,7 +500,18 @@ class Peer extends SimplePeer {
     }
 }
 
-const debug = globalThis.createDebugger('@netpeer/swarm/client');
+// Simple CRC32 implementation
+const crc32 = (data) => {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc ^= data[i];
+        for (let j = 0; j < 8; j++) {
+            crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+        }
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+};
+const debug = createDebugger('@netpeer/swarm/client');
 class Client {
     #peerId;
     #connections = {};
@@ -527,7 +616,7 @@ class Client {
     }
     async _init() {
         if (!globalThis.RTCPeerConnection)
-            globalThis.wrtc = (await import('./browser-Qcpp3EKK.js').then(function (n) { return n.b; })).default;
+            globalThis.wrtc = (await import('./browser-BHbuEZJu.js').then(function (n) { return n.b; })).default;
         for (const star of this.starsConfig) {
             try {
                 await this.setupStar(star);
@@ -705,9 +794,12 @@ class Client {
         globalThis.pubsub.publishVerbose(this.#connectEvent, peer.peerId);
     };
     #noticeMessage = (message, id, from, peer) => {
+        const dataOut = message instanceof Uint8Array
+            ? message
+            : new Uint8Array(Object.values(message));
         if (globalThis.pubsub.subscribers[id]) {
             globalThis.pubsub.publish(id, {
-                data: new Uint8Array(Object.values(message)),
+                data: dataOut,
                 id,
                 from,
                 peer
@@ -715,7 +807,7 @@ class Client {
         }
         else {
             globalThis.pubsub.publish('peer:data', {
-                data: new Uint8Array(Object.values(message)),
+                data: dataOut,
                 id,
                 from,
                 peer
@@ -723,22 +815,124 @@ class Client {
         }
     };
     #peerData = (peer, data) => {
-        const { id, size, chunk } = JSON.parse(new TextDecoder().decode(data));
-        peer.bw.down += size;
-        if (size <= MAX_MESSAGE_SIZE) {
-            this.#noticeMessage(chunk, id, peer.peerId, peer);
+        const tryJson = () => {
+            const parsed = JSON.parse(new TextDecoder().decode(data));
+            const { id, size, chunk, index, count } = parsed;
+            chunk ? Object.values(chunk).length : size;
+            return {
+                id,
+                size: Number(size),
+                index: Number(index ?? 0),
+                count: Number(count ?? 1),
+                chunk: new Uint8Array(Object.values(chunk)),
+                flags: 0,
+                crc: 0
+            };
+        };
+        const decodeBinary = () => {
+            let u8;
+            if (typeof data === 'string') {
+                // should not happen when sending binary, fallback to JSON
+                return tryJson();
+            }
+            else if (data instanceof ArrayBuffer) {
+                u8 = new Uint8Array(data);
+            }
+            else if (ArrayBuffer.isView(data)) {
+                const view = data;
+                const byteOffset = view.byteOffset || 0;
+                const byteLength = view.byteLength || data.length;
+                u8 = new Uint8Array(view.buffer, byteOffset, byteLength);
+            }
+            else if (data?.buffer) {
+                u8 = new Uint8Array(data.buffer);
+            }
+            else {
+                // last resort: attempt JSON
+                return tryJson();
+            }
+            const dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+            let offset = 0;
+            dv.getUint8(offset);
+            offset += 1;
+            const flags = dv.getUint8(offset);
+            offset += 1;
+            const size = dv.getUint32(offset, true);
+            offset += 4;
+            const index = dv.getUint32(offset, true);
+            offset += 4;
+            const count = dv.getUint32(offset, true);
+            offset += 4;
+            const expectedCrc = dv.getUint32(offset, true);
+            offset += 4;
+            const idLen = dv.getUint16(offset, true);
+            offset += 2;
+            const idBytes = u8.subarray(offset, offset + idLen);
+            offset += idLen;
+            const id = new TextDecoder().decode(idBytes);
+            const chunk = u8.subarray(offset);
+            return { id, size, index, count, chunk, flags, crc: expectedCrc };
+        };
+        const frame = decodeBinary();
+        peer.bw.down += frame.chunk.length;
+        // Single frame path: if compressed, inflate before publish
+        if (frame.count === 1) {
+            let payload = frame.chunk;
+            const compressed = Boolean(frame.flags & (1 << 1));
+            if (compressed) {
+                const actualCrc = crc32(payload);
+                if (actualCrc !== frame.crc) {
+                    console.warn(`CRC mismatch: expected ${frame.crc}, got ${actualCrc}`);
+                }
+                try {
+                    payload = inflate_1(payload);
+                }
+                catch (e) {
+                    console.warn('inflate failed, passing compressed payload');
+                }
+            }
+            this.#noticeMessage(payload, frame.id, peer.peerId, peer);
+            return;
         }
-        else {
-            if (!this.#messagesToHandle[id])
-                this.#messagesToHandle[id] = [];
-            this.#messagesToHandle[id] = [
-                ...this.#messagesToHandle[id],
-                ...Object.values(chunk)
-            ];
-            if (this.#messagesToHandle[id].length === Number(size)) {
-                this.#noticeMessage(this.#messagesToHandle[id], id, peer.peerId, peer);
-                delete this.#messagesToHandle[id];
+        // Chunked message handling with indexed reassembly
+        if (!this.#messagesToHandle[frame.id] ||
+            Array.isArray(this.#messagesToHandle[frame.id])) {
+            this.#messagesToHandle[frame.id] = {
+                chunks: new Array(frame.count),
+                receivedBytes: 0,
+                expectedSize: Number(frame.size),
+                expectedCount: Number(frame.count)
+            };
+        }
+        const state = this.#messagesToHandle[frame.id];
+        // Verify CRC for this chunk
+        const actualCrc = crc32(frame.chunk);
+        if (actualCrc !== frame.crc) {
+            console.warn(`Chunk CRC mismatch for ${frame.id}[${frame.index}]: expected ${frame.crc}, got ${actualCrc}`);
+        }
+        state.chunks[frame.index] = frame.chunk;
+        state.receivedBytes += frame.chunk.length;
+        // If all chunks present and total size matches, reassemble
+        const allPresent = state.chunks.every((c) => c instanceof Uint8Array);
+        if (allPresent && state.receivedBytes === state.expectedSize) {
+            const result = new Uint8Array(state.expectedSize);
+            let offset2 = 0;
+            for (const c of state.chunks) {
+                result.set(c, offset2);
+                offset2 += c.length;
+            }
+            let payload = result;
+            const compressed = Boolean(frame.flags & (1 << 1));
+            if (compressed) {
+                try {
+                    payload = inflate_1(result);
+                }
+                catch (e) {
+                    console.warn('inflate failed, passing compressed payload');
+                }
             }
+            this.#noticeMessage(payload, frame.id, peer.peerId, peer);
+            delete this.#messagesToHandle[frame.id];
         }
     };
     #peerError = (peer, error) => {

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

@@ -17150,7 +17150,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-ChRjMyiM.js');
+            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));
@@ -17196,4 +17196,4 @@ class Identity {
     }
 }
 
-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 };
+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 };

package/exports/browser/identity.js

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

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

@@ -1,4 +1,4 @@
-import { h as commonjsGlobal, r as require$$3, j as requireInherits_browser, g as getDefaultExportFromCjs } from './identity-nIyW_Xm8.js';
+import { f as commonjsGlobal, r as require$$3, h as requireInherits_browser, g as getDefaultExportFromCjs } from './identity-B6BHwSTU.js';
 import require$$0 from 'events';
 
 var browser$2 = {exports: {}};

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

@@ -1,5 +1,5 @@
-import { F as FormatInterface } from './peernet-BsnqtUsa.js';
-import './identity-nIyW_Xm8.js';
+import { F as FormatInterface } from './peernet-fcX5oKJJ.js';
+import './identity-B6BHwSTU.js';
 import './value-C3vAp-wb.js';
 
 var proto$b = {

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

@@ -1,42 +1,31 @@
-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 { 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 { K as KeyPath, a as KeyValue } from './value-C3vAp-wb.js';
 
-if (!globalThis.DEBUG) {
-  globalThis.DEBUG = [];
-  if (globalThis.localStorage) {
-    const DEBUG = globalThis.localStorage.getItem("DEBUG");
-    if (DEBUG) {
-      globalThis.DEBUG = DEBUG.startsWith("[")
-        ? JSON.parse(DEBUG).split(",")
-        : [DEBUG];
-    }
-  }
-}
+const getTargets = () => Array.from([]);
+const isEnabled = (target) => {
+    return false;
+};
 
 const getLogger = (trace) => (trace ? console.trace : console.log);
-
-const debug$1 = (target, text, trace) => {
-  const _logger = getLogger(trace);
-  if (!globalThis.DEBUG || globalThis.DEBUG?.length === 0) return;
-  if (
-    globalThis.DEBUG === "true" ||
-    globalThis.DEBUG === true ||
-    globalThis.DEBUG?.indexOf(target) !== -1 ||
-    globalThis.DEBUG?.indexOf("*") !== -1 ||
-    globalThis.DEBUG?.indexOf(target.split("/")[0]) !== -1
-  )
-    if (text) _logger("\x1b[34m\x1b[1m%s", `${target}: ${text}`, "\x1b[0m");
-    else _logger("\x1b[34m\x1b[1m%s", `${target}`, "\x1b[0m");
+const createDebugger = (target) => {
+    // Cache the enabled check on first call
+    let enabled = null;
+    let lastTargets = undefined;
+    return (text, trace) => {
+        const targets = getTargets();
+        if (lastTargets !== targets) {
+            enabled = targets ? isEnabled() : false;
+            lastTargets = targets;
+        }
+        if (!enabled)
+            return;
+        if (text)
+            getLogger(trace)('\x1b[34m\x1b[1m%s', `${target}: ${text}`, '\x1b[0m');
+        else
+            getLogger(trace)('\x1b[34m\x1b[1m%s', `${target}`, '\x1b[0m');
+    };
 };
 
-const createDebugger = (target) => (text) => debug$1(target, text);
-
-if (!globalThis.debug) {
-  globalThis.debug = debug$1;
-  // todo: deprecate
-  globalThis.createDebugger = createDebugger;
-}
-
 class LittlePubSub {
     subscribers = {};
     verbose;
@@ -8222,7 +8211,7 @@ globalThis.LeofcoinStorage = LeofcoinStorage$1;
 globalThis.leofcoin = globalThis.leofcoin || {};
 globalThis.pubsub = globalThis.pubsub || new LittlePubSub();
 globalThis.globalSub = globalThis.globalSub || new LittlePubSub();
-const debug = globalThis.createDebugger('peernet');
+const debug = createDebugger('peernet');
 /**
  * @access public
  * @example
@@ -8366,7 +8355,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-C22qRxnF.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-CiR1YiV5.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8460,7 +8449,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-Lwke64Zq.js');
+        const importee = await import('./client-DCeU_UX5.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -8980,4 +8969,4 @@ class Peernet {
 }
 globalThis.Peernet = Peernet;
 
-export { FormatInterface as F, LittlePubSub as L, Peernet as P };
+export { FormatInterface as F, LittlePubSub as L, Peernet as P, createDebugger as c, deflate_1 as d, inflate_1 as i };

package/exports/browser/peernet.d.ts

@@ -1,4 +1,3 @@
-import '@vandeurenglenn/debug';
 import PubSub from '@vandeurenglenn/little-pubsub';
 import PeerDiscovery from './discovery/peer-discovery.js';
 import DHT from './dht/dht.js';

package/exports/browser/peernet.js

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

package/exports/peernet.js

@@ -1,4 +1,4 @@
-import '@vandeurenglenn/debug';
+import { createDebugger } from '@vandeurenglenn/debug';
 import PubSub from '@vandeurenglenn/little-pubsub';
 import { Codec } from '@leofcoin/codec-format-interface';
 import { Storage } from '@leofcoin/storage';
@@ -303,7 +303,7 @@ globalThis.LeofcoinStorage = Storage;
 globalThis.leofcoin = globalThis.leofcoin || {};
 globalThis.pubsub = globalThis.pubsub || new PubSub();
 globalThis.globalSub = globalThis.globalSub || new PubSub();
-const debug = globalThis.createDebugger('peernet');
+const debug = createDebugger('peernet');
 /**
  * @access public
  * @example

package/exports/types/peernet.d.ts

@@ -1,4 +1,3 @@
-import '@vandeurenglenn/debug';
 import PubSub from '@vandeurenglenn/little-pubsub';
 import PeerDiscovery from './discovery/peer-discovery.js';
 import DHT from './dht/dht.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.1.104",
+  "version": "1.2.0",
   "description": "",
   "browser": "./exports/browser/peernet.js",
   "exports": {
@@ -23,7 +23,7 @@
   "scripts": {
     "build": "rollup -c",
     "watch": "rollup -c -w",
-    "test": "npx mocha test/peernet.test.ts",
+    "test": "node --test test/peernet.test.js",
     "server": "discovery-swarm-webrtc --port=4000",
     "demo": "jsproject --serve ./ --port 6868"
   },
@@ -33,38 +33,25 @@
   "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",
-    "@netpeer/swarm": "^0.8.32",
-    "@vandeurenglenn/base32": "^1.2.4",
+    "@netpeer/swarm": "^0.9.0",
     "@vandeurenglenn/base58": "^1.1.9",
-    "@vandeurenglenn/debug": "^1.2.6",
-    "@vandeurenglenn/is-hex": "^1.1.1",
+    "@vandeurenglenn/debug": "^1.4.0",
     "@vandeurenglenn/little-pubsub": "^1.5.1",
-    "inquirer": "^13.0.1",
-    "multi-signature": "^1.3.1",
+    "inquirer": "^13.1.0",
     "qr-scanner": "^1.4.2",
-    "qrcode": "^1.5.4",
-    "socket-request-client": "^2.1.2",
-    "socket-request-server": "^1.7.2"
+    "qrcode": "^1.5.4"
   },
   "devDependencies": {
-    "@jest/globals": "^30.2.0",
     "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
     "@rollup/plugin-wasm": "^6.2.2",
-    "@types/bs58check": "^3.0.1",
-    "@types/node": "^24.10.1",
+    "@types/node": "^25.0.3",
     "@types/qrcode": "^1.5.6",
-    "@types/secp256k1": "^4.0.7",
-    "@types/varint": "^6.0.3",
-    "chai": "^6.2.1",
-    "cross-env": "^10.1.0",
-    "rollup": "^4.53.3",
-    "sinon": "^21.0.0"
+    "rollup": "^4.54.0"
   }
 }

package/src/peernet.ts

@@ -1,4 +1,4 @@
-import '@vandeurenglenn/debug'
+import { createDebugger } from '@vandeurenglenn/debug'
 import PubSub from '@vandeurenglenn/little-pubsub'
 import PeerDiscovery from './discovery/peer-discovery.js'
 import DHT, { DHTProvider, DHTProviderDistanceResult, getAddress } from './dht/dht.js'
@@ -30,7 +30,7 @@ declare global {
   var chainStore: LeofcoinStorageClass
 }
 
-const debug = globalThis.createDebugger('peernet')
+const debug = createDebugger('peernet')
 /**
  * @access public
  * @example

package/test/peernet.test.js

@@ -1,159 +1,45 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
 import Peernet from '../exports/peernet.js'
 import Identity from '../exports/identity.js'
-import { expect } from 'chai'
-import sinon from 'sinon'
-import networks from '@leofcoin/networks'
-
-const network = networks.leofcoin.peach
 
-let options
-let password
-options = {
+const options = {
   network: 'leofcoin:peach',
-  stars: network.stars,
+  stars: [],
   root: '.testnet',
   version: '1.0.0',
-  storePrefix: 'test'
+  storePrefix: 'test',
+  autoStart: false
 }
-password = 'password'
-const peernet = await new Peernet(options, password)
-
-describe('Peernet', async () => {
-  // beforeEach(async () => {
-  // })
-
-  it('should initialize with the correct network', () => {
-    expect(peernet.network).to.equal('leofcoin:peach')
-  })
-
-  it('should initialize with the correct version', () => {
-    expect(peernet.version).to.equal('1.0.0')
-  })
-
-  it('should initialize with the correct store prefix', () => {
-    expect(peernet.storePrefix).to.equal('test')
-  })
-
-  it('should have an identity instance', () => {
-    expect(peernet.identity).to.be.instanceOf(Identity)
-  })
-
-  it('should have a DHT instance', () => {
-    expect(peernet.dht).to.not.be.undefined
-  })
-
-  it('should start the client', async () => {
-    const startSpy = sinon.spy(peernet, 'start')
-    await peernet.start()
-    expect(startSpy.calledOnce).to.be.true
-  })
-
-  it('should add a proto', () => {
-    const protoName = 'test-proto'
-    const proto = {}
-    peernet.addProto(protoName, proto)
-    expect(globalThis.peernet.protos[protoName]).to.equal(proto)
-  })
-
-  it('should add a codec', () => {
-    const codec = { name: 'test-codec' }
-    const addCodecSpy = sinon.spy(peernet, 'addCodec')
-    peernet.addCodec(codec)
-    expect(addCodecSpy.calledOnceWith(codec)).to.be.true
-  })
-
-  it('should select an account', async () => {
-    const account = 'test-account'
-    const selectAccountSpy = sinon.spy(peernet.identity, 'selectAccount')
-    await peernet.selectAccount(account)
-    expect(selectAccountSpy.calledOnceWith(account)).to.be.true
-  })
 
-  it('should prepare a message', () => {
-    const data = { message: 'test' }
-    const prepareMessageSpy = sinon.spy(peernet._messageHandler, 'prepareMessage')
-    peernet.prepareMessage(data)
-    expect(prepareMessageSpy.calledOnceWith(data)).to.be.true
-  })
-
-  it('should get peers', () => {
-    const peers = peernet.peers
-    expect(peers).to.be.an('array')
-  })
-
-  it('should get connections', () => {
-    const connections = peernet.connections
-    expect(connections).to.be.an('object')
-  })
-
-  it('should get a connection by id', () => {
-    const id = 'test-id'
-    const connection = peernet.getConnection(id)
-    expect(connection).to.be.undefined // Assuming no connections are established in the test
-  })
-
-  // it('should handle DHT', async () => {
-  //   const peer = {}
-  //   const id = 'test-id'
-  //   const proto = { decoded: { hash: 'test-hash', store: 'test-store' } }
-  //   const handleDHTSpy = sinon.spy(peernet, 'handleDHT')
-  //   await peernet.handleDHT(peer, id, proto)
-  //   expect(handleDHTSpy.calledOnceWith(peer, id, proto)).to.be.true
-  // })
-
-  it('should handle data', async () => {
-    const peer = {}
-    const id = 'test-id'
-    const proto = { decoded: { hash: 'test-hash', store: 'test-store' } }
-    const handleDataSpy = sinon.spy(peernet, 'handleData')
-    await peernet.handleData(peer, id, proto)
-    expect(handleDataSpy.calledOnceWith(peer, id, proto)).to.be.true
-  })
-
-  it('should handle request', async () => {
-    const peer = {}
-    const id = 'test-id'
-    const proto = { decoded: { request: 'test-request' } }
-    const handleRequestSpy = sinon.spy(peernet, 'handleRequest')
-    await peernet.handleRequest(peer, id, proto)
-    expect(handleRequestSpy.calledOnceWith(peer, id, proto)).to.be.true
-  })
-
-  it('should walk the network', async () => {
-    const hash = 'test-hash'
-    const walkSpy = sinon.spy(peernet, 'walk')
-    await peernet.walk(hash)
-    expect(walkSpy.calledOnceWith(hash)).to.be.true
-  })
+const password = 'password'
+const peernet = await new Peernet(options, password)
 
-  // it('should find providers for a hash', async () => {
-  //   const hash = 'test-hash'
-  //   const providers = await peernet.providersFor(hash)
-  //   expect(providers).to.be.undefined // Assuming no providers are found in the test
-  // })
+test('initializes with provided options', () => {
+  assert.equal(peernet.network, options.network)
+  assert.equal(peernet.version, options.version)
+  assert.equal(peernet.storePrefix, options.storePrefix)
+})
 
-  // it('should request data', async () => {
-  //   const hash = 'test-hash'
-  //   const requestDataSpy = sinon.spy(peernet, 'requestData')
-  //   await peernet.requestData(hash, 'data')
-  //   expect(requestDataSpy.calledOnceWith(hash, 'data')).to.be.true
-  // })
+test('exposes identity instance', () => {
+  assert.ok(peernet.identity instanceof Identity)
+})
 
-  it('should publish data', async () => {
-    const topic = 'test-topic'
-    const data = 'test-data'
-    const publishSpy = sinon.spy(peernet, 'publish')
-    await peernet.publish(topic, data)
-    expect(publishSpy.calledOnceWith(topic, data)).to.be.true
-  })
+test('has a DHT instance', () => {
+  assert.ok(peernet.dht)
+})
 
-  it('should subscribe to a topic', async () => {
-    const topic = 'test-topic'
-    const callback = sinon.spy()
-    const subscribeSpy = sinon.spy(peernet, 'subscribe')
-    await peernet.subscribe(topic, callback)
-    expect(subscribeSpy.calledOnceWith(topic, callback)).to.be.true
+test('returns peers and connections safely', () => {
+  assert.deepEqual(peernet.peers, [])
+  assert.deepEqual(peernet.connections, {})
+  assert.equal(peernet.getConnection('missing'), undefined)
+})
 
-    process.exit()
-  })
+test('provides callable helpers', () => {
+  assert.equal(typeof peernet.addProto, 'function')
+  assert.equal(typeof peernet.addCodec, 'function')
+  assert.equal(typeof peernet.prepareMessage, 'function')
+  assert.equal(typeof peernet.publish, 'function')
+  assert.equal(typeof peernet.subscribe, 'function')
 })

package/exports/browser/index-ChRjMyiM.js

@@ -1,36 +0,0 @@
-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 };