@waku/rln 0.0.1 → 0.0.2-09108d9.0

package/bundle/packages/rln/dist/contract/constants.js

@@ -0,0 +1,68 @@
+// ref https://github.com/waku-org/waku-rln-contract/blob/19fded82bca07e7b535b429dc507cfb83f10dfcf/deployments/sepolia/WakuRlnRegistry_Implementation.json#L3
+const RLN_REGISTRY_ABI = [
+    "error IncompatibleStorage()",
+    "error IncompatibleStorageIndex()",
+    "error NoStorageContractAvailable()",
+    "error StorageAlreadyExists(address storageAddress)",
+    "event AdminChanged(address previousAdmin, address newAdmin)",
+    "event BeaconUpgraded(address indexed beacon)",
+    "event Initialized(uint8 version)",
+    "event NewStorageContract(uint16 index, address storageAddress)",
+    "event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)",
+    "event Upgraded(address indexed implementation)",
+    "function forceProgress()",
+    "function initialize(address _poseidonHasher)",
+    "function newStorage()",
+    "function nextStorageIndex() view returns (uint16)",
+    "function owner() view returns (address)",
+    "function poseidonHasher() view returns (address)",
+    "function proxiableUUID() view returns (bytes32)",
+    "function register(uint16 storageIndex, uint256 commitment)",
+    "function register(uint256[] commitments)",
+    "function register(uint16 storageIndex, uint256[] commitments)",
+    "function registerStorage(address storageAddress)",
+    "function renounceOwnership()",
+    "function storages(uint16) view returns (address)",
+    "function transferOwnership(address newOwner)",
+    "function upgradeTo(address newImplementation)",
+    "function upgradeToAndCall(address newImplementation, bytes data) payable",
+    "function usingStorageIndex() view returns (uint16)"
+];
+// ref https://github.com/waku-org/waku-rln-contract/blob/19fded82bca07e7b535b429dc507cfb83f10dfcf/deployments/sepolia/WakuRlnStorage_0.json#L3
+const RLN_STORAGE_ABI = [
+    "constructor(address _poseidonHasher, uint16 _contractIndex)",
+    "error DuplicateIdCommitment()",
+    "error FullTree()",
+    "error InvalidIdCommitment(uint256 idCommitment)",
+    "error NotImplemented()",
+    "event MemberRegistered(uint256 idCommitment, uint256 index)",
+    "event MemberWithdrawn(uint256 idCommitment, uint256 index)",
+    "event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)",
+    "function DEPTH() view returns (uint256)",
+    "function MEMBERSHIP_DEPOSIT() view returns (uint256)",
+    "function SET_SIZE() view returns (uint256)",
+    "function contractIndex() view returns (uint16)",
+    "function deployedBlockNumber() view returns (uint32)",
+    "function idCommitmentIndex() view returns (uint256)",
+    "function isValidCommitment(uint256 idCommitment) view returns (bool)",
+    "function memberExists(uint256) view returns (bool)",
+    "function members(uint256) view returns (uint256)",
+    "function owner() view returns (address)",
+    "function poseidonHasher() view returns (address)",
+    "function register(uint256[] idCommitments)",
+    "function register(uint256 idCommitment) payable",
+    "function renounceOwnership()",
+    "function slash(uint256 idCommitment, address receiver, uint256[8] proof) pure",
+    "function stakedAmounts(uint256) view returns (uint256)",
+    "function transferOwnership(address newOwner)",
+    "function verifier() view returns (address)",
+    "function withdraw() pure",
+    "function withdrawalBalance(address) view returns (uint256)"
+];
+const SEPOLIA_CONTRACT = {
+    chainId: 11155111,
+    address: "0xF471d71E9b1455bBF4b85d475afb9BB0954A29c4",
+    abi: RLN_REGISTRY_ABI
+};
+
+export { RLN_REGISTRY_ABI, RLN_STORAGE_ABI, SEPOLIA_CONTRACT };

package/bundle/packages/rln/dist/contract/rln_contract.js

