@waku/rln 0.0.2-09108d9.0 → 0.0.2-8a6571f.0

package/src/index.ts

@@ -1,10 +1,6 @@
 import { RLNDecoder, RLNEncoder } from "./codec.js";
-import {
-  RLN_REGISTRY_ABI,
-  RLN_STORAGE_ABI,
-  SEPOLIA_CONTRACT
-} from "./contract/index.js";
-import { RLNContract } from "./contract/index.js";
+import { RLN_ABI } from "./contract/abi.js";
+import { RLNContract, SEPOLIA_CONTRACT } from "./contract/index.js";
 import { createRLN } from "./create.js";
 import { IdentityCredential } from "./identity.js";
 import { Keystore } from "./keystore/index.js";
@@ -23,8 +19,7 @@ export {
   RLNDecoder,
   MerkleRootTracker,
   RLNContract,
-  RLN_STORAGE_ABI,
-  RLN_REGISTRY_ABI,
   SEPOLIA_CONTRACT,
-  extractMetaMaskSigner
+  extractMetaMaskSigner,
+  RLN_ABI
 };

package/src/message.ts

@@ -27,7 +27,7 @@ export class RlnMessage<T extends IDecodedMessage> implements IDecodedMessage {
       ? this.rlnInstance.zerokit.verifyWithRoots(
           this.rateLimitProof,
           toRLNSignal(this.msg.contentTopic, this.msg),
-          ...roots
+          roots
         ) // this.rlnInstance.verifyRLNProof once issue status-im/nwaku#1248 is fixed
       : undefined;
   }

package/src/rln.ts

@@ -15,6 +15,7 @@ import {
   type RLNDecoder,
   type RLNEncoder
 } from "./codec.js";
+import { DEFAULT_RATE_LIMIT } from "./contract/constants.js";
 import { RLNContract, SEPOLIA_CONTRACT } from "./contract/index.js";
 import { IdentityCredential } from "./identity.js";
 import { Keystore } from "./keystore/index.js";
