@waku/rln 0.1.5-1d384f2.0 → 0.1.5-1e590d7.0

package/src/contract/rln_base_contract.ts

@@ -33,15 +33,6 @@ export class RLNBaseContract {
    * Allows injecting a mocked contract for testing purposes.
    */
   public constructor(options: RLNContractInitOptions) {
-    // Initialize members and subscriptions
-    this.fetchMembers()
-      .then(() => {
-        this.subscribeToMembers();
-      })
-      .catch((error) => {
-        log.error("Failed to initialize members", { error });
-      });
-
     const {
       address,
       signer,
@@ -49,15 +40,38 @@ export class RLNBaseContract {
       contract
     } = options;
 
-    this.validateRateLimit(rateLimit);
+    log.info("Initializing RLNBaseContract", { address, rateLimit });
 
     this.contract = contract || new ethers.Contract(address, RLN_ABI, signer);
     this.rateLimit = rateLimit;
 
-    // Initialize event filters
-    this._membersFilter = this.contract.filters.MembershipRegistered();
-    this._membershipErasedFilter = this.contract.filters.MembershipErased();
-    this._membersExpiredFilter = this.contract.filters.MembershipExpired();
+    try {
+      log.info("Setting up event filters");
+      // Initialize event filters
+      this._membersFilter = this.contract.filters.MembershipRegistered();
+      this._membershipErasedFilter = this.contract.filters.MembershipErased();
+      this._membersExpiredFilter = this.contract.filters.MembershipExpired();
+      log.info("Event filters initialized successfully");
+    } catch (error) {
+      log.error("Failed to initialize event filters", { error });
+      throw new Error(
+        "Failed to initialize event filters: " + (error as Error).message
+      );
+    }
+
+    // Initialize members and subscriptions
+    this.fetchMembers()
+      .then(() => {
+        this.subscribeToMembers();
+      })
+      .catch((error) => {
+        log.error("Failed to initialize members", { error });
+      });
+
+    // Validate rate limit asynchronously
+    this.validateRateLimit(rateLimit).catch((error) => {
+      log.error("Failed to validate initial rate limit", { error });
+    });
   }
 
   /**
@@ -134,7 +148,7 @@ export class RLNBaseContract {
    * @param newRateLimit The new rate limit to use
    */
   public async setRateLimit(newRateLimit: number): Promise<void> {
-    this.validateRateLimit(newRateLimit);
+    await this.validateRateLimit(newRateLimit);
     this.rateLimit = newRateLimit;
   }
 
@@ -324,7 +338,7 @@ export class RLNBaseContract {
     this.contract.on(
       this.membersFilter,
       (
-        _idCommitment: string,
+        _idCommitment: bigint,
         _membershipRateLimit: ethers.BigNumber,
         _index: ethers.BigNumber,
         event: ethers.Event
@@ -336,7 +350,7 @@ export class RLNBaseContract {
     this.contract.on(
       this.membershipErasedFilter,
       (
-        _idCommitment: string,
+        _idCommitment: bigint,
         _membershipRateLimit: ethers.BigNumber,
         _index: ethers.BigNumber,
         event: ethers.Event
@@ -348,7 +362,7 @@ export class RLNBaseContract {
     this.contract.on(
       this.membersExpiredFilter,
       (
-        _idCommitment: string,
+        _idCommitment: bigint,
         _membershipRateLimit: ethers.BigNumber,
         _index: ethers.BigNumber,
         event: ethers.Event
@@ -358,94 +372,82 @@ export class RLNBaseContract {
     );
   }
 
-  /**
-   * Helper method to get remaining messages in current epoch
-   * @param membershipId The ID of the membership to check
-   * @returns number of remaining messages allowed in current epoch
-   */
-  public async getRemainingMessages(membershipId: number): Promise<number> {
-    try {
-      const [startTime, , rateLimit] =
-        await this.contract.getMembershipInfo(membershipId);
-
-      // Calculate current epoch
-      const currentTime = Math.floor(Date.now() / 1000);
-      const epochsPassed = Math.floor(
-        (currentTime - startTime) / RATE_LIMIT_PARAMS.EPOCH_LENGTH
-      );
-      const currentEpochStart =
-        startTime + epochsPassed * RATE_LIMIT_PARAMS.EPOCH_LENGTH;
-
-      // Get message count in current epoch using contract's function
-      const messageCount = await this.contract.getMessageCount(
-        membershipId,
-        currentEpochStart
-      );
-      return Math.max(
-        0,
-        ethers.BigNumber.from(rateLimit)
-          .sub(ethers.BigNumber.from(messageCount))
-          .toNumber()
-      );
-    } catch (error) {
-      log.error(
-        `Error getting remaining messages: ${(error as Error).message}`
-      );
-      return 0; // Fail safe: assume no messages remaining on error
-    }
-  }
-
   public async getMembershipInfo(
-    idCommitment: string
+    idCommitmentBigInt: bigint
   ): Promise<MembershipInfo | undefined> {
     try {
-      const [startBlock, endBlock, rateLimit] =
-        await this.contract.getMembershipInfo(idCommitment);
+      const membershipData =
+        await this.contract.memberships(idCommitmentBigInt);
       const currentBlock = await this.contract.provider.getBlockNumber();
+      const [
+        depositAmount,
+        activeDuration,
+        gracePeriodStartTimestamp,
+        gracePeriodDuration,
+        rateLimit,
+        index,
+        holder,
+        token
+      ] = membershipData;
+
+      const gracePeriodEnd = gracePeriodStartTimestamp.add(gracePeriodDuration);
 
       let state: MembershipState;
-      if (currentBlock < startBlock) {
+      if (currentBlock < gracePeriodStartTimestamp.toNumber()) {
         state = MembershipState.Active;
-      } else if (currentBlock < endBlock) {
+      } else if (currentBlock < gracePeriodEnd.toNumber()) {
         state = MembershipState.GracePeriod;
       } else {
         state = MembershipState.Expired;
       }
 
-      const index = await this.getMemberIndex(idCommitment);
-      if (!index) return undefined;
-
       return {
         index,
-        idCommitment,
-        rateLimit: rateLimit.toNumber(),
-        startBlock: startBlock.toNumber(),
-        endBlock: endBlock.toNumber(),
-        state
+        idCommitment: idCommitmentBigInt.toString(),
+        rateLimit: Number(rateLimit),
+        startBlock: gracePeriodStartTimestamp.toNumber(),
+        endBlock: gracePeriodEnd.toNumber(),
+        state,
+        depositAmount,
+        activeDuration,
+        gracePeriodDuration,
+        holder,
+        token
       };
     } catch (error) {
+      log.error("Error in getMembershipInfo:", error);
       return undefined;
     }
   }
 
   public async extendMembership(
-    idCommitment: string
+    idCommitmentBigInt: bigint
   ): Promise<ethers.ContractTransaction> {
-    return this.contract.extendMemberships([idCommitment]);
+    const tx = await this.contract.extendMemberships([idCommitmentBigInt]);
+    await tx.wait();
+    return tx;
   }
 
   public async eraseMembership(
-    idCommitment: string,
+    idCommitmentBigInt: bigint,
     eraseFromMembershipSet: boolean = true
   ): Promise<ethers.ContractTransaction> {
-    return this.contract.eraseMemberships(
-      [idCommitment],
-      eraseFromMembershipSet
+    const estimatedGas = await this.contract.estimateGas[
+      "eraseMemberships(uint256[],bool)"
+    ]([idCommitmentBigInt], eraseFromMembershipSet);
+    const gasLimit = estimatedGas.add(10000);
+
+    const tx = await this.contract["eraseMemberships(uint256[],bool)"](
+      [idCommitmentBigInt],
+      eraseFromMembershipSet,
+      { gasLimit }
     );
+    await tx.wait();
+    return tx;
   }
 
   public async registerMembership(
-    idCommitment: string,
+    idCommitmentBigInt: bigint,
     rateLimit: number = DEFAULT_RATE_LIMIT
   ): Promise<ethers.ContractTransaction> {
     if (
@@ -456,12 +458,12 @@ export class RLNBaseContract {
         `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`
       );
     }
-    return this.contract.register(idCommitment, rateLimit, []);
+    return this.contract.register(idCommitmentBigInt, rateLimit, []);
   }
 
-  public async withdraw(token: string, holder: string): Promise<void> {
+  public async withdraw(token: string, from: string): Promise<void> {
     try {
-      const tx = await this.contract.withdraw(token, { from: holder });
+      const tx = await this.contract.withdraw(token, from);
       await tx.wait();
     } catch (error) {
       log.error(`Error in withdraw: ${(error as Error).message}`);
@@ -478,7 +480,7 @@ export class RLNBaseContract {
 
       // Check if the ID commitment is already registered
       const existingIndex = await this.getMemberIndex(
-        identity.IDCommitmentBigInt.toString()
+        identity.IDCommitmentBigInt
       );
       if (existingIndex) {
         throw new Error(
@@ -516,7 +518,7 @@ export class RLNBaseContract {
       }
 
       const memberRegistered = txRegisterReceipt.events?.find(
-        (event) => event.event === "MembershipRegistered"
+        (event: ethers.Event) => event.event === "MembershipRegistered"
       );
 
       if (!memberRegistered || !memberRegistered.args) {
@@ -610,7 +612,7 @@ export class RLNBaseContract {
       const txRegisterReceipt = await txRegisterResponse.wait();
 
       const memberRegistered = txRegisterReceipt.events?.find(
-        (event) => event.event === "MembershipRegistered"
+        (event: ethers.Event) => event.event === "MembershipRegistered"
       );
 
       if (!memberRegistered || !memberRegistered.args) {
@@ -656,13 +658,18 @@ export class RLNBaseContract {
    * Validates that the rate limit is within the allowed range
    * @throws Error if the rate limit is outside the allowed range
    */
-  private validateRateLimit(rateLimit: number): void {
-    if (
-      rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
-      rateLimit > RATE_LIMIT_PARAMS.MAX_RATE
-    ) {
+  private async validateRateLimit(rateLimit: number): Promise<void> {
+    const [minRate, maxRate] = await Promise.all([
+      this.contract.minMembershipRateLimit(),
+      this.contract.maxMembershipRateLimit()
+    ]);
+
+    const minRateNum = ethers.BigNumber.from(minRate).toNumber();
+    const maxRateNum = ethers.BigNumber.from(maxRate).toNumber();
+
+    if (rateLimit < minRateNum || rateLimit > maxRateNum) {
       throw new Error(
-        `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE} messages per epoch`
+        `Rate limit must be between ${minRateNum} and ${maxRateNum} messages per epoch`
       );
     }
   }
@@ -689,11 +696,11 @@ export class RLNBaseContract {
   }
 
   private async getMemberIndex(
-    idCommitment: string
+    idCommitmentBigInt: bigint
   ): Promise<ethers.BigNumber | undefined> {
     try {
       const events = await this.contract.queryFilter(
-        this.contract.filters.MembershipRegistered(idCommitment)
+        this.contract.filters.MembershipRegistered(idCommitmentBigInt)
       );
       if (events.length === 0) return undefined;
 

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/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

@@ -21,8 +21,8 @@ import { isCredentialValid, isKeystoreValid } from "./schema_validator.js";
 import type {
   Keccak256Hash,
   KeystoreEntity,
+  KeystoreMembershipInfo,
   MembershipHash,
-  MembershipInfo,
   Password,
   Sha256Hash
 } from "./types.js";
@@ -310,7 +310,9 @@ export class Keystore {
 
   // 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();

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 };