@waku/rln/dist/zerokit.js

RLN (Rate Limiting Nullifier) implementation for Waku

import * as zerokitRLN from "@waku/zerokit-rln-wasm";
import { DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from "./contract/constants.js";
import { IdentityCredential } from "./identity.js";
import { Proof, proofToBytes } from "./proof.js";
import { BytesUtils, dateToEpoch, epochIntToBytes } from "./utils/index.js";
export class Zerokit {
    zkRLN;
    witnessCalculator;
    _rateLimit;
    constructor(zkRLN, witnessCalculator, _rateLimit = DEFAULT_RATE_LIMIT) {
        this.zkRLN = zkRLN;
        this.witnessCalculator = witnessCalculator;
        this._rateLimit = _rateLimit;
    }
    get getZkRLN() {
        return this.zkRLN;
    }
    get getWitnessCalculator() {
        return this.witnessCalculator;
    }
    get rateLimit() {
        return this._rateLimit;
    }
    generateIdentityCredentials() {
        const memKeys = zerokitRLN.generateExtendedMembershipKey(this.zkRLN); // TODO: rename this function in zerokit rln-wasm
        return IdentityCredential.fromBytes(memKeys);
    }
    generateSeededIdentityCredential(seed) {
        const stringEncoder = new TextEncoder();
        const seedBytes = stringEncoder.encode(seed);
        // TODO: rename this function in zerokit rln-wasm
        const memKeys = zerokitRLN.generateSeededExtendedMembershipKey(this.zkRLN, seedBytes);
        return IdentityCredential.fromBytes(memKeys);
    }
    insertMember(idCommitment) {
        zerokitRLN.insertMember(this.zkRLN, idCommitment);
    }
    insertMembers(index, ...idCommitments) {
        // serializes a seq of IDCommitments to a byte seq
        // the order of serialization is |id_commitment_len<8>|id_commitment<var>|
        const idCommitmentLen = BytesUtils.writeUIntLE(new Uint8Array(8), idCommitments.length, 0, 8);
        const idCommitmentBytes = BytesUtils.concatenate(idCommitmentLen, ...idCommitments);
        zerokitRLN.setLeavesFrom(this.zkRLN, index, idCommitmentBytes);
    }
    deleteMember(index) {
        zerokitRLN.deleteLeaf(this.zkRLN, index);
    }
    getMerkleRoot() {
        return zerokitRLN.getRoot(this.zkRLN);
    }
    serializeMessage(uint8Msg, memIndex, epoch, idKey, rateLimit) {
        // calculate message length
        const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), uint8Msg.length, 0, 8);
        const memIndexBytes = BytesUtils.writeUIntLE(new Uint8Array(8), memIndex, 0, 8);
        const rateLimitBytes = BytesUtils.writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
        // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> | rate_limit<8> ]
        return BytesUtils.concatenate(idKey, memIndexBytes, epoch, msgLen, uint8Msg, rateLimitBytes);
    }
    async generateRLNProof(msg, index, epoch, idSecretHash, rateLimit) {
        if (epoch === undefined) {
            epoch = epochIntToBytes(dateToEpoch(new Date()));
        }
        else if (epoch instanceof Date) {
            epoch = epochIntToBytes(dateToEpoch(epoch));
        }
        const effectiveRateLimit = rateLimit ?? this.rateLimit;
        if (epoch.length !== 32)
            throw new Error("invalid epoch");
        if (idSecretHash.length !== 32)
            throw new Error("invalid id secret hash");
        if (index < 0)
            throw new Error("index must be >= 0");
        if (effectiveRateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
            effectiveRateLimit > RATE_LIMIT_PARAMS.MAX_RATE) {
            throw new Error(`Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`);
        }
        const serialized_msg = this.serializeMessage(msg, index, epoch, idSecretHash, effectiveRateLimit);
        const rlnWitness = zerokitRLN.getSerializedRLNWitness(this.zkRLN, serialized_msg);
        const inputs = zerokitRLN.RLNWitnessToJson(this.zkRLN, rlnWitness);
        const calculatedWitness = await this.witnessCalculator.calculateWitness(inputs, false);
        const proofBytes = zerokitRLN.generate_rln_proof_with_witness(this.zkRLN, calculatedWitness, rlnWitness);
        return new Proof(proofBytes);
    }
    verifyRLNProof(proof, msg, rateLimit) {
        let pBytes;
        if (proof instanceof Uint8Array) {
            pBytes = proof;
        }
        else {
            pBytes = proofToBytes(proof);
        }
        // calculate message length
        const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
        const rateLimitBytes = BytesUtils.writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
        return zerokitRLN.verifyRLNProof(this.zkRLN, BytesUtils.concatenate(pBytes, msgLen, msg, rateLimitBytes));
    }
    verifyWithRoots(proof, msg, roots, rateLimit) {
        let pBytes;
        if (proof instanceof Uint8Array) {
            pBytes = proof;
        }
        else {
            pBytes = proofToBytes(proof);
        }
        // calculate message length
        const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
        const rateLimitBytes = BytesUtils.writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
        const rootsBytes = BytesUtils.concatenate(...roots);
        return zerokitRLN.verifyWithRoots(this.zkRLN, BytesUtils.concatenate(pBytes, msgLen, msg, rateLimitBytes), rootsBytes);
    }
    verifyWithNoRoot(proof, msg, rateLimit) {
        let pBytes;
        if (proof instanceof Uint8Array) {
            pBytes = proof;
        }
        else {
            pBytes = proofToBytes(proof);
        }
        // calculate message length
        const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
        const rateLimitBytes = BytesUtils.writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
        return zerokitRLN.verifyWithRoots(this.zkRLN, BytesUtils.concatenate(pBytes, msgLen, msg, rateLimitBytes), new Uint8Array());
    }
}
//# sourceMappingURL=zerokit.js.map