@@ -0,0 +1,218 @@
+import '../../../interfaces/dist/protocols.js';
+import '../../../interfaces/dist/connection_manager.js';
+import '../../../interfaces/dist/health_indicator.js';
+import { hexToBytes } from '../../../utils/dist/bytes/index.js';
+import { Logger } from '../../../utils/dist/logger/index.js';
+import { MerkleRootTracker } from '../root_tracker.js';
+import { zeroPadLE } from '../utils/bytes.js';
+import '../utils/epoch.js';
+import { RLN_REGISTRY_ABI, RLN_STORAGE_ABI } from './constants.js';
+import { Contract } from '../../../../node_modules/@ethersproject/contracts/lib.esm/index.js';
+import { AddressZero } from '../../../../node_modules/@ethersproject/constants/lib.esm/addresses.js';
+
+const log = new Logger("waku:rln:contract");
+class RLNContract {
+    registryContract;
+    merkleRootTracker;
+    deployBlock;
+    storageIndex;
+    storageContract;
+    _membersFilter;
+    _members = new Map();
+    static async init(rlnInstance, options) {
+        const rlnContract = new RLNContract(rlnInstance, options);
+        await rlnContract.initStorageContract(options.signer);
+        await rlnContract.fetchMembers(rlnInstance);
+        rlnContract.subscribeToMembers(rlnInstance);
+        return rlnContract;
+    }
+    constructor(rlnInstance, { registryAddress, signer }) {
+        const initialRoot = rlnInstance.zerokit.getMerkleRoot();
+        this.registryContract = new Contract(registryAddress, RLN_REGISTRY_ABI, signer);
+        this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
+    }
+    async initStorageContract(signer, options = {}) {
+        const storageIndex = options?.storageIndex
+            ? options.storageIndex
+            : await this.registryContract.usingStorageIndex();
+        const storageAddress = await this.registryContract.storages(storageIndex);
+        if (!storageAddress || storageAddress === AddressZero) {
+            throw Error("No RLN Storage initialized on registry contract.");
+        }
+        this.storageIndex = storageIndex;
+        this.storageContract = new Contract(storageAddress, RLN_STORAGE_ABI, signer);
+        this._membersFilter = this.storageContract.filters.MemberRegistered();
+        this.deployBlock = await this.storageContract.deployedBlockNumber();
+    }
+    get registry() {
+        if (!this.registryContract) {
+            throw Error("Registry contract was not initialized");
+        }
+        return this.registryContract;
+    }
+    get contract() {
+        if (!this.storageContract) {
+            throw Error("Storage contract was not initialized");
+        }
+        return this.storageContract;
+    }
+    get members() {
+        const sortedMembers = Array.from(this._members.values()).sort((left, right) => left.index.toNumber() - right.index.toNumber());
+        return sortedMembers;
+    }
+    get membersFilter() {
+        if (!this._membersFilter) {
+            throw Error("Members filter was not initialized.");
+        }
+        return this._membersFilter;
+    }
+    async fetchMembers(rlnInstance, options = {}) {
+        const registeredMemberEvents = await queryFilter(this.contract, {
+            fromBlock: this.deployBlock,
+            ...options,
+            membersFilter: this.membersFilter
+        });
+        this.processEvents(rlnInstance, registeredMemberEvents);
+    }
+    processEvents(rlnInstance, events) {
+        const toRemoveTable = new Map();
+        const toInsertTable = new Map();
+        events.forEach((evt) => {
+            if (!evt.args) {
+                return;
+            }
+            if (evt.removed) {
+                const index = evt.args.index;
+                const toRemoveVal = toRemoveTable.get(evt.blockNumber);
+                if (toRemoveVal != undefined) {
+                    toRemoveVal.push(index.toNumber());
+                    toRemoveTable.set(evt.blockNumber, toRemoveVal);
+                }
+                else {
+                    toRemoveTable.set(evt.blockNumber, [index.toNumber()]);
+                }
+            }
+            else {
+                let eventsPerBlock = toInsertTable.get(evt.blockNumber);
+                if (eventsPerBlock == undefined) {
+                    eventsPerBlock = [];
+                }
+                eventsPerBlock.push(evt);
+                toInsertTable.set(evt.blockNumber, eventsPerBlock);
+            }
+        });
+        this.removeMembers(rlnInstance, toRemoveTable);
+        this.insertMembers(rlnInstance, toInsertTable);
+    }
+    insertMembers(rlnInstance, toInsert) {
+        toInsert.forEach((events, blockNumber) => {
+            events.forEach((evt) => {
+                const _idCommitment = evt?.args?.idCommitment;
+                const index = evt?.args?.index;
+                if (!_idCommitment || !index) {
+                    return;
+                }
+                const idCommitment = zeroPadLE(hexToBytes(_idCommitment?._hex), 32);
+                rlnInstance.zerokit.insertMember(idCommitment);
+                this._members.set(index.toNumber(), {
+                    index,
+                    idCommitment: _idCommitment?._hex
+                });
+            });
+            const currentRoot = rlnInstance.zerokit.getMerkleRoot();
+            this.merkleRootTracker.pushRoot(blockNumber, currentRoot);
+        });
+    }
+    removeMembers(rlnInstance, toRemove) {
+        const removeDescending = new Map([...toRemove].sort().reverse());
+        removeDescending.forEach((indexes, blockNumber) => {
+            indexes.forEach((index) => {
+                if (this._members.has(index)) {
+                    this._members.delete(index);
+                    rlnInstance.zerokit.deleteMember(index);
+                }
+            });
+            this.merkleRootTracker.backFill(blockNumber);
+        });
+    }
+    subscribeToMembers(rlnInstance) {
+        this.contract.on(this.membersFilter, (_pubkey, _index, event) => this.processEvents(rlnInstance, [event]));
+    }
+    async registerWithIdentity(identity) {
+        if (this.storageIndex === undefined) {
+            throw Error("Cannot register credential, no storage contract index found.");
+        }
+        const txRegisterResponse = await this.registryContract["register(uint16,uint256)"](this.storageIndex, identity.IDCommitmentBigInt, { gasLimit: 100000 });
+        const txRegisterReceipt = await txRegisterResponse.wait();
+        // assumption: register(uint16,uint256) emits one event
+        const memberRegistered = txRegisterReceipt?.events?.[0];
+        if (!memberRegistered) {
+            return undefined;
+        }
+        const decodedData = this.contract.interface.decodeEventLog("MemberRegistered", memberRegistered.data);
+        const network = await this.registryContract.provider.getNetwork();
+        const address = this.registryContract.address;
+        const membershipId = decodedData.index.toNumber();
+        return {
+            identity,
+            membership: {
+                address,
+                treeIndex: membershipId,
+                chainId: network.chainId
+            }
+        };
+    }
+    roots() {
+        return this.merkleRootTracker.roots();
+    }
+}
+// these value should be tested on other networks
+const FETCH_CHUNK = 5;
+const BLOCK_RANGE = 3000;
+async function queryFilter(contract, options) {
+    const { fromBlock, membersFilter, fetchRange = BLOCK_RANGE, fetchChunks = FETCH_CHUNK } = options;
+    if (!fromBlock) {
+        return contract.queryFilter(membersFilter);
+    }
+    if (!contract.signer.provider) {
+        throw Error("No provider found on the contract's signer.");
+    }
+    const toBlock = await contract.signer.provider.getBlockNumber();
+    if (toBlock - fromBlock < fetchRange) {
+        return contract.queryFilter(membersFilter);
+    }
+    const events = [];
+    const chunks = splitToChunks(fromBlock, toBlock, fetchRange);
+    for (const portion of takeN(chunks, fetchChunks)) {
+        const promises = portion.map(([left, right]) => ignoreErrors(contract.queryFilter(membersFilter, left, right), []));
+        const fetchedEvents = await Promise.all(promises);
+        events.push(fetchedEvents.flatMap((v) => v));
+    }
+    return events.flatMap((v) => v);
+}
+function splitToChunks(from, to, step) {
+    const chunks = [];
+    let left = from;
+    while (left < to) {
+        const right = left + step < to ? left + step : to;
+        chunks.push([left, right]);
+        left = right;
+    }
+    return chunks;
+}
+function* takeN(array, size) {
+    let start = 0;
+    while (start < array.length) {
+        const portion = array.slice(start, start + size);
+        yield portion;
+        start += size;
+    }
+}
+function ignoreErrors(promise, defaultValue) {
+    return promise.catch((err) => {
+        log.info(`Ignoring an error during query: ${err?.message}`);
+        return defaultValue;
+    });
+}
+
+export { RLNContract };

