@waku/rln 0.0.1 → 0.0.2-00f2e75.0

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

@@ -0,0 +1,28 @@
+import { commonjsGlobal } from '../../../../../../_virtual/_commonjsHelpers.js';
+import { __exports as lib } from '../../../../../../_virtual/index.js';
+import './types.js';
+import './functional.js';
+import './class.js';
+import './schema-validation.js';
+import { __exports as types } from '../../../../../../_virtual/types.js';
+import { __exports as functional } from '../../../../../../_virtual/functional.js';
+import { __exports as _class } from '../../../../../../_virtual/class.js';
+import { __exports as schemaValidation } from '../../../../../../_virtual/schema-validation.js';
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(types, exports);
+	__exportStar(functional, exports);
+	__exportStar(_class, exports);
+	__exportStar(schemaValidation, exports); 
+} (lib));

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

@@ -0,0 +1,78 @@
+import { commonjsGlobal } from '../../../../../../_virtual/_commonjsHelpers.js';
+import { __exports as kdf$1 } from '../../../../../../_virtual/kdf.js';
+import '../node_modules/ethereum-cryptography/random.js';
+import '../node_modules/ethereum-cryptography/pbkdf2.js';
+import '../node_modules/ethereum-cryptography/scrypt.js';
+import { u as utilsExports } from '../node_modules/ethereum-cryptography/utils.js';
+import { __exports as random } from '../../../../../../_virtual/random.js';
+import { __exports as pbkdf2 } from '../../../../../../_virtual/pbkdf2.js';
+import { __exports as scrypt } from '../../../../../../_virtual/scrypt.js';
+
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(kdf$1, "__esModule", { value: true });
+var kdf_2 = kdf$1.kdf = kdf$1.defaultScryptModule = kdf$1.defaultPbkdfModule = undefined;
+const random_1 = random;
+const pbkdf2_1 = pbkdf2;
+const scrypt_1 = scrypt;
+const utils_1 = utilsExports;
+// default kdf configurations
+function defaultPbkdfModule() {
+    return {
+        function: "pbkdf2",
+        params: {
+            dklen: 32,
+            c: 262144,
+            prf: "hmac-sha256",
+            salt: utils_1.bytesToHex(random_1.getRandomBytesSync(32)),
+        },
+    };
+}
+kdf$1.defaultPbkdfModule = defaultPbkdfModule;
+function defaultScryptModule() {
+    return {
+        function: "scrypt",
+        params: {
+            dklen: 32,
+            n: 262144,
+            r: 8,
+            p: 1,
+            salt: utils_1.bytesToHex(random_1.getRandomBytesSync(32)),
+        },
+    };
+}
+kdf$1.defaultScryptModule = defaultScryptModule;
+// kdf operations
+function kdf(mod, password) {
+    return __awaiter(this, undefined, undefined, function* () {
+        if (mod.function === "pbkdf2") {
+            return yield doPbkdf2(mod.params, password);
+        }
+        else if (mod.function === "scrypt") {
+            return yield doScrypt(mod.params, password);
+        }
+        else {
+            throw new Error("Invalid kdf type");
+        }
+    });
+}
+kdf_2 = kdf$1.kdf = kdf;
+function doPbkdf2(params, password) {
+    return __awaiter(this, undefined, undefined, function* () {
+        return pbkdf2_1.pbkdf2(password, utils_1.hexToBytes(params.salt), params.c, params.dklen, params.prf.slice(5));
+    });
+}
+function doScrypt(params, password) {
+    return __awaiter(this, undefined, undefined, function* () {
+        return scrypt_1.scrypt(password, utils_1.hexToBytes(params.salt), params.n, params.p, params.r, params.dklen);
+    });
+}
+
+export { kdf$1 as default, kdf_2 as kdf };

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

@@ -0,0 +1,17 @@
+import { __exports as password } from '../../../../../../_virtual/password.js';
+import { u as utilsExports } from '../node_modules/ethereum-cryptography/utils.js';
+
+Object.defineProperty(password, "__esModule", { value: true });
+var normalizePassword_1 = password.normalizePassword = undefined;
+const utils_1 = utilsExports;
+function normalizePassword(password) {
+    if (typeof password === "string") {
+        return utils_1.utf8ToBytes(password.normalize("NFKD"));
+    }
+    else {
+        return password;
+    }
+}
+normalizePassword_1 = password.normalizePassword = normalizePassword;
+
+export { password as default, normalizePassword_1 as normalizePassword };