@waku/rln 0.1.5-76f86de.0 → 0.1.5-ad0e277.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (50) hide show
  1. package/bundle/index.js +2 -0
  2. package/bundle/packages/rln/dist/contract/constants.js +1 -1
  3. package/bundle/packages/rln/dist/contract/rln_contract.js +8 -8
  4. package/bundle/packages/rln/dist/contract/rln_light_contract.js +477 -0
  5. package/bundle/packages/rln/dist/identity.js +8 -0
  6. package/bundle/packages/rln/dist/keystore/keystore.js +19 -28
  7. package/bundle/packages/rln/dist/rln.js +4 -4
  8. package/bundle/packages/rln/dist/rln_light.js +149 -0
  9. package/bundle/packages/rln/node_modules/@noble/hashes/esm/_assert.js +43 -0
  10. package/bundle/packages/rln/node_modules/@noble/hashes/esm/_sha2.js +116 -0
  11. package/bundle/packages/rln/node_modules/@noble/hashes/esm/hmac.js +79 -0
  12. package/bundle/packages/rln/node_modules/@noble/hashes/esm/sha256.js +126 -0
  13. package/bundle/packages/rln/node_modules/@noble/hashes/esm/utils.js +43 -0
  14. package/dist/.tsbuildinfo +1 -1
  15. package/dist/contract/constants.d.ts +1 -1
  16. package/dist/contract/constants.js +1 -1
  17. package/dist/contract/constants.js.map +1 -1
  18. package/dist/contract/rln_contract.js +8 -8
  19. package/dist/contract/rln_contract.js.map +1 -1
  20. package/dist/contract/rln_light_contract.d.ts +124 -0
  21. package/dist/contract/rln_light_contract.js +460 -0
  22. package/dist/contract/rln_light_contract.js.map +1 -0
  23. package/dist/contract/test-utils.js +1 -1
  24. package/dist/contract/test-utils.js.map +1 -1
  25. package/dist/identity.d.ts +1 -0
  26. package/dist/identity.js +8 -0
  27. package/dist/identity.js.map +1 -1
  28. package/dist/index.d.ts +3 -1
  29. package/dist/index.js +3 -1
  30. package/dist/index.js.map +1 -1
  31. package/dist/keystore/keystore.d.ts +0 -1
  32. package/dist/keystore/keystore.js +19 -28
  33. package/dist/keystore/keystore.js.map +1 -1
  34. package/dist/keystore/types.d.ts +1 -1
  35. package/dist/rln.js +4 -4
  36. package/dist/rln.js.map +1 -1
  37. package/dist/rln_light.d.ts +64 -0
  38. package/dist/rln_light.js +144 -0
  39. package/dist/rln_light.js.map +1 -0
  40. package/package.json +1 -1
  41. package/src/contract/constants.ts +1 -1
  42. package/src/contract/rln_contract.ts +8 -8
  43. package/src/contract/rln_light_contract.ts +725 -0
  44. package/src/contract/test-utils.ts +1 -1
  45. package/src/identity.ts +9 -0
  46. package/src/index.ts +4 -0
  47. package/src/keystore/keystore.ts +31 -46
  48. package/src/keystore/types.ts +1 -1
  49. package/src/rln.ts +4 -4
  50. package/src/rln_light.ts +235 -0