@@ -25,26 +26,53 @@ import type {
 import { KeystoreEntity, Password } from "./keystore/types.js";
 import verificationKey from "./resources/verification_key";
 import * as wc from "./resources/witness_calculator";
+import { WitnessCalculator } from "./resources/witness_calculator";
 import { extractMetaMaskSigner } from "./utils/index.js";
 import { Zerokit } from "./zerokit.js";
 
 const log = new Logger("waku:rln");
 
-async function loadWitnessCalculator(): Promise<wc.WitnessCalculator> {
-  const res = await fetch("/base/rln.wasm");
-  if (!res.ok) {
-    throw new Error(`Failed to fetch rln.wasm: ${res.statusText}`);
+async function loadWitnessCalculator(): Promise<WitnessCalculator> {
+  try {
+    const url = new URL("./resources/rln.wasm", import.meta.url);
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch witness calculator: ${response.status} ${response.statusText}`
+      );
+    }
+
+    return await wc.builder(
+      new Uint8Array(await response.arrayBuffer()),
+      false
+    );
+  } catch (error) {
+    log.error("Error loading witness calculator:", error);
+    throw new Error(
+      `Failed to load witness calculator: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
-  const witnessBuffer = await res.arrayBuffer();
-  return wc.builder(new Uint8Array(witnessBuffer), false);
 }
 
 async function loadZkey(): Promise<Uint8Array> {
-  const res = await fetch("/base/rln_final.zkey");
-  if (!res.ok) {
-    throw new Error(`Failed to fetch rln_final.zkey: ${res.statusText}`);
+  try {
+    const url = new URL("./resources/rln_final.zkey", import.meta.url);
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch zkey: ${response.status} ${response.statusText}`
+      );
+    }
+
+    return new Uint8Array(await response.arrayBuffer());
+  } catch (error) {
+    log.error("Error loading zkey:", error);
+    throw new Error(
+      `Failed to load zkey: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
-  return new Uint8Array(await res.arrayBuffer());
 }
 
 /**
@@ -65,7 +93,7 @@ export async function create(): Promise<RLNInstance> {
 
     const DEPTH = 20;
     const zkRLN = zerokitRLN.newRLN(DEPTH, zkey, vkey);
-    const zerokit = new Zerokit(zkRLN, witnessCalculator);
+    const zerokit = new Zerokit(zkRLN, witnessCalculator, DEFAULT_RATE_LIMIT);
 
     return new RLNInstance(zerokit);
   } catch (error) {
@@ -82,12 +110,16 @@ type StartRLNOptions = {
   /**
    * If not set - will use default SEPOLIA_CONTRACT address.
    */
-  registryAddress?: string;
+  address?: string;
   /**
    * Credentials to use for generating proofs and connecting to the contract and network.
    * If provided used for validating the network chainId and connecting to registry contract.
    */
   credentials?: EncryptedCredentials | DecryptedCredentials;
+  /**
+   * Rate limit for the member.
+   */
+  rateLimit?: number;
 };
 
 type RegisterMembershipOptions =
@@ -119,6 +151,8 @@ export class RLNInstance {
   }
 
   public async start(options: StartRLNOptions = {}): Promise<void> {
+    // eslint-disable-next-line no-console
+    console.log("starting", options);
     if (this.started || this.starting) {
       return;
     }
@@ -128,7 +162,7 @@ export class RLNInstance {
     try {
       const { credentials, keystore } =
         await RLNInstance.decryptCredentialsIfNeeded(options.credentials);
-      const { signer, registryAddress } = await this.determineStartOptions(
+      const { signer, address } = await this.determineStartOptions(
         options,
         credentials
       );
@@ -140,8 +174,9 @@ export class RLNInstance {
       this._credentials = credentials;
       this._signer = signer!;
       this._contract = await RLNContract.init(this, {
-        registryAddress: registryAddress!,
-        signer: signer!
+        address: address!,
+        signer: signer!,
+        rateLimit: options.rateLimit ?? this.zerokit.getRateLimit
       });
       this.started = true;
     } finally {
@@ -154,15 +189,22 @@ export class RLNInstance {
     credentials: KeystoreEntity | undefined
   ): Promise<StartRLNOptions> {
     let chainId = credentials?.membership.chainId;
-    const registryAddress =
+    const address =
       credentials?.membership.address ||
-      options.registryAddress ||
+      options.address ||
       SEPOLIA_CONTRACT.address;
 
-    if (registryAddress === SEPOLIA_CONTRACT.address) {
+    if (address === SEPOLIA_CONTRACT.address) {
       chainId = SEPOLIA_CONTRACT.chainId;
     }
 
+    // eslint-disable-next-line no-console
+    console.log({
+      chainId,
+      address,
+      SEPOLIA_CONTRACT
+    });
+
     const signer = options.signer || (await extractMetaMaskSigner());
     const currentChainId = await signer.getChainId();
 
@@ -174,7 +216,7 @@ export class RLNInstance {
 
     return {
       signer,
-      registryAddress
+      address
     };
   }
 
@@ -270,7 +312,7 @@ export class RLNInstance {
     }
 
     const registryAddress = credentials.membership.address;
-    const currentRegistryAddress = this._contract.registry.address;
+    const currentRegistryAddress = this._contract.address;
     if (registryAddress !== currentRegistryAddress) {
       throw Error(
         `Failed to verify chain coordinates: credentials contract address=${registryAddress} is not equal to registryContract address=${currentRegistryAddress}`
@@ -278,7 +320,7 @@ export class RLNInstance {
     }
 
     const chainId = credentials.membership.chainId;
-    const network = await this._contract.registry.provider.getNetwork();
+    const network = await this._contract.provider.getNetwork();
     const currentChainId = network.chainId;
     if (chainId !== currentChainId) {
       throw Error(

package/src/zerokit.ts

@@ -1,6 +1,7 @@
 import type { IRateLimitProof } from "@waku/interfaces";
 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 { WitnessCalculator } from "./resources/witness_calculator";
@@ -14,9 +15,22 @@ import {
 export class Zerokit {
   public constructor(
     private readonly zkRLN: number,
-    private readonly witnessCalculator: WitnessCalculator
+    private readonly witnessCalculator: WitnessCalculator,
+    private readonly rateLimit: number = DEFAULT_RATE_LIMIT
   ) {}
 
+  public get getZkRLN(): number {
+    return this.zkRLN;
+  }
+
+  public get getWitnessCalculator(): WitnessCalculator {
+    return this.witnessCalculator;
+  }
+
+  public get getRateLimit(): number {
+    return this.rateLimit;
+  }
+
   public generateIdentityCredentials(): IdentityCredential {
     const memKeys = zerokitRLN.generateExtendedMembershipKey(this.zkRLN); // TODO: rename this function in zerokit rln-wasm
     return IdentityCredential.fromBytes(memKeys);
@@ -65,23 +79,36 @@ export class Zerokit {
     uint8Msg: Uint8Array,
     memIndex: number,
     epoch: Uint8Array,
-    idKey: Uint8Array
+    idKey: Uint8Array,
+    rateLimit?: number
   ): Uint8Array {
     // calculate message length
     const msgLen = writeUIntLE(new Uint8Array(8), uint8Msg.length, 0, 8);
-
-    // Converting index to LE bytes
     const memIndexBytes = writeUIntLE(new Uint8Array(8), memIndex, 0, 8);
+    const rateLimitBytes = writeUIntLE(
+      new Uint8Array(8),
+      rateLimit ?? this.rateLimit,
+      0,
+      8
+    );
 
-    // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
-    return concatenate(idKey, memIndexBytes, epoch, msgLen, uint8Msg);
+    // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> | rate_limit<8> ]
+    return concatenate(
+      idKey,
+      memIndexBytes,
+      epoch,
+      msgLen,
+      uint8Msg,
+      rateLimitBytes
+    );
   }
 
   public async generateRLNProof(
     msg: Uint8Array,
     index: number,
     epoch: Uint8Array | Date | undefined,
-    idSecretHash: Uint8Array
+    idSecretHash: Uint8Array,
+    rateLimit?: number
   ): Promise<IRateLimitProof> {
     if (epoch === undefined) {
       epoch = epochIntToBytes(dateToEpoch(new Date()));
@@ -89,15 +116,26 @@ export class Zerokit {
       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
+      idSecretHash,
+      effectiveRateLimit
     );
     const rlnWitness = zerokitRLN.getSerializedRLNWitness(
       this.zkRLN,
@@ -107,7 +145,7 @@ export class Zerokit {
     const calculatedWitness = await this.witnessCalculator.calculateWitness(
       inputs,
       false
-    ); // no sanity check being used in zerokit
+    );
 
     const proofBytes = zerokitRLN.generate_rln_proof_with_witness(
       this.zkRLN,
@@ -120,7 +158,8 @@ export class Zerokit {
 
   public verifyRLNProof(
     proof: IRateLimitProof | Uint8Array,
-    msg: Uint8Array
+    msg: Uint8Array,
+    rateLimit?: number
   ): boolean {
     let pBytes: Uint8Array;
     if (proof instanceof Uint8Array) {
@@ -131,17 +170,24 @@ export class Zerokit {
 
     // calculate message length
     const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+    const rateLimitBytes = writeUIntLE(
+      new Uint8Array(8),
+      rateLimit ?? this.rateLimit,
+      0,
+      8
+    );
 
     return zerokitRLN.verifyRLNProof(
       this.zkRLN,
-      concatenate(pBytes, msgLen, msg)
+      concatenate(pBytes, msgLen, msg, rateLimitBytes)
     );
   }
 
   public verifyWithRoots(
     proof: IRateLimitProof | Uint8Array,
     msg: Uint8Array,
-    ...roots: Array<Uint8Array>
+    roots: Array<Uint8Array>,
+    rateLimit?: number
   ): boolean {
     let pBytes: Uint8Array;
     if (proof instanceof Uint8Array) {
@@ -151,19 +197,26 @@ export class Zerokit {
     }
     // calculate message length
     const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+    const rateLimitBytes = writeUIntLE(
+      new Uint8Array(8),
+      rateLimit ?? this.rateLimit,
+      0,
+      8
+    );
 
     const rootsBytes = concatenate(...roots);
 
     return zerokitRLN.verifyWithRoots(
       this.zkRLN,
-      concatenate(pBytes, msgLen, msg),
+      concatenate(pBytes, msgLen, msg, rateLimitBytes),
       rootsBytes
     );
   }
 
   public verifyWithNoRoot(
     proof: IRateLimitProof | Uint8Array,
-    msg: Uint8Array
+    msg: Uint8Array,
+    rateLimit?: number
   ): boolean {
     let pBytes: Uint8Array;
     if (proof instanceof Uint8Array) {
@@ -174,10 +227,16 @@ export class Zerokit {
 
     // calculate message length
     const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+    const rateLimitBytes = writeUIntLE(
+      new Uint8Array(8),
+      rateLimit ?? this.rateLimit,
+      0,
+      8
+    );
 
     return zerokitRLN.verifyWithRoots(
       this.zkRLN,
-      concatenate(pBytes, msgLen, msg),
+      concatenate(pBytes, msgLen, msg, rateLimitBytes),
       new Uint8Array()
     );
   }