shogun-core 3.2.3 → 3.3.1

package/dist/browser/shogun-core.js

@@ -7999,14 +7999,7 @@ function output(out, instance) {
     }
 }
 exports.output = output;
-const assert = {
-    number,
-    bool,
-    bytes,
-    hash,
-    exists,
-    output,
-};
+const assert = { number, bool, bytes, hash, exists, output };
 exports["default"] = assert;
 //# sourceMappingURL=_assert.js.map
 
@@ -8053,7 +8046,7 @@ class SHA2 extends utils_js_1.Hash {
         this.view = (0, utils_js_1.createView)(this.buffer);
     }
     update(data) {
-        _assert_js_1.default.exists(this);
+        (0, _assert_js_1.exists)(this);
         const { view, buffer, blockLen } = this;
         data = (0, utils_js_1.toBytes)(data);
         const len = data.length;
@@ -8079,8 +8072,8 @@ class SHA2 extends utils_js_1.Hash {
         return this;
     }
     digestInto(out) {
-        _assert_js_1.default.exists(this);
-        _assert_js_1.default.output(out, this);
+        (0, _assert_js_1.exists)(this);
+        (0, _assert_js_1.output)(out, this);
         this.finished = true;
         // Padding
         // We can avoid allocation of buffer for padding completely if it
@@ -8149,9 +8142,9 @@ exports.SHA2 = SHA2;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.add = exports.toBig = exports.split = exports.fromBig = void 0;
-const U32_MASK64 = BigInt(2 ** 32 - 1);
-const _32n = BigInt(32);
+exports.add5L = exports.add5H = exports.add4H = exports.add4L = exports.add3H = exports.add3L = exports.add = exports.rotlBL = exports.rotlBH = exports.rotlSL = exports.rotlSH = exports.rotr32L = exports.rotr32H = exports.rotrBL = exports.rotrBH = exports.rotrSL = exports.rotrSH = exports.shrSL = exports.shrSH = exports.toBig = exports.split = exports.fromBig = void 0;
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
 // We are not using BigUint64Array, because they are extremely slow as per 2022
 function fromBig(n, le = false) {
     if (le)
@@ -8172,26 +8165,37 @@ exports.split = split;
 const toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);
 exports.toBig = toBig;
 // for Shift in [0, 32)
-const shrSH = (h, l, s) => h >>> s;
+const shrSH = (h, _l, s) => h >>> s;
+exports.shrSH = shrSH;
 const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+exports.shrSL = shrSL;
 // Right rotate for Shift in [1, 32)
 const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
+exports.rotrSH = rotrSH;
 const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+exports.rotrSL = rotrSL;
 // Right rotate for Shift in (32, 64), NOTE: 32 is special case.
 const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
+exports.rotrBH = rotrBH;
 const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
+exports.rotrBL = rotrBL;
 // Right rotate for shift===32 (just swaps l&h)
-const rotr32H = (h, l) => l;
-const rotr32L = (h, l) => h;
+const rotr32H = (_h, l) => l;
+exports.rotr32H = rotr32H;
+const rotr32L = (h, _l) => h;
+exports.rotr32L = rotr32L;
 // Left rotate for Shift in [1, 32)
 const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
+exports.rotlSH = rotlSH;
 const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
+exports.rotlSL = rotlSL;
 // Left rotate for Shift in (32, 64), NOTE: 32 is special case.
 const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+exports.rotlBH = rotlBH;
 const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+exports.rotlBL = rotlBL;
 // JS uses 32-bit signed integers for bitwise operations which means we cannot
 // simple take carry out of low bit sum by shift, we need to use division.
-// Removing "export" has 5% perf penalty -_-
 function add(Ah, Al, Bh, Bl) {
     const l = (Al >>> 0) + (Bl >>> 0);
     return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
@@ -8199,14 +8203,20 @@ function add(Ah, Al, Bh, Bl) {
 exports.add = add;
 // Addition with more than 2 elements
 const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+exports.add3L = add3L;
 const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
+exports.add3H = add3H;
 const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+exports.add4L = add4L;
 const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
+exports.add4H = add4H;
 const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+exports.add5L = add5L;
 const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
+exports.add5H = add5H;
 // prettier-ignore
 const u64 = {
-    fromBig, split, toBig: exports.toBig,
+    fromBig, split, toBig,
     shrSH, shrSL,
     rotrSH, rotrSL, rotrBH, rotrBL,
     rotr32H, rotr32L,
@@ -8233,186 +8243,6 @@ exports.crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? glob
 
 /***/ }),
 
-/***/ "./node_modules/@noble/hashes/hkdf.js":
-/*!********************************************!*\
-  !*** ./node_modules/@noble/hashes/hkdf.js ***!
-  \********************************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.hkdf = exports.expand = exports.extract = void 0;
-const _assert_js_1 = __webpack_require__(/*! ./_assert.js */ "./node_modules/@noble/hashes/_assert.js");
-const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/@noble/hashes/utils.js");
-const hmac_js_1 = __webpack_require__(/*! ./hmac.js */ "./node_modules/@noble/hashes/hmac.js");
-// HKDF (RFC 5869)
-// https://soatok.blog/2021/11/17/understanding-hkdf/
-/**
- * HKDF-Extract(IKM, salt) -> PRK
- * Arguments position differs from spec (IKM is first one, since it is not optional)
- * @param hash
- * @param ikm
- * @param salt
- * @returns
- */
-function extract(hash, ikm, salt) {
-    _assert_js_1.default.hash(hash);
-    // NOTE: some libraries treat zero-length array as 'not provided';
-    // we don't, since we have undefined as 'not provided'
-    // https://github.com/RustCrypto/KDFs/issues/15
-    if (salt === undefined)
-        salt = new Uint8Array(hash.outputLen); // if not provided, it is set to a string of HashLen zeros
-    return (0, hmac_js_1.hmac)(hash, (0, utils_js_1.toBytes)(salt), (0, utils_js_1.toBytes)(ikm));
-}
-exports.extract = extract;
-// HKDF-Expand(PRK, info, L) -> OKM
-const HKDF_COUNTER = new Uint8Array([0]);
-const EMPTY_BUFFER = new Uint8Array();
-/**
- * HKDF-expand from the spec.
- * @param prk - a pseudorandom key of at least HashLen octets (usually, the output from the extract step)
- * @param info - optional context and application specific information (can be a zero-length string)
- * @param length - length of output keying material in octets
- */
-function expand(hash, prk, info, length = 32) {
-    _assert_js_1.default.hash(hash);
-    _assert_js_1.default.number(length);
-    if (length > 255 * hash.outputLen)
-        throw new Error('Length should be <= 255*HashLen');
-    const blocks = Math.ceil(length / hash.outputLen);
-    if (info === undefined)
-        info = EMPTY_BUFFER;
-    // first L(ength) octets of T
-    const okm = new Uint8Array(blocks * hash.outputLen);
-    // Re-use HMAC instance between blocks
-    const HMAC = hmac_js_1.hmac.create(hash, prk);
-    const HMACTmp = HMAC._cloneInto();
-    const T = new Uint8Array(HMAC.outputLen);
-    for (let counter = 0; counter < blocks; counter++) {
-        HKDF_COUNTER[0] = counter + 1;
-        // T(0) = empty string (zero length)
-        // T(N) = HMAC-Hash(PRK, T(N-1) | info | N)
-        HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T)
-            .update(info)
-            .update(HKDF_COUNTER)
-            .digestInto(T);
-        okm.set(T, hash.outputLen * counter);
-        HMAC._cloneInto(HMACTmp);
-    }
-    HMAC.destroy();
-    HMACTmp.destroy();
-    T.fill(0);
-    HKDF_COUNTER.fill(0);
-    return okm.slice(0, length);
-}
-exports.expand = expand;
-/**
- * HKDF (RFC 5869): extract + expand in one step.
- * @param hash - hash function that would be used (e.g. sha256)
- * @param ikm - input keying material, the initial key
- * @param salt - optional salt value (a non-secret random value)
- * @param info - optional context and application specific information
- * @param length - length of output keying material in octets
- */
-const hkdf = (hash, ikm, salt, info, length) => expand(hash, extract(hash, ikm, salt), info, length);
-exports.hkdf = hkdf;
-//# sourceMappingURL=hkdf.js.map
-
-/***/ }),
-
-/***/ "./node_modules/@noble/hashes/hmac.js":
-/*!********************************************!*\
-  !*** ./node_modules/@noble/hashes/hmac.js ***!
-  \********************************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.hmac = exports.HMAC = void 0;
-const _assert_js_1 = __webpack_require__(/*! ./_assert.js */ "./node_modules/@noble/hashes/_assert.js");
-const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/@noble/hashes/utils.js");
-// HMAC (RFC 2104)
-class HMAC extends utils_js_1.Hash {
-    constructor(hash, _key) {
-        super();
-        this.finished = false;
-        this.destroyed = false;
-        _assert_js_1.default.hash(hash);
-        const key = (0, utils_js_1.toBytes)(_key);
-        this.iHash = hash.create();
-        if (typeof this.iHash.update !== 'function')
-            throw new Error('Expected instance of class which extends utils.Hash');
-        this.blockLen = this.iHash.blockLen;
-        this.outputLen = this.iHash.outputLen;
-        const blockLen = this.blockLen;
-        const pad = new Uint8Array(blockLen);
-        // blockLen can be bigger than outputLen
-        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
-        for (let i = 0; i < pad.length; i++)
-            pad[i] ^= 0x36;
-        this.iHash.update(pad);
-        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone
-        this.oHash = hash.create();
-        // Undo internal XOR && apply outer XOR
-        for (let i = 0; i < pad.length; i++)
-            pad[i] ^= 0x36 ^ 0x5c;
-        this.oHash.update(pad);
-        pad.fill(0);
-    }
-    update(buf) {
-        _assert_js_1.default.exists(this);
-        this.iHash.update(buf);
-        return this;
-    }
-    digestInto(out) {
-        _assert_js_1.default.exists(this);
-        _assert_js_1.default.bytes(out, this.outputLen);
-        this.finished = true;
-        this.iHash.digestInto(out);
-        this.oHash.update(out);
-        this.oHash.digestInto(out);
-        this.destroy();
-    }
-    digest() {
-        const out = new Uint8Array(this.oHash.outputLen);
-        this.digestInto(out);
-        return out;
-    }
-    _cloneInto(to) {
-        // Create new instance without calling constructor since key already in state and we don't know it.
-        to || (to = Object.create(Object.getPrototypeOf(this), {}));
-        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
-        to = to;
-        to.finished = finished;
-        to.destroyed = destroyed;
-        to.blockLen = blockLen;
-        to.outputLen = outputLen;
-        to.oHash = oHash._cloneInto(to.oHash);
-        to.iHash = iHash._cloneInto(to.iHash);
-        return to;
-    }
-    destroy() {
-        this.destroyed = true;
-        this.oHash.destroy();
-        this.iHash.destroy();
-    }
-}
-exports.HMAC = HMAC;
-/**
- * HMAC: RFC2104 message authentication code.
- * @param hash - function that would be used e.g. sha256
- * @param key - message key
- * @param message - message data
- */
-const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
-exports.hmac = hmac;
-exports.hmac.create = (hash, key) => new HMAC(hash, key);
-//# sourceMappingURL=hmac.js.map
-
-/***/ }),
-
 /***/ "./node_modules/@noble/hashes/ripemd160.js":
 /*!*************************************************!*\
   !*** ./node_modules/@noble/hashes/ripemd160.js ***!
@@ -8427,25 +8257,29 @@ const _sha2_js_1 = __webpack_require__(/*! ./_sha2.js */ "./node_modules/@noble/
 const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/@noble/hashes/utils.js");
 // https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
 // https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
-const Rho = new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
-const Id = Uint8Array.from({ length: 16 }, (_, i) => i);
-const Pi = Id.map((i) => (9 * i + 5) % 16);
+const Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
+const Id = /* @__PURE__ */ Uint8Array.from({ length: 16 }, (_, i) => i);
+const Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
 let idxL = [Id];
 let idxR = [Pi];
 for (let i = 0; i < 4; i++)
     for (let j of [idxL, idxR])
         j.push(j[i].map((k) => Rho[k]));
