@leofcoin/peernet 1.2.21 → 1.2.22

package/exports/browser/identity.js

@@ -1,2 +1,2 @@
-export { I as default } from './identity-BeVZQ2Dp.js';
+export { I as default } from './identity-CjBX8cWv.js';
 import 'crypto';

package/exports/browser/{index-D6qd-AUn.js → index-DIhxISkU.js}

@@ -1,4 +1,4 @@
-import { M as MultiWallet, h as encrypt, a as base58$1 } from './identity-BeVZQ2Dp.js';
+import { M as MultiWallet, l as encrypt, a as base58$1 } from './identity-CjBX8cWv.js';
 import 'crypto';
 
 /**

package/exports/browser/{messages-BfDvXW-x.js → messages-BX59GgBQ.js}

@@ -1,5 +1,5 @@
-import { F as FormatInterface } from './peernet-DFiLLjUD.js';
-import './identity-BeVZQ2Dp.js';
+import { F as FormatInterface } from './peernet-D3z5pEBD.js';
+import './identity-CjBX8cWv.js';
 import 'crypto';
 import './value-C3vAp-wb.js';
 

package/exports/browser/{peernet-DFiLLjUD.js → peernet-D3z5pEBD.js}

@@ -1,4 +1,4 @@
-import { j as index$2, b as base, a as base58$1, k as index$3, l as index$4, m as index$5, g as createSHA512, f as createSHA384, e as createSHA256, d as createSHA224, c as createSHA1, I as Identity } from './identity-BeVZQ2Dp.js';
+import { i as index$2, b as base, a as base58$1, c as index$3, d as index$4, e as index$5, f as createSHA512, g as createSHA384, h as createSHA256, j as createSHA224, k as createSHA1, I as Identity } from './identity-CjBX8cWv.js';
 import { K as KeyPath, a as KeyValue } from './value-C3vAp-wb.js';
 
 const getTargets = () => Array.from([]);
@@ -126,7 +126,7 @@ var isHex = string => /^[A-F0-9]+$/i.test(
   string
 );
 
-/*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
+/*! pako 2.2.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
 //
@@ -1548,7 +1548,7 @@ const { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = tr
 
 const {
   Z_NO_FLUSH: Z_NO_FLUSH$2, Z_PARTIAL_FLUSH, Z_FULL_FLUSH: Z_FULL_FLUSH$1, Z_FINISH: Z_FINISH$3, Z_BLOCK: Z_BLOCK$1,
-  Z_OK: Z_OK$3, Z_STREAM_END: Z_STREAM_END$3, Z_STREAM_ERROR: Z_STREAM_ERROR$2, Z_DATA_ERROR: Z_DATA_ERROR$2, Z_BUF_ERROR: Z_BUF_ERROR$1,
+  Z_OK: Z_OK$3, Z_STREAM_END: Z_STREAM_END$3, Z_STREAM_ERROR: Z_STREAM_ERROR$2, Z_DATA_ERROR: Z_DATA_ERROR$2, Z_BUF_ERROR: Z_BUF_ERROR$2,
   Z_DEFAULT_COMPRESSION: Z_DEFAULT_COMPRESSION$1,
   Z_FILTERED, Z_HUFFMAN_ONLY, Z_RLE, Z_FIXED, Z_DEFAULT_STRATEGY: Z_DEFAULT_STRATEGY$1,
   Z_UNKNOWN,
@@ -1647,11 +1647,35 @@ const slide_hash = (s) => {
 };
 
 /* eslint-disable new-cap */
