@waku/rln 0.1.8-e224c05.0 → 0.1.8-e800af3.0

package/src/contract/test_utils.ts

@@ -0,0 +1,179 @@
+import { hexToBytes } from "@waku/utils/bytes";
+import { expect } from "chai";
+import * as ethers from "ethers";
+import sinon from "sinon";
+
+import type { IdentityCredential } from "../identity.js";
+
+import { DEFAULT_RATE_LIMIT, RLN_CONTRACT } from "./constants.js";
+
+export const mockRateLimits = {
+  minRate: 20,
+  maxRate: 600,
+  maxTotalRate: 1200,
+  currentTotalRate: 500
+};
+
+type MockProvider = {
+  getLogs: () => never[];
+  getBlockNumber: () => Promise<number>;
+  getNetwork: () => Promise<{ chainId: number }>;
+};
+
+type MockFilters = {
+  MembershipRegistered: () => { address: string };
+  MembershipErased: () => { address: string };
+  MembershipExpired: () => { address: string };
+};
+
+export function createMockProvider(): MockProvider {
+  return {
+    getLogs: () => [],
+    getBlockNumber: () => Promise.resolve(1000),
+    getNetwork: () => Promise.resolve({ chainId: 11155111 })
+  };
+}
+
+export function createMockFilters(): MockFilters {
+  return {
+    MembershipRegistered: () => ({ address: RLN_CONTRACT.address }),
+    MembershipErased: () => ({ address: RLN_CONTRACT.address }),
+    MembershipExpired: () => ({ address: RLN_CONTRACT.address })
+  };
+}
+
+type ContractOverrides = Partial<{
+  filters: Record<string, unknown>;
+  [key: string]: unknown;
+}>;
+
+export function createMockRegistryContract(
+  overrides: ContractOverrides = {}
+): ethers.Contract {
+  const filters = {
+    MembershipRegistered: () => ({ address: RLN_CONTRACT.address }),
+    MembershipErased: () => ({ address: RLN_CONTRACT.address }),
+    MembershipExpired: () => ({ address: RLN_CONTRACT.address })
+  };
+
+  const baseContract = {
+    minMembershipRateLimit: () =>
+      Promise.resolve(ethers.BigNumber.from(mockRateLimits.minRate)),
+    maxMembershipRateLimit: () =>
+      Promise.resolve(ethers.BigNumber.from(mockRateLimits.maxRate)),
+    maxTotalRateLimit: () =>
+      Promise.resolve(ethers.BigNumber.from(mockRateLimits.maxTotalRate)),
+    currentTotalRateLimit: () =>
+      Promise.resolve(ethers.BigNumber.from(mockRateLimits.currentTotalRate)),
+    queryFilter: () => [],
+    provider: createMockProvider(),
+    filters,
+    on: () => ({}),
+    removeAllListeners: () => ({}),
+    register: () => ({
+      wait: () =>
+        Promise.resolve({
+          events: [mockRLNRegisteredEvent()]
+        })
+    }),
+    estimateGas: {
+      register: () => Promise.resolve(ethers.BigNumber.from(100000))
+    },
+    functions: {
+      register: () => Promise.resolve()
+    },
+    getMemberIndex: () => Promise.resolve(null),
+    interface: {
+      getEvent: (eventName: string) => ({
+        name: eventName,
+        format: () => {}
+      })
+    },
+    address: RLN_CONTRACT.address
+  };
+
+  // Merge overrides while preserving filters
+  const merged = {
+    ...baseContract,
+    ...overrides,
+    filters: { ...filters, ...(overrides.filters || {}) }
+  };
+
+  return merged as unknown as ethers.Contract;
+}
+
+export function mockRLNRegisteredEvent(idCommitment?: string): ethers.Event {
+  return {
+    args: {
+      idCommitment:
+        idCommitment ||
+        "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+      membershipRateLimit: ethers.BigNumber.from(DEFAULT_RATE_LIMIT),
+      index: ethers.BigNumber.from(1)
+    },
+    event: "MembershipRegistered"
+  } as unknown as ethers.Event;
+}
+
+export function formatIdCommitment(idCommitmentBigInt: bigint): string {
+  return "0x" + idCommitmentBigInt.toString(16).padStart(64, "0");
+}
+
+export function createRegisterStub(
+  identity: IdentityCredential
+): sinon.SinonStub {
+  return sinon.stub().callsFake(() => ({
+    wait: () =>
+      Promise.resolve({
+        events: [
+          {
+            event: "MembershipRegistered",
+            args: {
+              idCommitment: formatIdCommitment(identity.IDCommitmentBigInt),
+              membershipRateLimit: ethers.BigNumber.from(DEFAULT_RATE_LIMIT),
+              index: ethers.BigNumber.from(1)
+            }
+          }
+        ]
+      })
+  }));
+}
+
+export function verifyRegistration(
+  decryptedCredentials: any,
+  identity: IdentityCredential,
+  registerStub: sinon.SinonStub,
+  insertMemberSpy: sinon.SinonStub
+): void {
+  if (!decryptedCredentials) {
+    throw new Error("Decrypted credentials should not be undefined");
+  }
+
+  // Verify registration call
+  expect(
+    registerStub.calledWith(
+      sinon.match.same(identity.IDCommitmentBigInt),
+      sinon.match.same(DEFAULT_RATE_LIMIT),
+      sinon.match.array,
+      sinon.match.object
+    )
+  ).to.be.true;
+
+  // Verify credential properties
+  expect(decryptedCredentials).to.have.property("identity");
+  expect(decryptedCredentials).to.have.property("membership");
+  expect(decryptedCredentials.membership).to.include({
+    address: RLN_CONTRACT.address,
+    treeIndex: 1
+  });
+
+  // Verify member insertion
+  const expectedIdCommitment = ethers.utils.zeroPad(
+    hexToBytes(formatIdCommitment(identity.IDCommitmentBigInt)),
+    32
+  );
+  expect(insertMemberSpy.callCount).to.equal(1);
+  expect(insertMemberSpy.getCall(0).args[0]).to.deep.equal(
+    expectedIdCommitment
+  );
+}

