@waku/rln 0.1.3-f6d5deb → 0.1.4-29a4c3f.0

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/lib/schema-validation.js

@@ -0,0 +1,40 @@
+import { __exports as schemaValidation } from '../../../../../../_virtual/schema-validation.js';
+import './schema-validation-generated.js';
+import { __exports as schemaValidationGenerated } from '../../../../../../_virtual/schema-validation-generated.js';
+
+Object.defineProperty(schemaValidation, "__esModule", { value: true });
+schemaValidation.isValidKeystore = schemaValidation.validateKeystore = schemaValidation.schemaValidationErrors = undefined;
+const schema_validation_generated_1 = schemaValidationGenerated;
+// Redeclare generated function with the proper type
+const _validateKeystore = schema_validation_generated_1.Keystore;
+/**
+ * Return schema validation errors for a potential keystore object
+ */
+// This function wraps the generated code weirdness
+function schemaValidationErrors(data) {
+    const validated = _validateKeystore(data);
+    if (validated) {
+        return null;
+    }
+    return _validateKeystore.errors;
+}
+schemaValidation.schemaValidationErrors = schemaValidationErrors;
+/**
+ * Validate an unknown object as a valid keystore, throws on invalid keystore
+ */
+function validateKeystore(keystore) {
+    const errors = schemaValidationErrors(keystore);
+    if (errors) {
+        throw new Error(errors.map((error) => `${error.instancePath}: ${error.message}`).join('\n'));
+    }
+}
+schemaValidation.validateKeystore = validateKeystore;
+/**
+ * Predicate for validating an unknown object as a valid keystore
+ */
+function isValidKeystore(keystore) {
+    return !schemaValidationErrors(keystore);
+}
+schemaValidation.isValidKeystore = isValidKeystore;
+
+export { schemaValidation as default };

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/lib/types.js

@@ -0,0 +1,5 @@
+import { __exports as types } from '../../../../../../_virtual/types.js';
+
+Object.defineProperty(types, "__esModule", { value: true });
+
+export { types as default };

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/ethereum-cryptography/aes.js