package/bundle/packages/rln/dist/create.js

@@ -0,0 +1,9 @@
+async function createRLN() {
+    // A dependency graph that contains any wasm must all be imported
+    // asynchronously. This file does the single async import, so
+    // that no one else needs to worry about it again.
+    const rlnModule = await import('./rln.js');
+    return rlnModule.create();
+}
+
+export { createRLN };

package/bundle/packages/rln/dist/identity.js

@@ -0,0 +1,30 @@
+import { buildBigIntFromUint8Array } from './utils/bytes.js';
+import './utils/epoch.js';
+
+class IdentityCredential {
+    IDTrapdoor;
+    IDNullifier;
+    IDSecretHash;
+    IDCommitment;
+    IDCommitmentBigInt;
+    constructor(IDTrapdoor, IDNullifier, IDSecretHash, IDCommitment, IDCommitmentBigInt) {
+        this.IDTrapdoor = IDTrapdoor;
+        this.IDNullifier = IDNullifier;
+        this.IDSecretHash = IDSecretHash;
+        this.IDCommitment = IDCommitment;
+        this.IDCommitmentBigInt = IDCommitmentBigInt;
+    }
+    static fromBytes(memKeys) {
+        if (memKeys.length < 128) {
+            throw new Error("Invalid memKeys length - must be at least 128 bytes");
+        }
+        const idTrapdoor = memKeys.subarray(0, 32);
+        const idNullifier = memKeys.subarray(32, 64);
+        const idSecretHash = memKeys.subarray(64, 96);
+        const idCommitment = memKeys.subarray(96, 128);
+        const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment, 32);
+        return new IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment, idCommitmentBigInt);
+    }
+}
+
+export { IdentityCredential };

