@waku/rln 0.0.1 → 0.0.2-c41b319.0

package/bundle/node_modules/@noble/hashes/esm/utils.js

@@ -0,0 +1,144 @@
+import { abytes } from './_assert.js';
+
+/**
+ * Utilities for hex, bytes, CSPRNG.
+ * @module
+ */
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// 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 (2025-04-30), we can just drop the import.
+function u32(arr) {
+    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+// Cast array to view
+function createView(arr) {
+    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** The rotate right (circular right shift) operation for uint32 */
+function rotr(word, shift) {
+    return (word << (32 - shift)) | (word >>> shift);
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
+// The byte swap operation for uint32
+function byteSwap(word) {
+    return (((word << 24) & 0xff000000) |
+        ((word << 8) & 0xff0000) |
+        ((word >>> 8) & 0xff00) |
+        ((word >>> 24) & 0xff));
+}
+/** In place byte swap for Uint32Array */
+function byteSwap32(arr) {
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = byteSwap(arr[i]);
+    }
+}
+// Array where index 0xf0 (240) is mapped to string 'f0'
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+/**
+ * Convert byte array to hex string.
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+function bytesToHex(bytes) {
+    abytes(bytes);
+    // pre-caching improves the speed 6x
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += hexes[bytes[i]];
+    }
+    return hex;
+}
+// We use optimized technique to convert hex string to byte array
+const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function asciiToBase16(ch) {
+    if (ch >= asciis._0 && ch <= asciis._9)
+        return ch - asciis._0; // '2' => 50-48
+    if (ch >= asciis.A && ch <= asciis.F)
+        return ch - (asciis.A - 10); // 'B' => 66-(65-10)
+    if (ch >= asciis.a && ch <= asciis.f)
+        return ch - (asciis.a - 10); // 'b' => 98-(97-10)
+    return;
+}
+/**
+ * Convert hex string to byte array.
+ * @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 hl = hex.length;
+    const al = hl / 2;
+    if (hl % 2)
+        throw new Error('hex string expected, got unpadded hex of length ' + hl);
+    const array = new Uint8Array(al);
+    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+        const n1 = asciiToBase16(hex.charCodeAt(hi));
+        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+        if (n1 === undefined || n2 === undefined) {
+            const char = hex[hi] + hex[hi + 1];
+            throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+        }
+        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
+    }
+    return array;
+}
+/**
+ * Convert JS string to byte array.
+ * @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
+}
+/**
+ * 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);
+    abytes(data);
+    return data;
+}
+/**
+ * Copies several Uint8Arrays into one.
+ */
+function concatBytes(...arrays) {
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        abytes(a);
+        sum += a.length;
+    }
+    const res = new Uint8Array(sum);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        res.set(a, pad);
+        pad += a.length;
+    }
+    return res;
+}
+/** For runtime check if class implements interface */
+class Hash {
+    // Safe version that clones internal state
+    clone() {
+        return this._cloneInto();
+    }
+}
+/** Wraps hash function, creating an interface on top of it */
+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;
+}
+
+export { Hash, byteSwap, byteSwap32, bytesToHex, concatBytes, createView, hexToBytes, isLE, rotr, toBytes, u32, utf8ToBytes, wrapConstructor };

package/bundle/node_modules/@stablelib/binary/lib/binary.js

@@ -0,0 +1,22 @@
+// Copyright (C) 2016 Dmitry Chestnykh
+// MIT License. See LICENSE file for details.
+/**
+ * Package binary provides functions for encoding and decoding numbers in byte arrays.
+ */
+/**
+ * Writes 4-byte little-endian representation of 32-bit unsigned
+ * value to array starting at offset.
+ *
+ * If byte array is not given, creates a new 4-byte one.
+ *
+ * Returns the output byte array.
+ */
+function writeUint32LE(value, out = new Uint8Array(4), offset = 0) {
+    out[offset + 0] = value >>> 0;
+    out[offset + 1] = value >>> 8;
+    out[offset + 2] = value >>> 16;
+    out[offset + 3] = value >>> 24;
+    return out;
+}
+
+export { writeUint32LE };

package/bundle/node_modules/@stablelib/chacha/lib/chacha.js