@@ -0,0 +1,725 @@
1
+ import { Logger } from "@waku/utils";
2
+ import { ethers } from "ethers";
3
+
4
+ import type { IdentityCredential } from "../identity.js";
5
+ import type { DecryptedCredentials } from "../keystore/index.js";
6
+
7
+ import { RLN_ABI } from "./abi.js";
8
+ import { DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from "./constants.js";
9
+
10
+ const log = new Logger("waku:rln:contract");
11
+
12
+ type Member = {
13
+ idCommitment: string;
14
+ index: ethers.BigNumber;
15
+ };
16
+
17
+ interface RLNContractOptions {
18
+ signer: ethers.Signer;
19
+ address: string;
20
+ rateLimit?: number;
21
+ }
22
+
23
+ interface RLNContractInitOptions extends RLNContractOptions {
24
+ contract?: ethers.Contract;
25
+ }
26
+
27
+ export interface MembershipRegisteredEvent {
28
+ idCommitment: string;
29
+ membershipRateLimit: ethers.BigNumber;
30
+ index: ethers.BigNumber;
31
+ }
32
+
33
+ type FetchMembersOptions = {
34
+ fromBlock?: number;
35
+ fetchRange?: number;
36
+ fetchChunks?: number;
37
+ };
38
+
39
+ export interface MembershipInfo {
40
+ index: ethers.BigNumber;
41
+ idCommitment: string;
42
+ rateLimit: number;
43
+ startBlock: number;
44
+ endBlock: number;
45
+ state: MembershipState;
46
+ }
47
+
48
+ export enum MembershipState {
49
+ Active = "Active",
50
+ GracePeriod = "GracePeriod",
51
+ Expired = "Expired",
52
+ ErasedAwaitsWithdrawal = "ErasedAwaitsWithdrawal"
53
+ }
54
+
55
+ export class RLNLightContract {
56
+ public contract: ethers.Contract;
57
+
58
+ private deployBlock: undefined | number;
59
+ private rateLimit: number;
60
+
61
+ private _members: Map<number, Member> = new Map();
62
+ private _membersFilter: ethers.EventFilter;
63
+ private _membershipErasedFilter: ethers.EventFilter;
64
+ private _membersExpiredFilter: ethers.EventFilter;
65
+
66
+ /**
67
+ * Asynchronous initializer for RLNContract.
68
+ * Allows injecting a mocked contract for testing purposes.
69
+ */
70
+ public static async init(
71
+ options: RLNContractInitOptions
72
+ ): Promise<RLNLightContract> {
73
+ const rlnContract = new RLNLightContract(options);
74
+
75
+ await rlnContract.fetchMembers();
76
+ rlnContract.subscribeToMembers();
77
+
78
+ return rlnContract;
79
+ }
80
+
81
+ private constructor(options: RLNContractInitOptions) {
82
+ const {
83
+ address,
84
+ signer,
85
+ rateLimit = DEFAULT_RATE_LIMIT,
86
+ contract
87
+ } = options;
88
+
89
+ if (
90
+ rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
91
+ rateLimit > RATE_LIMIT_PARAMS.MAX_RATE
92
+ ) {
93
+ throw new Error(
94
+ `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE} messages per epoch`
95
+ );
96
+ }
97
+
98
+ this.rateLimit = rateLimit;
99
+
100
+ // Use the injected contract if provided; otherwise, instantiate a new one.
101
+ this.contract = contract || new ethers.Contract(address, RLN_ABI, signer);
102
+
103
+ // Initialize event filters
104
+ this._membersFilter = this.contract.filters.MembershipRegistered();
105
+ this._membershipErasedFilter = this.contract.filters.MembershipErased();
106
+ this._membersExpiredFilter = this.contract.filters.MembershipExpired();
107
+ }
108
+
109
+ /**
110
+ * Gets the current rate limit for this contract instance
111
+ */
112
+ public getRateLimit(): number {
113
+ return this.rateLimit;
114
+ }
115
+
116
+ /**
117
+ * Gets the contract address
118
+ */
119
+ public get address(): string {
120
+ return this.contract.address;
121
+ }
122
+
123
+ /**
124
+ * Gets the contract provider
125
+ */
126
+ public get provider(): ethers.providers.Provider {
127
+ return this.contract.provider;
128
+ }
129
+
130
+ /**
131
+ * Gets the minimum allowed rate limit from the contract
132
+ * @returns Promise<number> The minimum rate limit in messages per epoch
133
+ */
134
+ public async getMinRateLimit(): Promise<number> {
135
+ const minRate = await this.contract.minMembershipRateLimit();
136
+ return ethers.BigNumber.from(minRate).toNumber();
137
+ }
138
+
139
+ /**
140
+ * Gets the maximum allowed rate limit from the contract
141
+ * @returns Promise<number> The maximum rate limit in messages per epoch
142
+ */
143
+ public async getMaxRateLimit(): Promise<number> {
144
+ const maxRate = await this.contract.maxMembershipRateLimit();
145
+ return ethers.BigNumber.from(maxRate).toNumber();
146
+ }
147
+
148
+ /**
149
+ * Gets the maximum total rate limit across all memberships
150
+ * @returns Promise<number> The maximum total rate limit in messages per epoch
151
+ */
152
+ public async getMaxTotalRateLimit(): Promise<number> {
153
+ const maxTotalRate = await this.contract.maxTotalRateLimit();
154
+ return ethers.BigNumber.from(maxTotalRate).toNumber();
155
+ }
156
+
157
+ /**
158
+ * Gets the current total rate limit usage across all memberships
159
+ * @returns Promise<number> The current total rate limit usage in messages per epoch
160
+ */
161
+ public async getCurrentTotalRateLimit(): Promise<number> {
162
+ const currentTotal = await this.contract.currentTotalRateLimit();
163
+ return ethers.BigNumber.from(currentTotal).toNumber();
164
+ }
165
+
166
+ /**
167
+ * Gets the remaining available total rate limit that can be allocated
168
+ * @returns Promise<number> The remaining rate limit that can be allocated
169
+ */
170
+ public async getRemainingTotalRateLimit(): Promise<number> {
171
+ const [maxTotal, currentTotal] = await Promise.all([
172
+ this.contract.maxTotalRateLimit(),
173
+ this.contract.currentTotalRateLimit()
174
+ ]);
175
+ return ethers.BigNumber.from(maxTotal)
176
+ .sub(ethers.BigNumber.from(currentTotal))
177
+ .toNumber();
178
+ }
179
+
180
+ /**
181
+ * Updates the rate limit for future registrations
182
+ * @param newRateLimit The new rate limit to use
183
+ */
184
+ public async setRateLimit(newRateLimit: number): Promise<void> {
185
+ this.rateLimit = newRateLimit;
186
+ }
187
+
188
+ public get members(): Member[] {
189
+ const sortedMembers = Array.from(this._members.values()).sort(
190
+ (left, right) => left.index.toNumber() - right.index.toNumber()
191
+ );
192
+ return sortedMembers;
193
+ }
194
+
195
+ private get membersFilter(): ethers.EventFilter {
196
+ if (!this._membersFilter) {
197
+ throw Error("Members filter was not initialized.");
198
+ }
199
+ return this._membersFilter;
200
+ }
201
+
202
+ private get membershipErasedFilter(): ethers.EventFilter {
203
+ if (!this._membershipErasedFilter) {
204
+ throw Error("MembershipErased filter was not initialized.");
205
+ }
206
+ return this._membershipErasedFilter;
207
+ }
208
+
209
+ private get membersExpiredFilter(): ethers.EventFilter {
210
+ if (!this._membersExpiredFilter) {
211
+ throw Error("MembersExpired filter was not initialized.");
212
+ }
213
+ return this._membersExpiredFilter;
214
+ }
215
+
216
+ public async fetchMembers(options: FetchMembersOptions = {}): Promise<void> {
217
+ const registeredMemberEvents = await queryFilter(this.contract, {
218
+ fromBlock: this.deployBlock,
219
+ ...options,
220
+ membersFilter: this.membersFilter
221
+ });
222
+ const removedMemberEvents = await queryFilter(this.contract, {
223
+ fromBlock: this.deployBlock,
224
+ ...options,
225
+ membersFilter: this.membershipErasedFilter
226
+ });
227
+ const expiredMemberEvents = await queryFilter(this.contract, {
228
+ fromBlock: this.deployBlock,
229
+ ...options,
230
+ membersFilter: this.membersExpiredFilter
231
+ });
232
+
233
+ const events = [
234
+ ...registeredMemberEvents,
235
+ ...removedMemberEvents,
236
+ ...expiredMemberEvents
237
+ ];
238
+ this.processEvents(events);
239
+ }
240
+
241
+ public processEvents(events: ethers.Event[]): void {
242
+ const toRemoveTable = new Map<number, number[]>();
243
+ const toInsertTable = new Map<number, ethers.Event[]>();
244
+
245
+ events.forEach((evt) => {
246
+ if (!evt.args) {
247
+ return;
248
+ }
249
+
250
+ if (
251
+ evt.event === "MembershipErased" ||
252
+ evt.event === "MembershipExpired"
253
+ ) {
254
+ let index = evt.args.index;
255
+
256
+ if (!index) {
257
+ return;
258
+ }
259
+
260
+ if (typeof index === "number" || typeof index === "string") {
261
+ index = ethers.BigNumber.from(index);
262
+ }
263
+
264
+ const toRemoveVal = toRemoveTable.get(evt.blockNumber);
265
+ if (toRemoveVal != undefined) {
266
+ toRemoveVal.push(index.toNumber());
267
+ toRemoveTable.set(evt.blockNumber, toRemoveVal);
268
+ } else {
269
+ toRemoveTable.set(evt.blockNumber, [index.toNumber()]);
270
+ }
271
+ } else if (evt.event === "MembershipRegistered") {
272
+ let eventsPerBlock = toInsertTable.get(evt.blockNumber);
273
+ if (eventsPerBlock == undefined) {
274
+ eventsPerBlock = [];
275
+ }
276
+
277
+ eventsPerBlock.push(evt);
278
+ toInsertTable.set(evt.blockNumber, eventsPerBlock);
279
+ }
280
+ });
281
+ }
282
+
283
+ public subscribeToMembers(): void {
284
+ this.contract.on(
285
+ this.membersFilter,
286
+ (
287
+ _idCommitment: string,
288
+ _membershipRateLimit: ethers.BigNumber,
289
+ _index: ethers.BigNumber,
290
+ event: ethers.Event
291
+ ) => {
292
+ this.processEvents([event]);
293
+ }
294
+ );
295
+
296
+ this.contract.on(
297
+ this.membershipErasedFilter,
298
+ (
299
+ _idCommitment: string,
300
+ _membershipRateLimit: ethers.BigNumber,
301
+ _index: ethers.BigNumber,
302
+ event: ethers.Event
303
+ ) => {
304
+ this.processEvents([event]);
305
+ }
306
+ );
307
+
308
+ this.contract.on(
309
+ this.membersExpiredFilter,
310
+ (
311
+ _idCommitment: string,
312
+ _membershipRateLimit: ethers.BigNumber,
313
+ _index: ethers.BigNumber,
314
+ event: ethers.Event
315
+ ) => {
316
+ this.processEvents([event]);
317
+ }
318
+ );
319
+ }
320
+
321
+ public async registerWithIdentity(
322
+ identity: IdentityCredential
323
+ ): Promise<DecryptedCredentials | undefined> {
324
+ try {
325
+ log.info(
326
+ `Registering identity with rate limit: ${this.rateLimit} messages/epoch`
327
+ );
328
+
329
+ // Check if the ID commitment is already registered
330
+ const existingIndex = await this.getMemberIndex(
331
+ identity.IDCommitmentBigInt.toString()
332
+ );
333
+ if (existingIndex) {
334
+ throw new Error(
335
+ `ID commitment is already registered with index ${existingIndex}`
336
+ );
337
+ }
338
+
339
+ // Check if there's enough remaining rate limit
340
+ const remainingRateLimit = await this.getRemainingTotalRateLimit();
341
+ if (remainingRateLimit < this.rateLimit) {
342
+ throw new Error(
343
+ `Not enough remaining rate limit. Requested: ${this.rateLimit}, Available: ${remainingRateLimit}`
344
+ );
345
+ }
346
+
347
+ const estimatedGas = await this.contract.estimateGas.register(
348
+ identity.IDCommitmentBigInt,
349
+ this.rateLimit,
350
+ []
351
+ );
352
+ const gasLimit = estimatedGas.add(10000);
353
+
354
+ const txRegisterResponse: ethers.ContractTransaction =
355
+ await this.contract.register(
356
+ identity.IDCommitmentBigInt,
357
+ this.rateLimit,
358
+ [],
359
+ { gasLimit }
360
+ );
361
+
362
+ const txRegisterReceipt = await txRegisterResponse.wait();
363
+
364
+ if (txRegisterReceipt.status === 0) {
365
+ throw new Error("Transaction failed on-chain");
366
+ }
367
+
368
+ const memberRegistered = txRegisterReceipt.events?.find(
369
+ (event) => event.event === "MembershipRegistered"
370
+ );
371
+
372
+ if (!memberRegistered || !memberRegistered.args) {
373
+ log.error(
374
+ "Failed to register membership: No MembershipRegistered event found"
375
+ );
376
+ return undefined;
377
+ }
378
+
379
+ const decodedData: MembershipRegisteredEvent = {
380
+ idCommitment: memberRegistered.args.idCommitment,
381
+ membershipRateLimit: memberRegistered.args.membershipRateLimit,
382
+ index: memberRegistered.args.index
383
+ };
384
+
385
+ log.info(
386
+ `Successfully registered membership with index ${decodedData.index} ` +
387
+ `and rate limit ${decodedData.membershipRateLimit}`
388
+ );
389
+
390
+ const network = await this.contract.provider.getNetwork();
391
+ const address = this.contract.address;
392
+ const membershipId = decodedData.index.toString();
393
+
394
+ return {
395
+ identity,
396
+ membership: {
397
+ address,
398
+ treeIndex: parseInt(membershipId),
399
+ chainId: network.chainId.toString(),
400
+ rateLimit: decodedData.membershipRateLimit.toNumber()
401
+ }
402
+ };
403
+ } catch (error) {
404
+ if (error instanceof Error) {
405
+ const errorMessage = error.message;
406
+ log.error("registerWithIdentity - error message:", errorMessage);
407
+ log.error("registerWithIdentity - error stack:", error.stack);
408
+
409
+ // Try to extract more specific error information
410
+ if (errorMessage.includes("CannotExceedMaxTotalRateLimit")) {
411
+ throw new Error(
412
+ "Registration failed: Cannot exceed maximum total rate limit"
413
+ );
414
+ } else if (errorMessage.includes("InvalidIdCommitment")) {
415
+ throw new Error("Registration failed: Invalid ID commitment");
416
+ } else if (errorMessage.includes("InvalidMembershipRateLimit")) {
417
+ throw new Error("Registration failed: Invalid membership rate limit");
418
+ } else if (errorMessage.includes("execution reverted")) {
419
+ throw new Error(
420
+ "Contract execution reverted. Check contract requirements."
421
+ );
422
+ } else {
423
+ throw new Error(`Error in registerWithIdentity: ${errorMessage}`);
424
+ }
425
+ } else {
426
+ throw new Error("Unknown error in registerWithIdentity", {
427
+ cause: error
428
+ });
429
+ }
430
+ }
431
+ }
432
+
433
+ /**
434
+ * Helper method to get remaining messages in current epoch
435
+ * @param membershipId The ID of the membership to check
436
+ * @returns number of remaining messages allowed in current epoch
437
+ */
438
+ public async getRemainingMessages(membershipId: number): Promise<number> {
439
+ try {
440
+ const [startTime, , rateLimit] =
441
+ await this.contract.getMembershipInfo(membershipId);
442
+
443
+ // Calculate current epoch
444
+ const currentTime = Math.floor(Date.now() / 1000);
445
+ const epochsPassed = Math.floor(
446
+ (currentTime - startTime) / RATE_LIMIT_PARAMS.EPOCH_LENGTH
447
+ );
448
+ const currentEpochStart =
449
+ startTime + epochsPassed * RATE_LIMIT_PARAMS.EPOCH_LENGTH;
450
+
451
+ // Get message count in current epoch using contract's function
452
+ const messageCount = await this.contract.getMessageCount(
453
+ membershipId,
454
+ currentEpochStart
455
+ );
456
+ return Math.max(
457
+ 0,
458
+ ethers.BigNumber.from(rateLimit)
459
+ .sub(ethers.BigNumber.from(messageCount))
460
+ .toNumber()
461
+ );
462
+ } catch (error) {
463
+ log.error(
464
+ `Error getting remaining messages: ${(error as Error).message}`
465
+ );
466
+ return 0; // Fail safe: assume no messages remaining on error
467
+ }
468
+ }
469
+
470
+ public async registerWithPermitAndErase(
471
+ identity: IdentityCredential,
472
+ permit: {
473
+ owner: string;
474
+ deadline: number;
475
+ v: number;
476
+ r: string;
477
+ s: string;
478
+ },
479
+ idCommitmentsToErase: string[]
480
+ ): Promise<DecryptedCredentials | undefined> {
481
+ try {
482
+ log.info(
483
+ `Registering identity with permit and rate limit: ${this.rateLimit} messages/epoch`
484
+ );
485
+
486
+ const txRegisterResponse: ethers.ContractTransaction =
487
+ await this.contract.registerWithPermit(
488
+ permit.owner,
489
+ permit.deadline,
490
+ permit.v,
491
+ permit.r,
492
+ permit.s,
493
+ identity.IDCommitmentBigInt,
494
+ this.rateLimit,
495
+ idCommitmentsToErase.map((id) => ethers.BigNumber.from(id))
496
+ );
497
+ const txRegisterReceipt = await txRegisterResponse.wait();
498
+
499
+ const memberRegistered = txRegisterReceipt.events?.find(
500
+ (event) => event.event === "MembershipRegistered"
501
+ );
502
+
503
+ if (!memberRegistered || !memberRegistered.args) {
504
+ log.error(
505
+ "Failed to register membership with permit: No MembershipRegistered event found"
506
+ );
507
+ return undefined;
508
+ }
509
+
510
+ const decodedData: MembershipRegisteredEvent = {
511
+ idCommitment: memberRegistered.args.idCommitment,
512
+ membershipRateLimit: memberRegistered.args.membershipRateLimit,
513
+ index: memberRegistered.args.index
514
+ };
515
+
516
+ log.info(
517
+ `Successfully registered membership with permit. Index: ${decodedData.index}, ` +
518
+ `Rate limit: ${decodedData.membershipRateLimit}, Erased ${idCommitmentsToErase.length} commitments`
519
+ );
520
+
521
+ const network = await this.contract.provider.getNetwork();
522
+ const address = this.contract.address;
523
+ const membershipId = decodedData.index.toString();
524
+
525
+ return {
526
+ identity,
527
+ membership: {
528
+ address,
529
+ treeIndex: parseInt(membershipId),
530
+ chainId: network.chainId.toString(),
531
+ rateLimit: decodedData.membershipRateLimit.toNumber()
532
+ }
533
+ };
534
+ } catch (error) {
535
+ log.error(
536
+ `Error in registerWithPermitAndErase: ${(error as Error).message}`
537
+ );
538
+ return undefined;
539
+ }
540
+ }
541
+
542
+ public async withdraw(token: string, holder: string): Promise<void> {
543
+ try {
544
+ const tx = await this.contract.withdraw(token, { from: holder });
545
+ await tx.wait();
546
+ } catch (error) {
547
+ log.error(`Error in withdraw: ${(error as Error).message}`);
548
+ }
549
+ }
550
+
551
+ public async getMembershipInfo(
552
+ idCommitment: string
553
+ ): Promise<MembershipInfo | undefined> {
554
+ try {
555
+ const [startBlock, endBlock, rateLimit] =
556
+ await this.contract.getMembershipInfo(idCommitment);
557
+ const currentBlock = await this.contract.provider.getBlockNumber();
558
+
559
+ let state: MembershipState;
560
+ if (currentBlock < startBlock) {
561
+ state = MembershipState.Active;
562
+ } else if (currentBlock < endBlock) {
563
+ state = MembershipState.GracePeriod;
564
+ } else {
565
+ state = MembershipState.Expired;
566
+ }
567
+
568
+ const index = await this.getMemberIndex(idCommitment);
569
+ if (!index) return undefined;
570
+
571
+ return {
572
+ index,
573
+ idCommitment,
574
+ rateLimit: rateLimit.toNumber(),
575
+ startBlock: startBlock.toNumber(),
576
+ endBlock: endBlock.toNumber(),
577
+ state
578
+ };
579
+ } catch (error) {
580
+ return undefined;
581
+ }
582
+ }
583
+
584
+ public async extendMembership(
585
+ idCommitment: string
586
+ ): Promise<ethers.ContractTransaction> {
587
+ return this.contract.extendMemberships([idCommitment]);
588
+ }
589
+
590
+ public async eraseMembership(
591
+ idCommitment: string,
592
+ eraseFromMembershipSet: boolean = true
593
+ ): Promise<ethers.ContractTransaction> {
594
+ return this.contract.eraseMemberships(
595
+ [idCommitment],
596
+ eraseFromMembershipSet
597
+ );
598
+ }
599
+
600
+ public async registerMembership(
601
+ idCommitment: string,
602
+ rateLimit: number = DEFAULT_RATE_LIMIT
603
+ ): Promise<ethers.ContractTransaction> {
604
+ if (
605
+ rateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
606
+ rateLimit > RATE_LIMIT_PARAMS.MAX_RATE
607
+ ) {
608
+ throw new Error(
609
+ `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`
610
+ );
611
+ }
612
+ return this.contract.register(idCommitment, rateLimit, []);
613
+ }
614
+
615
+ private async getMemberIndex(
616
+ idCommitment: string
617
+ ): Promise<ethers.BigNumber | undefined> {
618
+ try {
619
+ const events = await this.contract.queryFilter(
620
+ this.contract.filters.MembershipRegistered(idCommitment)
621
+ );
622
+ if (events.length === 0) return undefined;
623
+
624
+ // Get the most recent registration event
625
+ const event = events[events.length - 1];
626
+ return event.args?.index;
627
+ } catch (error) {
628
+ return undefined;
629
+ }
630
+ }
631
+ }
632
+
633
+ interface CustomQueryOptions extends FetchMembersOptions {
634
+ membersFilter: ethers.EventFilter;
635
+ }
636
+
637
+ // These values should be tested on other networks
638
+ const FETCH_CHUNK = 5;
639
+ const BLOCK_RANGE = 3000;
640
+
641
+ async function queryFilter(
642
+ contract: ethers.Contract,
643
+ options: CustomQueryOptions
644
+ ): Promise<ethers.Event[]> {
645
+ const {
646
+ fromBlock,
647
+ membersFilter,
648
+ fetchRange = BLOCK_RANGE,
649
+ fetchChunks = FETCH_CHUNK
650
+ } = options;
651
+
652
+ if (fromBlock === undefined) {
653
+ return contract.queryFilter(membersFilter);
654
+ }
655
+
656
+ if (!contract.provider) {
657
+ throw Error("No provider found on the contract.");
658
+ }
659
+
660
+ const toBlock = await contract.provider.getBlockNumber();
661
+
662
+ if (toBlock - fromBlock < fetchRange) {
663
+ return contract.queryFilter(membersFilter, fromBlock, toBlock);
664
+ }
665
+
666
+ const events: ethers.Event[][] = [];
667
+ const chunks = splitToChunks(fromBlock, toBlock, fetchRange);
668
+
669
+ for (const portion of takeN<[number, number]>(chunks, fetchChunks)) {
670
+ const promises = portion.map(([left, right]) =>
671
+ ignoreErrors(contract.queryFilter(membersFilter, left, right), [])
672
+ );
673
+ const fetchedEvents = await Promise.all(promises);
674
+ events.push(fetchedEvents.flatMap((v) => v));
675
+ }
676
+
677
+ return events.flatMap((v) => v);
678
+ }
679
+
680
+ function splitToChunks(
681
+ from: number,
682
+ to: number,
683
+ step: number
684
+ ): Array<[number, number]> {
685
+ const chunks: Array<[number, number]> = [];
686
+
687
+ let left = from;
688
+ while (left < to) {
689
+ const right = left + step < to ? left + step : to;
690
+
691
+ chunks.push([left, right] as [number, number]);
692
+
693
+ left = right;
694
+ }
695
+
696
+ return chunks;
697
+ }
698
+
699
+ function* takeN<T>(array: T[], size: number): Iterable<T[]> {
700
+ let start = 0;
701
+
702
+ while (start < array.length) {
703
+ const portion = array.slice(start, start + size);
704
+
705
+ yield portion;
706
+
707
+ start += size;
708
+ }
709
+ }
710
+
711
+ async function ignoreErrors<T>(
712
+ promise: Promise<T>,
713
+ defaultValue: T
714
+ ): Promise<T> {
715
+ try {
716
+ return await promise;
717
+ } catch (err: unknown) {
718
+ if (err instanceof Error) {
719
+ log.info(`Ignoring an error during query: ${err.message}`);
720
+ } else {
721
+ log.info(`Ignoring an unknown error during query`);
722
+ }
723
+ return defaultValue;
724
+ }
725
+ }