-let HASH_ZLIB = (s, prev, data) => ((prev << s.hash_shift) ^ data) & s.hash_mask;
-// This hash causes less collisions, https://github.com/nodeca/pako/issues/135
-// But breaks binary compatibility
-//let HASH_FAST = (s, prev, data) => ((prev << 8) + (prev >> 8) + (data << 4)) & s.hash_mask;
-let HASH = HASH_ZLIB;
+let HASH = (s, prev, data) => ((prev << s.hash_shift) ^ data) & s.hash_mask;
+
+
+/* ===========================================================================
+ * Insert string str in the dictionary and set match_head to the previous head
+ * of the hash chain (the most recent string with same hash key). Return
+ * the previous length of the hash chain.
+ * IN  assertion: all calls to INSERT_STRING are made with consecutive input
+ *    characters and the first MIN_MATCH bytes of str are valid (except for
+ *    the last MIN_MATCH-1 bytes of the input file).
+ */
+const INSERT_STRING = (s, str) => {
+  let h;
+  if (s.legacy_hash) {
+    /* UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]); */
+    h = s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);
+  } else {
+    // ANZAC++ hash: reads 4 bytes, matches node.js zlib output (legacyHash
+    // restores classic zlib hash). Faster, with fewer collisions.
+    const w = s.window;
+    // Read 4 bytes little-endian. Math.imul reproduces C uint32 overflow in
+    // `(value * 66521 + 66521) >> 16` exactly.
+    const value = w[str] | (w[str + 1] << 8) | (w[str + 2] << 16) | (w[str + 3] << 24);
+    h = s.ins_h = ((Math.imul(value, 66521) + 66521) >>> 16) & s.hash_mask;
+  }
+  const hash_head = s.prev[str & s.w_mask] = s.head[h];
+  s.head[h] = str;
+  return hash_head;
+};
 
 
 /* =========================================================================
@@ -1925,7 +1949,20 @@ const fill_window = (s) => {
     s.lookahead += n;
 
     /* Initialize the hash value now that we have some input: */