@@ -0,0 +1,245 @@
+import { writeUint32LE } from '../../binary/lib/binary.js';
+import { wipe } from '../../wipe/lib/wipe.js';
+
+// Copyright (C) 2016 Dmitry Chestnykh
+// MIT License. See LICENSE file for details.
+/**
+ * Package chacha implements ChaCha stream cipher.
+ */
+// Number of ChaCha rounds (ChaCha20).
+const ROUNDS = 20;
+// Applies the ChaCha core function to 16-byte input,
+// 32-byte key key, and puts the result into 64-byte array out.
+function core(out, input, key) {
+    let j0 = 0x61707865; // "expa"  -- ChaCha's "sigma" constant
+    let j1 = 0x3320646E; // "nd 3"     for 32-byte keys
+    let j2 = 0x79622D32; // "2-by"
+    let j3 = 0x6B206574; // "te k"
+    let j4 = (key[3] << 24) | (key[2] << 16) | (key[1] << 8) | key[0];
+    let j5 = (key[7] << 24) | (key[6] << 16) | (key[5] << 8) | key[4];
+    let j6 = (key[11] << 24) | (key[10] << 16) | (key[9] << 8) | key[8];
+    let j7 = (key[15] << 24) | (key[14] << 16) | (key[13] << 8) | key[12];
+    let j8 = (key[19] << 24) | (key[18] << 16) | (key[17] << 8) | key[16];
+    let j9 = (key[23] << 24) | (key[22] << 16) | (key[21] << 8) | key[20];
+    let j10 = (key[27] << 24) | (key[26] << 16) | (key[25] << 8) | key[24];
+    let j11 = (key[31] << 24) | (key[30] << 16) | (key[29] << 8) | key[28];
+    let j12 = (input[3] << 24) | (input[2] << 16) | (input[1] << 8) | input[0];
+    let j13 = (input[7] << 24) | (input[6] << 16) | (input[5] << 8) | input[4];
+    let j14 = (input[11] << 24) | (input[10] << 16) | (input[9] << 8) | input[8];
+    let j15 = (input[15] << 24) | (input[14] << 16) | (input[13] << 8) | input[12];
+    let x0 = j0;
+    let x1 = j1;
+    let x2 = j2;
+    let x3 = j3;
+    let x4 = j4;
+    let x5 = j5;
+    let x6 = j6;
+    let x7 = j7;
+    let x8 = j8;
+    let x9 = j9;
+    let x10 = j10;
+    let x11 = j11;
+    let x12 = j12;
+    let x13 = j13;
+    let x14 = j14;
+    let x15 = j15;
+    for (let i = 0; i < ROUNDS; i += 2) {
+        x0 = x0 + x4 | 0;
+        x12 ^= x0;
+        x12 = x12 >>> (32 - 16) | x12 << 16;
+        x8 = x8 + x12 | 0;
+        x4 ^= x8;
+        x4 = x4 >>> (32 - 12) | x4 << 12;
+        x1 = x1 + x5 | 0;
+        x13 ^= x1;
+        x13 = x13 >>> (32 - 16) | x13 << 16;
+        x9 = x9 + x13 | 0;
+        x5 ^= x9;
+        x5 = x5 >>> (32 - 12) | x5 << 12;
+        x2 = x2 + x6 | 0;
+        x14 ^= x2;
+        x14 = x14 >>> (32 - 16) | x14 << 16;
+        x10 = x10 + x14 | 0;
+        x6 ^= x10;
+        x6 = x6 >>> (32 - 12) | x6 << 12;
+        x3 = x3 + x7 | 0;
+        x15 ^= x3;
+        x15 = x15 >>> (32 - 16) | x15 << 16;
+        x11 = x11 + x15 | 0;
+        x7 ^= x11;
+        x7 = x7 >>> (32 - 12) | x7 << 12;
+        x2 = x2 + x6 | 0;
+        x14 ^= x2;
+        x14 = x14 >>> (32 - 8) | x14 << 8;
+        x10 = x10 + x14 | 0;
+        x6 ^= x10;
+        x6 = x6 >>> (32 - 7) | x6 << 7;
+        x3 = x3 + x7 | 0;
+        x15 ^= x3;
+        x15 = x15 >>> (32 - 8) | x15 << 8;
+        x11 = x11 + x15 | 0;
+        x7 ^= x11;
+        x7 = x7 >>> (32 - 7) | x7 << 7;
+        x1 = x1 + x5 | 0;
+        x13 ^= x1;
+        x13 = x13 >>> (32 - 8) | x13 << 8;
+        x9 = x9 + x13 | 0;
+        x5 ^= x9;
+        x5 = x5 >>> (32 - 7) | x5 << 7;
+        x0 = x0 + x4 | 0;
+        x12 ^= x0;
+        x12 = x12 >>> (32 - 8) | x12 << 8;
+        x8 = x8 + x12 | 0;
+        x4 ^= x8;
+        x4 = x4 >>> (32 - 7) | x4 << 7;
+        x0 = x0 + x5 | 0;
+        x15 ^= x0;
+        x15 = x15 >>> (32 - 16) | x15 << 16;
+        x10 = x10 + x15 | 0;
+        x5 ^= x10;
+        x5 = x5 >>> (32 - 12) | x5 << 12;
+        x1 = x1 + x6 | 0;
+        x12 ^= x1;
+        x12 = x12 >>> (32 - 16) | x12 << 16;
+        x11 = x11 + x12 | 0;
+        x6 ^= x11;
+        x6 = x6 >>> (32 - 12) | x6 << 12;
+        x2 = x2 + x7 | 0;
+        x13 ^= x2;
+        x13 = x13 >>> (32 - 16) | x13 << 16;
+        x8 = x8 + x13 | 0;
+        x7 ^= x8;
+        x7 = x7 >>> (32 - 12) | x7 << 12;
+        x3 = x3 + x4 | 0;
+        x14 ^= x3;
+        x14 = x14 >>> (32 - 16) | x14 << 16;
+        x9 = x9 + x14 | 0;
+        x4 ^= x9;
+        x4 = x4 >>> (32 - 12) | x4 << 12;
+        x2 = x2 + x7 | 0;
+        x13 ^= x2;
+        x13 = x13 >>> (32 - 8) | x13 << 8;
+        x8 = x8 + x13 | 0;
+        x7 ^= x8;
+        x7 = x7 >>> (32 - 7) | x7 << 7;
+        x3 = x3 + x4 | 0;
+        x14 ^= x3;
+        x14 = x14 >>> (32 - 8) | x14 << 8;
+        x9 = x9 + x14 | 0;
+        x4 ^= x9;
+        x4 = x4 >>> (32 - 7) | x4 << 7;
+        x1 = x1 + x6 | 0;
+        x12 ^= x1;
+        x12 = x12 >>> (32 - 8) | x12 << 8;
+        x11 = x11 + x12 | 0;
+        x6 ^= x11;
+        x6 = x6 >>> (32 - 7) | x6 << 7;
+        x0 = x0 + x5 | 0;
+        x15 ^= x0;
+        x15 = x15 >>> (32 - 8) | x15 << 8;
+        x10 = x10 + x15 | 0;
+        x5 ^= x10;
+        x5 = x5 >>> (32 - 7) | x5 << 7;
+    }
+    writeUint32LE(x0 + j0 | 0, out, 0);
+    writeUint32LE(x1 + j1 | 0, out, 4);
+    writeUint32LE(x2 + j2 | 0, out, 8);
+    writeUint32LE(x3 + j3 | 0, out, 12);
+    writeUint32LE(x4 + j4 | 0, out, 16);
+    writeUint32LE(x5 + j5 | 0, out, 20);
+    writeUint32LE(x6 + j6 | 0, out, 24);
+    writeUint32LE(x7 + j7 | 0, out, 28);
+    writeUint32LE(x8 + j8 | 0, out, 32);
+    writeUint32LE(x9 + j9 | 0, out, 36);
+    writeUint32LE(x10 + j10 | 0, out, 40);
+    writeUint32LE(x11 + j11 | 0, out, 44);
+    writeUint32LE(x12 + j12 | 0, out, 48);
+    writeUint32LE(x13 + j13 | 0, out, 52);
+    writeUint32LE(x14 + j14 | 0, out, 56);
+    writeUint32LE(x15 + j15 | 0, out, 60);
+}
+/**
+ * Encrypt src with ChaCha20 stream generated for the given 32-byte key and
+ * 8-byte (as in original implementation) or 12-byte (as in RFC7539) nonce and
+ * write the result into dst and return it.
+ *
+ * dst and src may be the same, but otherwise must not overlap.
+ *
+ * If nonce is 12 bytes, users should not encrypt more than 256 GiB with the
+ * same key and nonce, otherwise the stream will repeat. The function will
+ * throw error if counter overflows to prevent this.
+ *
+ * If nonce is 8 bytes, the output is practically unlimited (2^70 bytes, which
+ * is more than a million petabytes). However, it is not recommended to
+ * generate 8-byte nonces randomly, as the chance of collision is high.
+ *
+ * Never use the same key and nonce to encrypt more than one message.
+ *
+ * If nonceInplaceCounterLength is not 0, the nonce is assumed to be a 16-byte
+ * array with stream counter in first nonceInplaceCounterLength bytes and nonce
+ * in the last remaining bytes. The counter will be incremented inplace for
+ * each ChaCha block. This is useful if you need to encrypt one stream of data
+ * in chunks.
+ */
+function streamXOR(key, nonce, src, dst, nonceInplaceCounterLength = 0) {
+    // We only support 256-bit keys.
+    if (key.length !== 32) {
+        throw new Error("ChaCha: key size must be 32 bytes");
+    }
+    if (dst.length < src.length) {
+        throw new Error("ChaCha: destination is shorter than source");
+    }
+    let nc;
+    let counterLength;
+    if (nonceInplaceCounterLength === 0) {
+        if (nonce.length !== 8 && nonce.length !== 12) {
+            throw new Error("ChaCha nonce must be 8 or 12 bytes");
+        }
+        nc = new Uint8Array(16);
+        // First counterLength bytes of nc are counter, starting with zero.
+        counterLength = nc.length - nonce.length;
+        // Last bytes of nc after counterLength are nonce, set them.
+        nc.set(nonce, counterLength);
+    }
+    else {
+        if (nonce.length !== 16) {
+            throw new Error("ChaCha nonce with counter must be 16 bytes");
+        }
+        // This will update passed nonce with counter inplace.
+        nc = nonce;
+        counterLength = nonceInplaceCounterLength;
+    }
+    // Allocate temporary space for ChaCha block.
+    const block = new Uint8Array(64);
+    for (let i = 0; i < src.length; i += 64) {
+        // Generate a block.
+        core(block, nc, key);
+        // XOR block bytes with src into dst.
+        for (let j = i; j < i + 64 && j < src.length; j++) {
+            dst[j] = src[j] ^ block[j - i];
+        }
+        // Increment counter.
+        incrementCounter(nc, 0, counterLength);
+    }
+    // Cleanup temporary space.
+    wipe(block);
+    if (nonceInplaceCounterLength === 0) {
+        // Cleanup counter.
+        wipe(nc);
+    }
+    return dst;
+}
+function incrementCounter(counter, pos, len) {
+    let carry = 1;
+    while (len--) {
+        carry = carry + (counter[pos] & 0xff) | 0;
+        counter[pos] = carry & 0xff;
+        carry >>>= 8;
+        pos++;
+    }
+    if (carry > 0) {
+        throw new Error("ChaCha: counter overflow");
+    }
+}
+
+export { streamXOR };

package/bundle/node_modules/@stablelib/wipe/lib/wipe.js

@@ -0,0 +1,26 @@
+// Copyright (C) 2016 Dmitry Chestnykh
+// MIT License. See LICENSE file for details.
+/**
+ * Sets all values in the given array to zero and returns it.
+ *
+ * The fact that it sets bytes to zero can be relied on.
+ *
+ * There is no guarantee that this function makes data disappear from memory,
+ * as runtime implementation can, for example, have copying garbage collector
+ * that will make copies of sensitive data before we wipe it. Or that an
+ * operating system will write our data to swap or sleep image. Another thing
+ * is that an optimizing compiler can remove calls to this function or make it
+ * no-op. There's nothing we can do with it, so we just do our best and hope
+ * that everything will be okay and good will triumph over evil.
+ */
+function wipe(array) {
+    // Right now it's similar to array.fill(0). If it turns
+    // out that runtimes optimize this call away, maybe
+    // we can try something else.
+    for (let i = 0; i < array.length; i++) {
+        array[i] = 0;
+    }
+    return array;
+}
+
+export { wipe };