@waku/rln 0.1.1-5b9414a → 0.1.1-7e8cb89

package/bundle/index.js

@@ -1907,7 +1907,7 @@ class RlnMessage {
         this.rlnInstance = rlnInstance;
         this.msg = msg;
         this.rateLimitProof = rateLimitProof;
-        this.pubSubTopic = "";
+        this.pubsubTopic = "";
     }
     verify(roots) {
         return this.rateLimitProof
@@ -1973,6 +1973,9 @@ class RLNEncoder {
         console.timeEnd("proof_gen_timer");
         return proof;
     }
+    get pubsubTopic() {
+        return this.encoder.pubsubTopic;
+    }
     get contentTopic() {
         return this.encoder.contentTopic;
     }
@@ -1985,6 +1988,9 @@ class RLNDecoder {
         this.rlnInstance = rlnInstance;
         this.decoder = decoder;
     }
+    get pubsubTopic() {
+        return this.decoder.pubsubTopic;
+    }
     get contentTopic() {
         return this.decoder.contentTopic;
     }
@@ -1993,8 +1999,8 @@ class RLNDecoder {
         log("Message decoded", protoMessage);
         return Promise.resolve(protoMessage);
     }
-    async fromProtoObj(pubSubTopic, proto) {
-        const msg = await this.decoder.fromProtoObj(pubSubTopic, proto);
+    async fromProtoObj(pubsubTopic, proto) {
+        const msg = await this.decoder.fromProtoObj(pubsubTopic, proto);
         if (!msg)
             return;
         return new RlnMessage(this.rlnInstance, msg, proto.rateLimitProof);
@@ -2064,7 +2070,7 @@ const RLN_STORAGE_ABI = [
 ];
 const SEPOLIA_CONTRACT = {
     chainId: 11155111,
-    address: "0xF1935b338321013f11068abCafC548A7B0db732C",
+    address: "0xF471d71E9b1455bBF4b85d475afb9BB0954A29c4",
     abi: RLN_REGISTRY_ABI,
 };
 
@@ -24528,11 +24534,11 @@ class Keystore {
             // TODO: add runtime validation of nwaku credentials
             return {
                 identity: {
-                    IDCommitment: _.get(obj, "identityCredential.idCommitment"),
-                    IDTrapdoor: _.get(obj, "identityCredential.idTrapdoor"),
-                    IDNullifier: _.get(obj, "identityCredential.idNullifier"),
-                    IDCommitmentBigInt: buildBigIntFromUint8Array(new Uint8Array(_.get(obj, "identityCredential.idCommitment", []))),
-                    IDSecretHash: _.get(obj, "identityCredential.idSecretHash"),
+                    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"),
@@ -24546,6 +24552,17 @@ class Keystore {
             return null;
         }
     }
+    static fromArraylikeToBytes(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
     static computeMembershipHash(info) {
@@ -25779,7 +25796,7 @@ async function loadZkey() {
  * @returns RLNInstance
  */
 async function create$1() {
-    await init();
+    await init?.();
     init_panic_hook();
     const witnessCalculator = await loadWitnessCalculator();
     const zkey = await loadZkey();
@@ -49745,12 +49762,6 @@ class MerkleRootTracker {
 }
 
 class RLNContract {
-    constructor(rlnInstance, { address, provider }) {
-        this._members = [];
-        const initialRoot = rlnInstance.getMerkleRoot();
-        this.registryContract = new Contract(address, RLN_REGISTRY_ABI, provider);
-        this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
-    }
     static async init(rlnInstance, options) {
         const rlnContract = new RLNContract(rlnInstance, options);
         await rlnContract.initStorageContract(options.provider);
@@ -49758,22 +49769,34 @@ class RLNContract {
         rlnContract.subscribeToMembers(rlnInstance);
         return rlnContract;
     }
-    async initStorageContract(provider) {
-        const index = await this.registryContract.usingStorageIndex();
-        const address = await this.registryContract.storages(index);
-        this.storageIndex = index;
-        this.storageContract = new Contract(address, RLN_STORAGE_ABI, provider);
+    constructor(rlnInstance, { registryAddress, provider }) {
+        this._members = new Map();
+        const initialRoot = rlnInstance.getMerkleRoot();
+        this.registryContract = new Contract(registryAddress, RLN_REGISTRY_ABI, provider);
+        this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
+    }
+    async initStorageContract(provider, options = {}) {
+        const storageIndex = options?.storageIndex
+            ? options.storageIndex
+            : await this.registryContract.usingStorageIndex();
+        const storageAddress = await this.registryContract.storages(storageIndex);
+        if (!storageAddress || storageAddress === AddressZero) {
+            throw Error("No RLN Storage initialized on registry contract.");
+        }
+        this.storageIndex = storageIndex;
+        this.storageContract = new Contract(storageAddress, RLN_STORAGE_ABI, provider);
         this._membersFilter = this.storageContract.filters.MemberRegistered();
         this.deployBlock = await this.storageContract.deployedBlockNumber();
     }
     get contract() {
         if (!this.storageContract) {
-            throw Error("Storage contract was not initialized.");
+            throw Error("Storage contract was not initialized");
         }
         return this.storageContract;
     }
     get members() {
-        return this._members;
+        const sortedMembers = Array.from(this._members.values()).sort((left, right) => left.index.toNumber() - right.index.toNumber());
+        return sortedMembers;
     }
     get membersFilter() {
         if (!this._membersFilter) {
@@ -49800,11 +49823,11 @@ class RLNContract {
                 const index = evt.args.index;
                 const toRemoveVal = toRemoveTable.get(evt.blockNumber);
                 if (toRemoveVal != undefined) {
-                    toRemoveVal.push(index);
+                    toRemoveVal.push(index.toNumber());
                     toRemoveTable.set(evt.blockNumber, toRemoveVal);
                 }
                 else {
-                    toRemoveTable.set(evt.blockNumber, [index]);
+                    toRemoveTable.set(evt.blockNumber, [index.toNumber()]);
                 }
             }
             else {
@@ -49822,14 +49845,17 @@ class RLNContract {
     insertMembers(rlnInstance, toInsert) {
         toInsert.forEach((events, blockNumber) => {
             events.forEach((evt) => {
-                if (!evt.args) {
+                const _idCommitment = evt?.args?.idCommitment;
+                const index = evt?.args?.index;
+                if (!_idCommitment || !index) {
                     return;
                 }
-                const pubkey = evt.args.pubkey;
-                const index = evt.args.index;
-                const idCommitment = zeroPad(arrayify(pubkey), 32);
+                const idCommitment = zeroPad(arrayify(_idCommitment), 32);
                 rlnInstance.insertMember(idCommitment);
-                this.members.push({ index, pubkey });
+                this._members.set(index.toNumber(), {
+                    index,
+                    idCommitment: _idCommitment?._hex || hexlify(idCommitment),
+                });
             });
             const currentRoot = rlnInstance.getMerkleRoot();
             this.merkleRootTracker.pushRoot(blockNumber, currentRoot);
@@ -49839,9 +49865,8 @@ class RLNContract {
         const removeDescending = new Map([...toRemove].sort().reverse());
         removeDescending.forEach((indexes, blockNumber) => {
             indexes.forEach((index) => {
-                const idx = this.members.findIndex((m) => m.index === index);
-                if (idx > -1) {
-                    this.members.splice(idx, 1);
+                if (this._members.has(index)) {
+                    this._members.delete(index);
                 }
                 rlnInstance.deleteMember(index);
             });
@@ -49849,21 +49874,28 @@ class RLNContract {
         });
     }
     subscribeToMembers(rlnInstance) {
-        this.contract.on(this.membersFilter, (_pubkey, _index, event) => this.processEvents(rlnInstance, event));
+        this.contract.on(this.membersFilter, (_pubkey, _index, event) => this.processEvents(rlnInstance, [event]));
     }
     async registerWithSignature(rlnInstance, signature) {
         const identityCredential = await rlnInstance.generateSeededIdentityCredential(signature);
         return this.registerWithKey(identityCredential);
     }
     async registerWithKey(credential) {
-        if (!this.storageIndex) {
+        if (this.storageIndex === undefined) {
             throw Error("Cannot register credential, no storage contract index found.");
         }
-        const txRegisterResponse = await this.registryContract.register(this.storageIndex, credential.IDCommitmentBigInt, {
-            gasLimit: 100000,
-        });
+        const txRegisterResponse = await this.registryContract["register(uint16,uint256)"](this.storageIndex, credential.IDCommitmentBigInt, { gasLimit: 100000 });
         const txRegisterReceipt = await txRegisterResponse.wait();
-        return txRegisterReceipt?.events?.[0];
+        // assumption: register(uint16,uint256) emits one event
+        const memberRegistered = txRegisterReceipt?.events?.[0];
+        if (!memberRegistered) {
+            return undefined;
+        }
+        const decodedData = this.contract.interface.decodeEventLog("MemberRegistered", memberRegistered.data);
+        return {
+            idCommitment: decodedData.idCommitment,
+            index: decodedData.index,
+        };
     }
     roots() {
         return this.merkleRootTracker.roots();