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

RLN (Rate Limiting Nullifier) implementation for Waku

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 = void 0;
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, void 0, void 0, 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, void 0, void 0, 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, void 0, void 0, 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 };