@@ -0,0 +1,103 @@
+import { __exports as aes } from '../../../../../../../_virtual/aes.js';
+import '../../../../@noble/hashes/cryptoBrowser.js';
+import { u as utilsExports } from './utils.js';
+import { __exports as cryptoBrowser } from '../../../../../../../_virtual/cryptoBrowser.js';
+
+Object.defineProperty(aes, "__esModule", { value: true });
+aes.decrypt = aes.encrypt = undefined;
+const crypto_1 = cryptoBrowser;
+const utils_1 = utilsExports;
+function validateOpt(key, iv, mode) {
+    if (!mode.startsWith("aes-")) {
+        throw new Error(`AES submodule doesn't support mode ${mode}`);
+    }
+    if (iv.length !== 16) {
+        throw new Error("AES: wrong IV length");
+    }
+    if ((mode.startsWith("aes-128") && key.length !== 16) ||
+        (mode.startsWith("aes-256") && key.length !== 32)) {
+        throw new Error("AES: wrong key length");
+    }
+}
+async function getBrowserKey(mode, key, iv) {
+    if (!crypto_1.crypto.web) {
+        throw new Error("Browser crypto not available.");
+    }
+    let keyMode;
+    if (["aes-128-cbc", "aes-256-cbc"].includes(mode)) {
+        keyMode = "cbc";
+    }
+    if (["aes-128-ctr", "aes-256-ctr"].includes(mode)) {
+        keyMode = "ctr";
+    }
+    if (!keyMode) {
+        throw new Error("AES: unsupported mode");
+    }
+    const wKey = await crypto_1.crypto.web.subtle.importKey("raw", key, { name: `AES-${keyMode.toUpperCase()}`, length: key.length * 8 }, true, ["encrypt", "decrypt"]);
+    // node.js uses whole 128 bit as a counter, without nonce, instead of 64 bit
+    // recommended by NIST SP800-38A
+    return [wKey, { name: `aes-${keyMode}`, iv, counter: iv, length: 128 }];
+}
+async function encrypt(msg, key, iv, mode = "aes-128-ctr", pkcs7PaddingEnabled = true) {
+    validateOpt(key, iv, mode);
+    if (crypto_1.crypto.web) {
+        const [wKey, wOpt] = await getBrowserKey(mode, key, iv);
+        const cipher = await crypto_1.crypto.web.subtle.encrypt(wOpt, wKey, msg);
+        // Remove PKCS7 padding on cbc mode by stripping end of message
+        let res = new Uint8Array(cipher);
+        if (!pkcs7PaddingEnabled && wOpt.name === "aes-cbc" && !(msg.length % 16)) {
+            res = res.slice(0, -16);
+        }
+        return res;
+    }
+    else if (crypto_1.crypto.node) {
+        const cipher = crypto_1.crypto.node.createCipheriv(mode, key, iv);
+        cipher.setAutoPadding(pkcs7PaddingEnabled);
+        return (0, utils_1.concatBytes)(cipher.update(msg), cipher.final());
+    }
+    else {
+        throw new Error("The environment doesn't have AES module");
+    }
+}
+aes.encrypt = encrypt;
+async function getPadding(cypherText, key, iv, mode) {
+    const lastBlock = cypherText.slice(-16);
+    for (let i = 0; i < 16; i++) {
+        // Undo xor of iv and fill with lastBlock ^ padding (16)
+        lastBlock[i] ^= iv[i] ^ 16;
+    }
+    const res = await encrypt(lastBlock, key, iv, mode);
+    return res.slice(0, 16);
+}
+async function decrypt(cypherText, key, iv, mode = "aes-128-ctr", pkcs7PaddingEnabled = true) {
+    validateOpt(key, iv, mode);
+    if (crypto_1.crypto.web) {
+        const [wKey, wOpt] = await getBrowserKey(mode, key, iv);
+        // Add empty padding so Chrome will correctly decrypt message
+        if (!pkcs7PaddingEnabled && wOpt.name === "aes-cbc") {
+            const padding = await getPadding(cypherText, key, iv, mode);
+            cypherText = (0, utils_1.concatBytes)(cypherText, padding);
+        }
+        const msg = await crypto_1.crypto.web.subtle.decrypt(wOpt, wKey, cypherText);
+        const msgBytes = new Uint8Array(msg);
+        // Safari always ignores padding (if no padding -> broken message)
+        if (wOpt.name === "aes-cbc") {
+            const encrypted = await encrypt(msgBytes, key, iv, mode);
+            if (!(0, utils_1.equalsBytes)(encrypted, cypherText)) {
+                throw new Error("AES: wrong padding");
+            }
+        }
+        return msgBytes;
+    }
+    else if (crypto_1.crypto.node) {
+        const decipher = crypto_1.crypto.node.createDecipheriv(mode, key, iv);
+        decipher.setAutoPadding(pkcs7PaddingEnabled);
+        return (0, utils_1.concatBytes)(decipher.update(cypherText), decipher.final());
+    }
+    else {
+        throw new Error("The environment doesn't have AES module");
+    }
+}
+aes.decrypt = decrypt;
+
+export { aes as default };

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/ethereum-cryptography/pbkdf2.js

@@ -0,0 +1,41 @@
+import { __exports as pbkdf2$1 } from '../../../../../../../_virtual/pbkdf2.js';
+import '../../../../@noble/hashes/pbkdf2.js';
+import '../../../../@noble/hashes/sha256.js';
+import '../../../../@noble/hashes/sha512.js';
+import { u as utilsExports } from './utils.js';
+import { __exports as pbkdf2$2 } from '../../../../../../../_virtual/pbkdf22.js';
+import { __exports as sha256 } from '../../../../../../../_virtual/sha2562.js';
+import { __exports as sha512 } from '../../../../../../../_virtual/sha512.js';
+
+Object.defineProperty(pbkdf2$1, "__esModule", { value: true });
+pbkdf2$1.pbkdf2Sync = pbkdf2$1.pbkdf2 = undefined;
+const pbkdf2_1 = pbkdf2$2;
+const sha256_1 = sha256;
+const sha512_1 = sha512;
+const utils_1 = utilsExports;
+async function pbkdf2(password, salt, iterations, keylen, digest) {
+    if (!["sha256", "sha512"].includes(digest)) {
+        throw new Error("Only sha256 and sha512 are supported");
+    }
+    (0, utils_1.assertBytes)(password);
+    (0, utils_1.assertBytes)(salt);
+    return (0, pbkdf2_1.pbkdf2Async)(digest === "sha256" ? sha256_1.sha256 : sha512_1.sha512, password, salt, {
+        c: iterations,
+        dkLen: keylen
+    });
+}
+pbkdf2$1.pbkdf2 = pbkdf2;
+function pbkdf2Sync(password, salt, iterations, keylen, digest) {
+    if (!["sha256", "sha512"].includes(digest)) {
+        throw new Error("Only sha256 and sha512 are supported");
+    }
+    (0, utils_1.assertBytes)(password);
+    (0, utils_1.assertBytes)(salt);
+    return (0, pbkdf2_1.pbkdf2)(digest === "sha256" ? sha256_1.sha256 : sha512_1.sha512, password, salt, {
+        c: iterations,
+        dkLen: keylen
+    });
+}
+pbkdf2$1.pbkdf2Sync = pbkdf2Sync;
+
+export { pbkdf2$1 as default };

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/ethereum-cryptography/random.js