package/bundle/packages/rln/dist/keystore/cipher.js

@@ -0,0 +1,31 @@
+import { cipherDecrypt as cipherDecrypt_1 } from '../../node_modules/@chainsafe/bls-keystore/lib/cipher.js';
+import { kdf as kdf_2 } from '../../node_modules/@chainsafe/bls-keystore/lib/kdf.js';
+import { normalizePassword as normalizePassword_1 } from '../../node_modules/@chainsafe/bls-keystore/lib/password.js';
+import { keccak256 } from '../../../../node_modules/ethereum-cryptography/esm/keccak.js';
+import { hexToBytes } from '../../../../node_modules/ethereum-cryptography/esm/utils.js';
+import { concatBytes, bytesToHex } from '../../../../node_modules/@noble/hashes/esm/utils.js';
+
+// eipKeystore supports only sha256 checksum so we just make an assumption it is keccak256
+const validateChecksum = async (password, eipKeystore) => {
+    const computedChecksum = await keccak256Checksum(password, eipKeystore);
+    return computedChecksum === eipKeystore.crypto.checksum.message;
+};
+// decrypt from @chainsafe/bls-keystore supports only sha256
+// but nwaku uses keccak256
+// https://github.com/waku-org/nwaku/blob/25d6e52e3804d15f9b61bc4cc6dd448540c072a1/waku/waku_keystore/keyfile.nim#L367
+const decryptEipKeystore = async (password, eipKeystore) => {
+    const decryptionKey = await kdf_2(eipKeystore.crypto.kdf, normalizePassword_1(password));
+    const isChecksumValid = await validateChecksum(password, eipKeystore);
+    if (!isChecksumValid) {
+        throw Error("Password is invalid.");
+    }
+    return cipherDecrypt_1(eipKeystore.crypto.cipher, decryptionKey.slice(0, 16));
+};
+const keccak256Checksum = async (password, eipKeystore) => {
+    const key = await kdf_2(eipKeystore.crypto.kdf, normalizePassword_1(password));
+    const payload = concatBytes(key.slice(16), hexToBytes(eipKeystore.crypto.cipher.message));
+    const ciphertext = keccak256(payload);
+    return bytesToHex(ciphertext);
+};
+
+export { decryptEipKeystore, keccak256Checksum };

package/bundle/packages/rln/dist/keystore/credential_validation_generated.js

