@waku/rln 0.1.3-f6d5deb → 0.1.4-0e49a1e.0

package/bundle/packages/rln/node_modules/@noble/hashes/sha512.js

@@ -0,0 +1,243 @@
+import { __exports as sha512 } from '../../../../../_virtual/sha512.js';
+import './_sha2.js';
+import './_u64.js';
+import './utils.js';
+import { __exports as _sha2 } from '../../../../../_virtual/_sha2.js';
+import { __exports as _u64 } from '../../../../../_virtual/_u64.js';
+import { __exports as utils } from '../../../../../_virtual/utils.js';
+
+Object.defineProperty(sha512, "__esModule", { value: true });
+sha512.sha384 = sha512.sha512_256 = sha512.sha512_224 = sha512.sha512 = sha512.SHA512 = undefined;
+const _sha2_js_1 = _sha2;
+const _u64_js_1 = _u64;
+const utils_js_1 = utils;
+// Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):
+// prettier-ignore
+const [SHA512_Kh, SHA512_Kl] = _u64_js_1.default.split([
+    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',
+    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',
+    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',
+    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',
+    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',
+    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',
+    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',
+    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',
+    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',
+    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',
+    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',
+    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',
+    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',
+    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',
+    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',
+    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',
+    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',
+    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',
+    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',
+    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'
+].map(n => BigInt(n)));
+// Temporary buffer, not used to store anything between runs
+const SHA512_W_H = new Uint32Array(80);
+const SHA512_W_L = new Uint32Array(80);
+class SHA512 extends _sha2_js_1.SHA2 {
+    constructor() {
+        super(128, 64, 16, false);
+        // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.
+        // Also looks cleaner and easier to verify with spec.
+        // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
+        // h -- high 32 bits, l -- low 32 bits
+        this.Ah = 0x6a09e667 | 0;
+        this.Al = 0xf3bcc908 | 0;
+        this.Bh = 0xbb67ae85 | 0;
+        this.Bl = 0x84caa73b | 0;
+        this.Ch = 0x3c6ef372 | 0;
+        this.Cl = 0xfe94f82b | 0;
+        this.Dh = 0xa54ff53a | 0;
+        this.Dl = 0x5f1d36f1 | 0;
+        this.Eh = 0x510e527f | 0;
+        this.El = 0xade682d1 | 0;
+        this.Fh = 0x9b05688c | 0;
+        this.Fl = 0x2b3e6c1f | 0;
+        this.Gh = 0x1f83d9ab | 0;
+        this.Gl = 0xfb41bd6b | 0;
+        this.Hh = 0x5be0cd19 | 0;
+        this.Hl = 0x137e2179 | 0;
+    }
+    // prettier-ignore
+    get() {
+        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+    }
+    // prettier-ignore
+    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+        this.Ah = Ah | 0;
+        this.Al = Al | 0;
+        this.Bh = Bh | 0;
+        this.Bl = Bl | 0;
+        this.Ch = Ch | 0;
+        this.Cl = Cl | 0;
+        this.Dh = Dh | 0;
+        this.Dl = Dl | 0;
+        this.Eh = Eh | 0;
+        this.El = El | 0;
+        this.Fh = Fh | 0;
+        this.Fl = Fl | 0;
+        this.Gh = Gh | 0;
+        this.Gl = Gl | 0;
+        this.Hh = Hh | 0;
+        this.Hl = Hl | 0;
+    }
+    process(view, offset) {
+        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array
+        for (let i = 0; i < 16; i++, offset += 4) {
+            SHA512_W_H[i] = view.getUint32(offset);
+            SHA512_W_L[i] = view.getUint32((offset += 4));
+        }
+        for (let i = 16; i < 80; i++) {
+            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
+            const W15h = SHA512_W_H[i - 15] | 0;
+            const W15l = SHA512_W_L[i - 15] | 0;
+            const s0h = _u64_js_1.default.rotrSH(W15h, W15l, 1) ^ _u64_js_1.default.rotrSH(W15h, W15l, 8) ^ _u64_js_1.default.shrSH(W15h, W15l, 7);
+            const s0l = _u64_js_1.default.rotrSL(W15h, W15l, 1) ^ _u64_js_1.default.rotrSL(W15h, W15l, 8) ^ _u64_js_1.default.shrSL(W15h, W15l, 7);
+            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)
+            const W2h = SHA512_W_H[i - 2] | 0;
+            const W2l = SHA512_W_L[i - 2] | 0;
+            const s1h = _u64_js_1.default.rotrSH(W2h, W2l, 19) ^ _u64_js_1.default.rotrBH(W2h, W2l, 61) ^ _u64_js_1.default.shrSH(W2h, W2l, 6);
+            const s1l = _u64_js_1.default.rotrSL(W2h, W2l, 19) ^ _u64_js_1.default.rotrBL(W2h, W2l, 61) ^ _u64_js_1.default.shrSL(W2h, W2l, 6);
+            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];
+            const SUMl = _u64_js_1.default.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+            const SUMh = _u64_js_1.default.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+            SHA512_W_H[i] = SUMh | 0;
+            SHA512_W_L[i] = SUMl | 0;
+        }
+        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+        // Compression function main loop, 80 rounds
+        for (let i = 0; i < 80; i++) {
+            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)
+            const sigma1h = _u64_js_1.default.rotrSH(Eh, El, 14) ^ _u64_js_1.default.rotrSH(Eh, El, 18) ^ _u64_js_1.default.rotrBH(Eh, El, 41);
+            const sigma1l = _u64_js_1.default.rotrSL(Eh, El, 14) ^ _u64_js_1.default.rotrSL(Eh, El, 18) ^ _u64_js_1.default.rotrBL(Eh, El, 41);
+            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+            const CHIh = (Eh & Fh) ^ (~Eh & Gh);
+            const CHIl = (El & Fl) ^ (~El & Gl);
+            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]
+            // prettier-ignore
+            const T1ll = _u64_js_1.default.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+            const T1h = _u64_js_1.default.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+            const T1l = T1ll | 0;
+            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
+            const sigma0h = _u64_js_1.default.rotrSH(Ah, Al, 28) ^ _u64_js_1.default.rotrBH(Ah, Al, 34) ^ _u64_js_1.default.rotrBH(Ah, Al, 39);
+            const sigma0l = _u64_js_1.default.rotrSL(Ah, Al, 28) ^ _u64_js_1.default.rotrBL(Ah, Al, 34) ^ _u64_js_1.default.rotrBL(Ah, Al, 39);
+            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);
+            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);
+            Hh = Gh | 0;
+            Hl = Gl | 0;
+            Gh = Fh | 0;
+            Gl = Fl | 0;
+            Fh = Eh | 0;
+            Fl = El | 0;
+            ({ h: Eh, l: El } = _u64_js_1.default.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+            Dh = Ch | 0;
+            Dl = Cl | 0;
+            Ch = Bh | 0;
+            Cl = Bl | 0;
+            Bh = Ah | 0;
+            Bl = Al | 0;
+            const All = _u64_js_1.default.add3L(T1l, sigma0l, MAJl);
+            Ah = _u64_js_1.default.add3H(All, T1h, sigma0h, MAJh);
+            Al = All | 0;
+        }
+        // Add the compressed chunk to the current hash value
+        ({ h: Ah, l: Al } = _u64_js_1.default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+        ({ h: Bh, l: Bl } = _u64_js_1.default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+        ({ h: Ch, l: Cl } = _u64_js_1.default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+        ({ h: Dh, l: Dl } = _u64_js_1.default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+        ({ h: Eh, l: El } = _u64_js_1.default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+        ({ h: Fh, l: Fl } = _u64_js_1.default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+        ({ h: Gh, l: Gl } = _u64_js_1.default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+        ({ h: Hh, l: Hl } = _u64_js_1.default.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+    }
+    roundClean() {
+        SHA512_W_H.fill(0);
+        SHA512_W_L.fill(0);
+    }
+    destroy() {
+        this.buffer.fill(0);
+        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    }
+}
+sha512.SHA512 = SHA512;
+class SHA512_224 extends SHA512 {
+    constructor() {
+        super();
+        // h -- high 32 bits, l -- low 32 bits
+        this.Ah = 0x8c3d37c8 | 0;
+        this.Al = 0x19544da2 | 0;
+        this.Bh = 0x73e19966 | 0;
+        this.Bl = 0x89dcd4d6 | 0;
+        this.Ch = 0x1dfab7ae | 0;
+        this.Cl = 0x32ff9c82 | 0;
+        this.Dh = 0x679dd514 | 0;
+        this.Dl = 0x582f9fcf | 0;
+        this.Eh = 0x0f6d2b69 | 0;
+        this.El = 0x7bd44da8 | 0;
+        this.Fh = 0x77e36f73 | 0;
+        this.Fl = 0x04c48942 | 0;
+        this.Gh = 0x3f9d85a8 | 0;
+        this.Gl = 0x6a1d36c8 | 0;
+        this.Hh = 0x1112e6ad | 0;
+        this.Hl = 0x91d692a1 | 0;
+        this.outputLen = 28;
+    }
+}
+class SHA512_256 extends SHA512 {
+    constructor() {
+        super();
+        // h -- high 32 bits, l -- low 32 bits
+        this.Ah = 0x22312194 | 0;
+        this.Al = 0xfc2bf72c | 0;
+        this.Bh = 0x9f555fa3 | 0;
+        this.Bl = 0xc84c64c2 | 0;
+        this.Ch = 0x2393b86b | 0;
+        this.Cl = 0x6f53b151 | 0;
+        this.Dh = 0x96387719 | 0;
+        this.Dl = 0x5940eabd | 0;
+        this.Eh = 0x96283ee2 | 0;
+        this.El = 0xa88effe3 | 0;
+        this.Fh = 0xbe5e1e25 | 0;
+        this.Fl = 0x53863992 | 0;
+        this.Gh = 0x2b0199fc | 0;
+        this.Gl = 0x2c85b8aa | 0;
+        this.Hh = 0x0eb72ddc | 0;
+        this.Hl = 0x81c52ca2 | 0;
+        this.outputLen = 32;
+    }
+}
+class SHA384 extends SHA512 {
+    constructor() {
+        super();
+        // h -- high 32 bits, l -- low 32 bits
+        this.Ah = 0xcbbb9d5d | 0;
+        this.Al = 0xc1059ed8 | 0;
+        this.Bh = 0x629a292a | 0;
+        this.Bl = 0x367cd507 | 0;
+        this.Ch = 0x9159015a | 0;
+        this.Cl = 0x3070dd17 | 0;
+        this.Dh = 0x152fecd8 | 0;
+        this.Dl = 0xf70e5939 | 0;
+        this.Eh = 0x67332667 | 0;
+        this.El = 0xffc00b31 | 0;
+        this.Fh = 0x8eb44a87 | 0;
+        this.Fl = 0x68581511 | 0;
+        this.Gh = 0xdb0c2e0d | 0;
+        this.Gl = 0x64f98fa7 | 0;
+        this.Hh = 0x47b5481d | 0;
+        this.Hl = 0xbefa4fa4 | 0;
+        this.outputLen = 48;
+    }
+}
+sha512.sha512 = (0, utils_js_1.wrapConstructor)(() => new SHA512());
+sha512.sha512_224 = (0, utils_js_1.wrapConstructor)(() => new SHA512_224());
+sha512.sha512_256 = (0, utils_js_1.wrapConstructor)(() => new SHA512_256());
+sha512.sha384 = (0, utils_js_1.wrapConstructor)(() => new SHA384());
+
+export { sha512 as default };

package/bundle/packages/rln/node_modules/@noble/hashes/utils.js

@@ -0,0 +1,167 @@
+import { __exports as utils } from '../../../../../_virtual/utils.js';
+import './cryptoBrowser.js';
+import { __exports as cryptoBrowser } from '../../../../../_virtual/cryptoBrowser.js';
+
+(function (exports) {
+	/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.randomBytes = 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 = undefined;
+	// The import here is via the package name. This is to ensure
+	// that exports mapping/resolution does fall into place.
+	const crypto_1 = cryptoBrowser;
+	// 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;
+	exports.isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
+	// There is almost no big endian hardware, but js typed arrays uses platform specific endianness.
+	// So, just to be sure not to corrupt anything.
+	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([0xde, 0xad, 0xbe, 0xef]))
+	 */
+	function bytesToHex(uint8a) {
+	    // pre-caching improves the speed 6x
+	    if (!(uint8a instanceof Uint8Array))
+	        throw new Error('Uint8Array expected');
+	    let hex = '';
+	    for (let i = 0; i < uint8a.length; i++) {
+	        hex += hexes[uint8a[i]];
+	    }
+	    return hex;
+	}
+	exports.bytesToHex = bytesToHex;
+	/**
+	 * @example hexToBytes('deadbeef')
+	 */
+	function hexToBytes(hex) {
+	    if (typeof hex !== 'string') {
+	        throw new TypeError('hexToBytes: expected string, got ' + typeof hex);
+	    }
+	    if (hex.length % 2)
+	        throw new Error('hexToBytes: received invalid unpadded hex');
+	    const array = new Uint8Array(hex.length / 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. However, call to async function 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;
+	function utf8ToBytes(str) {
+	    if (typeof str !== 'string') {
+	        throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);
+	    }
+	    return new TextEncoder().encode(str);
+	}
+	exports.utf8ToBytes = utf8ToBytes;
+	function toBytes(data) {
+	    if (typeof data === 'string')
+	        data = utf8ToBytes(data);
+	    if (!(data instanceof Uint8Array))
+	        throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);
+	    return data;
+	}
+	exports.toBytes = toBytes;
+	/**
+	 * Concats Uint8Array-s into one; like `Buffer.concat([buf1, buf2])`
+	 * @example concatBytes(buf1, buf2)
+	 */
+	function concatBytes(...arrays) {
+	    if (!arrays.every((a) => a instanceof Uint8Array))
+	        throw new Error('Uint8Array list expected');
+	    if (arrays.length === 1)
+	        return arrays[0];
+	    const length = arrays.reduce((a, arr) => a + arr.length, 0);
+	    const result = new Uint8Array(length);
+	    for (let i = 0, pad = 0; i < arrays.length; i++) {
+	        const arr = arrays[i];
+	        result.set(arr, pad);
+	        pad += arr.length;
+	    }
+	    return result;
+	}
+	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 TypeError('Options should be object or undefined');
+	    const merged = Object.assign(defaults, opts);
+	    return merged;
+	}
+	exports.checkOpts = checkOpts;
+	function wrapConstructor(hashConstructor) {
+	    const hashC = (message) => hashConstructor().update(toBytes(message)).digest();
+	    const tmp = hashConstructor();
+	    hashC.outputLen = tmp.outputLen;
+	    hashC.blockLen = tmp.blockLen;
+	    hashC.create = () => hashConstructor();
+	    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;
+	/**
+	 * Secure PRNG
+	 */
+	function randomBytes(bytesLength = 32) {
+	    if (crypto_1.crypto.web) {
+	        return crypto_1.crypto.web.getRandomValues(new Uint8Array(bytesLength));
+	    }
+	    else if (crypto_1.crypto.node) {
+	        return new Uint8Array(crypto_1.crypto.node.randomBytes(bytesLength).buffer);
+	    }
+	    else {
+	        throw new Error("The environment doesn't have randomBytes function");
+	    }
+	}
+	exports.randomBytes = randomBytes;
+	
+} (utils));

package/bundle/packages/rln/node_modules/uuid/dist/esm-browser/native.js

@@ -0,0 +1,4 @@
+const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native = { randomUUID };
+
+export { native as default };

package/bundle/packages/rln/node_modules/uuid/dist/esm-browser/rng.js

@@ -0,0 +1,13 @@
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+    if (!getRandomValues) {
+        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
+            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+        }
+        getRandomValues = crypto.getRandomValues.bind(crypto);
+    }
+    return getRandomValues(rnds8);
+}
+
+export { rng as default };

package/bundle/packages/rln/node_modules/uuid/dist/esm-browser/stringify.js

@@ -0,0 +1,28 @@
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+    byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+    return (byteToHex[arr[offset + 0]] +
+        byteToHex[arr[offset + 1]] +
+        byteToHex[arr[offset + 2]] +
+        byteToHex[arr[offset + 3]] +
+        '-' +
+        byteToHex[arr[offset + 4]] +
+        byteToHex[arr[offset + 5]] +
+        '-' +
+        byteToHex[arr[offset + 6]] +
+        byteToHex[arr[offset + 7]] +
+        '-' +
+        byteToHex[arr[offset + 8]] +
+        byteToHex[arr[offset + 9]] +
+        '-' +
+        byteToHex[arr[offset + 10]] +
+        byteToHex[arr[offset + 11]] +
+        byteToHex[arr[offset + 12]] +
+        byteToHex[arr[offset + 13]] +
+        byteToHex[arr[offset + 14]] +
+        byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+export { unsafeStringify };

package/bundle/packages/rln/node_modules/uuid/dist/esm-browser/v4.js

@@ -0,0 +1,19 @@
+import native from './native.js';
+import rng from './rng.js';
+import { unsafeStringify } from './stringify.js';
+
+function v4(options, buf, offset) {
+    if (native.randomUUID && true && !options) {
+        return native.randomUUID();
+    }
+    options = options || {};
+    const rnds = options.random ?? options.rng?.() ?? rng();
+    if (rnds.length < 16) {
+        throw new Error('Random bytes length must be >= 16');
+    }
+    rnds[6] = (rnds[6] & 0x0f) | 0x40;
+    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+    return unsafeStringify(rnds);
+}
+
+export { v4 as default };

package/bundle/packages/utils/dist/bytes/index.js

@@ -0,0 +1,44 @@
+import { fromString } from '../../../../node_modules/uint8arrays/dist/src/from-string.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base10.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base16.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base2.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base256emoji.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base32.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base36.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base58.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base64.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base8.js';
+import '../../../../node_modules/multiformats/dist/src/bases/identity.js';
+import '../../../../node_modules/multiformats/dist/src/codecs/json.js';
+
+/**
+ * Convert input to a byte array.
+ *
+ * Handles both `0x` prefixed and non-prefixed strings.
+ */
+function hexToBytes(hex) {
+    if (typeof hex === "string") {
+        const _hex = hex.replace(/^0x/i, "");
+        return fromString(_hex.toLowerCase(), "base16");
+    }
+    return hex;
+}
+/**
+ * Encode utf-8 string to byte array.
+ */
+const utf8ToBytes = (s) => fromString(s, "utf8");
+/**
+ * Concatenate using Uint8Arrays as `Buffer` has a different behavior with `DataView`
+ */
+function concat(byteArrays, totalLength) {
+    const len = byteArrays.reduce((acc, curr) => acc + curr.length, 0);
+    const res = new Uint8Array(len);
+    let offset = 0;
+    for (const bytes of byteArrays) {
+        res.set(bytes, offset);
+        offset += bytes.length;
+    }
+    return res;
+}
+
+export { concat, hexToBytes, utf8ToBytes };

package/bundle/packages/utils/dist/common/sharding/index.js

@@ -0,0 +1,91 @@
+import { sha256 } from '../../../../../node_modules/@noble/hashes/esm/sha256.js';
+import '../../../../interfaces/dist/protocols.js';
+import '../../../../interfaces/dist/connection_manager.js';
+import { DEFAULT_CLUSTER_ID } from '../../../../interfaces/dist/constants.js';
+import '../../../../interfaces/dist/health_indicator.js';
+import { concat, utf8ToBytes } from '../../bytes/index.js';
+
+const singleShardInfoToPubsubTopic = (shardInfo) => {
+    if (shardInfo.shard === undefined)
+        throw new Error("Invalid shard");
+    return `/waku/2/rs/${shardInfo.clusterId ?? DEFAULT_CLUSTER_ID}/${shardInfo.shard}`;
+};
+/**
+ * Given a string, will throw an error if it is not formatted as a valid content topic for autosharding based on https://rfc.vac.dev/spec/51/
+ * @param contentTopic String to validate
+ * @returns Object with each content topic field as an attribute
+ */
+function ensureValidContentTopic(contentTopic) {
+    const parts = contentTopic.split("/");
+    if (parts.length < 5 || parts.length > 6) {
+        throw Error("Content topic format is invalid");
+    }
+    // Validate generation field if present
+    let generation = 0;
+    if (parts.length == 6) {
+        generation = parseInt(parts[1]);
+        if (isNaN(generation)) {
+            throw new Error("Invalid generation field in content topic");
+        }
+        if (generation > 0) {
+            throw new Error("Generation greater than 0 is not supported");
+        }
+    }
+    // Validate remaining fields
+    const fields = parts.splice(-4);
+    // Validate application field
+    if (fields[0].length == 0) {
+        throw new Error("Application field cannot be empty");
+    }
+    // Validate version field
+    if (fields[1].length == 0) {
+        throw new Error("Version field cannot be empty");
+    }
+    // Validate topic name field
+    if (fields[2].length == 0) {
+        throw new Error("Topic name field cannot be empty");
+    }
+    // Validate encoding field
+    if (fields[3].length == 0) {
+        throw new Error("Encoding field cannot be empty");
+    }
+    return {
+        generation,
+        application: fields[0],
+        version: fields[1],
+        topicName: fields[2],
+        encoding: fields[3]
+    };
+}
+/**
+ * Given a string, determines which autoshard index to use for its pubsub topic.
+ * Based on the algorithm described in the RFC: https://rfc.vac.dev/spec/51//#algorithm
+ */
+function contentTopicToShardIndex(contentTopic, networkShards = 8) {
+    const { application, version } = ensureValidContentTopic(contentTopic);
+    const digest = sha256(concat([utf8ToBytes(application), utf8ToBytes(version)]));
+    const dataview = new DataView(digest.buffer.slice(-8));
+    return Number(dataview.getBigUint64(0, false) % BigInt(networkShards));
+}
+function contentTopicToPubsubTopic(contentTopic, clusterId = DEFAULT_CLUSTER_ID, networkShards = 8) {
+    if (!contentTopic) {
+        throw Error("Content topic must be specified");
+    }
+    const shardIndex = contentTopicToShardIndex(contentTopic, networkShards);
+    return `/waku/2/rs/${clusterId}/${shardIndex}`;
+}
+/**
+ * Used when creating encoders/decoders to determine which pubsub topic to use
+ */
+function determinePubsubTopic(contentTopic, 
+// TODO: make it accept ShardInfo https://github.com/waku-org/js-waku/issues/2086
+pubsubTopicShardInfo) {
+    if (typeof pubsubTopicShardInfo == "string") {
+        return pubsubTopicShardInfo;
+    }
+    return pubsubTopicShardInfo?.shard !== undefined
+        ? singleShardInfoToPubsubTopic(pubsubTopicShardInfo)
+        : contentTopicToPubsubTopic(contentTopic, pubsubTopicShardInfo?.clusterId ?? DEFAULT_CLUSTER_ID);
+}
+
+export { contentTopicToPubsubTopic, contentTopicToShardIndex, determinePubsubTopic, ensureValidContentTopic, singleShardInfoToPubsubTopic };

package/bundle/packages/utils/dist/logger/index.js

@@ -0,0 +1,31 @@
+import debug from '../../../../node_modules/debug/src/browser.js';
+
+const APP_NAME = "waku";
+class Logger {
+    _info;
+    _warn;
+    _error;
+    static createDebugNamespace(level, prefix) {
+        return prefix ? `${APP_NAME}:${level}:${prefix}` : `${APP_NAME}:${level}`;
+    }
+    constructor(prefix) {
+        this._info = debug(Logger.createDebugNamespace("info", prefix));
+        this._warn = debug(Logger.createDebugNamespace("warn", prefix));
+        this._error = debug(Logger.createDebugNamespace("error", prefix));
+    }
+    get info() {
+        return this._info;
+    }
+    get warn() {
+        return this._warn;
+    }
+    get error() {
+        return this._error;
+    }
+    log(level, ...args) {
+        const logger = this[level];
+        logger(...args);
+    }
+}
+
+export { Logger };

package/bundle/resources/verification_key.d.ts

@@ -0,0 +1,13 @@
+declare const verificationKey: {
+  protocol: string;
+  curve: string;
+  nPublic: number;
+  vk_alpha_1: string[];
+  vk_beta_2: string[][];
+  vk_gamma_2: string[][];
+  vk_delta_2: string[][];
+  vk_alphabeta_12: string[][][];
+  IC: string[][];
+};
+
+export default verificationKey;