@@ -0,0 +1,17 @@
+import { __exports as random } from '../../../../../../../_virtual/random.js';
+import '../../../../@noble/hashes/utils.js';
+import { __exports as utils } from '../../../../../../../_virtual/utils.js';
+
+Object.defineProperty(random, "__esModule", { value: true });
+random.getRandomBytes = random.getRandomBytesSync = undefined;
+const utils_1 = utils;
+function getRandomBytesSync(bytes) {
+    return (0, utils_1.randomBytes)(bytes);
+}
+random.getRandomBytesSync = getRandomBytesSync;
+async function getRandomBytes(bytes) {
+    return (0, utils_1.randomBytes)(bytes);
+}
+random.getRandomBytes = getRandomBytes;
+
+export { random as default };

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/ethereum-cryptography/scrypt.js

@@ -0,0 +1,23 @@
+import { __exports as scrypt$1 } from '../../../../../../../_virtual/scrypt.js';
+import '../../../../@noble/hashes/scrypt.js';
+import { u as utilsExports } from './utils.js';
+import { __exports as scrypt$2 } from '../../../../../../../_virtual/scrypt2.js';
+
+Object.defineProperty(scrypt$1, "__esModule", { value: true });
+scrypt$1.scryptSync = scrypt$1.scrypt = undefined;
+const scrypt_1 = scrypt$2;
+const utils_1 = utilsExports;
+async function scrypt(password, salt, n, p, r, dkLen, onProgress) {
+    (0, utils_1.assertBytes)(password);
+    (0, utils_1.assertBytes)(salt);
+    return (0, scrypt_1.scryptAsync)(password, salt, { N: n, r, p, dkLen, onProgress });
+}
+scrypt$1.scrypt = scrypt;
+function scryptSync(password, salt, n, p, r, dkLen, onProgress) {
+    (0, utils_1.assertBytes)(password);
+    (0, utils_1.assertBytes)(salt);
+    return (0, scrypt_1.scrypt)(password, salt, { N: n, r, p, dkLen, onProgress });
+}
+scrypt$1.scryptSync = scryptSync;
+
+export { scrypt$1 as default };

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/ethereum-cryptography/sha256.js

@@ -0,0 +1,12 @@
+import { __exports as sha256 } from '../../../../../../../_virtual/sha256.js';
+import '../../../../@noble/hashes/sha256.js';
+import { u as utilsExports } from './utils.js';
+import { __exports as sha256$1 } from '../../../../../../../_virtual/sha2562.js';
+
+Object.defineProperty(sha256, "__esModule", { value: true });
+sha256.sha256 = undefined;
+const sha256_1 = sha256$1;
+const utils_1 = utilsExports;
+sha256.sha256 = (0, utils_1.wrapHash)(sha256_1.sha256);
+
+export { sha256 as default };

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/ethereum-cryptography/utils.js

