@waku/rln 0.1.5-1e590d7.0 → 0.1.5-3038c48.0

package/bundle/node_modules/inherits/inherits_browser.js

@@ -0,0 +1,33 @@
+import { __module as inherits_browser } from '../../_virtual/inherits_browser.js';
+
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  inherits_browser.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor;
+      ctor.prototype = Object.create(superCtor.prototype, {
+        constructor: {
+          value: ctor,
+          enumerable: false,
+          writable: true,
+          configurable: true
+        }
+      });
+    }
+  };
+} else {
+  // old school shim for old browsers
+  inherits_browser.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor;
+      var TempCtor = function () {};
+      TempCtor.prototype = superCtor.prototype;
+      ctor.prototype = new TempCtor();
+      ctor.prototype.constructor = ctor;
+    }
+  };
+}
+
+var inherits_browserExports = inherits_browser.exports;
+
+export { inherits_browserExports as i };

package/bundle/node_modules/minimalistic-assert/index.js

@@ -0,0 +1,13 @@
+var minimalisticAssert = assert;
+
+function assert(val, msg) {
+  if (!val)
+    throw new Error(msg || 'Assertion failed');
+}
+
+assert.equal = function assertEqual(l, r, msg) {
+  if (l != r)
+    throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));
+};
+
+export { minimalisticAssert as m };

package/bundle/packages/rln/dist/contract/constants.js

@@ -12,7 +12,6 @@ const LINEA_CONTRACT = {
  */
 const RATE_LIMIT_TIERS = {
     LOW: 20, // Suggested minimum rate - 20 messages per epoch
-    MEDIUM: 200,
     HIGH: 600 // Suggested maximum rate - 600 messages per epoch
 };
 // Global rate limit parameters

package/bundle/packages/rln/dist/contract/rln_base_contract.js

@@ -16,8 +16,8 @@ import { Logger } from '../../../utils/dist/logger/index.js';
 import { RLN_ABI } from './abi.js';
 import { DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from './constants.js';
 import { MembershipState } from './types.js';
-import { Contract } from '@ethersproject/contracts';
-import { BigNumber } from '@ethersproject/bignumber';
+import { Contract } from '../../../../node_modules/@ethersproject/contracts/lib.esm/index.js';
+import { BigNumber } from '../../../../node_modules/@ethersproject/bignumber/lib.esm/bignumber.js';
 
 const log = new Logger("waku:rln:contract:base");
 class RLNBaseContract {
@@ -33,22 +33,6 @@ class RLNBaseContract {
      * Allows injecting a mocked contract for testing purposes.
      */
     constructor(options) {
-        const { address, signer, rateLimit = DEFAULT_RATE_LIMIT, contract } = options;
-        log.info("Initializing RLNBaseContract", { address, rateLimit });
-        this.contract = contract || new Contract(address, RLN_ABI, signer);
-        this.rateLimit = rateLimit;
-        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.message);
-        }
         // Initialize members and subscriptions
         this.fetchMembers()
             .then(() => {
@@ -57,10 +41,14 @@ class RLNBaseContract {
             .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 });
-        });
+        const { address, signer, rateLimit = DEFAULT_RATE_LIMIT, contract } = options;
+        this.validateRateLimit(rateLimit);
+        this.contract = contract || new 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();
     }
     /**
      * Gets the current rate limit for this contract instance
@@ -128,7 +116,7 @@ class RLNBaseContract {
      * @param newRateLimit The new rate limit to use
      */
     async setRateLimit(newRateLimit) {
-        await this.validateRateLimit(newRateLimit);
+        this.validateRateLimit(newRateLimit);
         this.rateLimit = newRateLimit;
     }
     get members() {
@@ -259,63 +247,75 @@ class RLNBaseContract {
             this.processEvents([event]);
         });
     }
