@waku/rln/dist/proof.js

RLN (Rate Limiting Nullifier) implementation for Waku

import { BytesUtils, poseidonHash } from "./utils/index.js";
const proofOffset = 128;
const rootOffset = proofOffset + 32;
const epochOffset = rootOffset + 32;
const shareXOffset = epochOffset + 32;
const shareYOffset = shareXOffset + 32;
const nullifierOffset = shareYOffset + 32;
const rlnIdentifierOffset = nullifierOffset + 32;
class ProofMetadata {
    nullifier;
    shareX;
    shareY;
    externalNullifier;
    constructor(nullifier, shareX, shareY, externalNullifier) {
        this.nullifier = nullifier;
        this.shareX = shareX;
        this.shareY = shareY;
        this.externalNullifier = externalNullifier;
    }
}
export class Proof {
    proof;
    merkleRoot;
    epoch;
    shareX;
    shareY;
    nullifier;
    rlnIdentifier;
    constructor(proofBytes) {
        if (proofBytes.length < rlnIdentifierOffset) {
            throw new Error("invalid proof");
        }
        // parse the proof as proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32>
        this.proof = proofBytes.subarray(0, proofOffset);
        this.merkleRoot = proofBytes.subarray(proofOffset, rootOffset);
        this.epoch = proofBytes.subarray(rootOffset, epochOffset);
        this.shareX = proofBytes.subarray(epochOffset, shareXOffset);
        this.shareY = proofBytes.subarray(shareXOffset, shareYOffset);
        this.nullifier = proofBytes.subarray(shareYOffset, nullifierOffset);
        this.rlnIdentifier = proofBytes.subarray(nullifierOffset, rlnIdentifierOffset);
    }
    extractMetadata() {
        const externalNullifier = poseidonHash(this.epoch, this.rlnIdentifier);
        return new ProofMetadata(this.nullifier, this.shareX, this.shareY, externalNullifier);
    }
}
export function proofToBytes(p) {
    return BytesUtils.concatenate(p.proof, p.merkleRoot, p.epoch, p.shareX, p.shareY, p.nullifier, p.rlnIdentifier);
}
//# sourceMappingURL=proof.js.map