@@ -0,0 +1,77 @@
+import { commonjsGlobal } from '../../../../../../../_virtual/_commonjsHelpers.js';
+import { commonjsRequire } from '../../../../../../../_virtual/_commonjs-dynamic-modules.js';
+import { __module as utils } from '../../../../../../../_virtual/utils2.js';
+import '../../../../@noble/hashes/_assert.js';
+import '../../../../@noble/hashes/utils.js';
+import { __exports as _assert } from '../../../../../../../_virtual/_assert.js';
+import { __exports as utils$1 } from '../../../../../../../_virtual/utils.js';
+
+utils.exports;
+
+(function (module, exports) {
+	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.crypto = exports.wrapHash = exports.equalsBytes = exports.hexToBytes = exports.bytesToUtf8 = exports.utf8ToBytes = exports.createView = exports.concatBytes = exports.toHex = exports.bytesToHex = exports.assertBytes = exports.assertBool = undefined;
+	// buf.toString('hex') -> toHex(buf)
+	const _assert_1 = __importDefault(_assert);
+	const utils_1 = utils$1;
+	const assertBool = _assert_1.default.bool;
+	exports.assertBool = assertBool;
+	const assertBytes = _assert_1.default.bytes;
+	exports.assertBytes = assertBytes;
+	var utils_2 = utils$1;
+	Object.defineProperty(exports, "bytesToHex", { enumerable: true, get: function () { return utils_2.bytesToHex; } });
+	Object.defineProperty(exports, "toHex", { enumerable: true, get: function () { return utils_2.bytesToHex; } });
+	Object.defineProperty(exports, "concatBytes", { enumerable: true, get: function () { return utils_2.concatBytes; } });
+	Object.defineProperty(exports, "createView", { enumerable: true, get: function () { return utils_2.createView; } });
+	Object.defineProperty(exports, "utf8ToBytes", { enumerable: true, get: function () { return utils_2.utf8ToBytes; } });
+	// buf.toString('utf8') -> bytesToUtf8(buf)
+	function bytesToUtf8(data) {
+	    if (!(data instanceof Uint8Array)) {
+	        throw new TypeError(`bytesToUtf8 expected Uint8Array, got ${typeof data}`);
+	    }
+	    return new TextDecoder().decode(data);
+	}
+	exports.bytesToUtf8 = bytesToUtf8;
+	function hexToBytes(data) {
+	    const sliced = data.startsWith("0x") ? data.substring(2) : data;
+	    return (0, utils_1.hexToBytes)(sliced);
+	}
+	exports.hexToBytes = hexToBytes;
+	// buf.equals(buf2) -> equalsBytes(buf, buf2)
+	function equalsBytes(a, b) {
+	    if (a.length !== b.length) {
+	        return false;
+	    }
+	    for (let i = 0; i < a.length; i++) {
+	        if (a[i] !== b[i]) {
+	            return false;
+	        }
+	    }
+	    return true;
+	}
+	exports.equalsBytes = equalsBytes;
+	// Internal utils
+	function wrapHash(hash) {
+	    return (msg) => {
+	        _assert_1.default.bytes(msg);
+	        return hash(msg);
+	    };
+	}
+	exports.wrapHash = wrapHash;
+	exports.crypto = (() => {
+	    const webCrypto = typeof self === "object" && "crypto" in self ? self.crypto : undefined;
+	    const nodeRequire = typeof commonjsRequire === "function" &&
+	        commonjsRequire.bind(module);
+	    return {
+	        node: nodeRequire && !webCrypto ? nodeRequire("crypto") : undefined,
+	        web: webCrypto
+	    };
+	})(); 
+} (utils, utils.exports));
+
+var utilsExports = utils.exports;
+
+export { utilsExports as u };

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/uuid/dist/esm-browser/index.js

@@ -0,0 +1,9 @@
+export { default as v1 } from './v1.js';
+export { default as v3 } from './v3.js';
+export { default as v4 } from './v4.js';
+export { default as v5 } from './v5.js';
+export { default as NIL } from './nil.js';
+export { default as version } from './version.js';
+export { default as validate } from './validate.js';
+export { default as stringify } from './stringify.js';
+export { default as parse } from './parse.js';

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/uuid/dist/esm-browser/md5.js