package/src/credentials_manager.ts

@@ -1,8 +1,11 @@
+import { hmac } from "@noble/hashes/hmac";
+import { sha256 } from "@noble/hashes/sha2";
 import { Logger } from "@waku/utils";
 import { ethers } from "ethers";
 
-import { RLN_CONTRACT } from "./contract/constants.js";
+import { RLN_CONTRACT, RLN_Q } from "./contract/constants.js";
 import { RLNBaseContract } from "./contract/rln_base_contract.js";
+import { IdentityCredential } from "./identity.js";
 import { Keystore } from "./keystore/index.js";
 import type {
   DecryptedCredentials,
@@ -10,6 +13,7 @@ import type {
 } from "./keystore/index.js";
 import { KeystoreEntity, Password } from "./keystore/types.js";
 import { RegisterMembershipOptions, StartRLNOptions } from "./types.js";
+import { BytesUtils } from "./utils/bytes.js";
 import { extractMetaMaskSigner } from "./utils/index.js";
 import { Zerokit } from "./zerokit.js";
 
@@ -17,6 +21,7 @@ const log = new Logger("waku:credentials");
 
 /**
  * Manages credentials for RLN
+ * This is a lightweight implementation of the RLN contract that doesn't require Zerokit
  * It is used to register membership and generate identity credentials
  */
 export class RLNCredentialsManager {
@@ -29,9 +34,9 @@ export class RLNCredentialsManager {
   protected keystore = Keystore.create();
   public credentials: undefined | DecryptedCredentials;
 
-  public zerokit: Zerokit;
+  public zerokit: undefined | Zerokit;
 
-  public constructor(zerokit: Zerokit) {
+  public constructor(zerokit?: Zerokit) {
     log.info("RLNCredentialsManager initialized");
     this.zerokit = zerokit;
   }
@@ -76,7 +81,7 @@ export class RLNCredentialsManager {
       this.contract = await RLNBaseContract.create({
         address: address!,
         signer: signer!,
-        rateLimit: rateLimit ?? this.zerokit.rateLimit
+        rateLimit: rateLimit ?? this.zerokit?.rateLimit
       });
 
       log.info("RLNCredentialsManager successfully started");
@@ -101,10 +106,18 @@ export class RLNCredentialsManager {
     let identity = "identity" in options && options.identity;
 
     if ("signature" in options) {
-      log.info("Using Zerokit to generate identity");
-      identity = this.zerokit.generateSeededIdentityCredential(
-        options.signature
-      );
+      log.info("Generating identity from signature");
+      if (this.zerokit) {
+        log.info("Using Zerokit to generate identity");
+        identity = this.zerokit.generateSeededIdentityCredential(
+          options.signature
+        );
+      } else {
+        log.info("Using local implementation to generate identity");
+        identity = await this.generateSeededIdentityCredential(
+          options.signature
+        );
+      }
     }
 
     if (!identity) {
@@ -229,4 +242,55 @@ export class RLNCredentialsManager {
       );
     }
   }
+
+  /**
+   * Generates an identity credential from a seed string
+   * This is a pure implementation that doesn't rely on Zerokit
+   * @param seed A string seed to generate the identity from
+   * @returns IdentityCredential
+   */
+  private async generateSeededIdentityCredential(
+    seed: string
+  ): Promise<IdentityCredential> {
+    log.info("Generating seeded identity credential");
+    // Convert the seed to bytes
+    const encoder = new TextEncoder();
+    const seedBytes = encoder.encode(seed);
+
+    // Generate deterministic values using HMAC-SHA256
+    // We use different context strings for each component to ensure they're different
+    const idTrapdoorBE = hmac(sha256, seedBytes, encoder.encode("IDTrapdoor"));
+    const idNullifierBE = hmac(
+      sha256,
+      seedBytes,
+      encoder.encode("IDNullifier")
+    );
+
+    const combinedBytes = new Uint8Array([...idTrapdoorBE, ...idNullifierBE]);
+    const idSecretHashBE = sha256(combinedBytes);
+
+    const idCommitmentRawBE = sha256(idSecretHashBE);
+    const idCommitmentBE = this.reduceIdCommitment(idCommitmentRawBE);
+
+    log.info(
+      "Successfully generated identity credential, storing in Big Endian format"
+    );
+    return new IdentityCredential(
+      idTrapdoorBE,
+      idNullifierBE,
+      idSecretHashBE,
+      idCommitmentBE
+    );
+  }
+
+  /**
+   * Helper: take 32-byte BE, reduce mod Q, return 32-byte BE
+   */
+  private reduceIdCommitment(
+    bytesBE: Uint8Array,
+    limit: bigint = RLN_Q
+  ): Uint8Array {
+    const nBE = BytesUtils.buildBigIntFromUint8ArrayBE(bytesBE);
+    return BytesUtils.bigIntToUint8Array32BE(nBE % limit);
+  }
 }

package/src/identity.ts

@@ -11,7 +11,8 @@ export class IdentityCredential {
     public readonly IDSecretHash: Uint8Array,
     public readonly IDCommitment: Uint8Array
   ) {
-    this.IDCommitmentBigInt = BytesUtils.toBigInt(IDCommitment);
+    this.IDCommitmentBigInt =
+      BytesUtils.buildBigIntFromUint8ArrayBE(IDCommitment);
   }
 
   public static fromBytes(memKeys: Uint8Array): IdentityCredential {

package/src/index.ts

@@ -1,18 +1,28 @@
+import { RLNDecoder, RLNEncoder } from "./codec.js";
 import { RLN_ABI } from "./contract/abi/rln.js";
-import { RLN_CONTRACT } from "./contract/index.js";
+import { RLN_CONTRACT, RLNContract } from "./contract/index.js";
 import { RLNBaseContract } from "./contract/rln_base_contract.js";
 import { createRLN } from "./create.js";
+import { RLNCredentialsManager } from "./credentials_manager.js";
 import { IdentityCredential } from "./identity.js";
 import { Keystore } from "./keystore/index.js";
+import { Proof } from "./proof.js";
 import { RLNInstance } from "./rln.js";
+import { MerkleRootTracker } from "./root_tracker.js";
 import { extractMetaMaskSigner } from "./utils/index.js";
 
 export {
+  RLNCredentialsManager,
   RLNBaseContract,
   createRLN,
   Keystore,
   RLNInstance,
   IdentityCredential,
+  Proof,
+  RLNEncoder,
+  RLNDecoder,
+  MerkleRootTracker,
+  RLNContract,
   RLN_CONTRACT,
   extractMetaMaskSigner,
   RLN_ABI

package/src/keystore/keystore.ts

@@ -264,14 +264,20 @@ export class Keystore {
         _.get(obj, "identityCredential.idSecretHash", [])
       );
 
-      const idCommitmentBigInt = BytesUtils.toBigInt(idCommitmentLE);
+      // Big Endian
+      const idCommitmentBE = BytesUtils.switchEndianness(idCommitmentLE);
+      const idTrapdoorBE = BytesUtils.switchEndianness(idTrapdoorLE);
+      const idNullifierBE = BytesUtils.switchEndianness(idNullifierLE);
+      const idSecretHashBE = BytesUtils.switchEndianness(idSecretHashLE);
+      const idCommitmentBigInt =
+        BytesUtils.buildBigIntFromUint8ArrayBE(idCommitmentBE);
 
       return {
         identity: {
-          IDCommitment: idCommitmentLE,
-          IDTrapdoor: idTrapdoorLE,
-          IDNullifier: idNullifierLE,
-          IDSecretHash: idSecretHashLE,
+          IDCommitment: idCommitmentBE,
+          IDTrapdoor: idTrapdoorBE,
+          IDNullifier: idNullifierBE,
+          IDSecretHash: idSecretHashBE,
           IDCommitmentBigInt: idCommitmentBigInt
         },
         membership: {
@@ -323,18 +329,35 @@ export class Keystore {
 
   // follows nwaku implementation
   // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L98
+  // IdentityCredential is stored in Big Endian format => switch to Little Endian
   private static fromIdentityToBytes(options: KeystoreEntity): Uint8Array {
     const { IDCommitment, IDNullifier, IDSecretHash, IDTrapdoor } =
       options.identity;
+    const idCommitmentLE = BytesUtils.switchEndianness(IDCommitment);
+    const idNullifierLE = BytesUtils.switchEndianness(IDNullifier);
+    const idSecretHashLE = BytesUtils.switchEndianness(IDSecretHash);
+    const idTrapdoorLE = BytesUtils.switchEndianness(IDTrapdoor);
+
+    // eslint-disable-next-line no-console
+    console.log({
+      idCommitmentBE: IDCommitment,
+      idCommitmentLE,
+      idNullifierBE: IDNullifier,
+      idNullifierLE,
+      idSecretHashBE: IDSecretHash,
+      idSecretHashLE,
+      idTrapdoorBE: IDTrapdoor,
+      idTrapdoorLE
+    });
 
     return utf8ToBytes(
       JSON.stringify({
         treeIndex: options.membership.treeIndex,
         identityCredential: {
-          idCommitment: Array.from(IDCommitment),
-          idNullifier: Array.from(IDNullifier),
-          idSecretHash: Array.from(IDSecretHash),
-          idTrapdoor: Array.from(IDTrapdoor)
+          idCommitment: Array.from(idCommitmentLE),
+          idNullifier: Array.from(idNullifierLE),
+          idSecretHash: Array.from(idSecretHashLE),
+          idTrapdoor: Array.from(idTrapdoorLE)
         },
         membershipContract: {
           chainId: options.membership.chainId,

package/src/message.ts

@@ -0,0 +1,73 @@
+import { message } from "@waku/core";
+import type {
+  IDecodedMessage,
+  IMessage,
+  IRateLimitProof,
+  IRlnMessage
+} from "@waku/interfaces";
+import * as utils from "@waku/utils/bytes";
+
+import { RLNInstance } from "./rln.js";
+import { epochBytesToInt } from "./utils/index.js";
+
+export function toRLNSignal(contentTopic: string, msg: IMessage): Uint8Array {
+  const contentTopicBytes = utils.utf8ToBytes(contentTopic ?? "");
+  return new Uint8Array([...(msg.payload ?? []), ...contentTopicBytes]);
+}
+
+export class RlnMessage<T extends IDecodedMessage> implements IRlnMessage {
+  public pubsubTopic = "";
+  public version = message.version_0.Version;
+
+  public constructor(
+    private rlnInstance: RLNInstance,
+    private msg: T,
+    public rateLimitProof: IRateLimitProof | undefined
+  ) {}
+
+  public verify(roots: Uint8Array[]): boolean | undefined {
+    return this.rateLimitProof
+      ? this.rlnInstance.zerokit.verifyWithRoots(
+          this.rateLimitProof,
+          toRLNSignal(this.msg.contentTopic, this.msg),
+          roots
+        ) // this.rlnInstance.verifyRLNProof once issue status-im/nwaku#1248 is fixed
+      : undefined;
+  }
+
+  public verifyNoRoot(): boolean | undefined {
+    return this.rateLimitProof
+      ? this.rlnInstance.zerokit.verifyWithNoRoot(
+          this.rateLimitProof,
+          toRLNSignal(this.msg.contentTopic, this.msg)
+        ) // this.rlnInstance.verifyRLNProof once issue status-im/nwaku#1248 is fixed
+      : undefined;
+  }
+
+  public get payload(): Uint8Array {
+    return this.msg.payload;
+  }
+
+  public get contentTopic(): string {
+    return this.msg.contentTopic;
+  }
+
+  public get timestamp(): Date | undefined {
+    return this.msg.timestamp;
+  }
+
+  public get ephemeral(): boolean | undefined {
+    return this.msg.ephemeral;
+  }
+
+  public get meta(): Uint8Array | undefined {
+    return this.msg.meta;
+  }
+
+  public get epoch(): number | undefined {
+    const bytes = this.rateLimitProof?.epoch;
+    if (!bytes) return undefined;
+
+    return epochBytesToInt(bytes);
+  }
+}

package/src/proof.ts

@@ -0,0 +1,69 @@
+import type { IRateLimitProof } from "@waku/interfaces";
+
+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 {
+  public constructor(
+    public readonly nullifier: Uint8Array,
+    public readonly shareX: Uint8Array,
+    public readonly shareY: Uint8Array,
+    public readonly externalNullifier: Uint8Array
+  ) {}
+}
+
+export class Proof implements IRateLimitProof {
+  public readonly proof: Uint8Array;
+  public readonly merkleRoot: Uint8Array;
+  public readonly epoch: Uint8Array;
+  public readonly shareX: Uint8Array;
+  public readonly shareY: Uint8Array;
+  public readonly nullifier: Uint8Array;
+  public readonly rlnIdentifier: Uint8Array;
+
+  public constructor(proofBytes: Uint8Array) {
+    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
+    );
+  }
+
+  public extractMetadata(): ProofMetadata {
+    const externalNullifier = poseidonHash(this.epoch, this.rlnIdentifier);
+    return new ProofMetadata(
+      this.nullifier,
+      this.shareX,
+      this.shareY,
+      externalNullifier
+    );
+  }
+}
+
+export function proofToBytes(p: IRateLimitProof): Uint8Array {
+  return BytesUtils.concatenate(
+    p.proof,
+    p.merkleRoot,
+    p.epoch,
+    p.shareX,
+    p.shareY,
+    p.nullifier,
+    p.rlnIdentifier
+  );
+}

package/src/resources/verification_key.d.ts

@@ -0,0 +1,13 @@
+declare const verificationKey: {
+  protocol: string;
+  curve: string;
+  nPublic: number;
+  vk_alpha_1: string[];
+  vk_beta_2: string[][];
+  vk_gamma_2: string[][];
+  vk_delta_2: string[][];
+  vk_alphabeta_12: string[][][];
+  IC: string[][];
+};
+
+export default verificationKey;

package/src/resources/witness_calculator.d.ts

@@ -1,25 +1,11 @@
-export const builder: (
+export async function builder(
   code: Uint8Array,
-  sanityCheck?: boolean
-) => Promise<WitnessCalculator>;
+  sanityCheck: boolean
+): Promise<WitnessCalculator>;
 
 export class WitnessCalculator {
-  constructor(instance: any, sanityCheck?: boolean);
-
-  circom_version(): number;
-
-  calculateWitness(
-    input: Record<string, unknown>,
-    sanityCheck?: boolean
-  ): Promise<bigint[]>;
-
-  calculateBinWitness(
-    input: Record<string, unknown>,
-    sanityCheck?: boolean
-  ): Promise<Uint8Array>;
-
-  calculateWTNSBin(
-    input: Record<string, unknown>,
-    sanityCheck?: boolean
-  ): Promise<Uint8Array>;
+  public calculateWitness(
+    input: unknown,
+    sanityCheck: boolean
+  ): Promise<Array<bigint>>;
 }