@waku/rln 0.1.5-053bb95.0 → 0.1.5-164df63.0

package/src/contract/rln_contract.ts

@@ -1,11 +1,11 @@
 import { Logger } from "@waku/utils";
 import { hexToBytes } from "@waku/utils/bytes";
+import { ethers } from "ethers";
 
 import type { RLNInstance } from "../rln.js";
 import { MerkleRootTracker } from "../root_tracker.js";
 import { zeroPadLE } from "../utils/bytes.js";
 
-import { ContractStateError } from "./errors.js";
 import { RLNBaseContract } from "./rln_base_contract.js";
 import { RLNContractInitOptions } from "./types.js";
 
@@ -14,7 +14,6 @@ const log = new Logger("waku:rln:contract");
 export class RLNContract extends RLNBaseContract {
   private instance: RLNInstance;
   private merkleRootTracker: MerkleRootTracker;
-  private lastSyncedBlock: number = 0;
 
   /**
    * Asynchronous initializer for RLNContract.
@@ -25,42 +24,8 @@ export class RLNContract extends RLNBaseContract {
     options: RLNContractInitOptions
   ): Promise<RLNContract> {
     const rlnContract = new RLNContract(rlnInstance, options);
-    await rlnContract.syncState();
-    return rlnContract;
-  }
-
-  /**
-   * Override base contract method to keep Merkle tree in sync
-   * Registers a new membership with the given commitment and rate limit
-   */
-  public override async registerMembership(
-    idCommitment: string,
-    rateLimit: number = this.getRateLimit()
-  ): Promise<void> {
-    await super.registerMembership(idCommitment, rateLimit);
-    await this.syncState();
-  }
 
-  /**
-   * Override base contract method to keep Merkle tree in sync
-   * Erases an existing membership from the contract
-   */
-  public override async eraseMembership(
-    idCommitment: string,
-    eraseFromMembershipSet: boolean = true
-  ): Promise<void> {
-    await super.eraseMembership(idCommitment, eraseFromMembershipSet);
-    await this.syncState();
-  }
-
-  /**
-   * Gets the current Merkle root
-   * Returns the latest valid root or empty array if no roots exist
-   */
-  public async getMerkleRoot(): Promise<Uint8Array> {
-    await this.syncState();
-    const roots = this.merkleRootTracker.roots();
-    return roots.length > 0 ? roots[0] : new Uint8Array();
+    return rlnContract;
   }
 
   private constructor(
@@ -68,102 +33,112 @@ export class RLNContract extends RLNBaseContract {
     options: RLNContractInitOptions
   ) {
     super(options);
+
     this.instance = rlnInstance;
+
     const initialRoot = rlnInstance.zerokit.getMerkleRoot();
     this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
   }
 
-  /**
-   * Syncs the local Merkle tree with the current contract state
-   */
-  private async syncState(): Promise<void> {
-    try {
-      const currentBlock = await this.provider.getBlockNumber();
-
-      // If we're already synced, just get new members
-      if (this.lastSyncedBlock > 0) {
-        await this.syncNewMembers(this.lastSyncedBlock, currentBlock);
-        this.lastSyncedBlock = currentBlock;
+  public override processEvents(events: ethers.Event[]): void {
+    const toRemoveTable = new Map<number, number[]>();
+    const toInsertTable = new Map<number, ethers.Event[]>();
+
+    events.forEach((evt) => {
+      if (!evt.args) {
         return;
       }
 
-      // First time sync - get all members
-      const nextIndex = await this.contract.nextFreeIndex();
-      const members = await this.getMembersInRange(0, nextIndex.toNumber());
-
-      // Clear existing members by deleting them one by one
-      // This effectively resets the tree without needing resetTree()
-      for (let i = 0; i < nextIndex.toNumber(); i++) {
-        try {
-          this.instance.zerokit.deleteMember(i);
-        } catch (error) {
-          // Ignore errors for non-existent members
-          continue;
+      if (
+        evt.event === "MembershipErased" ||
+        evt.event === "MembershipExpired"
+      ) {
+        let index = evt.args.index;
+
+        if (!index) {
+          return;
         }
-      }
 
-      // Insert all members
-      for (const member of members) {
-        const idCommitment = zeroPadLE(hexToBytes(member.idCommitment), 32);
-        this.instance.zerokit.insertMember(idCommitment);
+        if (typeof index === "number" || typeof index === "string") {
+          index = ethers.BigNumber.from(index);
+        } else {
+          log.error("Index is not a number or string", {
+            index,
+            event: evt
+          });
+          return;
+        }
+
+        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 if (evt.event === "MembershipRegistered") {
+        let eventsPerBlock = toInsertTable.get(evt.blockNumber);
+        if (eventsPerBlock == undefined) {
+          eventsPerBlock = [];
+        }
+
+        eventsPerBlock.push(evt);
+        toInsertTable.set(evt.blockNumber, eventsPerBlock);
       }
+    });
 
-      // Update root tracker
-      const currentRoot = this.instance.zerokit.getMerkleRoot();
-      this.merkleRootTracker.pushRoot(currentBlock, currentRoot);
-      this.lastSyncedBlock = currentBlock;
-
-      log.info(
-        `Synced ${members.length} members to current block ${currentBlock}`
-      );
-    } catch (error) {
-      log.error("Failed to sync state", error);
-      throw new ContractStateError("Failed to sync contract state");
-    }
+    this.removeMembers(this.instance, toRemoveTable);
+    this.insertMembers(this.instance, toInsertTable);
   }
 
-  /**
-   * Syncs new members added between fromBlock and toBlock
-   */
-  private async syncNewMembers(
-    fromBlock: number,
-    toBlock: number
-  ): Promise<void> {
-    // Get members that were added
-    const filter = this.contract.filters.MembershipRegistered();
-    const addEvents = await this.contract.queryFilter(
-      filter,
-      fromBlock,
-      toBlock
-    );
-
-    // Get members that were removed
-    const removeFilter = this.contract.filters.MembershipErased();
-    const removeEvents = await this.contract.queryFilter(
-      removeFilter,
-      fromBlock,
-      toBlock
-    );
-
-    // Process removals first (in reverse block order)
-    for (const evt of removeEvents.sort(
-      (a, b) => b.blockNumber - a.blockNumber
-    )) {
-      if (!evt.args) continue;
-      const index = evt.args.index.toNumber();
-      this.instance.zerokit.deleteMember(index);
-      this.merkleRootTracker.backFill(evt.blockNumber);
-    }
-
-    // Then process additions
-    for (const evt of addEvents) {
-      if (!evt.args) continue;
-      const idCommitment = zeroPadLE(hexToBytes(evt.args.idCommitment), 32);
-      this.instance.zerokit.insertMember(idCommitment);
-      this.merkleRootTracker.pushRoot(
-        evt.blockNumber,
-        this.instance.zerokit.getMerkleRoot()
-      );
-    }
+  private insertMembers(
+    rlnInstance: RLNInstance,
+    toInsert: Map<number, ethers.Event[]>
+  ): void {
+    toInsert.forEach((events: ethers.Event[], blockNumber: number) => {
+      events.forEach((evt) => {
+        if (!evt.args) return;
+
+        const _idCommitment = evt.args.idCommitment as string;
+        let index = evt.args.index;
+
+        if (!_idCommitment || !index) {
+          return;
+        }
+
+        if (typeof index === "number" || typeof index === "string") {
+          index = ethers.BigNumber.from(index);
+        }
+
+        const idCommitment = zeroPadLE(hexToBytes(_idCommitment), 32);
+        rlnInstance.zerokit.insertMember(idCommitment);
+
+        const numericIndex = index.toNumber();
+        this._members.set(numericIndex, {
+          index,
+          idCommitment: _idCommitment
+        });
+      });
+
+      const currentRoot = rlnInstance.zerokit.getMerkleRoot();
+      this.merkleRootTracker.pushRoot(blockNumber, currentRoot);
+    });
+  }
+
+  private removeMembers(
+    rlnInstance: RLNInstance,
+    toRemove: Map<number, number[]>
+  ): void {
+    const removeDescending = new Map([...toRemove].reverse());
+    removeDescending.forEach((indexes: number[], blockNumber: number) => {
+      indexes.forEach((index) => {
+        if (this._members.has(index)) {
+          this._members.delete(index);
+          rlnInstance.zerokit.deleteMember(index);
+        }
+      });
+
+      this.merkleRootTracker.backFill(blockNumber);
+    });
   }
 }

package/src/contract/types.ts

@@ -38,6 +38,11 @@ export interface MembershipInfo {
   startBlock: number;
   endBlock: number;
   state: MembershipState;
+  depositAmount: ethers.BigNumber;
+  activeDuration: number;
+  gracePeriodDuration: number;
+  holder: string;
+  token: string;
 }
 
 export enum MembershipState {

package/src/credentials_manager.ts

@@ -155,7 +155,7 @@ export class RLNCredentialsManager {
       LINEA_CONTRACT.address;
 
     if (address === LINEA_CONTRACT.address) {
-      chainId = LINEA_CONTRACT.chainId;
+      chainId = LINEA_CONTRACT.chainId.toString();
       log.info(`Using Linea contract with chainId: ${chainId}`);
     }
 

package/src/identity.ts

@@ -28,13 +28,4 @@ export class IdentityCredential {
       idCommitmentBigInt
     );
   }
-
-  public toJSON(): Record<string, number[]> {
-    return {
-      idTrapdoor: Array.from(this.IDTrapdoor),
-      idNullifier: Array.from(this.IDNullifier),
-      idSecretHash: Array.from(this.IDSecretHash),
-      idCommitment: Array.from(this.IDCommitment)
-    };
-  }
 }

package/src/index.ts

@@ -34,7 +34,9 @@ export type {
   Keccak256Hash,
   KeystoreEntity,
   MembershipHash,
-  MembershipInfo,
+  KeystoreMembershipInfo,
   Password,
   Sha256Hash
 } from "./keystore/types.js";
+
+export * from "./contract/index.js";

package/src/keystore/keystore.ts

@@ -14,7 +14,6 @@ import {
 import _ from "lodash";
 import { v4 as uuidV4 } from "uuid";
 
-import { IdentityCredential } from "../identity.js";
 import { buildBigIntFromUint8Array } from "../utils/bytes.js";
 
 import { decryptEipKeystore, keccak256Checksum } from "./cipher.js";
@@ -22,8 +21,8 @@ import { isCredentialValid, isKeystoreValid } from "./schema_validator.js";
 import type {
   Keccak256Hash,
   KeystoreEntity,
+  KeystoreMembershipInfo,
   MembershipHash,
-  MembershipInfo,
   Password,
   Sha256Hash
 } from "./types.js";
@@ -251,27 +250,27 @@ export class Keystore {
       const str = bytesToUtf8(bytes);
       const obj = JSON.parse(str);
 
-      // Get identity fields from named object
-      const { idTrapdoor, idNullifier, idSecretHash, idCommitment } = _.get(
-        obj,
-        "identityCredential",
-        {}
-      );
-
-      const idTrapdoorArray = new Uint8Array(idTrapdoor || []);
-      const idNullifierArray = new Uint8Array(idNullifier || []);
-      const idSecretHashArray = new Uint8Array(idSecretHash || []);
-      const idCommitmentArray = new Uint8Array(idCommitment || []);
-      const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitmentArray);
-
+      // TODO: add runtime validation of nwaku credentials
       return {
-        identity: new IdentityCredential(
-          idTrapdoorArray,
-          idNullifierArray,
-          idSecretHashArray,
-          idCommitmentArray,
-          idCommitmentBigInt
-        ),
+        identity: {
+          IDCommitment: Keystore.fromArraylikeToBytes(
+            _.get(obj, "identityCredential.idCommitment", [])
+          ),
+          IDTrapdoor: Keystore.fromArraylikeToBytes(
+            _.get(obj, "identityCredential.idTrapdoor", [])
+          ),
+          IDNullifier: Keystore.fromArraylikeToBytes(
+            _.get(obj, "identityCredential.idNullifier", [])
+          ),
+          IDCommitmentBigInt: buildBigIntFromUint8Array(
+            Keystore.fromArraylikeToBytes(
+              _.get(obj, "identityCredential.idCommitment", [])
+            )
+          ),
+          IDSecretHash: Keystore.fromArraylikeToBytes(
+            _.get(obj, "identityCredential.idSecretHash", [])
+          )
+        },
         membership: {
           treeIndex: _.get(obj, "treeIndex"),
           chainId: _.get(obj, "membershipContract.chainId"),
@@ -285,9 +284,35 @@ export class Keystore {
     }
   }
 
+  private static fromArraylikeToBytes(
+    obj:
+      | number[]
+      | {
+          [key: number]: number;
+        }
+  ): Uint8Array {
+    if (Array.isArray(obj)) {
+      return new Uint8Array(obj);
+    }
+
+    const bytes = [];
+    let index = 0;
+    let lastElement = obj[index];
+
+    while (lastElement !== undefined) {
+      bytes.push(lastElement);
+      index += 1;
+      lastElement = obj[index];
+    }
+
+    return new Uint8Array(bytes);
+  }
+
   // follows nwaku implementation
   // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L111
-  private static computeMembershipHash(info: MembershipInfo): MembershipHash {
+  private static computeMembershipHash(
+    info: KeystoreMembershipInfo
+  ): MembershipHash {
     return bytesToHex(
       sha256(utf8ToBytes(`${info.chainId}${info.address}${info.treeIndex}`))
     ).toUpperCase();
@@ -298,16 +323,16 @@ export class Keystore {
   private static fromIdentityToBytes(options: KeystoreEntity): Uint8Array {
     return utf8ToBytes(
       JSON.stringify({
-        membershipContract: {
-          chainId: options.membership.chainId,
-          address: options.membership.address
-        },
         treeIndex: options.membership.treeIndex,
         identityCredential: {
-          idTrapdoor: Array.from(options.identity.IDTrapdoor),
+          idCommitment: Array.from(options.identity.IDCommitment),
           idNullifier: Array.from(options.identity.IDNullifier),
           idSecretHash: Array.from(options.identity.IDSecretHash),
-          idCommitment: Array.from(options.identity.IDCommitment)
+          idTrapdoor: Array.from(options.identity.IDTrapdoor)
+        },
+        membershipContract: {
+          chainId: options.membership.chainId,
+          address: options.membership.address
         },
         userMessageLimit: options.membership.rateLimit
       })

package/src/keystore/types.ts

@@ -7,7 +7,7 @@ export type Password = string | Uint8Array;
 
 // see reference
 // https://github.com/waku-org/nwaku/blob/f05528d4be3d3c876a8b07f9bb7dfaae8aa8ec6e/waku/waku_keystore/protocol_types.nim#L111
-export type MembershipInfo = {
+export type KeystoreMembershipInfo = {
   chainId: string;
   address: string;
   treeIndex: number;
@@ -16,7 +16,7 @@ export type MembershipInfo = {
 
 export type KeystoreEntity = {
   identity: IdentityCredential;
-  membership: MembershipInfo;
+  membership: KeystoreMembershipInfo;
 };
 
 export type DecryptedCredentials = KeystoreEntity;

package/src/utils/bytes.ts

@@ -65,8 +65,16 @@ export function buildBigIntFromUint8Array(
   array: Uint8Array,
   byteOffset: number = 0
 ): bigint {
-  const dataView = new DataView(array.buffer);
-  return dataView.getBigUint64(byteOffset, true);
+  // Convert byte array to BigInt in big-endian format (to match nwaku)
+  let result = 0n;
+  // Process all 32 bytes (or the available bytes if less)
+  const length = Math.min(array.length - byteOffset, 32);
+
+  for (let i = 0; i < length; i++) {
+    result = (result << 8n) | BigInt(array[byteOffset + i]);
+  }
+
+  return result;
 }
 
 /**

package/bundle/_virtual/__node-resolve_empty.js

@@ -1,6 +0,0 @@
-import * as _nodeResolve_empty from './_node-resolve_empty.js';
-import { getAugmentedNamespace } from './_commonjsHelpers.js';
-
-var require$$0 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty);
-
-export { require$$0 as default };

package/bundle/_virtual/_node-resolve_empty.js

@@ -1,3 +0,0 @@
-var _nodeResolve_empty = {};
-
-export { _nodeResolve_empty as default };

package/bundle/_virtual/bn.js

@@ -1,3 +0,0 @@
-var bn = {exports: {}};
-
-export { bn as __module };

package/bundle/_virtual/common.js

@@ -1,3 +0,0 @@
-var common = {};
-
-export { common as __exports };

package/bundle/_virtual/common2.js

@@ -1,3 +0,0 @@
-var common = {};
-
-export { common as __exports };

package/bundle/_virtual/hash.js

@@ -1,3 +0,0 @@
-var hash = {};
-
-export { hash as __exports };

package/bundle/_virtual/inherits_browser.js

@@ -1,3 +0,0 @@
-var inherits_browser = {exports: {}};
-
-export { inherits_browser as __module };

package/bundle/_virtual/ripemd.js

@@ -1,3 +0,0 @@
-var ripemd = {};
-
-export { ripemd as __exports };

package/bundle/_virtual/sha.js

@@ -1,3 +0,0 @@
-var sha = {};
-
-export { sha as __exports };

package/bundle/_virtual/sha3.js

@@ -1,3 +0,0 @@
-var sha3 = {exports: {}};
-
-export { sha3 as __module };

package/bundle/_virtual/utils3.js

@@ -1,3 +0,0 @@
-var utils = {};
-
-export { utils as __exports };

package/bundle/node_modules/@ethersproject/abi/lib.esm/_version.js

@@ -1,3 +0,0 @@
-const version = "abi/5.7.0";
-
-export { version };

package/bundle/node_modules/@ethersproject/abi/lib.esm/abi-coder.js

@@ -1,96 +0,0 @@
-import { arrayify } from '../../bytes/lib.esm/index.js';
-import { defineReadOnly } from '../../properties/lib.esm/index.js';
-import { Logger } from '../../logger/lib.esm/index.js';
-import { version } from './_version.js';
-import { Reader, Writer } from './coders/abstract-coder.js';
-import { AddressCoder } from './coders/address.js';
-import { ArrayCoder } from './coders/array.js';
-import { BooleanCoder } from './coders/boolean.js';
-import { BytesCoder } from './coders/bytes.js';
-import { FixedBytesCoder } from './coders/fixed-bytes.js';
-import { NullCoder } from './coders/null.js';
-import { NumberCoder } from './coders/number.js';
-import { StringCoder } from './coders/string.js';
-import { TupleCoder } from './coders/tuple.js';
-import { ParamType } from './fragments.js';
-
-const logger = new Logger(version);
-const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
-const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
-class AbiCoder {
-    constructor(coerceFunc) {
-        defineReadOnly(this, "coerceFunc", coerceFunc || null);
-    }
-    _getCoder(param) {
-        switch (param.baseType) {
-            case "address":
-                return new AddressCoder(param.name);
-            case "bool":
-                return new BooleanCoder(param.name);
-            case "string":
-                return new StringCoder(param.name);
-            case "bytes":
-                return new BytesCoder(param.name);
-            case "array":
-                return new ArrayCoder(this._getCoder(param.arrayChildren), param.arrayLength, param.name);
-            case "tuple":
-                return new TupleCoder((param.components || []).map((component) => {
-                    return this._getCoder(component);
-                }), param.name);
-            case "":
-                return new NullCoder(param.name);
-        }
-        // u?int[0-9]*
-        let match = param.type.match(paramTypeNumber);
-        if (match) {
-            let size = parseInt(match[2] || "256");
-            if (size === 0 || size > 256 || (size % 8) !== 0) {
-                logger.throwArgumentError("invalid " + match[1] + " bit length", "param", param);
-            }
-            return new NumberCoder(size / 8, (match[1] === "int"), param.name);
-        }
-        // bytes[0-9]+
-        match = param.type.match(paramTypeBytes);
-        if (match) {
-            let size = parseInt(match[1]);
-            if (size === 0 || size > 32) {
-                logger.throwArgumentError("invalid bytes length", "param", param);
-            }
-            return new FixedBytesCoder(size, param.name);
-        }
-        return logger.throwArgumentError("invalid type", "type", param.type);
-    }
-    _getWordSize() { return 32; }
-    _getReader(data, allowLoose) {
-        return new Reader(data, this._getWordSize(), this.coerceFunc, allowLoose);
-    }
-    _getWriter() {
-        return new Writer(this._getWordSize());
-    }
-    getDefaultValue(types) {
-        const coders = types.map((type) => this._getCoder(ParamType.from(type)));
-        const coder = new TupleCoder(coders, "_");
-        return coder.defaultValue();
-    }
-    encode(types, values) {
-        if (types.length !== values.length) {
-            logger.throwError("types/values length mismatch", Logger.errors.INVALID_ARGUMENT, {
-                count: { types: types.length, values: values.length },
-                value: { types: types, values: values }
-            });
-        }
-        const coders = types.map((type) => this._getCoder(ParamType.from(type)));
-        const coder = (new TupleCoder(coders, "_"));
-        const writer = this._getWriter();
-        coder.encode(writer, values);
-        return writer.data;
-    }
-    decode(types, data, loose) {
-        const coders = types.map((type) => this._getCoder(ParamType.from(type)));
-        const coder = new TupleCoder(coders, "_");
-        return coder.decode(this._getReader(arrayify(data), loose));
-    }
-}
-const defaultAbiCoder = new AbiCoder();
-
-export { AbiCoder, defaultAbiCoder };