@@ -0,0 +1,215 @@
+/*
+ * Browser-compatible JavaScript MD5
+ *
+ * Modification of JavaScript MD5
+ * https://github.com/blueimp/JavaScript-MD5
+ *
+ * Copyright 2011, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ *
+ * Based on
+ * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+ * Digest Algorithm, as defined in RFC 1321.
+ * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for more info.
+ */
+function md5(bytes) {
+  if (typeof bytes === 'string') {
+    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+
+    bytes = new Uint8Array(msg.length);
+
+    for (var i = 0; i < msg.length; ++i) {
+      bytes[i] = msg.charCodeAt(i);
+    }
+  }
+
+  return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));
+}
+/*
+ * Convert an array of little-endian words to an array of bytes
+ */
+
+
+function md5ToHexEncodedArray(input) {
+  var output = [];
+  var length32 = input.length * 32;
+  var hexTab = '0123456789abcdef';
+
+  for (var i = 0; i < length32; i += 8) {
+    var x = input[i >> 5] >>> i % 32 & 0xff;
+    var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
+    output.push(hex);
+  }
+
+  return output;
+}
+/**
+ * Calculate output length with padding and bit length
+ */
+
+
+function getOutputLength(inputLength8) {
+  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
+}
+/*
+ * Calculate the MD5 of an array of little-endian words, and a bit length.
+ */
+
+
+function wordsToMd5(x, len) {
+  /* append padding */
+  x[len >> 5] |= 0x80 << len % 32;
+  x[getOutputLength(len) - 1] = len;
+  var a = 1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d = 271733878;
+
+  for (var i = 0; i < x.length; i += 16) {
+    var olda = a;
+    var oldb = b;
+    var oldc = c;
+    var oldd = d;
+    a = md5ff(a, b, c, d, x[i], 7, -680876936);
+    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
+    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
+    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
+    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
+    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
+    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
+    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
+    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
+    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
+    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
+    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
+    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
+    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
+    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
+    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
+    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
+    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
+    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
+    b = md5gg(b, c, d, a, x[i], 20, -373897302);
+    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
+    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
+    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
+    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
+    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
+    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
+    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
+    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
+    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
+    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
+    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
+    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
+    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
+    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
+    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
+    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
+    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
+    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
+    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
+    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
+    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
+    d = md5hh(d, a, b, c, x[i], 11, -358537222);
+    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
+    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
+    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
+    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
+    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
+    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
+    a = md5ii(a, b, c, d, x[i], 6, -198630844);
+    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
+    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
+    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
+    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
+    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
+    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
+    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
+    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
+    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
+    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
+    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
+    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
+    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
+    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
+    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
+    a = safeAdd(a, olda);
+    b = safeAdd(b, oldb);
+    c = safeAdd(c, oldc);
+    d = safeAdd(d, oldd);
+  }
+
+  return [a, b, c, d];
+}
+/*
+ * Convert an array bytes to an array of little-endian words
+ * Characters >255 have their high-byte silently ignored.
+ */
+
+
+function bytesToWords(input) {
+  if (input.length === 0) {
+    return [];
+  }
+
+  var length8 = input.length * 8;
+  var output = new Uint32Array(getOutputLength(length8));
+
+  for (var i = 0; i < length8; i += 8) {
+    output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
+  }
+
+  return output;
+}
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+
+
+function safeAdd(x, y) {
+  var lsw = (x & 0xffff) + (y & 0xffff);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 0xffff;
+}
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+
+
+function bitRotateLeft(num, cnt) {
+  return num << cnt | num >>> 32 - cnt;
+}
+/*
+ * These functions implement the four basic operations the algorithm uses.
+ */
+
+
+function md5cmn(q, a, b, x, s, t) {
+  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
+}
+
+function md5ff(a, b, c, d, x, s, t) {
+  return md5cmn(b & c | ~b & d, a, b, x, s, t);
+}
+
+function md5gg(a, b, c, d, x, s, t) {
+  return md5cmn(b & d | c & ~d, a, b, x, s, t);
+}
+
+function md5hh(a, b, c, d, x, s, t) {
+  return md5cmn(b ^ c ^ d, a, b, x, s, t);
+}
+
+function md5ii(a, b, c, d, x, s, t) {
+  return md5cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+
+export { md5 as default };

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/uuid/dist/esm-browser/nil.js

@@ -0,0 +1,3 @@
+var nil = '00000000-0000-0000-0000-000000000000';
+
+export { nil as default };

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/uuid/dist/esm-browser/parse.js

@@ -0,0 +1,35 @@
+import validate from './validate.js';
+
+function parse(uuid) {
+  if (!validate(uuid)) {
+    throw TypeError('Invalid UUID');
+  }
+
+  var v;
+  var arr = new Uint8Array(16); // Parse ########-....-....-....-............
+
+  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+  arr[1] = v >>> 16 & 0xff;
+  arr[2] = v >>> 8 & 0xff;
+  arr[3] = v & 0xff; // Parse ........-####-....-....-............
+
+  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+  arr[5] = v & 0xff; // Parse ........-....-####-....-............
+
+  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+  arr[7] = v & 0xff; // Parse ........-....-....-####-............
+
+  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+  arr[9] = v & 0xff; // Parse ........-....-....-....-############
+  // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+
+  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
+  arr[11] = v / 0x100000000 & 0xff;
+  arr[12] = v >>> 24 & 0xff;
+  arr[13] = v >>> 16 & 0xff;
+  arr[14] = v >>> 8 & 0xff;
+  arr[15] = v & 0xff;
+  return arr;
+}
+
+export { parse as default };

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/uuid/dist/esm-browser/regex.js

@@ -0,0 +1,3 @@
+var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+
+export { REGEX as default };

package/bundle/packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/uuid/dist/esm-browser/rng.js

@@ -0,0 +1,21 @@
+// Unique ID creation requires a high quality random # generator. In the browser we therefore
+// require the crypto API and do not support built-in fallback to lower quality random number
+// generators (like Math.random()).
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+  // lazy load so that environments that need to polyfill have a chance to do so
+  if (!getRandomValues) {
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
+    // find the complete implementation of crypto (msCrypto) on IE11.
+    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
+
+    if (!getRandomValues) {
+      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+    }
+  }
+
+  return getRandomValues(rnds8);
+}
+
+export { rng as default };