-    async getMembershipInfo(idCommitmentBigInt) {
+    /**
+     * 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
+     */
+    async getRemainingMessages(membershipId) {
         try {
-            const membershipData = await this.contract.memberships(idCommitmentBigInt);
+            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, BigNumber.from(rateLimit)
+                .sub(BigNumber.from(messageCount))
+                .toNumber());
+        }
+        catch (error) {
+            log.error(`Error getting remaining messages: ${error.message}`);
+            return 0; // Fail safe: assume no messages remaining on error
+        }
+    }
+    async getMembershipInfo(idCommitment) {
+        try {
+            const [startBlock, endBlock, rateLimit] = await this.contract.getMembershipInfo(idCommitment);
             const currentBlock = await this.contract.provider.getBlockNumber();
-            const [depositAmount, activeDuration, gracePeriodStartTimestamp, gracePeriodDuration, rateLimit, index, holder, token] = membershipData;
-            const gracePeriodEnd = gracePeriodStartTimestamp.add(gracePeriodDuration);
             let state;
-            if (currentBlock < gracePeriodStartTimestamp.toNumber()) {
+            if (currentBlock < startBlock) {
                 state = MembershipState.Active;
             }
-            else if (currentBlock < gracePeriodEnd.toNumber()) {
+            else if (currentBlock < endBlock) {
                 state = MembershipState.GracePeriod;
             }
             else {
                 state = MembershipState.Expired;
             }
+            const index = await this.getMemberIndex(idCommitment);
+            if (!index)
+                return undefined;
             return {
                 index,
-                idCommitment: idCommitmentBigInt.toString(),
-                rateLimit: Number(rateLimit),
-                startBlock: gracePeriodStartTimestamp.toNumber(),
-                endBlock: gracePeriodEnd.toNumber(),
-                state,
-                depositAmount,
-                activeDuration,
-                gracePeriodDuration,
-                holder,
-                token
+                idCommitment,
+                rateLimit: rateLimit.toNumber(),
+                startBlock: startBlock.toNumber(),
+                endBlock: endBlock.toNumber(),
+                state
             };
         }
         catch (error) {
-            log.error("Error in getMembershipInfo:", error);
             return undefined;
         }
     }
-    async extendMembership(idCommitmentBigInt) {
-        const tx = await this.contract.extendMemberships([idCommitmentBigInt]);
-        await tx.wait();
-        return tx;
+    async extendMembership(idCommitment) {
+        return this.contract.extendMemberships([idCommitment]);
     }
-    async eraseMembership(idCommitmentBigInt, eraseFromMembershipSet = true) {
-        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;
+    async eraseMembership(idCommitment, eraseFromMembershipSet = true) {
+        return this.contract.eraseMemberships([idCommitment], eraseFromMembershipSet);
     }
-    async registerMembership(idCommitmentBigInt, rateLimit = DEFAULT_RATE_LIMIT) {
+    async registerMembership(idCommitment, rateLimit = DEFAULT_RATE_LIMIT) {
         if (rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
             rateLimit > RATE_LIMIT_PARAMS.MAX_RATE) {
             throw new Error(`Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`);
         }
-        return this.contract.register(idCommitmentBigInt, rateLimit, []);
+        return this.contract.register(idCommitment, rateLimit, []);
     }
-    async withdraw(token, from) {
+    async withdraw(token, holder) {
         try {
-            const tx = await this.contract.withdraw(token, from);
+            const tx = await this.contract.withdraw(token, { from: holder });
             await tx.wait();
         }
         catch (error) {
@@ -326,7 +326,7 @@ class RLNBaseContract {
         try {
             log.info(`Registering identity with rate limit: ${this.rateLimit} messages/epoch`);
             // Check if the ID commitment is already registered
-            const existingIndex = await this.getMemberIndex(identity.IDCommitmentBigInt);
+            const existingIndex = await this.getMemberIndex(identity.IDCommitmentBigInt.toString());
             if (existingIndex) {
                 throw new Error(`ID commitment is already registered with index ${existingIndex}`);
             }
@@ -435,15 +435,10 @@ class RLNBaseContract {
      * Validates that the rate limit is within the allowed range
      * @throws Error if the rate limit is outside the allowed range
      */
-    async validateRateLimit(rateLimit) {
-        const [minRate, maxRate] = await Promise.all([
-            this.contract.minMembershipRateLimit(),
-            this.contract.maxMembershipRateLimit()
-        ]);
-        const minRateNum = BigNumber.from(minRate).toNumber();
-        const maxRateNum = BigNumber.from(maxRate).toNumber();
-        if (rateLimit < minRateNum || rateLimit > maxRateNum) {
-            throw new Error(`Rate limit must be between ${minRateNum} and ${maxRateNum} messages per epoch`);
+    validateRateLimit(rateLimit) {
+        if (rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
+            rateLimit > RATE_LIMIT_PARAMS.MAX_RATE) {
+            throw new Error(`Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE} messages per epoch`);
         }
     }
     get membersFilter() {
@@ -464,9 +459,9 @@ class RLNBaseContract {
         }
         return this._membersExpiredFilter;
     }
-    async getMemberIndex(idCommitmentBigInt) {
+    async getMemberIndex(idCommitment) {
         try {
-            const events = await this.contract.queryFilter(this.contract.filters.MembershipRegistered(idCommitmentBigInt));
+            const events = await this.contract.queryFilter(this.contract.filters.MembershipRegistered(idCommitment));
             if (events.length === 0)
                 return undefined;
             // Get the most recent registration event

package/bundle/packages/rln/dist/contract/rln_contract.js

@@ -6,7 +6,7 @@ import { Logger } from '../../../utils/dist/logger/index.js';
 import { MerkleRootTracker } from '../root_tracker.js';
 import { zeroPadLE } from '../utils/bytes.js';
 import { RLNBaseContract } from './rln_base_contract.js';
-import { BigNumber } from '@ethersproject/bignumber';
+import { BigNumber } from '../../../../node_modules/@ethersproject/bignumber/lib.esm/bignumber.js';
 
 const log = new Logger("waku:rln:contract");
 class RLNContract extends RLNBaseContract {

package/bundle/packages/rln/dist/utils/bytes.js

@@ -45,14 +45,8 @@ function writeUIntLE(buf, value, offset, byteLength, noAssert) {
  * @returns BigInt
  */
 function buildBigIntFromUint8Array(array, byteOffset = 0) {
-    // 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;
+    const dataView = new DataView(array.buffer);
+    return dataView.getBigUint64(byteOffset, true);
 }
 /**
  * Fills with zeros to set length

package/bundle/packages/rln/dist/utils/metamask.js

@@ -1,4 +1,4 @@
-import * as providers from '@ethersproject/providers';
+import { Web3Provider } from '../../../../node_modules/@ethersproject/providers/lib.esm/web3-provider.js';
 
 const extractMetaMaskSigner = async () => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -7,7 +7,7 @@ const extractMetaMaskSigner = async () => {
         throw Error("Missing or invalid Ethereum provider. Please install a Web3 wallet such as MetaMask.");
     }
     await ethereum.request({ method: "eth_requestAccounts" });
-    const provider = new providers.Web3Provider(ethereum, "any");
+    const provider = new Web3Provider(ethereum, "any");
     return provider.getSigner();
 };