-    if (s.lookahead + s.insert >= MIN_MATCH) {
+    if (!s.legacy_hash) {
+      /* The 4-byte hash reads one extra byte, so it needs one more available. */
+      if (s.lookahead + s.insert > MIN_MATCH) {
+        str = s.strstart - s.insert;
+        while (s.insert) {
+          INSERT_STRING(s, str);
+          str++;
+          s.insert--;
+          if (s.lookahead + s.insert <= MIN_MATCH) {
+            break;
+          }
+        }
+      }
+    } else if (s.lookahead + s.insert >= MIN_MATCH) {
       str = s.strstart - s.insert;
       s.ins_h = s.window[str];
 
@@ -1935,11 +1972,7 @@ const fill_window = (s) => {
 //        Call update_hash() MIN_MATCH-3 more times
 //#endif
       while (s.insert) {
-        /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
-        s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);
-
-        s.prev[str & s.w_mask] = s.head[s.ins_h];
-        s.head[s.ins_h] = str;
+        INSERT_STRING(s, str);
         str++;
         s.insert--;
         if (s.lookahead + s.insert < MIN_MATCH) {
@@ -2237,11 +2270,7 @@ const deflate_fast = (s, flush) => {
      */
     hash_head = 0/*NIL*/;
     if (s.lookahead >= MIN_MATCH) {
-      /*** INSERT_STRING(s, s.strstart, hash_head); ***/
-      s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
-      hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
-      s.head[s.ins_h] = s.strstart;
-      /***/
+      hash_head = INSERT_STRING(s, s.strstart);
     }
 
     /* Find the longest match, discarding those <= prev_length.
@@ -2271,11 +2300,7 @@ const deflate_fast = (s, flush) => {
         s.match_length--; /* string at strstart already in table */
         do {
           s.strstart++;
-          /*** INSERT_STRING(s, s.strstart, hash_head); ***/
-          s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
-          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
-          s.head[s.ins_h] = s.strstart;
-          /***/
+          hash_head = INSERT_STRING(s, s.strstart);
           /* strstart never exceeds WSIZE-MAX_MATCH, so there are
            * always MIN_MATCH bytes ahead.
            */
@@ -2285,16 +2310,18 @@ const deflate_fast = (s, flush) => {
       {
         s.strstart += s.match_length;
         s.match_length = 0;
-        s.ins_h = s.window[s.strstart];
-        /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */
-        s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]);
+        if (s.legacy_hash) {
+          s.ins_h = s.window[s.strstart];
+          /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */
+          s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]);
 
 //#if MIN_MATCH != 3
 //                Call UPDATE_HASH() MIN_MATCH-3 more times
 //#endif
-        /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
-         * matter since it will be recomputed at next deflate call.
-         */
+          /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
+           * matter since it will be recomputed at next deflate call.
+           */
+        }
       }
     } else {
       /* No match, output a literal byte */
@@ -2367,11 +2394,7 @@ const deflate_slow = (s, flush) => {
      */
     hash_head = 0/*NIL*/;
     if (s.lookahead >= MIN_MATCH) {
-      /*** INSERT_STRING(s, s.strstart, hash_head); ***/
-      s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
-      hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
-      s.head[s.ins_h] = s.strstart;
-      /***/
+      hash_head = INSERT_STRING(s, s.strstart);
     }
 
     /* Find the longest match, discarding those <= prev_length.
@@ -2419,11 +2442,7 @@ const deflate_slow = (s, flush) => {
       s.prev_length -= 2;
       do {
         if (++s.strstart <= max_insert) {
-          /*** INSERT_STRING(s, s.strstart, hash_head); ***/
-          s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
-          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
-          s.head[s.ins_h] = s.strstart;
-          /***/
+          hash_head = INSERT_STRING(s, s.strstart);
         }
       } while (--s.prev_length !== 0);
       s.match_available = 0;
@@ -2748,6 +2767,7 @@ function DeflateState() {
   this.head = null;   /* Heads of the hash chains or NIL. */
 
   this.ins_h = 0;       /* hash index of string to be inserted */
+  this.legacy_hash = 0; /* use classic zlib hash instead of default ANZAC++ */
   this.hash_size = 0;   /* number of elements in hash table */
   this.hash_bits = 0;   /* log2(hash_size) */
   this.hash_mask = 0;   /* hash_size-1 */
@@ -2970,7 +2990,7 @@ const deflateSetHeader = (strm, head) => {
 };
 
 
-const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {
+const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy, legacyHash) => {
 
   if (!strm) { // === Z_NULL
     return Z_STREAM_ERROR$2;
@@ -3016,7 +3036,13 @@ const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {
   s.w_size = 1 << s.w_bits;
   s.w_mask = s.w_size - 1;
 
+  s.legacy_hash = legacyHash ? 1 : 0;
+
   s.hash_bits = memLevel + 7;
+  /* ANZAC++ hash needs >= 15 hash bits to span its 4 read bytes. */
+  if (!s.legacy_hash && s.hash_bits < 15) {
+    s.hash_bits = 15;
+  }
   s.hash_size = 1 << s.hash_bits;
   s.hash_mask = s.hash_size - 1;
   s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
@@ -3108,7 +3134,7 @@ const deflate$2 = (strm, flush) => {
   if (!strm.output ||
       (strm.avail_in !== 0 && !strm.input) ||
       (s.status === FINISH_STATE && flush !== Z_FINISH$3)) {
-    return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR$1 : Z_STREAM_ERROR$2);
+    return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR$2 : Z_STREAM_ERROR$2);
   }
 
   const old_flush = s.last_flush;
@@ -3134,12 +3160,12 @@ const deflate$2 = (strm, flush) => {
      */
   } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&
     flush !== Z_FINISH$3) {
-    return err(strm, Z_BUF_ERROR$1);
+    return err(strm, Z_BUF_ERROR$2);
   }
 
   /* User must not provide more input after the first FINISH: */
   if (s.status === FINISH_STATE && strm.avail_in !== 0) {
-    return err(strm, Z_BUF_ERROR$1);
+    return err(strm, Z_BUF_ERROR$2);
   }
 
   /* Write the header */
@@ -3520,12 +3546,7 @@ const deflateSetDictionary = (strm, dictionary) => {
     let str = s.strstart;
     let n = s.lookahead - (MIN_MATCH - 1);
     do {
-      /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
-      s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);
-
-      s.prev[str & s.w_mask] = s.head[s.ins_h];
-
-      s.head[s.ins_h] = str;
+      INSERT_STRING(s, str);
       str++;
     } while (--n);
     s.strstart = str;
@@ -3649,7 +3670,7 @@ const _utf8len = new Uint8Array(256);
 for (let q = 0; q < 256; q++) {
   _utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);
 }
-_utf8len[254] = _utf8len[254] = 1; // Invalid sequence start
+_utf8len[254] = _utf8len[255] = 1; // Invalid sequence start
 
 
 // convert string to array (typed, when possible)
@@ -3870,6 +3891,15 @@ const {
 
 /* ===========================================================================*/
 
+const defaultOptions$1 = {
+  level: Z_DEFAULT_COMPRESSION,
+  method: Z_DEFLATED$1,
+  chunkSize: 16384,
+  windowBits: 15,
+  memLevel: 8,
+  strategy: Z_DEFAULT_STRATEGY,
+  legacyHash: true
+};
 
 /**
  * class Deflate
@@ -3925,6 +3955,10 @@ const {
  * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
  * for more information on these.
  *
+ * - `legacyHash` (Boolean) - use the classic zlib hash (default), which matches
+ *   canonical zlib output byte-for-byte. Set to `false` to use the faster
+ *   ANZAC++ hash, which matches recent (chromium) node.js output instead.
+ *
  * Additional options, for internal needs:
  *
  * - `chunkSize` - size of generated data chunks (16K by default)
@@ -3957,14 +3991,7 @@ const {
  * ```
  **/
 function Deflate$1(options) {
-  this.options = common.assign({
-    level: Z_DEFAULT_COMPRESSION,
-    method: Z_DEFLATED$1,
-    chunkSize: 16384,
-    windowBits: 15,
-    memLevel: 8,
-    strategy: Z_DEFAULT_STRATEGY
-  }, options || {});
+  this.options = common.assign({}, defaultOptions$1, options || {});
 
   let opt = this.options;
 
@@ -3990,7 +4017,8 @@ function Deflate$1(options) {
     opt.method,
     opt.windowBits,
     opt.memLevel,
-    opt.strategy
+    opt.strategy,
+    opt.legacyHash
   );
 
   if (status !== Z_OK$2) {
@@ -4610,7 +4638,7 @@ const lbase = new Uint16Array([ /* Length codes 257..285 base */
 
 const lext = new Uint8Array([ /* Length codes 257..285 extra */
   16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
-  19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78
+  19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 199, 75
 ]);
 
 const dbase = new Uint16Array([ /* Distance codes 0..29 base */
@@ -4947,7 +4975,7 @@ const DISTS = 2;
 
 const {
   Z_FINISH: Z_FINISH$1, Z_BLOCK, Z_TREES,
-  Z_OK: Z_OK$1, Z_STREAM_END: Z_STREAM_END$1, Z_NEED_DICT: Z_NEED_DICT$1, Z_STREAM_ERROR: Z_STREAM_ERROR$1, Z_DATA_ERROR: Z_DATA_ERROR$1, Z_MEM_ERROR: Z_MEM_ERROR$1, Z_BUF_ERROR,
+  Z_OK: Z_OK$1, Z_STREAM_END: Z_STREAM_END$1, Z_NEED_DICT: Z_NEED_DICT$1, Z_STREAM_ERROR: Z_STREAM_ERROR$1, Z_DATA_ERROR: Z_DATA_ERROR$1, Z_MEM_ERROR: Z_MEM_ERROR$1, Z_BUF_ERROR: Z_BUF_ERROR$1,
   Z_DEFLATED
 } = constants$2;
 
@@ -5257,11 +5285,14 @@ const updatewindow = (strm, src, end, copy) => {
 
   /* if it hasn't been done already, allocate space for the window */
   if (state.window === null) {
+    state.window = new Uint8Array(1 << state.wbits);
+  }
+
+  /* if window not in use yet, initialize */
+  if (state.wsize === 0) {
     state.wsize = 1 << state.wbits;
     state.wnext = 0;
     state.whave = 0;
-
-    state.window = new Uint8Array(state.wsize);
   }
 
   /* copy state->wsize or less output bytes into the circular window */
@@ -6387,7 +6418,7 @@ const inflate$2 = (strm, flush) => {
                     (state.mode === TYPE ? 128 : 0) +
                     (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
   if (((_in === 0 && _out === 0) || flush === Z_FINISH$1) && ret === Z_OK$1) {
-    ret = Z_BUF_ERROR;
+    ret = Z_BUF_ERROR$1;
   }
   return ret;
 };
@@ -6559,11 +6590,16 @@ const toString$2 = Object.prototype.toString;
 
 const {
   Z_NO_FLUSH, Z_FINISH,
-  Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR
+  Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR, Z_BUF_ERROR
 } = constants$2;
 
 /* ===========================================================================*/
 
+const defaultOptions$2 = {
+  chunkSize: 1024 * 64,
+  windowBits: 15,
+  to: ''
+};
 
 /**
  * class Inflate
@@ -6643,11 +6679,7 @@ const {
  * ```
  **/
 function Inflate$1(options) {
-  this.options = common.assign({
-    chunkSize: 1024 * 64,
-    windowBits: 15,
-    to: ''
-  }, options || {});
+  this.options = common.assign({}, defaultOptions$2, options || {});
 
   const opt = this.options;
 
@@ -6778,11 +6810,19 @@ Inflate$1.prototype.push = function (data, flush_mode) {
       }
     }
 
-    // Skip snyc markers if more data follows and not raw mode
+    // Only the gzip format defines concatenated members (RFC 1952: a gzip file
+    // is "a series of members"). A zlib stream (RFC 1950) ends after its
+    // ADLER32, and a raw DEFLATE stream (RFC 1951) ends after its final block -
+    // neither format allows anything to follow, so bytes after the end are not
+    // ours to interpret and must be left in the input. Restart decoding only
+    // for a gzip member: `state.flags` is non-zero only once a gzip header has
+    // actually been decoded (it stays 0 for a zlib member, even when the format
+    // was auto-detected and the gzip bit of `wrap` is set). A trailing zero
+    // byte is padding, not the start of a member (no member can begin with 0).
     while (strm.avail_in > 0 &&
            status === Z_STREAM_END &&
-           strm.state.wrap > 0 &&
-           data[strm.next_in] !== 0)
+           (strm.state.wrap & 2) && strm.state.flags !== 0 &&
+           strm.input[strm.next_in] !== 0)
     {
       inflate_1$2.inflateReset(strm);
       status = inflate_1$2.inflate(strm, _flush_mode);
@@ -6803,7 +6843,9 @@ Inflate$1.prototype.push = function (data, flush_mode) {
     last_avail_out = strm.avail_out;
 
     if (strm.next_out) {
-      if (strm.avail_out === 0 || status === Z_STREAM_END) {
+      // Flush output if buffer is full, stream ended, or an explicit flush was
+      // requested (e.g. Z_SYNC_FLUSH) - to push out the tail, same as node's zlib.
+      if (strm.avail_out === 0 || status === Z_STREAM_END || _flush_mode > 0) {
 
         if (this.options.to === 'string') {
 
@@ -6821,12 +6863,22 @@ Inflate$1.prototype.push = function (data, flush_mode) {
 
         } else {
           this.onData(strm.output.length === strm.next_out ? strm.output : strm.output.subarray(0, strm.next_out));
+
+          // Force a fresh output buffer on next iteration / next push, so the
+          // already emitted tail is not sent again.
+          strm.avail_out = 0;
+          strm.next_out = 0;
         }
       }
     }
 
-    // Must repeat iteration if out buffer is full
-    if (status === Z_OK && last_avail_out === 0) continue;
+    // A full output buffer means there may be more to produce - allocate a new
+    // one and call inflate again. The status depends on the flush mode: with
+    // Z_NO_FLUSH a full buffer is reported as Z_OK, but with Z_FINISH the same
+    // situation is reported as Z_BUF_ERROR ("could not make progress now",
+    // non-fatal) even though output is still pending. Both must continue; the
+    // distinction that matters is purely "was the output buffer exhausted".
+    if ((status === Z_OK || status === Z_BUF_ERROR) && last_avail_out === 0) continue;
 
     // Finalize if end of stream reached.
     if (status === Z_STREAM_END) {
@@ -6836,7 +6888,23 @@ Inflate$1.prototype.push = function (data, flush_mode) {
       return true;
     }
 
-    if (strm.avail_in === 0) break;
+    if (strm.avail_in === 0) {
+      // Input is exhausted. If the caller declared this the end of the stream
+      // (Z_FINISH) but we never saw Z_STREAM_END, the compressed data ended
+      // before its terminating marker - i.e. it is truncated/incomplete. That
+      // is an error: returning the partial output as success would be
+      // indistinguishable from a complete decode, hiding the data loss. Report
+      // it via Z_BUF_ERROR. (Reached only when the output buffer still had room
+      // - a full buffer is handled by the `continue` above - so this genuinely
+      // means "ran out of input", not "ran out of output".)
+      if (_flush_mode === Z_FINISH) {
+        status = inflate_1$2.inflateEnd(this.strm);
+        this.onEnd(status === Z_OK ? Z_BUF_ERROR : status);
+        this.ended = true;
+        return false;
+      }
+      break;
+    }
   }
 
   return true;
@@ -6922,7 +6990,7 @@ Inflate$1.prototype.onEnd = function (status) {
 function inflate$1(input, options) {
   const inflator = new Inflate$1(options);
 
-  inflator.push(input);
+  inflator.push(input, true);
 
   // That will never happens, if you don't cheat with options :)
   if (inflator.err) throw inflator.msg || messages[inflator.err];
@@ -8417,6 +8485,7 @@ class Peernet {
     client;
     network;
     stars;
+    transport;
     networkVersion;
     bw;
     hasDaemon = false;
@@ -8438,6 +8507,7 @@ class Peernet {
      * @param {String} options.root - path to root directory
      * @param {String} options.version - path to root directory
      * @param {String} options.storePrefix - prefix for datatores (lfc)
+     * @param {Object} options.transport - transport selection and fallback options passed to @netpeer/swarm
      *
      * @return {Promise} instance of Peernet
      *
@@ -8451,6 +8521,7 @@ class Peernet {
         this.network = options.network || 'leofcoin';
         this.autoStart = options.autoStart === undefined ? true : options.autoStart;
         this.stars = options.stars;
+        this.transport = options.transport;
         this.version = options.version;
         const parts = this.network.split(':');
         this.networkVersion = options.networkVersion || parts.length > 1 ? parts[1] : 'mainnet';
@@ -8544,7 +8615,7 @@ class Peernet {
         await getAddress();
         this.storePrefix = options.storePrefix;
         this.root = options.root;
-        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-BfDvXW-x.js');
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-BX59GgBQ.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8591,7 +8662,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-lPe0SUWx.js');
+        const importee = await import('./client-Ba1cHcxF.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -8601,7 +8672,8 @@ class Peernet {
             peerId: this.id,
             networkVersion: this.networkVersion,
             version: this.version,
-            stars: this.stars
+            stars: this.stars,
+            transport: this.transport
         });
         this.#started = true;
         this.#starting = false;

package/exports/browser/peernet.js

@@ -1,4 +1,4 @@
-export { P as default } from './peernet-DFiLLjUD.js';
-import './identity-BeVZQ2Dp.js';
+export { P as default } from './peernet-D3z5pEBD.js';
+import './identity-CjBX8cWv.js';
 import './value-C3vAp-wb.js';
 import 'crypto';

package/exports/peernet.js

@@ -326,6 +326,7 @@ class Peernet {
     client;
     network;
     stars;
+    transport;
     networkVersion;
     bw;
     hasDaemon = false;
@@ -347,6 +348,7 @@ class Peernet {
      * @param {String} options.root - path to root directory
      * @param {String} options.version - path to root directory
      * @param {String} options.storePrefix - prefix for datatores (lfc)
+     * @param {Object} options.transport - transport selection and fallback options passed to @netpeer/swarm
      *
      * @return {Promise} instance of Peernet
      *
@@ -360,6 +362,7 @@ class Peernet {
         this.network = options.network || 'leofcoin';
         this.autoStart = options.autoStart === undefined ? true : options.autoStart;
         this.stars = options.stars;
+        this.transport = options.transport;
         this.version = options.version;
         const parts = this.network.split(':');
         this.networkVersion = options.networkVersion || parts.length > 1 ? parts[1] : 'mainnet';
@@ -510,7 +513,8 @@ class Peernet {
             peerId: this.id,
             networkVersion: this.networkVersion,
             version: this.version,
-            stars: this.stars
+            stars: this.stars,
+            transport: this.transport
         });
         this.#started = true;
         this.#starting = false;

package/exports/store.js

@@ -102,6 +102,9 @@ class Store {
         this.root = await init(root, homedir);
         this.version = version;
         this.db = new ClassicLevel(join(this.root, this.name), { valueEncoding: 'view' });
+        if (typeof this.db.open === 'function') {
+            await this.db.open();
+        }
     }
     toKeyPath(key) {
         if (!key.isKeyPath())

package/exports/types/peernet.d.ts

@@ -39,6 +39,7 @@ export default class Peernet {
     client: swarm;
     network: string;
     stars: string[];
+    transport: any;
     networkVersion: string;
     bw: {
         up: number;
@@ -60,6 +61,7 @@ export default class Peernet {
      * @param {String} options.root - path to root directory
      * @param {String} options.version - path to root directory
      * @param {String} options.storePrefix - prefix for datatores (lfc)
+     * @param {Object} options.transport - transport selection and fallback options passed to @netpeer/swarm
      *
      * @return {Promise} instance of Peernet
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.2.21",
+  "version": "1.2.22",
   "description": "",
   "browser": "./exports/browser/peernet.js",
   "exports": {
@@ -107,7 +107,7 @@
     "@leofcoin/multi-wallet": "^3.1.8",
     "@leofcoin/storage": "^3.5.38",
     "@mapbox/node-pre-gyp": "^2.0.3",
-    "@netpeer/swarm": "^0.9.7",
+    "@netpeer/swarm": "^0.9.8",
     "@vandeurenglenn/base58": "^1.1.9",
     "@vandeurenglenn/debug": "^1.4.0",
     "@vandeurenglenn/little-pubsub": "^1.5.2",
@@ -125,6 +125,7 @@
     "@types/node": "^25.9.1",
     "@types/qrcode": "^1.5.6",
     "rollup": "^4.60.4",
-    "tslib": "^2.8.1"
+    "tslib": "^2.8.1",
+    "typescript": "^6.0.2"
   }
 }

package/src/peernet.ts

@@ -52,6 +52,7 @@ export default class Peernet {
   client: swarm
   network: string
   stars: string[]
+  transport
   networkVersion: string
   bw: {
     up: number
@@ -77,6 +78,7 @@ export default class Peernet {
    * @param {String} options.root - path to root directory
    * @param {String} options.version - path to root directory
    * @param {String} options.storePrefix - prefix for datatores (lfc)
+   * @param {Object} options.transport - transport selection and fallback options passed to @netpeer/swarm
    *
    * @return {Promise} instance of Peernet
    *
@@ -90,6 +92,7 @@ export default class Peernet {
     this.network = options.network || 'leofcoin'
     this.autoStart = options.autoStart === undefined ? true : options.autoStart
     this.stars = options.stars
+    this.transport = options.transport
     this.version = options.version
     const parts = this.network.split(':')
     this.networkVersion = options.networkVersion || parts.length > 1 ? parts[1] : 'mainnet'
@@ -281,7 +284,8 @@ export default class Peernet {
       peerId: this.id,
       networkVersion: this.networkVersion,
       version: this.version,
-      stars: this.stars
+      stars: this.stars,
+      transport: this.transport
     })
     this.#started = true
     this.#starting = false