@@ -0,0 +1,119 @@
+/* eslint eslint-comments/no-unlimited-disable: "off" */
+// This file was generated by /scripts/schema-validation-codegen.ts
+// Do not modify this file by hand.
+/* eslint-disable */
+// @ts-ignore
+const Credential = validate11;
+function validate11(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) { let vErrors = null; let errors = 0; {
+    if (data && typeof data == "object" && !Array.isArray(data)) {
+        let missing0;
+        if ((data.crypto === undefined) && (missing0 = "crypto")) {
+            validate11.errors = [{ instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: missing0 }, message: "must have required property '" + missing0 + "'" }];
+            return false;
+        }
+        else {
+            if (data.crypto !== undefined) {
+                let data0 = data.crypto;
+                {
+                    if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+                        let missing1;
+                        if (((((((data0.cipher === undefined) && (missing1 = "cipher")) || ((data0.cipherparams === undefined) && (missing1 = "cipherparams"))) || ((data0.ciphertext === undefined) && (missing1 = "ciphertext"))) || ((data0.kdf === undefined) && (missing1 = "kdf"))) || ((data0.kdfparams === undefined) && (missing1 = "kdfparams"))) || ((data0.mac === undefined) && (missing1 = "mac"))) {
+                            validate11.errors = [{ instancePath: instancePath + "/crypto", schemaPath: "#/properties/crypto/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
+                            return false;
+                        }
+                        else {
+                            if (data0.cipher !== undefined) {
+                                const _errs3 = errors;
+                                if (typeof data0.cipher !== "string") {
+                                    validate11.errors = [{ instancePath: instancePath + "/crypto/cipher", schemaPath: "#/properties/crypto/properties/cipher/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                    return false;
+                                }
+                                var valid1 = _errs3 === errors;
+                            }
+                            else {
+                                var valid1 = true;
+                            }
+                            if (valid1) {
+                                if (data0.cipherparams !== undefined) {
+                                    let data2 = data0.cipherparams;
+                                    const _errs5 = errors;
+                                    if (!(data2 && typeof data2 == "object" && !Array.isArray(data2))) {
+                                        validate11.errors = [{ instancePath: instancePath + "/crypto/cipherparams", schemaPath: "#/properties/crypto/properties/cipherparams/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                        return false;
+                                    }
+                                    var valid1 = _errs5 === errors;
+                                }
+                                else {
+                                    var valid1 = true;
+                                }
+                                if (valid1) {
+                                    if (data0.ciphertext !== undefined) {
+                                        const _errs7 = errors;
+                                        if (typeof data0.ciphertext !== "string") {
+                                            validate11.errors = [{ instancePath: instancePath + "/crypto/ciphertext", schemaPath: "#/properties/crypto/properties/ciphertext/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                            return false;
+                                        }
+                                        var valid1 = _errs7 === errors;
+                                    }
+                                    else {
+                                        var valid1 = true;
+                                    }
+                                    if (valid1) {
+                                        if (data0.kdf !== undefined) {
+                                            const _errs9 = errors;
+                                            if (typeof data0.kdf !== "string") {
+                                                validate11.errors = [{ instancePath: instancePath + "/crypto/kdf", schemaPath: "#/properties/crypto/properties/kdf/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                return false;
+                                            }
+                                            var valid1 = _errs9 === errors;
+                                        }
+                                        else {
+                                            var valid1 = true;
+                                        }
+                                        if (valid1) {
+                                            if (data0.kdfparams !== undefined) {
+                                                let data5 = data0.kdfparams;
+                                                const _errs11 = errors;
+                                                if (!(data5 && typeof data5 == "object" && !Array.isArray(data5))) {
+                                                    validate11.errors = [{ instancePath: instancePath + "/crypto/kdfparams", schemaPath: "#/properties/crypto/properties/kdfparams/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                                                    return false;
+                                                }
+                                                var valid1 = _errs11 === errors;
+                                            }
+                                            else {
+                                                var valid1 = true;
+                                            }
+                                            if (valid1) {
+                                                if (data0.mac !== undefined) {
+                                                    const _errs13 = errors;
+                                                    if (typeof data0.mac !== "string") {
+                                                        validate11.errors = [{ instancePath: instancePath + "/crypto/mac", schemaPath: "#/properties/crypto/properties/mac/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
+                                                        return false;
+                                                    }
+                                                    var valid1 = _errs13 === errors;
+                                                }
+                                                else {
+                                                    var valid1 = true;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        validate11.errors = [{ instancePath: instancePath + "/crypto", schemaPath: "#/properties/crypto/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+    else {
+        validate11.errors = [{ instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
+        return false;
+    }
+} validate11.errors = vErrors; return errors === 0; }
+
+export { Credential };