-const shifts = [
+const shifts = /* @__PURE__ */ [
     [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
     [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
     [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
     [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
     [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5],
 ].map((i) => new Uint8Array(i));
-const shiftsL = idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
-const shiftsR = idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
-const Kl = new Uint32Array([0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]);
-const Kr = new Uint32Array([0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]);
+const shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
+const shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
+const Kl = /* @__PURE__ */ new Uint32Array([
+    0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e,
+]);
+const Kr = /* @__PURE__ */ new Uint32Array([
+    0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000,
+]);
 // The rotate left (circular left shift) operation for uint32
 const rotl = (word, shift) => (word << shift) | (word >>> (32 - shift));
 // It's called f() in spec.
@@ -8462,7 +8296,7 @@ function f(group, x, y, z) {
         return x ^ (y | ~z);
 }
 // Temporary buffer, not used to store anything between runs
-const BUF = new Uint32Array(16);
+const BUF = /* @__PURE__ */ new Uint32Array(16);
 class RIPEMD160 extends _sha2_js_1.SHA2 {
     constructor() {
         super(64, 20, 8, true);
@@ -8539,6 +8373,8 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.sha224 = exports.sha256 = void 0;
 const _sha2_js_1 = __webpack_require__(/*! ./_sha2.js */ "./node_modules/@noble/hashes/_sha2.js");
 const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/@noble/hashes/utils.js");
+// SHA2-256 need to try 2^128 hashes to execute birthday attack.
+// BTC network is doing 2^67 hashes/sec as per early 2023.
 // Choice: a ? b : c
 const Chi = (a, b, c) => (a & b) ^ (~a & c);
 // Majority function, true if any two inpust is true
@@ -8546,7 +8382,7 @@ const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
 // Round constants:
 // first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)
 // prettier-ignore
-const SHA256_K = new Uint32Array([
+const SHA256_K = /* @__PURE__ */ new Uint32Array([
     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
@@ -8558,12 +8394,12 @@ const SHA256_K = new Uint32Array([
 ]);
 // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
 // prettier-ignore
-const IV = new Uint32Array([
+const IV = /* @__PURE__ */ new Uint32Array([
     0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
 ]);
 // Temporary buffer, not used to store anything between runs
 // Named this way because it matches specification.
-const SHA256_W = new Uint32Array(64);
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
 class SHA256 extends _sha2_js_1.SHA2 {
     constructor() {
         super(64, 32, 8, false);
@@ -8677,14 +8513,16 @@ exports.shake256 = exports.shake128 = exports.keccak_512 = exports.keccak_384 =
 const _assert_js_1 = __webpack_require__(/*! ./_assert.js */ "./node_modules/@noble/hashes/_assert.js");
 const _u64_js_1 = __webpack_require__(/*! ./_u64.js */ "./node_modules/@noble/hashes/_u64.js");
 const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/@noble/hashes/utils.js");
+// SHA3 (keccak) is based on a new design: basically, the internal state is bigger than output size.
+// It's called a sponge function.
 // Various per round constants calculations
 const [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
-const _0n = BigInt(0);
-const _1n = BigInt(1);
-const _2n = BigInt(2);
-const _7n = BigInt(7);
-const _256n = BigInt(256);
-const _0x71n = BigInt(0x71);
+const _0n = /* @__PURE__ */ BigInt(0);
+const _1n = /* @__PURE__ */ BigInt(1);
+const _2n = /* @__PURE__ */ BigInt(2);
+const _7n = /* @__PURE__ */ BigInt(7);
+const _256n = /* @__PURE__ */ BigInt(256);
+const _0x71n = /* @__PURE__ */ BigInt(0x71);
 for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
     // Pi
     [x, y] = [y, (2 * x + 3 * y) % 5];
@@ -8696,14 +8534,14 @@ for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
     for (let j = 0; j < 7; j++) {
         R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;
         if (R & _2n)
-            t ^= _1n << ((_1n << BigInt(j)) - _1n);
+            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);
     }
     _SHA3_IOTA.push(t);
 }
-const [SHA3_IOTA_H, SHA3_IOTA_L] = _u64_js_1.default.split(_SHA3_IOTA, true);
+const [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ (0, _u64_js_1.split)(_SHA3_IOTA, true);
 // Left rotation (without 0, 32, 64)
-const rotlH = (h, l, s) => s > 32 ? _u64_js_1.default.rotlBH(h, l, s) : _u64_js_1.default.rotlSH(h, l, s);
-const rotlL = (h, l, s) => s > 32 ? _u64_js_1.default.rotlBL(h, l, s) : _u64_js_1.default.rotlSL(h, l, s);
+const rotlH = (h, l, s) => (s > 32 ? (0, _u64_js_1.rotlBH)(h, l, s) : (0, _u64_js_1.rotlSH)(h, l, s));
+const rotlL = (h, l, s) => (s > 32 ? (0, _u64_js_1.rotlBL)(h, l, s) : (0, _u64_js_1.rotlSL)(h, l, s));
 // Same as keccakf1600, but allows to skip some rounds
 function keccakP(s, rounds = 24) {
     const B = new Uint32Array(5 * 2);
@@ -8765,7 +8603,7 @@ class Keccak extends utils_js_1.Hash {
         this.finished = false;
         this.destroyed = false;
         // Can be passed from user as dkLen
-        _assert_js_1.default.number(outputLen);
+        (0, _assert_js_1.number)(outputLen);
         // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
         if (0 >= this.blockLen || this.blockLen >= 200)
             throw new Error('Sha3 supports only keccak-f1600 function');
@@ -8778,7 +8616,7 @@ class Keccak extends utils_js_1.Hash {
         this.pos = 0;
     }
     update(data) {
-        _assert_js_1.default.exists(this);
+        (0, _assert_js_1.exists)(this);
         const { blockLen, state } = this;
         data = (0, utils_js_1.toBytes)(data);
         const len = data.length;
@@ -8804,8 +8642,8 @@ class Keccak extends utils_js_1.Hash {
         this.keccak();
     }
     writeInto(out) {
-        _assert_js_1.default.exists(this, false);
-        _assert_js_1.default.bytes(out);
+        (0, _assert_js_1.exists)(this, false);
+        (0, _assert_js_1.bytes)(out);
         this.finish();
         const bufferOut = this.state;
         const { blockLen } = this;
@@ -8826,11 +8664,11 @@ class Keccak extends utils_js_1.Hash {
         return this.writeInto(out);
     }
     xof(bytes) {
-        _assert_js_1.default.number(bytes);
+        (0, _assert_js_1.number)(bytes);
         return this.xofInto(new Uint8Array(bytes));
     }
     digestInto(out) {
-        _assert_js_1.default.output(out, this);
+        (0, _assert_js_1.output)(out, this);
         if (this.finished)
             throw new Error('digest() was already called');
         this.writeInto(out);
@@ -8920,7 +8758,7 @@ exports.rotr = rotr;
 exports.isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
 if (!exports.isLE)
     throw new Error('Non little-endian hardware is not supported');
-const hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
 /**
  * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
  */
@@ -9020,10 +8858,9 @@ class Hash {
     }
 }
 exports.Hash = Hash;
-// Check if object doens't have custom constructor (like Uint8Array/Array)
-const isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;
+const toStr = {}.toString;
 function checkOpts(defaults, opts) {
-    if (opts !== undefined && (typeof opts !== 'object' || !isPlainObject(opts)))
+    if (opts !== undefined && toStr.call(opts) !== '[object Object]')
         throw new Error('Options should be object or undefined');
     const merged = Object.assign(defaults, opts);
     return merged;
@@ -73856,7 +73693,7 @@ module.exports = __toCommonJS(nostr_tools_exports);
 
 // pure.ts
 var import_secp256k1 = __webpack_require__(/*! @noble/curves/secp256k1 */ "./node_modules/nostr-tools/node_modules/@noble/curves/secp256k1.js");
-var import_utils2 = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/@noble/hashes/utils.js");
+var import_utils2 = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js");
 
 // core.ts
 var verifiedSymbol = Symbol("verified");
@@ -73897,7 +73734,7 @@ function sortEvents(events) {
 }
 
 // pure.ts
-var import_sha256 = __webpack_require__(/*! @noble/hashes/sha256 */ "./node_modules/@noble/hashes/sha256.js");
+var import_sha256 = __webpack_require__(/*! @noble/hashes/sha256 */ "./node_modules/nostr-tools/node_modules/@noble/hashes/sha256.js");
 
 // utils.ts
 var utils_exports = {};
@@ -73913,7 +73750,7 @@ __export(utils_exports, {
   utf8Decoder: () => utf8Decoder,
   utf8Encoder: () => utf8Encoder
 });
-var import_utils = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/@noble/hashes/utils.js");
+var import_utils = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js");
 var utf8Decoder = new TextDecoder("utf-8");
 var utf8Encoder = new TextEncoder();
 function normalizeURL(url) {
@@ -75073,7 +74910,7 @@ __export(nip19_exports, {
   npubEncode: () => npubEncode,
   nsecEncode: () => nsecEncode
 });
-var import_utils6 = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/@noble/hashes/utils.js");
+var import_utils6 = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js");
 var import_base = __webpack_require__(/*! @scure/base */ "./node_modules/nostr-tools/node_modules/@scure/base/lib/index.js");
 var NostrTypeGuard = {
   isNProfile: (value) => /^nprofile1[a-z\d]+$/.test(value || ""),
@@ -75343,7 +75180,7 @@ __export(nip04_exports, {
   decrypt: () => decrypt,
   encrypt: () => encrypt
 });
-var import_utils8 = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/@noble/hashes/utils.js");
+var import_utils8 = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js");
 var import_secp256k12 = __webpack_require__(/*! @noble/curves/secp256k1 */ "./node_modules/nostr-tools/node_modules/@noble/curves/secp256k1.js");
 var import_aes = __webpack_require__(/*! @noble/ciphers/aes */ "./node_modules/@noble/ciphers/aes.js");
 var import_base2 = __webpack_require__(/*! @scure/base */ "./node_modules/nostr-tools/node_modules/@scure/base/lib/index.js");
@@ -75561,8 +75398,8 @@ __export(nip13_exports, {
   getPow: () => getPow,
   minePow: () => minePow
 });
-var import_utils10 = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/@noble/hashes/utils.js");
-var import_sha2562 = __webpack_require__(/*! @noble/hashes/sha256 */ "./node_modules/@noble/hashes/sha256.js");
+var import_utils10 = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js");
+var import_sha2562 = __webpack_require__(/*! @noble/hashes/sha256 */ "./node_modules/nostr-tools/node_modules/@noble/hashes/sha256.js");
 function getPow(hex) {
   let count = 0;
   for (let i2 = 0; i2 < 64; i2 += 8) {
@@ -75633,10 +75470,10 @@ __export(nip44_exports, {
 var import_chacha = __webpack_require__(/*! @noble/ciphers/chacha */ "./node_modules/@noble/ciphers/chacha.js");
 var import_utils12 = __webpack_require__(/*! @noble/ciphers/utils */ "./node_modules/@noble/ciphers/utils.js");
 var import_secp256k13 = __webpack_require__(/*! @noble/curves/secp256k1 */ "./node_modules/nostr-tools/node_modules/@noble/curves/secp256k1.js");
-var import_hkdf = __webpack_require__(/*! @noble/hashes/hkdf */ "./node_modules/@noble/hashes/hkdf.js");
-var import_hmac = __webpack_require__(/*! @noble/hashes/hmac */ "./node_modules/@noble/hashes/hmac.js");
-var import_sha2563 = __webpack_require__(/*! @noble/hashes/sha256 */ "./node_modules/@noble/hashes/sha256.js");
-var import_utils13 = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/@noble/hashes/utils.js");
+var import_hkdf = __webpack_require__(/*! @noble/hashes/hkdf */ "./node_modules/nostr-tools/node_modules/@noble/hashes/hkdf.js");
+var import_hmac = __webpack_require__(/*! @noble/hashes/hmac */ "./node_modules/nostr-tools/node_modules/@noble/hashes/hmac.js");
+var import_sha2563 = __webpack_require__(/*! @noble/hashes/sha256 */ "./node_modules/nostr-tools/node_modules/@noble/hashes/sha256.js");
+var import_utils13 = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js");
 var import_base3 = __webpack_require__(/*! @scure/base */ "./node_modules/nostr-tools/node_modules/@scure/base/lib/index.js");
 var minPlaintextSize = 1;
 var maxPlaintextSize = 65535;
@@ -76469,8 +76306,8 @@ __export(nip98_exports, {
   validateEventUrlTag: () => validateEventUrlTag,
   validateToken: () => validateToken
 });
-var import_sha2564 = __webpack_require__(/*! @noble/hashes/sha256 */ "./node_modules/@noble/hashes/sha256.js");
-var import_utils16 = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/@noble/hashes/utils.js");
+var import_sha2564 = __webpack_require__(/*! @noble/hashes/sha256 */ "./node_modules/nostr-tools/node_modules/@noble/hashes/sha256.js");
+var import_utils16 = __webpack_require__(/*! @noble/hashes/utils */ "./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js");
 var import_base5 = __webpack_require__(/*! @scure/base */ "./node_modules/nostr-tools/node_modules/@scure/base/lib/index.js");
 var _authorizationScheme = "Nostr ";
 async function getToken(loginUrl, httpMethod, sign, includeAuthorizationScheme = false, payload) {
@@ -79667,6 +79504,713 @@ exports.encodeToCurve = (() => htf.encodeToCurve)();
 
 /***/ }),
 
+/***/ "./node_modules/nostr-tools/node_modules/@noble/hashes/_assert.js":
+/*!************************************************************************!*\
+  !*** ./node_modules/nostr-tools/node_modules/@noble/hashes/_assert.js ***!
+  \************************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.output = exports.exists = exports.hash = exports.bytes = exports.bool = exports.number = void 0;
+function number(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error(`Wrong positive integer: ${n}`);
+}
+exports.number = number;
+function bool(b) {
+    if (typeof b !== 'boolean')
+        throw new Error(`Expected boolean, not ${b}`);
+}
+exports.bool = bool;
+function bytes(b, ...lengths) {
+    if (!(b instanceof Uint8Array))
+        throw new Error('Expected Uint8Array');
+    if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+}
+exports.bytes = bytes;
+function hash(hash) {
+    if (typeof hash !== 'function' || typeof hash.create !== 'function')
+        throw new Error('Hash should be wrapped by utils.wrapConstructor');
+    number(hash.outputLen);
+    number(hash.blockLen);
+}
+exports.hash = hash;
+function exists(instance, checkFinished = true) {
+    if (instance.destroyed)
+        throw new Error('Hash instance has been destroyed');
+    if (checkFinished && instance.finished)
+        throw new Error('Hash#digest() has already been called');
+}
+exports.exists = exists;
+function output(out, instance) {
+    bytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+    }
+}
+exports.output = output;
+const assert = {
+    number,
+    bool,
+    bytes,
+    hash,
+    exists,
+    output,
+};
+exports["default"] = assert;
+//# sourceMappingURL=_assert.js.map
+
+/***/ }),
+
+/***/ "./node_modules/nostr-tools/node_modules/@noble/hashes/_sha2.js":
+/*!**********************************************************************!*\
+  !*** ./node_modules/nostr-tools/node_modules/@noble/hashes/_sha2.js ***!
+  \**********************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SHA2 = void 0;
+const _assert_js_1 = __webpack_require__(/*! ./_assert.js */ "./node_modules/nostr-tools/node_modules/@noble/hashes/_assert.js");
+const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js");
+// Polyfill for Safari 14
+function setBigUint64(view, byteOffset, value, isLE) {
+    if (typeof view.setBigUint64 === 'function')
+        return view.setBigUint64(byteOffset, value, isLE);
+    const _32n = BigInt(32);
+    const _u32_max = BigInt(0xffffffff);
+    const wh = Number((value >> _32n) & _u32_max);
+    const wl = Number(value & _u32_max);
+    const h = isLE ? 4 : 0;
+    const l = isLE ? 0 : 4;
+    view.setUint32(byteOffset + h, wh, isLE);
+    view.setUint32(byteOffset + l, wl, isLE);
+}
+// Base SHA2 class (RFC 6234)
+class SHA2 extends utils_js_1.Hash {
+    constructor(blockLen, outputLen, padOffset, isLE) {
+        super();
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.padOffset = padOffset;
+        this.isLE = isLE;
+        this.finished = false;
+        this.length = 0;
+        this.pos = 0;
+        this.destroyed = false;
+        this.buffer = new Uint8Array(blockLen);
+        this.view = (0, utils_js_1.createView)(this.buffer);
+    }
+    update(data) {
+        _assert_js_1.default.exists(this);
+        const { view, buffer, blockLen } = this;
+        data = (0, utils_js_1.toBytes)(data);
+        const len = data.length;
+        for (let pos = 0; pos < len;) {
+            const take = Math.min(blockLen - this.pos, len - pos);
+            // Fast path: we have at least one block in input, cast it to view and process
+            if (take === blockLen) {
+                const dataView = (0, utils_js_1.createView)(data);
+                for (; blockLen <= len - pos; pos += blockLen)
+                    this.process(dataView, pos);
+                continue;
+            }
+            buffer.set(data.subarray(pos, pos + take), this.pos);
+            this.pos += take;
+            pos += take;
+            if (this.pos === blockLen) {
+                this.process(view, 0);
+                this.pos = 0;
+            }
+        }
+        this.length += data.length;
+        this.roundClean();
+        return this;
+    }
+    digestInto(out) {
+        _assert_js_1.default.exists(this);
+        _assert_js_1.default.output(out, this);
+        this.finished = true;
+        // Padding
+        // We can avoid allocation of buffer for padding completely if it
+        // was previously not allocated here. But it won't change performance.
+        const { buffer, view, blockLen, isLE } = this;
+        let { pos } = this;
+        // append the bit '1' to the message
+        buffer[pos++] = 0b10000000;
+        this.buffer.subarray(pos).fill(0);
+        // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again
+        if (this.padOffset > blockLen - pos) {
+            this.process(view, 0);
+            pos = 0;
+        }
+        // Pad until full block byte with zeros
+        for (let i = pos; i < blockLen; i++)
+            buffer[i] = 0;
+        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
+        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
+        // So we just write lowest 64 bits of that value.
+        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+        this.process(view, 0);
+        const oview = (0, utils_js_1.createView)(out);
+        const len = this.outputLen;
+        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT
+        if (len % 4)
+            throw new Error('_sha2: outputLen should be aligned to 32bit');
+        const outLen = len / 4;
+        const state = this.get();
+        if (outLen > state.length)
+            throw new Error('_sha2: outputLen bigger than state');
+        for (let i = 0; i < outLen; i++)
+            oview.setUint32(4 * i, state[i], isLE);
+    }
+    digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+    }
+    _cloneInto(to) {
+        to || (to = new this.constructor());
+        to.set(...this.get());
+        const { blockLen, buffer, length, finished, destroyed, pos } = this;
+        to.length = length;
+        to.pos = pos;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        if (length % blockLen)
+            to.buffer.set(buffer);
+        return to;
+    }
+}
+exports.SHA2 = SHA2;
+//# sourceMappingURL=_sha2.js.map
+
+/***/ }),
+
+/***/ "./node_modules/nostr-tools/node_modules/@noble/hashes/crypto.js":
+/*!***********************************************************************!*\
+  !*** ./node_modules/nostr-tools/node_modules/@noble/hashes/crypto.js ***!
+  \***********************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.crypto = void 0;
+exports.crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
+//# sourceMappingURL=crypto.js.map
+
+/***/ }),
+
+/***/ "./node_modules/nostr-tools/node_modules/@noble/hashes/hkdf.js":
+/*!*********************************************************************!*\
+  !*** ./node_modules/nostr-tools/node_modules/@noble/hashes/hkdf.js ***!
+  \*********************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.hkdf = exports.expand = exports.extract = void 0;
+const _assert_js_1 = __webpack_require__(/*! ./_assert.js */ "./node_modules/nostr-tools/node_modules/@noble/hashes/_assert.js");
+const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js");
+const hmac_js_1 = __webpack_require__(/*! ./hmac.js */ "./node_modules/nostr-tools/node_modules/@noble/hashes/hmac.js");
+// HKDF (RFC 5869)
+// https://soatok.blog/2021/11/17/understanding-hkdf/
+/**
+ * HKDF-Extract(IKM, salt) -> PRK
+ * Arguments position differs from spec (IKM is first one, since it is not optional)
+ * @param hash
+ * @param ikm
+ * @param salt
+ * @returns
+ */
+function extract(hash, ikm, salt) {
+    _assert_js_1.default.hash(hash);
+    // NOTE: some libraries treat zero-length array as 'not provided';
+    // we don't, since we have undefined as 'not provided'
+    // https://github.com/RustCrypto/KDFs/issues/15
+    if (salt === undefined)
+        salt = new Uint8Array(hash.outputLen); // if not provided, it is set to a string of HashLen zeros
+    return (0, hmac_js_1.hmac)(hash, (0, utils_js_1.toBytes)(salt), (0, utils_js_1.toBytes)(ikm));
+}
+exports.extract = extract;
+// HKDF-Expand(PRK, info, L) -> OKM
+const HKDF_COUNTER = new Uint8Array([0]);
+const EMPTY_BUFFER = new Uint8Array();
+/**
+ * HKDF-expand from the spec.
+ * @param prk - a pseudorandom key of at least HashLen octets (usually, the output from the extract step)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in octets
+ */
+function expand(hash, prk, info, length = 32) {
+    _assert_js_1.default.hash(hash);
+    _assert_js_1.default.number(length);
+    if (length > 255 * hash.outputLen)
+        throw new Error('Length should be <= 255*HashLen');
+    const blocks = Math.ceil(length / hash.outputLen);
+    if (info === undefined)
+        info = EMPTY_BUFFER;
+    // first L(ength) octets of T
+    const okm = new Uint8Array(blocks * hash.outputLen);
+    // Re-use HMAC instance between blocks
+    const HMAC = hmac_js_1.hmac.create(hash, prk);
+    const HMACTmp = HMAC._cloneInto();
+    const T = new Uint8Array(HMAC.outputLen);
+    for (let counter = 0; counter < blocks; counter++) {
+        HKDF_COUNTER[0] = counter + 1;
+        // T(0) = empty string (zero length)
+        // T(N) = HMAC-Hash(PRK, T(N-1) | info | N)
+        HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T)
+            .update(info)
+            .update(HKDF_COUNTER)
+            .digestInto(T);
+        okm.set(T, hash.outputLen * counter);
+        HMAC._cloneInto(HMACTmp);
+    }
+    HMAC.destroy();
+    HMACTmp.destroy();
+    T.fill(0);
+    HKDF_COUNTER.fill(0);
+    return okm.slice(0, length);
+}
+exports.expand = expand;
+/**
+ * HKDF (RFC 5869): extract + expand in one step.
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information
+ * @param length - length of output keying material in octets
+ */
+const hkdf = (hash, ikm, salt, info, length) => expand(hash, extract(hash, ikm, salt), info, length);
+exports.hkdf = hkdf;
+//# sourceMappingURL=hkdf.js.map
+
+/***/ }),
+
+/***/ "./node_modules/nostr-tools/node_modules/@noble/hashes/hmac.js":
+/*!*********************************************************************!*\
+  !*** ./node_modules/nostr-tools/node_modules/@noble/hashes/hmac.js ***!
+  \*********************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.hmac = exports.HMAC = void 0;
+const _assert_js_1 = __webpack_require__(/*! ./_assert.js */ "./node_modules/nostr-tools/node_modules/@noble/hashes/_assert.js");
+const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js");
+// HMAC (RFC 2104)
+class HMAC extends utils_js_1.Hash {
+    constructor(hash, _key) {
+        super();
+        this.finished = false;
+        this.destroyed = false;
+        _assert_js_1.default.hash(hash);
+        const key = (0, utils_js_1.toBytes)(_key);
+        this.iHash = hash.create();
+        if (typeof this.iHash.update !== 'function')
+            throw new Error('Expected instance of class which extends utils.Hash');
+        this.blockLen = this.iHash.blockLen;
+        this.outputLen = this.iHash.outputLen;
+        const blockLen = this.blockLen;
+        const pad = new Uint8Array(blockLen);
+        // blockLen can be bigger than outputLen
+        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+        for (let i = 0; i < pad.length; i++)
+            pad[i] ^= 0x36;
+        this.iHash.update(pad);
+        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone
+        this.oHash = hash.create();
+        // Undo internal XOR && apply outer XOR
+        for (let i = 0; i < pad.length; i++)
+            pad[i] ^= 0x36 ^ 0x5c;
+        this.oHash.update(pad);
+        pad.fill(0);
+    }
+    update(buf) {
+        _assert_js_1.default.exists(this);
+        this.iHash.update(buf);
+        return this;
+    }
+    digestInto(out) {
+        _assert_js_1.default.exists(this);
+        _assert_js_1.default.bytes(out, this.outputLen);
+        this.finished = true;
+        this.iHash.digestInto(out);
+        this.oHash.update(out);
+        this.oHash.digestInto(out);
+        this.destroy();
+    }
+    digest() {
+        const out = new Uint8Array(this.oHash.outputLen);
+        this.digestInto(out);
+        return out;
+    }
+    _cloneInto(to) {
+        // Create new instance without calling constructor since key already in state and we don't know it.
+        to || (to = Object.create(Object.getPrototypeOf(this), {}));
+        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+        to = to;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        to.blockLen = blockLen;
+        to.outputLen = outputLen;
+        to.oHash = oHash._cloneInto(to.oHash);
+        to.iHash = iHash._cloneInto(to.iHash);
+        return to;
+    }
+    destroy() {
+        this.destroyed = true;
+        this.oHash.destroy();
+        this.iHash.destroy();
+    }
+}
+exports.HMAC = HMAC;
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256
+ * @param key - message key
+ * @param message - message data
+ */
+const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+exports.hmac = hmac;
+exports.hmac.create = (hash, key) => new HMAC(hash, key);
+//# sourceMappingURL=hmac.js.map
+
+/***/ }),
+
+/***/ "./node_modules/nostr-tools/node_modules/@noble/hashes/sha256.js":
+/*!***********************************************************************!*\
+  !*** ./node_modules/nostr-tools/node_modules/@noble/hashes/sha256.js ***!
+  \***********************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.sha224 = exports.sha256 = void 0;
+const _sha2_js_1 = __webpack_require__(/*! ./_sha2.js */ "./node_modules/nostr-tools/node_modules/@noble/hashes/_sha2.js");
+const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js");
+// Choice: a ? b : c
+const Chi = (a, b, c) => (a & b) ^ (~a & c);
+// Majority function, true if any two inpust is true
+const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
+// Round constants:
+// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)
+// prettier-ignore
+const SHA256_K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
+// prettier-ignore
+const IV = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+]);
+// Temporary buffer, not used to store anything between runs
+// Named this way because it matches specification.
+const SHA256_W = new Uint32Array(64);
+class SHA256 extends _sha2_js_1.SHA2 {
+    constructor() {
+        super(64, 32, 8, false);
+        // We cannot use array here since array allows indexing by variable
+        // which means optimizer/compiler cannot use registers.
+        this.A = IV[0] | 0;
+        this.B = IV[1] | 0;
+        this.C = IV[2] | 0;
+        this.D = IV[3] | 0;
+        this.E = IV[4] | 0;
+        this.F = IV[5] | 0;
+        this.G = IV[6] | 0;
+        this.H = IV[7] | 0;
+    }
+    get() {
+        const { A, B, C, D, E, F, G, H } = this;
+        return [A, B, C, D, E, F, G, H];
+    }
+    // prettier-ignore
+    set(A, B, C, D, E, F, G, H) {
+        this.A = A | 0;
+        this.B = B | 0;
+        this.C = C | 0;
+        this.D = D | 0;
+        this.E = E | 0;
+        this.F = F | 0;
+        this.G = G | 0;
+        this.H = H | 0;
+    }
+    process(view, offset) {
+        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
+        for (let i = 0; i < 16; i++, offset += 4)
+            SHA256_W[i] = view.getUint32(offset, false);
+        for (let i = 16; i < 64; i++) {
+            const W15 = SHA256_W[i - 15];
+            const W2 = SHA256_W[i - 2];
+            const s0 = (0, utils_js_1.rotr)(W15, 7) ^ (0, utils_js_1.rotr)(W15, 18) ^ (W15 >>> 3);
+            const s1 = (0, utils_js_1.rotr)(W2, 17) ^ (0, utils_js_1.rotr)(W2, 19) ^ (W2 >>> 10);
+            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
+        }
+        // Compression function main loop, 64 rounds
+        let { A, B, C, D, E, F, G, H } = this;
+        for (let i = 0; i < 64; i++) {
+            const sigma1 = (0, utils_js_1.rotr)(E, 6) ^ (0, utils_js_1.rotr)(E, 11) ^ (0, utils_js_1.rotr)(E, 25);
+            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+            const sigma0 = (0, utils_js_1.rotr)(A, 2) ^ (0, utils_js_1.rotr)(A, 13) ^ (0, utils_js_1.rotr)(A, 22);
+            const T2 = (sigma0 + Maj(A, B, C)) | 0;
+            H = G;
+            G = F;
+            F = E;
+            E = (D + T1) | 0;
+            D = C;
+            C = B;
+            B = A;
+            A = (T1 + T2) | 0;
+        }
+        // Add the compressed chunk to the current hash value
+        A = (A + this.A) | 0;
+        B = (B + this.B) | 0;
+        C = (C + this.C) | 0;
+        D = (D + this.D) | 0;
+        E = (E + this.E) | 0;
+        F = (F + this.F) | 0;
+        G = (G + this.G) | 0;
+        H = (H + this.H) | 0;
+        this.set(A, B, C, D, E, F, G, H);
+    }
+    roundClean() {
+        SHA256_W.fill(0);
+    }
+    destroy() {
+        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+        this.buffer.fill(0);
+    }
+}
+// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf
+class SHA224 extends SHA256 {
+    constructor() {
+        super();
+        this.A = 0xc1059ed8 | 0;
+        this.B = 0x367cd507 | 0;
+        this.C = 0x3070dd17 | 0;
+        this.D = 0xf70e5939 | 0;
+        this.E = 0xffc00b31 | 0;
+        this.F = 0x68581511 | 0;
+        this.G = 0x64f98fa7 | 0;
+        this.H = 0xbefa4fa4 | 0;
+        this.outputLen = 28;
+    }
+}
+/**
+ * SHA2-256 hash function
+ * @param message - data that would be hashed
+ */
+exports.sha256 = (0, utils_js_1.wrapConstructor)(() => new SHA256());
+exports.sha224 = (0, utils_js_1.wrapConstructor)(() => new SHA224());
+//# sourceMappingURL=sha256.js.map
+
+/***/ }),
+
+/***/ "./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js":
+/*!**********************************************************************!*\
+  !*** ./node_modules/nostr-tools/node_modules/@noble/hashes/utils.js ***!
+  \**********************************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.randomBytes = exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.checkOpts = exports.Hash = exports.concatBytes = exports.toBytes = exports.utf8ToBytes = exports.asyncLoop = exports.nextTick = exports.hexToBytes = exports.bytesToHex = exports.isLE = exports.rotr = exports.createView = exports.u32 = exports.u8 = void 0;
+// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+// node.js versions earlier than v19 don't declare it in global scope.
+// For node.js, package.json#exports field mapping rewrites import
+// from `crypto` to `cryptoNode`, which imports native module.
+// Makes the utils un-importable in browsers without a bundler.
+// Once node.js 18 is deprecated, we can just drop the import.
+const crypto_1 = __webpack_require__(/*! @noble/hashes/crypto */ "./node_modules/nostr-tools/node_modules/@noble/hashes/crypto.js");
+const u8a = (a) => a instanceof Uint8Array;
+// Cast array to different type
+const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+exports.u8 = u8;
+const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+exports.u32 = u32;
+// Cast array to view
+const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+exports.createView = createView;
+// The rotate right (circular right shift) operation for uint32
+const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
+exports.rotr = rotr;
+// big-endian hardware is rare. Just in case someone still decides to run hashes:
+// early-throw an error because we don't support BE yet.
+exports.isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
+if (!exports.isLE)
+    throw new Error('Non little-endian hardware is not supported');
+const hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
+/**
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+function bytesToHex(bytes) {
+    if (!u8a(bytes))
+        throw new Error('Uint8Array expected');
+    // pre-caching improves the speed 6x
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += hexes[bytes[i]];
+    }
+    return hex;
+}
+exports.bytesToHex = bytesToHex;
+/**
+ * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ */
+function hexToBytes(hex) {
+    if (typeof hex !== 'string')
+        throw new Error('hex string expected, got ' + typeof hex);
+    const len = hex.length;
+    if (len % 2)
+        throw new Error('padded hex string expected, got unpadded hex of length ' + len);
+    const array = new Uint8Array(len / 2);
+    for (let i = 0; i < array.length; i++) {
+        const j = i * 2;
+        const hexByte = hex.slice(j, j + 2);
+        const byte = Number.parseInt(hexByte, 16);
+        if (Number.isNaN(byte) || byte < 0)
+            throw new Error('Invalid byte sequence');
+        array[i] = byte;
+    }
+    return array;
+}
+exports.hexToBytes = hexToBytes;
+// There is no setImmediate in browser and setTimeout is slow.
+// call of async fn will return Promise, which will be fullfiled only on
+// next scheduler queue processing step and this is exactly what we need.
+const nextTick = async () => { };
+exports.nextTick = nextTick;
+// Returns control to thread each 'tick' ms to avoid blocking
+async function asyncLoop(iters, tick, cb) {
+    let ts = Date.now();
+    for (let i = 0; i < iters; i++) {
+        cb(i);
+        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too
+        const diff = Date.now() - ts;
+        if (diff >= 0 && diff < tick)
+            continue;
+        await (0, exports.nextTick)();
+        ts += diff;
+    }
+}
+exports.asyncLoop = asyncLoop;
+/**
+ * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+ */
+function utf8ToBytes(str) {
+    if (typeof str !== 'string')
+        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+exports.utf8ToBytes = utf8ToBytes;
+/**
+ * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+ * Warning: when Uint8Array is passed, it would NOT get copied.
+ * Keep in mind for future mutable operations.
+ */
+function toBytes(data) {
+    if (typeof data === 'string')
+        data = utf8ToBytes(data);
+    if (!u8a(data))
+        throw new Error(`expected Uint8Array, got ${typeof data}`);
+    return data;
+}
+exports.toBytes = toBytes;
+/**
+ * Copies several Uint8Arrays into one.
+ */
+function concatBytes(...arrays) {
+    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
+    let pad = 0; // walk through each item, ensure they have proper type
+    arrays.forEach((a) => {
+        if (!u8a(a))
+            throw new Error('Uint8Array expected');
+        r.set(a, pad);
+        pad += a.length;
+    });
+    return r;
+}
+exports.concatBytes = concatBytes;
+// For runtime check if class implements interface
+class Hash {
+    // Safe version that clones internal state
+    clone() {
+        return this._cloneInto();
+    }
+}
+exports.Hash = Hash;
+// Check if object doens't have custom constructor (like Uint8Array/Array)
+const isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;
+function checkOpts(defaults, opts) {
+    if (opts !== undefined && (typeof opts !== 'object' || !isPlainObject(opts)))
+        throw new Error('Options should be object or undefined');
+    const merged = Object.assign(defaults, opts);
+    return merged;
+}
+exports.checkOpts = checkOpts;
+function wrapConstructor(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+    const tmp = hashCons();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashCons();
+    return hashC;
+}
+exports.wrapConstructor = wrapConstructor;
+function wrapConstructorWithOpts(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+}
+exports.wrapConstructorWithOpts = wrapConstructorWithOpts;
+function wrapXOFConstructorWithOpts(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+}
+exports.wrapXOFConstructorWithOpts = wrapXOFConstructorWithOpts;
+/**
+ * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.
+ */
+function randomBytes(bytesLength = 32) {
+    if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === 'function') {
+        return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+    }
+    throw new Error('crypto.getRandomValues must be defined');
+}
+exports.randomBytes = randomBytes;
+//# sourceMappingURL=utils.js.map
+
+/***/ }),
+
 /***/ "./node_modules/nostr-tools/node_modules/@scure/base/lib/index.js":
 /*!************************************************************************!*\
   !*** ./node_modules/nostr-tools/node_modules/@scure/base/lib/index.js ***!
@@ -98485,1307 +99029,6 @@ module.exports = function whichTypedArray(value) {
 };
 
 
-/***/ }),
-
-/***/ "./ship/examples/messenger-cli.ts":
-/*!****************************************!*\
-  !*** ./ship/examples/messenger-cli.ts ***!
-  \****************************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-"use strict";
-/* provided dependency */ var process = __webpack_require__(/*! process/browser */ "./node_modules/process/browser.js");
-/* provided dependency */ var Buffer = __webpack_require__(/*! buffer */ "./node_modules/buffer/index.js")["Buffer"];
-//#!/usr/bin/env node
-
-/**
- * Shogun Chat - CLI Interface
- *
- * End-to-end encrypted decentralized chat
- * Simple and functional CLI interface
- */
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.MessengerCLI = void 0;
-const SHIP_01_1 = __webpack_require__(/*! ../implementation/SHIP_01 */ "./ship/implementation/SHIP_01.ts");
-// Only import readline in Node.js environment
-let readline;
-try {
-    if (false) // removed by dead control flow
-{}
-}
-catch (e) {
-    // Browser environment - readline not available
-}
-// ============================================================================
-// COLORS
-// ============================================================================
-const colors = {
-    reset: "\x1b[0m",
-    bold: "\x1b[1m",
-    dim: "\x1b[2m",
-    red: "\x1b[31m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    blue: "\x1b[34m",
-    magenta: "\x1b[35m",
-    cyan: "\x1b[36m",
-    white: "\x1b[37m",
-    gray: "\x1b[90m",
-};
-const c = (color, text) => `${colors[color]}${text}${colors.reset}`;
-// ============================================================================
-// CHAT CLI
-// ============================================================================
-class MessengerCLI {
-    constructor() {
-        this.currentUser = "";
-        this.recipient = "";
-        this.derivedAddress = "";
-        this.isAuthenticated = false;
-        // Initialize app in all environments (needed for TypeScript)
-        this.app = new SHIP_01_1.SHIP_01({
-            gunOptions: {
-                peers: [
-                    "https://peer.wallie.io/gun",
-                    "https://v5g5jseqhgkp43lppgregcfbvi.srv.us/gun",
-                    "https://relay.shogun-eco.xyz/gun",
-                ],
-                radisk: true,
-                localStorage: false,
-            },
-        });
-        // Don't initialize readline in browser environment
-        if (true) {
-            console.warn('MessengerCLI is designed for Node.js CLI usage only');
-            return;
-        }
-        // removed by dead control flow
-
-        // removed by dead control flow
-
-    }
-    // ========================================================================
-    // SETUP
-    // ========================================================================
-    setupHandlers() {
-        this.rl.on("line", async (line) => {
-            const input = line.trim();
-            if (!input) {
-                this.rl.prompt();
-                return;
-            }
-            if (input.startsWith("/")) {
-                await this.handleCommand(input);
-            }
-            else {
-                await this.sendMessage(input);
-            }
-            this.rl.prompt();
-        });
-        this.rl.on("close", () => {
-            console.log("\n" + c("yellow", "👋 Arrivederci!"));
-            process.exit(0);
-        });
-        // Ctrl+C handler
-        process.on("SIGINT", () => {
-            this.rl.close();
-        });
-    }
-    // ========================================================================
-    // UTILITIES
-    // ========================================================================
-    async withTimeout(promise, timeoutMs, errorMessage) {
-        return Promise.race([
-            promise,
-            new Promise((_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs)),
-        ]);
-    }
-    // ========================================================================
-    // AUTH
-    // ========================================================================
-    async login(username, password) {
-        console.log(c("cyan", "🔐 Login in corso..."));
-        // Loading indicator
-        const loadingInterval = setInterval(() => {
-            process.stdout.write(c("gray", "."));
-        }, 500);
-        try {
-            // Prova login con timeout
-            let result = await this.withTimeout(this.app.login(username, password), 15000, "Login timeout - verifica connessione ai peers");
-            clearInterval(loadingInterval);
-            console.log(""); // Nuova linea dopo i dots
-            // Se fallisce, prova signup
-            if (!result.success) {
-                console.log(c("yellow", "📝 Utente non trovato, creazione in corso..."));
-                const signupResult = await this.app.signup(username, password);
-                if (signupResult.success) {
-                    // Aspetta un momento per evitare race condition
-                    await new Promise((resolve) => setTimeout(resolve, 1000));
-                    // Riprova login
-                    result = await this.app.login(username, password);
-                }
-                else {
-                    console.log(c("red", `❌ Signup fallito: ${signupResult.error}`));
-                    return false;
-                }
-            }
-            if (result.success) {
-                this.currentUser = username;
-                this.derivedAddress = result.derivedAddress || "";
-                this.isAuthenticated = true;
-                console.log("");
-                console.log(c("green", "✅ Login effettuato!"));
-                console.log(c("gray", `   Username: ${c("bold", username)}`));
-                console.log(c("gray", `   Public Key: ${result.userPub?.substring(0, 40)}...`));
-                console.log(c("gray", `   Derived Address: ${c("cyan", result.derivedAddress || "")}`));
-                console.log("");
-                console.log(c("yellow", "📢 Pubblicazione chiave pubblica..."));
-                await this.app.publishPublicKey();
-                // Aspetta che la chiave sia sincronizzata
-                await new Promise((resolve) => setTimeout(resolve, 1000));
-                console.log(c("green", "✅ Chiave pubblicata su GunDB"));
-                console.log("");
-                // Ascolta messaggi
-                await this.app.listenForMessages((msg) => {
-                    this.onMessageReceived(msg);
-                });
-                console.log(c("cyan", "💬 Chat pronta! Scrivi /help per i comandi disponibili"));
-                console.log("");
-                return true;
-            }
-            else {
-                console.log(c("red", `❌ Login fallito: ${result.error}`));
-                return false;
-            }
-        }
-        catch (error) {
-            clearInterval(loadingInterval);
-            console.log("");
-            console.log(c("red", `❌ Errore: ${error.message}`));
-            return false;
-        }
-        finally {
-            clearInterval(loadingInterval);
-        }
-    }
-    // ========================================================================
-    // MESSAGING
-    // ========================================================================
-    async sendMessage(content) {
-        if (!this.isAuthenticated) {
-            console.log(c("red", "❌ Non autenticato. Usa /login"));
-            return;
-        }
-        if (!this.recipient) {
-            console.log(c("yellow", "⚠️  Nessun destinatario. Usa /to <username>"));
-            return;
-        }
-        try {
-            const result = await this.app.sendMessage(this.recipient, content);
-            if (result.success) {
-                const time = new Date().toLocaleTimeString();
-                console.log(c("gray", `[${time}]`) +
-                    " " +
-                    c("green", `${this.currentUser}:`) +
-                    " " +
-                    content);
-            }
-            else {
-                console.log(c("red", `❌ Errore invio: ${result.error}`));
-            }
-        }
-        catch (error) {
-            console.log(c("red", `❌ Errore: ${error.message}`));
-        }
-    }
-    onMessageReceived(message) {
-        const time = new Date(message.timestamp).toLocaleTimeString();
-        const fromUser = message.from.substring(0, 10) + "...";
-        console.log("");
-        console.log(c("cyan", "📨 Nuovo messaggio!"));
-        console.log(c("gray", `[${time}]`) +
-            " " +
-            c("cyan", `${fromUser}:`) +
-            " " +
-            message.content);
-        console.log("");
-        this.rl.prompt();
-    }
-    // ========================================================================
-    // KEY PAIR MANAGEMENT
-    // ========================================================================
-    async exportKeyPair() {
-        try {
-            // Ottieni il SEA pair completo
-            const seaPair = this.app["shogun"].db.gun.user()?._?.sea;
-            if (!seaPair) {
-                console.log(c("red", "❌ Impossibile accedere al SEA pair"));
-                return;
-            }
-            // Crea export object
-            const exportData = {
-                pub: seaPair.pub,
-                priv: seaPair.priv,
-                epub: seaPair.epub,
-                epriv: seaPair.epriv,
-                alias: this.currentUser,
-                exportedAt: Date.now()
-            };
-            // Converti in base64 per facilità di copia
-            const jsonString = JSON.stringify(exportData);
-            const base64 = Buffer.from(jsonString).toString('base64');
-            console.log("");
-            console.log(c("green", "✅ KEY PAIR ESPORTATO"));
-            console.log(c("yellow", "═".repeat(60)));
-            console.log("");
-            console.log(c("bold", "🔑 SEA PAIR (Base64):"));
-            console.log("");
-            console.log(c("cyan", base64));
-            console.log("");
-            console.log(c("yellow", "═".repeat(60)));
-            console.log("");
-            console.log(c("gray", "💾 SALVA QUESTO KEY PAIR IN UN LUOGO SICURO!"));
-            console.log(c("gray", "   Puoi usarlo per:"));
-            console.log(c("gray", "   - Fare login: /login-pair <keypair>"));
-            console.log(c("gray", "   - Importare: /import <keypair>"));
-            console.log(c("gray", "   - Backup della tua identità"));
-            console.log("");
-            console.log(c("red", "⚠️  NON CONDIVIDERE MAI QUESTO KEY PAIR!"));
-            console.log(c("red", "   Contiene le tue chiavi private!"));
-            console.log("");
-            // Salva anche su file (opzionale)
-            const fs = await __webpack_require__.e(/*! import() */ "_e6ae").then(__webpack_require__.t.bind(__webpack_require__, /*! fs */ "?e6ae", 23));
-            const filename = `shogun-keypair-${this.currentUser}-${Date.now()}.txt`;
-            fs.writeFileSync(filename, base64);
-            console.log(c("green", `💾 Key pair salvato anche in: ${filename}`));
-            console.log("");
-        }
-        catch (error) {
-            console.log(c("red", `❌ Errore export: ${error.message}`));
-        }
-    }
-    async importKeyPair(base64KeyPair) {
-        try {
-            // Decodifica da base64
-            const jsonString = Buffer.from(base64KeyPair, 'base64').toString('utf-8');
-            const keyPairData = JSON.parse(jsonString);
-            // Verifica che abbia tutti i campi necessari
-            if (!keyPairData.pub || !keyPairData.priv || !keyPairData.epub || !keyPairData.epriv) {
-                console.log(c("red", "❌ Key pair invalido. Mancano campi obbligatori."));
-                return;
-            }
-            console.log(c("cyan", "📥 Key pair importato con successo!"));
-            console.log(c("gray", `   Utente: ${keyPairData.alias || 'unknown'}`));
-            console.log(c("gray", `   Public Key: ${keyPairData.pub.substring(0, 30)}...`));
-            console.log("");
-            console.log(c("yellow", "💡 Usa /login-pair <keypair> per fare login"));
-            console.log("");
-        }
-        catch (error) {
-            console.log(c("red", `❌ Errore import: ${error.message}`));
-            console.log(c("gray", "   Verifica che il key pair sia valido"));
-        }
-    }
-    async loginWithPair(base64KeyPair) {
-        console.log(c("cyan", "🔐 Login con key pair..."));
-        const loadingInterval = setInterval(() => {
-            process.stdout.write(c("gray", "."));
-        }, 500);
-        try {
-            // Decodifica key pair
-            const jsonString = Buffer.from(base64KeyPair, 'base64').toString('utf-8');
-            const keyPairData = JSON.parse(jsonString);
-            // Verifica validità
-            if (!keyPairData.pub || !keyPairData.priv || !keyPairData.epub || !keyPairData.epriv) {
-                throw new Error("Key pair invalido");
-            }
-            // Crea SEA pair object
-            const seaPair = {
-                pub: keyPairData.pub,
-                priv: keyPairData.priv,
-                epub: keyPairData.epub,
-                epriv: keyPairData.epriv
-            };
-            // Login con pair
-            const result = await this.withTimeout(this.app["shogun"].loginWithPair(seaPair), 15000, "Login timeout");
-            clearInterval(loadingInterval);
-            console.log("");
-            if (result.success) {
-                this.currentUser = keyPairData.alias || result.username || 'unknown';
-                this.derivedAddress = await this.app.deriveEthereumAddress(seaPair.pub);
-                this.isAuthenticated = true;
-                console.log("");
-                console.log(c("green", "✅ Login con key pair effettuato!"));
-                console.log(c("gray", `   Username: ${c("bold", this.currentUser)}`));
-                console.log(c("gray", `   Public Key: ${seaPair.pub.substring(0, 40)}...`));
-                console.log(c("gray", `   Derived Address: ${c("cyan", this.derivedAddress)}`));
-                console.log("");
-                console.log(c("yellow", "📢 Pubblicazione chiave pubblica..."));
-                await this.app.publishPublicKey();
-                await new Promise((resolve) => setTimeout(resolve, 1000));
-                console.log(c("green", "✅ Chiave pubblicata su GunDB"));
-                console.log("");
-                // Ascolta messaggi
-                await this.app.listenForMessages((msg) => {
-                    this.onMessageReceived(msg);
-                });
-                console.log(c("cyan", "💬 Chat pronta!"));
-                console.log("");
-                this.updatePrompt();
-            }
-            else {
-                console.log(c("red", `❌ Login fallito: ${result.error}`));
-            }
-        }
-        catch (error) {
-            clearInterval(loadingInterval);
-            console.log("");
-            console.log(c("red", `❌ Errore: ${error.message}`));
-        }
-        finally {
-            clearInterval(loadingInterval);
-        }
-    }
-    async wipeAllMessages() {
-        console.log("");
-        console.log(c("yellow", "⚠️  ATTENZIONE: Stai per cancellare TUTTI i messaggi dal nodo GunDB"));
-        console.log(c("yellow", "   Questa operazione è IRREVERSIBILE!"));
-        console.log("");
-        // Conferma
-        this.rl.question(c("red", "Sei sicuro? Scrivi 'CONFERMA' per procedere: "), (answer) => {
-            if (answer.trim() === "CONFERMA") {
-                console.log(c("yellow", "🗑️  Cancellazione messaggi in corso..."));
-                // Ottieni tutti i messaggi
-                this.app["shogun"].db.gun.get(SHIP_01_1.SHIP_01.NODES.MESSAGES).once((allMessages) => {
-                    if (allMessages && typeof allMessages === 'object') {
-                        let count = 0;
-                        // Cancella ogni messaggio
-                        for (const [messageId, data] of Object.entries(allMessages)) {
-                            if (typeof data === "object" && data !== null && messageId !== '_') {
-                                this.app["shogun"].db.gun.get(SHIP_01_1.SHIP_01.NODES.MESSAGES).get(messageId).put(null);
-                                count++;
-                            }
-                        }
-                        console.log(c("green", `✅ ${count} messaggi cancellati dal nodo GunDB`));
-                    }
-                    else {
-                        console.log(c("gray", "ℹ️  Nessun messaggio da cancellare"));
-                    }
-                    console.log("");
-                    this.rl.prompt();
-                });
-            }
-            else {
-                console.log(c("gray", "❌ Cancellazione annullata"));
-                console.log("");
-                this.rl.prompt();
-            }
-        });
-    }
-    // ========================================================================
-    // COMMANDS
-    // ========================================================================
-    async handleCommand(cmd) {
-        const parts = cmd.split(" ");
-        const command = parts[0].toLowerCase();
-        const args = parts.slice(1);
-        switch (command) {
-            case "/login":
-                if (args.length >= 2) {
-                    const [username, password] = args;
-                    await this.login(username, password);
-                    this.updatePrompt();
-                }
-                else {
-                    console.log(c("yellow", "⚠️  Uso: /login <username> <password>"));
-                }
-                break;
-            case "/to":
-            case "/chat":
-                if (!this.isAuthenticated) {
-                    console.log(c("red", "❌ Prima fai login: /login <username> <password>"));
-                    break;
-                }
-                if (args[0]) {
-                    this.recipient = args[0];
-                    console.log(c("cyan", `💬 Chattando con ${c("bold", this.recipient)}`));
-                    // Carica storico
-                    const history = await this.app.getMessageHistory(this.recipient);
-                    if (history.length > 0) {
-                        console.log(c("gray", `\n📚 Storico conversazione (${history.length} messaggi):\n`));
-                        history.forEach((msg, i) => {
-                            const time = new Date(msg.timestamp).toLocaleTimeString();
-                            const isMe = msg.from === this.currentUser;
-                            const from = isMe ? this.currentUser : this.recipient;
-                            const color = isMe ? "green" : "cyan";
-                            console.log(c("gray", `[${time}]`) +
-                                " " +
-                                c(color, `${from}:`) +
-                                " " +
-                                msg.content);
-                        });
-                        console.log("");
-                    }
-                    this.updatePrompt();
-                }
-                else {
-                    console.log(c("yellow", "⚠️  Uso: /to <username>"));
-                }
-                break;
-            case "/help":
-                this.showHelp();
-                break;
-            case "/clear":
-                console.clear();
-                this.showHeader();
-                break;
-            case "/status":
-                this.showStatus();
-                break;
-            case "/logout":
-                this.app.logout();
-                this.isAuthenticated = false;
-                this.currentUser = "";
-                this.recipient = "";
-                console.log(c("yellow", "👋 Disconnesso"));
-                this.updatePrompt();
-                break;
-            case "/export":
-            case "/backup":
-                if (!this.isAuthenticated) {
-                    console.log(c("red", "❌ Prima fai login"));
-                    break;
-                }
-                await this.exportKeyPair();
-                break;
-            case "/import":
-            case "/restore":
-                if (args[0]) {
-                    await this.importKeyPair(args[0]);
-                }
-                else {
-                    console.log(c("yellow", "⚠️  Uso: /import <keypair-json-base64>"));
-                }
-                break;
-            case "/login-pair":
-                if (args[0]) {
-                    await this.loginWithPair(args[0]);
-                }
-                else {
-                    console.log(c("yellow", "⚠️  Uso: /login-pair <keypair-json-base64>"));
-                }
-                break;
-            case "/wipe":
-            case "/delete-all":
-                if (!this.isAuthenticated) {
-                    console.log(c("red", "❌ Prima fai login"));
-                    break;
-                }
-                await this.wipeAllMessages();
-                break;
-            case "/exit":
-            case "/quit":
-                this.rl.close();
-                break;
-            default:
-                console.log(c("red", `❌ Comando sconosciuto: ${command}`));
-                console.log(c("gray", "   Scrivi /help per aiuto"));
-        }
-    }
-    showHelp() {
-        console.log("");
-        console.log(c("bold", c("cyan", "📖 COMANDI DISPONIBILI")));
-        console.log("");
-        console.log(c("bold", "AUTENTICAZIONE:"));
-        console.log("  " + c("bold", "/login <user> <pass>") + "  - Login/Signup con password");
-        console.log("  " + c("bold", "/login-pair <keypair>") + "  - Login con SEA key pair");
-        console.log("");
-        console.log(c("bold", "MESSAGGISTICA:"));
-        console.log("  " + c("bold", "/to <username>") + "        - Inizia chat con un utente");
-        console.log("");
-        console.log(c("bold", "KEY MANAGEMENT:"));
-        console.log("  " + c("bold", "/export") + "                - Esporta il tuo key pair (backup)");
-        console.log("  " + c("bold", "/import <keypair>") + "     - Mostra info su key pair");
-        console.log("");
-        console.log(c("bold", "UTILITÀ:"));
-        console.log("  " + c("bold", "/help") + "                 - Mostra questo aiuto");
-        console.log("  " + c("bold", "/status") + "               - Mostra stato connessione");
-        console.log("  " + c("bold", "/clear") + "                - Pulisci schermo");
-        console.log("  " + c("bold", "/wipe") + "                 - Cancella TUTTI i messaggi (⚠️)");
-        console.log("  " + c("bold", "/logout") + "               - Disconnetti");
-        console.log("  " + c("bold", "/exit") + "                 - Esci dall'app");
-        console.log("");
-        console.log(c("bold", c("green", "🔐 SICUREZZA")));
-        console.log("");
-        console.log("  ✅ Crittografia end-to-end (ECDH + AES-GCM)");
-        console.log("  ✅ Storage decentralizzato P2P (GunDB)");
-        console.log("  ✅ Nessun server può leggere i messaggi");
-        console.log("  ✅ Key pair portabile (export/import)");
-        console.log("  ✅ Zero costi, completamente gratis");
-        console.log("");
-        console.log(c("bold", c("yellow", "💡 ESEMPI")));
-        console.log("");
-        console.log("  " + c("gray", "# Login normale"));
-        console.log("  " + c("gray", "/login alice password123"));
-        console.log("");
-        console.log("  " + c("gray", "# Export key pair (backup)"));
-        console.log("  " + c("gray", "/export"));
-        console.log("");
-        console.log("  " + c("gray", "# Login con key pair (no password)"));
-        console.log("  " + c("gray", "/login-pair eyJwdWIiOiIuLi4ifQ=="));
-        console.log("");
-        console.log("  " + c("gray", "# Chattare"));
-        console.log("  " + c("gray", "/to bob"));
-        console.log("  " + c("gray", "Ciao Bob! Come stai?"));
-        console.log("");
-    }
-    showStatus() {
-        console.log("");
-        console.log(c("bold", c("cyan", "📊 STATO SISTEMA")));
-        console.log("");
-        console.log("  " + c("gray", "Utente:") + " " + c("green", this.currentUser));
-        console.log("  " +
-            c("gray", "Destinatario:") +
-            " " +
-            c("yellow", this.recipient || "(nessuno)"));
-        console.log("  " + c("gray", "Address:") + " " + c("cyan", this.derivedAddress));
-        console.log("  " +
-            c("gray", "Autenticato:") +
-            " " +
-            (this.isAuthenticated ? c("green", "✅ Sì") : c("red", "❌ No")));
-        console.log("");
-    }
-    showHeader() {
-        console.log("");
-        console.log(c("bold", c("cyan", "═══════════════════════════════════════════════════════")));
-        console.log(c("bold", c("cyan", "       🗡️  SHOGUN CHAT - Decentralized E2E Messaging")));
-        console.log(c("bold", c("cyan", "═══════════════════════════════════════════════════════")));
-        console.log("");
-        console.log(c("gray", "  Powered by Shogun Core + GunDB"));
-        console.log(c("gray", "  Zero-cost encrypted messaging over P2P network"));
-        console.log("");
-    }
-    updatePrompt() {
-        let prompt = "";
-        if (this.recipient) {
-            prompt =
-                c("green", `[${this.currentUser}]`) +
-                    c("white", " → ") +
-                    c("yellow", this.recipient) +
-                    c("green", " ➤ ");
-        }
-        else if (this.currentUser) {
-            prompt = c("green", `[${this.currentUser}]`) + c("green", " ➤ ");
-        }
-        else {
-            prompt = c("gray", "➤ ");
-        }
-        this.rl.setPrompt(prompt);
-    }
-    // ========================================================================
-    // START
-    // ========================================================================
-    async start() {
-        this.showHeader();
-        const args = process.argv.slice(2);
-        if (args.length >= 2) {
-            // Auto-login
-            const [username, password] = args;
-            const success = await this.login(username, password);
-            if (success) {
-                this.updatePrompt();
-                this.rl.prompt();
-            }
-            else {
-                console.log(c("red", "❌ Auto-login fallito"));
-                this.rl.close();
-            }
-        }
-        else {
-            // Login manuale
-            console.log(c("cyan", "💡 Comandi disponibili:"));
-            console.log(c("yellow", "   /login <username> <password>") +
-                c("gray", " - Login o crea account"));
-            console.log(c("yellow", "   /help") +
-                c("gray", "                       - Mostra tutti i comandi"));
-            console.log("");
-            console.log(c("gray", "   Oppure avvia con: yarn chat <username> <password>"));
-            console.log("");
-            this.updatePrompt();
-            this.rl.prompt();
-        }
-    }
-}
-exports.MessengerCLI = MessengerCLI;
-// ============================================================================
-// MAIN
-// ============================================================================
-const cli = new MessengerCLI();
-cli.start().catch(console.error);
-
-
-/***/ }),
-
-/***/ "./ship/implementation/SHIP_01.ts":
-/*!****************************************!*\
-  !*** ./ship/implementation/SHIP_01.ts ***!
-  \****************************************/
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* module decorator */ module = __webpack_require__.nmd(module);
-
-/**
- * Esempio Pratico: Messaggistica Decentralizzata con Shogun Core
- *
- * Questo esempio mostra come creare un sistema di messaggistica sicuro usando:
- * - Shogun Core per autenticazione (username/password)
- * - GunDB per storage decentralizzato P2P
- * - SEA (Security, Encryption, Authorization) per crittografia
- *
- * Vantaggi:
- * ✅ Completamente decentralizzato (no server centrale)
- * ✅ Zero costi (no blockchain, no gas fees)
- * ✅ Real-time messaging
- * ✅ Offline-first
- * ✅ End-to-end encryption
- *
- * Note sull'ERC7627:
- * L'EIP era un template concettuale. Questo esempio implementa
- * solo la parte GunDB/Shogun Core senza interazione blockchain.
- * La funzione deriveEthereumAddress() rimane come utility per derivare
- * un address Ethereum dalla chiave GunDB se necessario in futuro.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.SHIP_01 = void 0;
-const core_1 = __webpack_require__(/*! ../../src/core */ "./src/core.ts");
-const ethers_1 = __webpack_require__(/*! ethers */ "./node_modules/ethers/lib.commonjs/index.js");
-const derive_1 = __importDefault(__webpack_require__(/*! ../../src/gundb/derive */ "./src/gundb/derive.ts"));
-// ============================================================================
-// 1. SETUP: Inizializzazione del Sistema Completo
-// ============================================================================
-/**
- * Classe per messaggistica sicura con Shogun Core
- * Implementa l'interfaccia ISHIP_01
- * Usa solo GunDB per storage decentralizzato (no blockchain)
- */
-class SHIP_01 {
-    constructor(shogunConfig) {
-        // Inizializza Shogun Core
-        this.shogun = new core_1.ShogunCore(shogunConfig);
-    }
-    // ========================================================================
-    // 2. AUTENTICAZIONE: Username e Password
-    // ========================================================================
-    /**
-     * Registra un nuovo utente
-     */
-    async signup(username, password) {
-        try {
-            // Registra con Shogun Core (crea SEA pair automaticamente)
-            const signupResult = await this.shogun.signUp(username, password);
-            if (!signupResult.success) {
-                return {
-                    success: false,
-                    error: signupResult.error || "Signup failed",
-                };
-            }
-            console.log("✅ Utente registrato");
-            console.log(`   Username: ${username}`);
-            console.log(`   GunDB Public Key: ${signupResult.pub}`);
-            // Opzionale: deriva address Ethereum dalla chiave GunDB
-            const derivedAddress = signupResult.pub
-                ? await this.deriveEthereumAddress(signupResult.pub)
-                : undefined;
-            if (derivedAddress) {
-                console.log(`   Derived Address: ${derivedAddress}`);
-            }
-            return {
-                success: true,
-                userPub: signupResult.pub,
-                derivedAddress,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message,
-            };
-        }
-    }
-    /**
-     * Login con username e password
-     */
-    async login(username, password) {
-        try {
-            // Login con Shogun Core
-            const loginResult = await this.shogun.login(username, password);
-            if (!loginResult.success) {
-                return {
-                    success: false,
-                    error: loginResult.error || "Login failed",
-                };
-            }
-            console.log("✅ Login effettuato");
-            console.log(`   Username: ${username}`);
-            console.log(`   GunDB Public Key: ${loginResult.userPub}`);
-            // Opzionale: deriva address Ethereum dalla chiave GunDB
-            const derivedAddress = loginResult.userPub
-                ? await this.deriveEthereumAddress(loginResult.userPub)
-                : undefined;
-            if (derivedAddress) {
-                console.log(`   Derived Address: ${derivedAddress}`);
-            }
-            return {
-                success: true,
-                userPub: loginResult.userPub,
-                derivedAddress,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message,
-            };
-        }
-    }
-    /**
-     * Login con SEA Key Pair
-     *
-     * Autenticazione diretta usando un key pair esportato.
-     * Utile per:
-     * - Recupero account senza password
-     * - Portabilità tra dispositivi
-     * - Backup dell'identità
-     */
-    async loginWithPair(seaPair) {
-        try {
-            console.log("🔐 Login con key pair...");
-            // Autentica con GunDB usando il pair
-            const authResult = await new Promise((resolve) => {
-                this.shogun.db.gun.user().auth(seaPair, (ack) => {
-                    if (ack.err) {
-                        resolve({
-                            success: false,
-                            error: ack.err,
-                        });
-                    }
-                    else {
-                        resolve({
-                            success: true,
-                            userPub: seaPair.pub,
-                        });
-                    }
-                });
-            });
-            if (!authResult.success) {
-                console.log("❌ Login fallito:", authResult.error);
-                return authResult;
-            }
-            // Opzionale: deriva address Ethereum dalla chiave GunDB
-            const derivedAddress = await this.deriveEthereumAddress(seaPair.pub);
-            console.log("✅ Login effettuato");
-            console.log(`   GunDB Public Key: ${seaPair.pub}`);
-            console.log(`   Derived Address: ${derivedAddress}`);
-            return {
-                success: true,
-                userPub: authResult.userPub,
-                derivedAddress,
-            };
-        }
-        catch (error) {
-            console.error("❌ Errore login con pair:", error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : "Unknown error",
-            };
-        }
-    }
-    /**
-     * Logout
-     */
-    logout() {
-        this.shogun.logout();
-        console.log("👋 Logout effettuato");
-    }
-    /**
-     * Verifica se l'utente è autenticato
-     */
-    isLoggedIn() {
-        return this.shogun.isLoggedIn();
-    }
-    // ========================================================================
-    // 3. GESTIONE CHIAVI PUBBLICHE: Salva su GunDB
-    // ========================================================================
-    /**
-     * Salva la chiave pubblica dell'utente su GunDB
-     * Questo permette ad altri di trovare la tua chiave per criptare messaggi
-     */
-    async publishPublicKey() {
-        try {
-            if (!this.isLoggedIn()) {
-                return { success: false, error: "Not logged in" };
-            }
-            // Ottieni il SEA pair dell'utente corrente
-            const currentUser = this.shogun.db.user;
-            if (!currentUser || !currentUser.is) {
-                return { success: false, error: "No user session" };
-            }
-            // Salva chiave pubblica sul nodo globale usando il userPub come chiave
-            // Questo permette ad altri di trovarla facilmente
-            const userPub = currentUser.is.pub;
-            await this.shogun.db.gun
-                .get(userPub)
-                .put({
-                pub: currentUser.is.pub,
-                epub: currentUser.is.epub,
-                algorithm: "ECDSA",
-                timestamp: Date.now().toString(),
-            })
-                .then();
-            console.log(`📝 Chiave pubblica pubblicata su GunDB`);
-            return { success: true };
-        }
-        catch (error) {
-            console.error("❌ Errore pubblicazione chiave:", error);
-            return { success: false, error: error.message };
-        }
-    }
-    // ========================================================================
-    // 4. INVIO MESSAGGI: Solo GunDB
-    // ========================================================================
-    /**
-     * Invia un messaggio crittografato a un altro utente
-     */
-    async sendMessage(recipientUsername, message) {
-        try {
-            if (!this.isLoggedIn()) {
-                return { success: false, error: "Not logged in" };
-            }
-            const currentUser = this.shogun.db.user;
-            if (!currentUser || !currentUser.is) {
-                return { success: false, error: "No user session" };
-            }
-            // 1. Ottieni la chiave pubblica del destinatario
-            const recipientKey = await this.getRecipientPublicKey(recipientUsername);
-            if (!recipientKey) {
-                return {
-                    success: false,
-                    error: `Recipient ${recipientUsername} has not published their public key`,
-                };
-            }
-            // 2. Ottieni il SEA pair completo (include chiavi private)
-            const senderPair = this.shogun.db.gun.user()?._?.sea;
-            if (!senderPair) {
-                return { success: false, error: "Cannot access SEA pair" };
-            }
-            // 3. Cripta il messaggio usando SEA.secret + SEA.encrypt (ECDH)
-            const encryptedMessage = await this.shogun.db.crypto.encFor(message, senderPair, // sender pair completo
-            { epub: recipientKey.epub } // recipient public encryption key
-            );
-            // 4. Genera ID messaggio
-            const messageId = this.generateMessageId();
-            const senderPub = currentUser.is.pub;
-            // 5. Salva messaggio crittografato su GunDB
-            const messageData = {
-                from: senderPub,
-                to: recipientUsername,
-                content: encryptedMessage, // Contenuto crittografato!
-                timestamp: Date.now().toString(),
-                messageId: messageId,
-            };
-            // Salva sul nodo globale 'messages' per permettere il listener
-            await this.shogun.db.gun
-                .get(SHIP_01.NODES.MESSAGES)
-                .get(messageId)
-                .put(messageData)
-                .then();
-            console.log(`✅ Messaggio salvato: ${messageId}`);
-            return {
-                success: true,
-                messageId: messageId,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message,
-            };
-        }
-    }
-    /**
-     * Ottiene la chiave pubblica di un utente da GunDB
-     */
-    async getRecipientPublicKey(username) {
-        try {
-            // Prima trova l'utente dal username
-            const userData = await this.shogun.db.getUserByAlias(username);
-            if (!userData || !userData.userPub) {
-                console.error(`❌ User ${username} not found`);
-                return null;
-            }
-            const userPub = userData.userPub;
-            // Le chiavi sono salvate direttamente sul nodo userPub
-            const publicKeyData = await this.shogun.db.gun.get(userPub).then();
-            if (publicKeyData && publicKeyData.epub && publicKeyData.pub) {
-                return {
-                    pub: publicKeyData.pub,
-                    epub: publicKeyData.epub,
-                };
-            }
-            return null;
-        }
-        catch (error) {
-            console.error("❌ Errore recupero chiave pubblica:", error);
-            return null;
-        }
-    }
-    // ========================================================================
-    // 5. RICEZIONE MESSAGGI: Ascolta GunDB in real-time
-    // ========================================================================
-    /**
-     * Ascolta messaggi crittografati in arrivo su GunDB
-     */
-    async listenForMessages(onMessage) {
-        if (!this.isLoggedIn()) {
-            console.error("❌ Non autenticato");
-            return;
-        }
-        const currentUser = this.shogun.db.user;
-        if (!currentUser || !currentUser.is) {
-            console.error("❌ Nessuna sessione utente");
-            return;
-        }
-        const userPub = currentUser.is.pub;
-        // Ottieni username dell'utente corrente
-        const username = currentUser.is.alias;
-        // Set per tracciare messaggi già ricevuti (evita duplicati)
-        const receivedMessages = new Set();
-        // Ascolta messaggi in tempo reale su GunDB
-        this.shogun.db.gun
-            .get(SHIP_01.NODES.MESSAGES)
-            .map()
-            .on(async (data, key) => {
-            // Filtra solo i messaggi destinati a questo utente (per username)
-            if (data &&
-                data.to === username &&
-                data.from &&
-                data.content &&
-                data.messageId) {
-                // Evita duplicati (GunDB può emettere più volte)
-                if (receivedMessages.has(data.messageId)) {
-                    return;
-                }
-                receivedMessages.add(data.messageId);
-                try {
-                    // Decripta il messaggio
-                    const decryptedContent = await this.decryptMessage(data.content, data.from);
-                    onMessage({
-                        from: data.from,
-                        content: decryptedContent,
-                        timestamp: parseInt(data.timestamp),
-                    });
-                }
-                catch (error) {
-                    console.error("❌ Errore decrittazione messaggio:", error);
-                }
-            }
-        });
-        console.log(`👂 In ascolto di messaggi per ${username} (${userPub.substring(0, 10)}...)`);
-    }
-    /**
-     * Decripta un messaggio usando SEA.secret + SEA.decrypt (ECDH)
-     */
-    async decryptMessage(encryptedContent, senderPub) {
-        // Ottieni il SEA pair completo del destinatario (noi)
-        const receiverPair = this.shogun.db.gun.user()?._?.sea;
-        if (!receiverPair) {
-            throw new Error("Cannot access SEA pair");
-        }
-        // Ottieni epub del mittente
-        const senderKey = await this.getPublicKeyByPub(senderPub);
-        if (!senderKey) {
-            throw new Error("Sender public key not found");
-        }
-        // Decripta usando SEA.secret + SEA.decrypt (ECDH)
-        const decrypted = await this.shogun.db.crypto.decFrom(encryptedContent, { epub: senderKey.epub }, // sender's public encryption key
-        receiverPair // receiver's pair completo
-        );
-        return decrypted;
-    }
-    /**
-     * Ottiene la chiave pubblica di un utente dalla sua pub key
-     */
-    async getPublicKeyByPub(userPub) {
-        try {
-            // Le chiavi sono salvate direttamente sul nodo userPub
-            const publicKeyData = await this.shogun.db.gun.get(userPub).then();
-            if (publicKeyData && publicKeyData.epub && publicKeyData.pub) {
-                return {
-                    pub: publicKeyData.pub,
-                    epub: publicKeyData.epub,
-                };
-            }
-            return null;
-        }
-        catch (error) {
-            console.error("❌ Errore recupero chiave:", error);
-            return null;
-        }
-    }
-    // ========================================================================
-    // 6. RECUPERO STORICO: Query messaggi passati
-    // ========================================================================
-    /**
-     * Recupera lo storico dei messaggi crittografati con un utente
-     */
-    async getMessageHistory(withUsername) {
-        if (!this.isLoggedIn()) {
-            console.error("❌ Non autenticato");
-            return [];
-        }
-        const currentUser = this.shogun.db.user;
-        if (!currentUser || !currentUser.is) {
-            console.error("❌ Nessuna sessione utente");
-            return [];
-        }
-        const userPub = currentUser.is.pub;
-        const username = currentUser.is.alias;
-        const allMessages = [];
-        // Ottieni il userPub dell'altro utente
-        const otherUserData = await this.shogun.db.getUserByAlias(withUsername);
-        const otherUserPub = otherUserData?.userPub;
-        // Use .map() instead of .then() to iterate all messages
-        return new Promise((resolve) => {
-            const messages = [];
-            let messageCount = 0;
-            this.shogun.db.gun
-                .get(SHIP_01.NODES.MESSAGES)
-                .map()
-                .once(async (msgData, messageId) => {
-                // Skip metadata fields
-                if (!msgData || typeof msgData !== "object" || messageId === "_") {
-                    return;
-                }
-                messageCount++;
-                try {
-                    // Check if message is part of this conversation
-                    // Fixed: Handle both username and userPub in matching
-                    const isSentToTarget = msgData.from === userPub &&
-                        (msgData.to === withUsername || msgData.to === otherUserPub);
-                    const isReceivedFromTarget = (msgData.to === username || msgData.to === userPub) &&
-                        msgData.from === otherUserPub;
-                    if (isSentToTarget || isReceivedFromTarget) {
-                        // Decrypt message
-                        const decryptedContent = await this.decryptMessage(msgData.content, msgData.from);
-                        messages.push({
-                            from: msgData.from,
-                            to: msgData.to,
-                            content: decryptedContent,
-                            timestamp: parseInt(msgData.timestamp),
-                        });
-                    }
-                }
-                catch (error) {
-                    // Silent error - message couldn't be decrypted
-                }
-            });
-            // Wait a bit for GunDB to return all messages, then resolve
-            setTimeout(() => {
-                const sorted = messages.sort((a, b) => a.timestamp - b.timestamp);
-                resolve(sorted);
-            }, 2000);
-        });
-    }
-    // ========================================================================
-    // 7. UTILITY FUNCTIONS
-    // ========================================================================
-    /**
-     * Converte la chiave pubblica di GunDB in address Ethereum
-     * Usa la chiave privata SEA come seed per derivazione deterministica
-     *
-     * Questo garantisce che:
-     * - Stesso SEA pair → stesso address Ethereum
-     * - Derivazione cryptografica sicura
-     * - Identità unificata tra GunDB e blockchain
-     */
-    async deriveEthereumAddress(publicKey) {
-        try {
-            // Ottieni il SEA pair completo
-            const seaPair = this.shogun.db.gun.user()?._?.sea;
-            if (!seaPair || !seaPair.priv) {
-                throw new Error("Cannot access SEA pair");
-            }
-            // Usa la chiave privata SEA come seed per derive
-            // Questo è MOLTO più sicuro e deterministico del username!
-            const derived = await (0, derive_1.default)(seaPair.priv, null, {
-                includeSecp256k1Ethereum: true,
-                includeP256: false,
-                includeSecp256k1Bitcoin: false,
-            });
-            return derived.secp256k1Ethereum.address;
-        }
-        catch (error) {
-            console.error("❌ Errore derivazione address:", error);
-            // Fallback: hash della chiave pubblica
-            const fallbackKey = publicKey || "unknown";
-            const hash = ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(fallbackKey));
-            return ethers_1.ethers.getAddress("0x" + hash.slice(-40));
-        }
-    }
-    /**
-     * Genera ID messaggio univoco
-     */
-    generateMessageId() {
-        return ethers_1.ethers.hexlify(ethers_1.ethers.randomBytes(16));
-    }
-}
-exports.SHIP_01 = SHIP_01;
-// GunDB Node Names - Constants for clarity
-SHIP_01.NODES = {
-    MESSAGES: "messages",
-    USERS: "users",
-    PUBLIC_KEYS: "publicKeys",
-};
-async function testAliceAndBob() {
-    console.log("🧪 TEST: Alice e Bob - Conversazione Crittografata E2E\n");
-    console.log("=".repeat(60));
-    // Setup Alice
-    console.log("\n👩 ALICE - Setup");
-    console.log("-".repeat(60));
-    const alice = new SHIP_01({
-        gunOptions: {
-            peers: ["https://peer.wallie.io/gun"],
-            radisk: true,
-        },
-    });
-    // Alice signup/login
-    await alice.signup("alice", "password123");
-    const aliceLogin = await alice.login("alice", "password123");
-    if (!aliceLogin.success) {
-        console.error("❌ Alice login failed");
-        return;
-    }
-    await alice.publishPublicKey();
-    // Aspetta che la chiave sia sincronizzata
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    // Setup Bob
-    console.log("\n👨 BOB - Setup");
-    console.log("-".repeat(60));
-    const bob = new SHIP_01({
-        gunOptions: {
-            peers: ["https://peer.wallie.io/gun"],
-            radisk: true,
-        },
-    });
-    // Bob signup/login
-    await bob.signup("bob", "password456");
-    const bobLogin = await bob.login("bob", "password456");
-    if (!bobLogin.success) {
-        console.error("❌ Bob login failed");
-        return;
-    }
-    await bob.publishPublicKey();
-    // Aspetta che la chiave sia sincronizzata
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    console.log("\n" + "=".repeat(60));
-    console.log("💬 CONVERSAZIONE");
-    console.log("=".repeat(60));
-    // Alice e Bob ascoltano messaggi
-    let aliceMessages = [];
-    let bobMessages = [];
-    await alice.listenForMessages((msg) => {
-        aliceMessages.push(msg);
-        console.log(`\n[Alice riceve] 📨`);
-        console.log(`   Da: ${msg.from.substring(0, 10)}...`);
-        console.log(`   Messaggio: "${msg.content}"`);
-        console.log(`   Timestamp: ${new Date(msg.timestamp).toLocaleTimeString()}`);
-    });
-    await bob.listenForMessages((msg) => {
-        bobMessages.push(msg);
-        console.log(`\n[Bob riceve] 📨`);
-        console.log(`   Da: ${msg.from.substring(0, 10)}...`);
-        console.log(`   Messaggio: "${msg.content}"`);
-        console.log(`   Timestamp: ${new Date(msg.timestamp).toLocaleTimeString()}`);
-    });
-    // Aspetta che i listener siano pronti
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-    // Alice invia messaggio a Bob
-    console.log("\n[Alice invia] 📤");
-    const msg1 = await alice.sendMessage("bob", "Ciao Bob! Come stai? 👋");
-    console.log(`   ✅ Inviato: "${msg1.messageId}"`);
-    // Aspetta che Bob riceva
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-    // Bob risponde ad Alice
-    console.log("\n[Bob invia] 📤");
-    const msg2 = await bob.sendMessage("alice", "Ciao Alice! Tutto bene, grazie! Tu? 😊");
-    console.log(`   ✅ Inviato: "${msg2.messageId}"`);
-    // Aspetta che Alice riceva
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-    // Alice risponde
-    console.log("\n[Alice invia] 📤");
-    const msg3 = await alice.sendMessage("bob", "Anch'io benissimo! Questo sistema di messaggistica è fantastico! 🚀");
-    console.log(`   ✅ Inviato: "${msg3.messageId}"`);
-    // Aspetta che Bob riceva
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-    // Bob conclude
-    console.log("\n[Bob invia] 📤");
-    const msg4 = await bob.sendMessage("alice", "Vero! Zero costi, decentralizzato e veloce! 💪");
-    console.log(`   ✅ Inviato: "${msg4.messageId}"`);
-    // Aspetta finale
-    await new Promise((resolve) => setTimeout(resolve, 3000));
-    // Mostra statistiche
-    console.log("\n" + "=".repeat(60));
-    console.log("📊 STATISTICHE FINALI");
-    console.log("=".repeat(60));
-    console.log(`\n👩 Alice:`);
-    console.log(`   - Messaggi inviati: 2`);
-    console.log(`   - Messaggi ricevuti: ${aliceMessages.length}`);
-    console.log(`   - Public Key: ${aliceLogin.userPub?.substring(0, 20)}...`);
-    console.log(`   - Derived Address: ${aliceLogin.derivedAddress}`);
-    console.log(`\n👨 Bob:`);
-    console.log(`   - Messaggi inviati: 2`);
-    console.log(`   - Messaggi ricevuti: ${bobMessages.length}`);
-    console.log(`   - Public Key: ${bobLogin.userPub?.substring(0, 20)}...`);
-    console.log(`   - Derived Address: ${bobLogin.derivedAddress}`);
-    // Recupera storico
-    console.log("\n" + "=".repeat(60));
-    console.log("📚 STORICO CONVERSAZIONE");
-    console.log("=".repeat(60));
-    const aliceHistory = await alice.getMessageHistory("bob");
-    console.log(`\n👩 Storico di Alice con Bob (${aliceHistory.length} messaggi):`);
-    aliceHistory.forEach((msg, i) => {
-        const sender = msg.from === aliceLogin.userPub ? "Alice" : "Bob";
-        console.log(`   ${i + 1}. [${sender}]: ${msg.content}`);
-    });
-    const bobHistory = await bob.getMessageHistory("alice");
-    console.log(`\n👨 Storico di Bob con Alice (${bobHistory.length} messaggi):`);
-    bobHistory.forEach((msg, i) => {
-        const sender = msg.from === bobLogin.userPub ? "Bob" : "Alice";
-        console.log(`   ${i + 1}. [${sender}]: ${msg.content}`);
-    });
-    // Riepilogo finale
-    console.log("\n" + "=".repeat(60));
-    console.log("✅ TEST COMPLETATO CON SUCCESSO!");
-    console.log("=".repeat(60));
-    console.log("\n📝 Riepilogo:");
-    console.log("   ✅ 2 utenti registrati (Alice, Bob)");
-    console.log("   ✅ 4 messaggi scambiati");
-    console.log("   ✅ Messaggi ricevuti in real-time");
-    console.log("   ✅ Storico recuperato correttamente");
-    console.log("   ✅ Storage: GunDB P2P (gratis!)");
-    console.log("   ✅ Costi: $0.00");
-    console.log("\n🎉 Sistema di messaggistica decentralizzato funzionante!\n");
-}
-// Esegui esempio o test
-if (__webpack_require__.c[__webpack_require__.s] === module) {
-    testAliceAndBob().catch(console.error); // Test completo Alice & Bob
-}
-
-
 /***/ }),
 
 /***/ "./src/config/simplified-config.ts":
@@ -101524,11 +100767,16 @@ const CONFIG = {
     },
 };
 class DataBase {
-    constructor(gun, appScope = "shogun") {
+    constructor(gun, appScope = "shogun", options) {
         this.user = null;
         this.onAuthCallbacks = [];
+        this.disableAutoRecall = false;
+        this.silent = false;
         // Initialize event emitter
         this.eventEmitter = new eventEmitter_1.EventEmitter();
+        // Set options
+        this.disableAutoRecall = options?.disableAutoRecall || false;
+        this.silent = options?.silent || false;
         // Validate Gun instance
         if (!gun) {
             throw new Error("Gun instance is required but was not provided");
@@ -101546,7 +100794,18 @@ class DataBase {
             throw new Error(`Gun instance is invalid: gun.on is not a function. Received gun.on type: ${typeof gun.on}`);
         }
         this.gun = gun;
-        this.user = this.gun.user().recall({ sessionStorage: true });
+        // Recall only if NOT disabled and there's a "pair" in sessionStorage
+        if (!this.disableAutoRecall &&
+            typeof sessionStorage !== "undefined" &&
+            sessionStorage.getItem("pair")) {
+            this.user = this.gun.user().recall({ sessionStorage: true });
+        }
+        else {
+            if (!this.silent && !this.disableAutoRecall) {
+                console.log("No pair found in sessionStorage, using gun.user()");
+            }
+            this.user = this.gun.user();
+        }
         this.subscribeToAuthEvents();
         this.crypto = crypto;
         this.sea = sea_1.default;
@@ -101953,7 +101212,13 @@ class DataBase {
                 }
                 // Attempt to recall user session
                 try {
-                    const recallResult = userInstance.recall({ sessionStorage: true });
+                    if (typeof sessionStorage !== "undefined" &&
+                        sessionStorage.getItem("pair")) {
+                        const recallResult = userInstance.recall({ sessionStorage: true });
+                    }
+                    else {
+                        const recallResult = userInstance;
+                    }
                     // console.log("recallResult", recallResult);
                 }
                 catch (recallError) {
@@ -103150,9 +102415,15 @@ class DataBase {
     /**
      * Recall user session
      */
-    recall() {
+    recall(options) {
         if (this.user) {
-            this.user.recall({ sessionStorage: true });
+            if (typeof sessionStorage !== "undefined" &&
+                sessionStorage.getItem("pair")) {
+                this.user.recall({ sessionStorage: true });
+            }
+            else {
+                this.user;
+            }
         }
     }
     /**
@@ -103200,7 +102471,13 @@ class DataBase {
      */
     saveSession(session) {
         if (this.user) {
-            this.user.recall({ sessionStorage: true });
+            if (typeof sessionStorage !== "undefined" &&
+                sessionStorage.getItem("pair")) {
+                this.user.recall({ sessionStorage: true });
+            }
+            else {
+                this.user;
+            }
         }
     }
     /**
@@ -103208,7 +102485,13 @@ class DataBase {
      */
     loadSession() {
         if (this.user) {
-            return this.user.recall({ sessionStorage: true });
+            if (typeof sessionStorage !== "undefined" &&
+                sessionStorage.getItem("pair")) {
+                return this.user.recall({ sessionStorage: true });
+            }
+            else {
+                return this.user;
+            }
         }
         return null;
     }
@@ -103245,11 +102528,15 @@ class DataBase {
 exports.DataBase = DataBase;
 // Errors
 DataBase.Errors = GunErrors;
-const createGun = (config) => {
-    console.log("Creating Gun instance with config:", config);
-    console.log("Config peers:", config?.peers);
+const createGun = (config, silent) => {
+    if (!silent) {
+        console.log("Creating Gun instance with config:", config);
+        console.log("Config peers:", config?.peers);
+    }
     const gunInstance = (0, gun_1.default)(config);
-    console.log("Created Gun instance:", gunInstance);
+    if (!silent) {
+        console.log("Created Gun instance:", gunInstance);
+    }
     return gunInstance;
 };
 exports.createGun = createGun;
@@ -104121,7 +103408,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.autoQuickStart = exports.AutoQuickStart = exports.createSimpleAPI = exports.quickStart = exports.QuickStart = exports.SimpleGunAPI = exports.DataBase = exports.GunErrors = exports.derive = exports.crypto = exports.RxJS = exports.SEA = exports.ShogunCore = exports.Gun = exports.MessengerCLI = exports.SHIP_01 = void 0;
+exports.autoQuickStart = exports.AutoQuickStart = exports.createSimpleAPI = exports.quickStart = exports.QuickStart = exports.SimpleGunAPI = exports.DataBase = exports.GunErrors = exports.derive = exports.crypto = exports.RxJS = exports.SEA = exports.ShogunCore = exports.Gun = void 0;
 const core_1 = __webpack_require__(/*! ./core */ "./src/core.ts");
 Object.defineProperty(exports, "ShogunCore", ({ enumerable: true, get: function () { return core_1.ShogunCore; } }));
 const db_1 = __webpack_require__(/*! ./gundb/db */ "./src/gundb/db.ts");
@@ -104146,12 +103433,6 @@ __exportStar(__webpack_require__(/*! ./utils/errorHandler */ "./src/utils/errorH
 __exportStar(__webpack_require__(/*! ./plugins */ "./src/plugins/index.ts"), exports);
 __exportStar(__webpack_require__(/*! ./interfaces/shogun */ "./src/interfaces/shogun.ts"), exports);
 __exportStar(__webpack_require__(/*! ./config/simplified-config */ "./src/config/simplified-config.ts"), exports);
-var SHIP_01_1 = __webpack_require__(/*! ../ship/implementation/SHIP_01 */ "./ship/implementation/SHIP_01.ts");
-Object.defineProperty(exports, "SHIP_01", ({ enumerable: true, get: function () { return SHIP_01_1.SHIP_01; } }));
-// Export MessengerCLI only in Node.js environment (not browser)
-// This prevents "readline is not a function" errors in browser builds
-var messenger_cli_1 = __webpack_require__(/*! ../ship/examples/messenger-cli */ "./ship/examples/messenger-cli.ts");
-Object.defineProperty(exports, "MessengerCLI", ({ enumerable: true, get: function () { return messenger_cli_1.MessengerCLI; } }));
 
 
 /***/ }),
@@ -104536,7 +103817,7 @@ class CoreInitializer {
             };
         }
         // Initialize storage
-        this.core.storage = new storage_1.ShogunStorage();
+        this.core.storage = new storage_1.ShogunStorage(config.silent);
         // Setup error handler
         errorHandler_1.ErrorHandler.addListener((error) => {
             this.core.emit("error", {
@@ -104564,25 +103845,35 @@ class CoreInitializer {
      * Initialize Gun instance
      */
     async initializeGun(config) {
-        console.log("Initialize Gun instance", config);
+        if (!config.silent) {
+            console.log("Initialize Gun instance", config);
+        }
         try {
             if (config.gunInstance && config.gunOptions === undefined) {
-                console.log("Using provided Gun instance");
+                if (!config.silent) {
+                    console.log("Using provided Gun instance");
+                }
                 this.core._gun = config.gunInstance;
             }
             else if (config.gunOptions && config.gunInstance === undefined) {
-                console.log("Creating new Gun instance");
-                this.core._gun = (0, gundb_1.createGun)(config.gunOptions);
+                if (!config.silent) {
+                    console.log("Creating new Gun instance");
+                }
+                this.core._gun = (0, gundb_1.createGun)(config.gunOptions, config.silent);
             }
             else if (config.gunInstance && config.gunOptions) {
                 // Both provided, prefer gunInstance
-                console.log("Both gunInstance and gunOptions provided, using gunInstance");
+                if (!config.silent) {
+                    console.log("Both gunInstance and gunOptions provided, using gunInstance");
+                }
                 this.core._gun = config.gunInstance;
             }
             else {
                 // Neither provided, create a default Gun instance for testing
-                console.log("No Gun instance or options provided, creating default instance");
-                this.core._gun = (0, gundb_1.createGun)({ peers: config.gunOptions?.peers || [] });
+                if (!config.silent) {
+                    console.log("No Gun instance or options provided, creating default instance");
+                }
+                this.core._gun = (0, gundb_1.createGun)({ peers: config.gunOptions?.peers || [] }, config.silent);
             }
         }
         catch (error) {
@@ -104592,8 +103883,10 @@ class CoreInitializer {
             throw new Error(`Failed to create Gun instance: ${error}`);
         }
         try {
-            console.log("Initialize Gun instance", this.core.gun);
-            this.core.db = new gundb_1.DataBase(this.core._gun, config.gunOptions?.scope || "");
+            if (!config.silent) {
+                console.log("Initialize Gun instance", this.core.gun);
+            }
+            this.core.db = new gundb_1.DataBase(this.core._gun, config.gunOptions?.scope || "", { disableAutoRecall: config.disableAutoRecall, silent: config.silent });
             // Note: user is a getter that returns _user, so we don't need to assign it
         }
         catch (error) {
@@ -104608,7 +103901,15 @@ class CoreInitializer {
      */
     async initializeGunUser() {
         try {
-            this.core._user = this.core.gun.user().recall({ sessionStorage: true });
+            // Skip recall if disabled in config
+            if (!this.core.config.disableAutoRecall &&
+                typeof sessionStorage !== "undefined" &&
+                sessionStorage.getItem("pair")) {
+                this.core._user = this.core.gun.user().recall({ sessionStorage: true });
+            }
+            else {
+                this.core._user = this.core.gun.user();
+            }
         }
         catch (error) {
             if (typeof console !== "undefined" && console.error) {
@@ -104617,7 +103918,15 @@ class CoreInitializer {
             throw new Error(`Failed to initialize Gun user: ${error}`);
         }
         this.core.gun.on("auth", (user) => {
-            this.core._user = this.core.gun.user().recall({ sessionStorage: true });
+            // Skip recall if disabled in config
+            if (!this.core.config.disableAutoRecall &&
+                typeof sessionStorage !== "undefined" &&
+                sessionStorage.getItem("pair")) {
+                this.core._user = this.core.gun.user().recall({ sessionStorage: true });
+            }
+            else {
+                this.core._user = this.core.gun.user();
+            }
             this.core.emit("auth:login", {
                 userPub: user.pub,
                 method: "password",
@@ -104651,7 +103960,7 @@ class CoreInitializer {
      */
     setupWalletDerivation() {
         this.core.gun.on("auth", async (user) => {
-            if (!user)
+            if (!user.is)
                 return;
             const priv = user._?.sea?.epriv;
             const pub = user._?.sea?.epub;
@@ -110259,28 +109568,37 @@ class ShogunStorage {
     /**
      * Initializes storage and loads any existing keypair from localStorage if available
      */
-    constructor() {
+    constructor(silent = false) {
         this.store = new Map();
+        this.silent = silent;
         this.isTestMode = "development" === "test";
         this.useLocalStorage = false;
-        // Debug: log the environment
-        console.log("ShogunStorage: NODE_ENV =", "development");
-        console.log("ShogunStorage: isTestMode =", this.isTestMode);
+        // Debug: log the environment (only if not silent)
+        if (!this.silent) {
+            console.log("ShogunStorage: NODE_ENV =", "development");
+            console.log("ShogunStorage: isTestMode =", this.isTestMode);
+        }
         // In test mode, don't use localStorage to avoid test pollution
         if (this.isTestMode) {
             this.useLocalStorage = false;
-            console.log("ShogunStorage: Test mode detected, localStorage disabled");
+            if (!this.silent) {
+                console.log("ShogunStorage: Test mode detected, localStorage disabled");
+            }
             return;
         }
         if (typeof localStorage !== "undefined") {
-            console.log("ShogunStorage: localStorage is defined");
+            if (!this.silent) {
+                console.log("ShogunStorage: localStorage is defined");
+            }
             try {
                 // Probe localStorage without polluting expectations in tests
                 const testKey = "_shogun_test";
                 localStorage.setItem(testKey, testKey);
                 localStorage.removeItem(testKey);
                 this.useLocalStorage = true;
-                console.log("ShogunStorage: localStorage enabled");
+                if (!this.silent) {
+                    console.log("ShogunStorage: localStorage enabled");
+                }
                 const storedPair = localStorage.getItem("shogun_keypair");
                 if (storedPair) {
                     this.store.set("keypair", JSON.parse(storedPair));
@@ -110289,11 +109607,15 @@ class ShogunStorage {
             catch (error) {
                 this.useLocalStorage = false;
                 // Silence logs in tests; tests expect no console.error during constructor
-                console.log("ShogunStorage: localStorage error:", error.message);
+                if (!this.silent) {
+                    console.log("ShogunStorage: localStorage error:", error.message);
+                }
             }
         }
         else {
-            console.log("ShogunStorage: localStorage is undefined");
+            if (!this.silent) {
+                console.log("ShogunStorage: localStorage is undefined");
+            }
         }
     }
     /**
@@ -110946,43 +110268,7 @@ function generateDeterministicPassword(salt) {
 /******/ 		return module.exports;
 /******/ 	}
 /******/ 	
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__webpack_require__.m = __webpack_modules__;
-/******/ 	
-/******/ 	// expose the module cache
-/******/ 	__webpack_require__.c = __webpack_module_cache__;
-/******/ 	
 /************************************************************************/
-/******/ 	/* webpack/runtime/create fake namespace object */
-/******/ 	(() => {
-/******/ 		var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);
-/******/ 		var leafPrototypes;
-/******/ 		// create a fake namespace object
-/******/ 		// mode & 1: value is a module id, require it
-/******/ 		// mode & 2: merge all properties of value into the ns
-/******/ 		// mode & 4: return value when already ns object
-/******/ 		// mode & 16: return value when it's Promise-like
-/******/ 		// mode & 8|1: behave like require
-/******/ 		__webpack_require__.t = function(value, mode) {
-/******/ 			if(mode & 1) value = this(value);
-/******/ 			if(mode & 8) return value;
-/******/ 			if(typeof value === 'object' && value) {
-/******/ 				if((mode & 4) && value.__esModule) return value;
-/******/ 				if((mode & 16) && typeof value.then === 'function') return value;
-/******/ 			}
-/******/ 			var ns = Object.create(null);
-/******/ 			__webpack_require__.r(ns);
-/******/ 			var def = {};
-/******/ 			leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
-/******/ 			for(var current = mode & 2 && value; (typeof current == 'object' || typeof current == 'function') && !~leafPrototypes.indexOf(current); current = getProto(current)) {
-/******/ 				Object.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));
-/******/ 			}
-/******/ 			def['default'] = () => (value);
-/******/ 			__webpack_require__.d(ns, def);
-/******/ 			return ns;
-/******/ 		};
-/******/ 	})();
-/******/ 	
 /******/ 	/* webpack/runtime/define property getters */
 /******/ 	(() => {
 /******/ 		// define getter functions for harmony exports
@@ -110995,28 +110281,6 @@ function generateDeterministicPassword(salt) {
 /******/ 		};
 /******/ 	})();
 /******/ 	
-/******/ 	/* webpack/runtime/ensure chunk */
-/******/ 	(() => {
-/******/ 		__webpack_require__.f = {};
-/******/ 		// This file contains only the entry chunk.
-/******/ 		// The chunk loading function for additional chunks
-/******/ 		__webpack_require__.e = (chunkId) => {
-/******/ 			return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {
-/******/ 				__webpack_require__.f[key](chunkId, promises);
-/******/ 				return promises;
-/******/ 			}, []));
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/get javascript chunk filename */
-/******/ 	(() => {
-/******/ 		// This function allow to reference async chunks
-/******/ 		__webpack_require__.u = (chunkId) => {
-/******/ 			// return url for filenames based on template
-/******/ 			return "" + chunkId + ".shogun-core.js";
-/******/ 		};
-/******/ 	})();
-/******/ 	
 /******/ 	/* webpack/runtime/global */
 /******/ 	(() => {
 /******/ 		__webpack_require__.g = (function() {
@@ -111034,52 +110298,6 @@ function generateDeterministicPassword(salt) {
 /******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
 /******/ 	})();
 /******/ 	
-/******/ 	/* webpack/runtime/load script */
-/******/ 	(() => {
-/******/ 		var inProgress = {};
-/******/ 		var dataWebpackPrefix = "ShogunCore:";
-/******/ 		// loadScript function to load a script via script tag
-/******/ 		__webpack_require__.l = (url, done, key, chunkId) => {
-/******/ 			if(inProgress[url]) { inProgress[url].push(done); return; }
-/******/ 			var script, needAttach;
-/******/ 			if(key !== undefined) {
-/******/ 				var scripts = document.getElementsByTagName("script");
-/******/ 				for(var i = 0; i < scripts.length; i++) {
-/******/ 					var s = scripts[i];
-/******/ 					if(s.getAttribute("src") == url || s.getAttribute("data-webpack") == dataWebpackPrefix + key) { script = s; break; }
-/******/ 				}
-/******/ 			}
-/******/ 			if(!script) {
-/******/ 				needAttach = true;
-/******/ 				script = document.createElement('script');
-/******/ 		
-/******/ 				script.charset = 'utf-8';
-/******/ 				script.timeout = 120;
-/******/ 				if (__webpack_require__.nc) {
-/******/ 					script.setAttribute("nonce", __webpack_require__.nc);
-/******/ 				}
-/******/ 				script.setAttribute("data-webpack", dataWebpackPrefix + key);
-/******/ 		
-/******/ 				script.src = url;
-/******/ 			}
-/******/ 			inProgress[url] = [done];
-/******/ 			var onScriptComplete = (prev, event) => {
-/******/ 				// avoid mem leaks in IE.
-/******/ 				script.onerror = script.onload = null;
-/******/ 				clearTimeout(timeout);
-/******/ 				var doneFns = inProgress[url];
-/******/ 				delete inProgress[url];
-/******/ 				script.parentNode && script.parentNode.removeChild(script);
-/******/ 				doneFns && doneFns.forEach((fn) => (fn(event)));
-/******/ 				if(prev) return prev(event);
-/******/ 			}
-/******/ 			var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);
-/******/ 			script.onerror = onScriptComplete.bind(null, script.onerror);
-/******/ 			script.onload = onScriptComplete.bind(null, script.onload);
-/******/ 			needAttach && document.head.appendChild(script);
-/******/ 		};
-/******/ 	})();
-/******/ 	
 /******/ 	/* webpack/runtime/make namespace object */
 /******/ 	(() => {
 /******/ 		// define __esModule on exports
@@ -111100,125 +110318,12 @@ function generateDeterministicPassword(salt) {
 /******/ 		};
 /******/ 	})();
 /******/ 	
-/******/ 	/* webpack/runtime/publicPath */
-/******/ 	(() => {
-/******/ 		var scriptUrl;
-/******/ 		if (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + "";
-/******/ 		var document = __webpack_require__.g.document;
-/******/ 		if (!scriptUrl && document) {
-/******/ 			if (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT')
-/******/ 				scriptUrl = document.currentScript.src;
-/******/ 			if (!scriptUrl) {
-/******/ 				var scripts = document.getElementsByTagName("script");
-/******/ 				if(scripts.length) {
-/******/ 					var i = scripts.length - 1;
-/******/ 					while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;
-/******/ 				}
-/******/ 			}
-/******/ 		}
-/******/ 		// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration
-/******/ 		// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.
-/******/ 		if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
-/******/ 		scriptUrl = scriptUrl.replace(/^blob:/, "").replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
-/******/ 		__webpack_require__.p = scriptUrl;
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/jsonp chunk loading */
-/******/ 	(() => {
-/******/ 		// no baseURI
-/******/ 		
-/******/ 		// object to store loaded and loading chunks
-/******/ 		// undefined = chunk not loaded, null = chunk preloaded/prefetched
-/******/ 		// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
-/******/ 		var installedChunks = {
-/******/ 			"main": 0
-/******/ 		};
-/******/ 		
-/******/ 		__webpack_require__.f.j = (chunkId, promises) => {
-/******/ 				// JSONP chunk loading for javascript
-/******/ 				var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;
-/******/ 				if(installedChunkData !== 0) { // 0 means "already installed".
-/******/ 		
-/******/ 					// a Promise means "currently loading".
-/******/ 					if(installedChunkData) {
-/******/ 						promises.push(installedChunkData[2]);
-/******/ 					} else {
-/******/ 						if(true) { // all chunks have JS
-/******/ 							// setup Promise in chunk cache
-/******/ 							var promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));
-/******/ 							promises.push(installedChunkData[2] = promise);
-/******/ 		
-/******/ 							// start chunk loading
-/******/ 							var url = __webpack_require__.p + __webpack_require__.u(chunkId);
-/******/ 							// create error before stack unwound to get useful stacktrace later
-/******/ 							var error = new Error();
-/******/ 							var loadingEnded = (event) => {
-/******/ 								if(__webpack_require__.o(installedChunks, chunkId)) {
-/******/ 									installedChunkData = installedChunks[chunkId];
-/******/ 									if(installedChunkData !== 0) installedChunks[chunkId] = undefined;
-/******/ 									if(installedChunkData) {
-/******/ 										var errorType = event && (event.type === 'load' ? 'missing' : event.type);
-/******/ 										var realSrc = event && event.target && event.target.src;
-/******/ 										error.message = 'Loading chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')';
-/******/ 										error.name = 'ChunkLoadError';
-/******/ 										error.type = errorType;
-/******/ 										error.request = realSrc;
-/******/ 										installedChunkData[1](error);
-/******/ 									}
-/******/ 								}
-/******/ 							};
-/******/ 							__webpack_require__.l(url, loadingEnded, "chunk-" + chunkId, chunkId);
-/******/ 						}
-/******/ 					}
-/******/ 				}
-/******/ 		};
-/******/ 		
-/******/ 		// no prefetching
-/******/ 		
-/******/ 		// no preloaded
-/******/ 		
-/******/ 		// no HMR
-/******/ 		
-/******/ 		// no HMR manifest
-/******/ 		
-/******/ 		// no on chunks loaded
-/******/ 		
-/******/ 		// install a JSONP callback for chunk loading
-/******/ 		var webpackJsonpCallback = (parentChunkLoadingFunction, data) => {
-/******/ 			var [chunkIds, moreModules, runtime] = data;
-/******/ 			// add "moreModules" to the modules object,
-/******/ 			// then flag all "chunkIds" as loaded and fire callback
-/******/ 			var moduleId, chunkId, i = 0;
-/******/ 			if(chunkIds.some((id) => (installedChunks[id] !== 0))) {
-/******/ 				for(moduleId in moreModules) {
-/******/ 					if(__webpack_require__.o(moreModules, moduleId)) {
-/******/ 						__webpack_require__.m[moduleId] = moreModules[moduleId];
-/******/ 					}
-/******/ 				}
-/******/ 				if(runtime) var result = runtime(__webpack_require__);
-/******/ 			}
-/******/ 			if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
-/******/ 			for(;i < chunkIds.length; i++) {
-/******/ 				chunkId = chunkIds[i];
-/******/ 				if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
-/******/ 					installedChunks[chunkId][0]();
-/******/ 				}
-/******/ 				installedChunks[chunkId] = 0;
-/******/ 			}
-/******/ 		
-/******/ 		}
-/******/ 		
-/******/ 		var chunkLoadingGlobal = this["webpackChunkShogunCore"] = this["webpackChunkShogunCore"] || [];
-/******/ 		chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
-/******/ 		chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
-/******/ 	})();
-/******/ 	
 /************************************************************************/
 /******/ 	
-/******/ 	// module cache are used so entry inlining is disabled
 /******/ 	// startup
 /******/ 	// Load entry module and return exports
-/******/ 	var __webpack_exports__ = __webpack_require__(__webpack_require__.s = "./src/index.ts");
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__("./src/index.ts");
 /******/ 	
 /******/ 	return __webpack_exports__;
 /******/ })()