@waku/rln 0.0.14 → 0.1.0-e52107d

package/bundle/index.js

@@ -1732,7 +1732,7 @@ const sha$1 = name =>
    */
   async data => new Uint8Array(await crypto.subtle.digest(name, data));
 
-const sha256$2 = from({
+const sha256$3 = from({
   name: 'sha2-256',
   code: 0x12,
   encode: sha$1('SHA-256')
@@ -1746,7 +1746,7 @@ const sha512$1 = from({
 
 var sha2 = /*#__PURE__*/Object.freeze({
 	__proto__: null,
-	sha256: sha256$2,
+	sha256: sha256$3,
 	sha512: sha512$1
 });
 
@@ -1941,13 +1941,13 @@ class RlnMessage {
 
 const log = debug("waku:rln:encoder");
 class RLNEncoder {
-    constructor(encoder, rlnInstance, index, membershipKey) {
+    constructor(encoder, rlnInstance, index, identityCredential) {
         this.encoder = encoder;
         this.rlnInstance = rlnInstance;
         this.index = index;
         if (index < 0)
             throw "invalid membership index";
-        this.idKey = membershipKey.IDKey;
+        this.idSecretHash = identityCredential.IDSecretHash;
     }
     async toWire(message) {
         message.rateLimitProof = await this.generateProof(message);
@@ -1966,7 +1966,7 @@ class RLNEncoder {
     async generateProof(message) {
         const signal = toRLNSignal(this.contentTopic, message);
         console.time("proof_gen_timer");
-        const proof = await this.rlnInstance.generateRLNProof(signal, this.index, message.timestamp, this.idKey);
+        const proof = await this.rlnInstance.generateRLNProof(signal, this.index, message.timestamp, this.idSecretHash);
         console.timeEnd("proof_gen_timer");
         return proof;
     }
@@ -2014,16 +2014,42 @@ const GOERLI_CONTRACT = {
 
 let wasm;
 
-const heap = new Array(32).fill(undefined);
+const heap = new Array(128).fill(undefined);
 
 heap.push(undefined, null, true, false);
 
 function getObject(idx) { return heap[idx]; }
 
+const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
 let heap_next = heap.length;
 
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
 function dropObject(idx) {
-    if (idx < 36) return;
+    if (idx < 132) return;
     heap[idx] = heap_next;
     heap_next = idx;
 }
@@ -2036,15 +2062,6 @@ function takeObject(idx) {
 
 let WASM_VECTOR_LEN = 0;
 
-let cachedUint8Memory0 = new Uint8Array();
-
-function getUint8Memory0() {
-    if (cachedUint8Memory0.byteLength === 0) {
-        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8Memory0;
-}
-
 const cachedTextEncoder = new TextEncoder('utf-8');
 
 const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
@@ -2102,32 +2119,15 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
-let cachedInt32Memory0 = new Int32Array();
+let cachedInt32Memory0 = null;
 
 function getInt32Memory0() {
-    if (cachedInt32Memory0.byteLength === 0) {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
         cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
     }
     return cachedInt32Memory0;
 }
 
-const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-function getStringFromWasm0(ptr, len) {
-    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
-}
-
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = obj;
-    return idx;
-}
-
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -2205,8 +2205,19 @@ function init_panic_hook() {
 * @returns {number}
 */
 function newRLN(tree_height, zkey, vk) {
-    const ret = wasm.newRLN(tree_height, addHeapObject(zkey), addHeapObject(vk));
-    return ret;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.newRLN(retptr, tree_height, addHeapObject(zkey), addHeapObject(vk));
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var r2 = getInt32Memory0()[retptr / 4 + 2];
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return r0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 }
 
 /**
@@ -2215,8 +2226,19 @@ function newRLN(tree_height, zkey, vk) {
 * @returns {Uint8Array}
 */
 function getSerializedRLNWitness(ctx, input) {
-    const ret = wasm.getSerializedRLNWitness(ctx, addHeapObject(input));
-    return takeObject(ret);
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.getSerializedRLNWitness(retptr, ctx, addHeapObject(input));
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var r2 = getInt32Memory0()[retptr / 4 + 2];
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 }
 
 /**
@@ -2237,20 +2259,68 @@ function insertMember(ctx, input) {
     }
 }
 
+/**
+* @param {number} ctx
+* @param {number} index
+* @param {Uint8Array} input
+*/
+function setLeavesFrom(ctx, index, input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.setLeavesFrom(retptr, ctx, index, addHeapObject(input));
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        if (r1) {
+            throw takeObject(r0);
+        }
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+* @param {number} ctx
+* @param {number} index
+*/
+function deleteLeaf(ctx, index) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.deleteLeaf(retptr, ctx, index);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        if (r1) {
+            throw takeObject(r0);
+        }
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
 * @param {number} ctx
 * @param {Uint8Array} serialized_witness
 * @returns {object}
 */
 function RLNWitnessToJson(ctx, serialized_witness) {
-    const ret = wasm.RLNWitnessToJson(ctx, addHeapObject(serialized_witness));
-    return takeObject(ret);
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.RLNWitnessToJson(retptr, ctx, addHeapObject(serialized_witness));
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var r2 = getInt32Memory0()[retptr / 4 + 2];
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 }
 
-let cachedUint32Memory0 = new Uint32Array();
+let cachedUint32Memory0 = null;
 
 function getUint32Memory0() {
-    if (cachedUint32Memory0.byteLength === 0) {
+    if (cachedUint32Memory0 === null || cachedUint32Memory0.byteLength === 0) {
         cachedUint32Memory0 = new Uint32Array(wasm.memory.buffer);
     }
     return cachedUint32Memory0;
@@ -2293,10 +2363,10 @@ function generate_rln_proof_with_witness(ctx, calculated_witness, serialized_wit
 * @param {number} ctx
 * @returns {Uint8Array}
 */
-function generateMembershipKey(ctx) {
+function generateExtendedMembershipKey(ctx) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.generateMembershipKey(retptr, ctx);
+        wasm.generateExtendedMembershipKey(retptr, ctx);
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
         var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -2314,10 +2384,10 @@ function generateMembershipKey(ctx) {
 * @param {Uint8Array} seed
 * @returns {Uint8Array}
 */
-function generateSeededMembershipKey(ctx, seed) {
+function generateSeededExtendedMembershipKey(ctx, seed) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.generateSeededMembershipKey(retptr, ctx, addHeapObject(seed));
+        wasm.generateSeededExtendedMembershipKey(retptr, ctx, addHeapObject(seed));
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
         var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -2393,6 +2463,46 @@ function getRoot(ctx) {
     }
 }
 
+/**
+* @param {Uint8Array} input
+* @returns {Uint8Array}
+*/
+function hash$1(input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hash(retptr, addHeapObject(input));
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var r2 = getInt32Memory0()[retptr / 4 + 2];
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+* @param {Uint8Array} input
+* @returns {Uint8Array}
+*/
+function poseidonHash$1(input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.poseidonHash(retptr, addHeapObject(input));
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var r2 = getInt32Memory0()[retptr / 4 + 2];
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 function handleError(f, args) {
     try {
         return f.apply(this, args);
@@ -2439,9 +2549,21 @@ async function load(module, imports) {
 function getImports() {
     const imports = {};
     imports.wbg = {};
+    imports.wbg.__wbindgen_is_string = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'string';
+        return ret;
+    };
+    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
         const obj = getObject(arg1);
         const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -2450,40 +2572,30 @@ function getImports() {
         getInt32Memory0()[arg0 / 4 + 1] = len0;
         getInt32Memory0()[arg0 / 4 + 0] = ptr0;
     };
-    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
-        const ret = getStringFromWasm0(arg0, arg1);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_is_string = function(arg0) {
-        const ret = typeof(getObject(arg0)) === 'string';
-        return ret;
-    };
-    imports.wbg.__wbg_BigInt_d0c7d465bfa30d3b = function(arg0) {
-        const ret = BigInt(arg0);
+    imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
+        const ret = arg0;
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_number_new = function(arg0) {
         const ret = arg0;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_BigInt_1fab4952b6c4a499 = function(arg0) {
-        const ret = BigInt(BigInt.asUintN(64, arg0));
+    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
+        const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
         const ret = getObject(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_is_undefined = function(arg0) {
-        const ret = getObject(arg0) === undefined;
-        return ret;
-    };
-    imports.wbg.__wbindgen_is_object = function(arg0) {
-        const val = getObject(arg0);
-        const ret = typeof(val) === 'object' && val !== null;
-        return ret;
+    imports.wbg.__wbg_String_91fba7ded13ba54c = function(arg0, arg1) {
+        const ret = String(getObject(arg1));
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
     };
-    imports.wbg.__wbg_set_c943d600fa71e4dd = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_set_20cbc34131e76824 = function(arg0, arg1, arg2) {
         getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
     };
     imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
@@ -2504,119 +2616,128 @@ function getImports() {
             wasm.__wbindgen_free(arg0, arg1);
         }
     };
-    imports.wbg.__wbg_randomFillSync_065afffde01daa66 = function() { return handleError(function (arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = getObject(arg0) === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg_randomFillSync_6894564c2c334c42 = function() { return handleError(function (arg0, arg1, arg2) {
         getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
     }, arguments) };
-    imports.wbg.__wbg_getRandomValues_b99eec4244a475bb = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_getRandomValues_805f1c3d65988a5a = function() { return handleError(function (arg0, arg1) {
         getObject(arg0).getRandomValues(getObject(arg1));
     }, arguments) };
-    imports.wbg.__wbg_process_0cc2ada8524d6f83 = function(arg0) {
+    imports.wbg.__wbg_crypto_e1d53a1d73fb10b8 = function(arg0) {
+        const ret = getObject(arg0).crypto;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_is_object = function(arg0) {
+        const val = getObject(arg0);
+        const ret = typeof(val) === 'object' && val !== null;
+        return ret;
+    };
+    imports.wbg.__wbg_process_038c26bf42b093f8 = function(arg0) {
         const ret = getObject(arg0).process;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_versions_c11acceab27a6c87 = function(arg0) {
+    imports.wbg.__wbg_versions_ab37218d2f0b24a8 = function(arg0) {
         const ret = getObject(arg0).versions;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_node_7ff1ce49caf23815 = function(arg0) {
+    imports.wbg.__wbg_node_080f4b19d15bc1fe = function(arg0) {
         const ret = getObject(arg0).node;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_static_accessor_NODE_MODULE_cf6401cc1091279e = function() {
-        const ret = module;
+    imports.wbg.__wbg_msCrypto_6e7d3e1f92610cbb = function(arg0) {
+        const ret = getObject(arg0).msCrypto;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_require_a746e79b322b9336 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).require(getStringFromWasm0(arg1, arg2));
+    imports.wbg.__wbg_require_78a3dcfbdba9cbce = function() { return handleError(function () {
+        const ret = module.require;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_crypto_2036bed7c44c25e7 = function(arg0) {
-        const ret = getObject(arg0).crypto;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_msCrypto_a21fc88caf1ecdc8 = function(arg0) {
-        const ret = getObject(arg0).msCrypto;
-        return addHeapObject(ret);
+    imports.wbg.__wbindgen_is_function = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'function';
+        return ret;
     };
-    imports.wbg.__wbg_new_1d9a920c6bfc44a8 = function() {
+    imports.wbg.__wbg_new_b525de17f44a8943 = function() {
         const ret = new Array();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_newnoargs_b5b063fc6c2f0376 = function(arg0, arg1) {
+    imports.wbg.__wbg_newnoargs_2b8b6bd7753c76ba = function(arg0, arg1) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_268f7b7dd3430798 = function() {
+    imports.wbg.__wbg_new_f841cc6f2098f4b5 = function() {
         const ret = new Map();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_call_97ae9d8645dc388b = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_call_95d1ea488d03e4e8 = function() { return handleError(function (arg0, arg1) {
         const ret = getObject(arg0).call(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_new_0b9bfdd97583284e = function() {
+    imports.wbg.__wbg_new_f9876326328f45ed = function() {
         const ret = new Object();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_self_6d479506f72c6a71 = function() { return handleError(function () {
+    imports.wbg.__wbg_self_e7c1f827057f6584 = function() { return handleError(function () {
         const ret = self.self;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_window_f2557cc78490aceb = function() { return handleError(function () {
+    imports.wbg.__wbg_window_a09ec664e14b1b81 = function() { return handleError(function () {
         const ret = window.window;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_globalThis_7f206bda628d5286 = function() { return handleError(function () {
+    imports.wbg.__wbg_globalThis_87cbb8506fecf3a9 = function() { return handleError(function () {
         const ret = globalThis.globalThis;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_global_ba75c50d1cf384f4 = function() { return handleError(function () {
+    imports.wbg.__wbg_global_c85a9259e621f3db = function() { return handleError(function () {
         const ret = global.global;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_set_a68214f35c417fa9 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_set_17224bc548dd1d7b = function(arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
     };
-    imports.wbg.__wbg_toString_d9cd5f001405e8ff = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_toString_91b13ec0b518b06b = function() { return handleError(function (arg0, arg1) {
         const ret = getObject(arg0).toString(arg1);
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_new_8d2af00bc1e329ee = function(arg0, arg1) {
-        const ret = new Error(getStringFromWasm0(arg0, arg1));
+    imports.wbg.__wbg_call_9495de66fdbe016b = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_set_933729cf5b66ac11 = function(arg0, arg1, arg2) {
+    }, arguments) };
+    imports.wbg.__wbg_set_388c4c6422704173 = function(arg0, arg1, arg2) {
         const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_fromEntries_7abdcb92016eb4b9 = function() { return handleError(function (arg0) {
+    imports.wbg.__wbg_fromEntries_47a432d7604fc06a = function() { return handleError(function (arg0) {
         const ret = Object.fromEntries(getObject(arg0));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_buffer_3f3d764d4747d564 = function(arg0) {
+    imports.wbg.__wbg_buffer_cf65c07de34b9a08 = function(arg0) {
         const ret = getObject(arg0).buffer;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_newwithbyteoffsetandlength_d9aa266703cb98be = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_newwithbyteoffsetandlength_9fb2f11355ecadf5 = function(arg0, arg1, arg2) {
         const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_8c3f0052272a457a = function(arg0) {
+    imports.wbg.__wbg_new_537b7341ce90bb31 = function(arg0) {
         const ret = new Uint8Array(getObject(arg0));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_set_83db9690f9353e79 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_set_17499e8aa4003ebd = function(arg0, arg1, arg2) {
         getObject(arg0).set(getObject(arg1), arg2 >>> 0);
     };
-    imports.wbg.__wbg_length_9e1ae1900cb0fbd5 = function(arg0) {
+    imports.wbg.__wbg_length_27a2afe8ab42b09f = function(arg0) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_newwithlength_f5933855e4f48a19 = function(arg0) {
+    imports.wbg.__wbg_newwithlength_b56c882b57805732 = function(arg0) {
         const ret = new Uint8Array(arg0 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_subarray_58ad4efbb5bcb886 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_subarray_7526649b91a252a6 = function(arg0, arg1, arg2) {
         const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
@@ -2641,9 +2762,9 @@ function getImports() {
 function finalizeInit(instance, module) {
     wasm = instance.exports;
     init.__wbindgen_wasm_module = module;
-    cachedInt32Memory0 = new Int32Array();
-    cachedUint32Memory0 = new Uint32Array();
-    cachedUint8Memory0 = new Uint8Array();
+    cachedInt32Memory0 = null;
+    cachedUint32Memory0 = null;
+    cachedUint8Memory0 = null;
 
 
     return wasm;
@@ -2651,7 +2772,7 @@ function finalizeInit(instance, module) {
 
 async function init(input) {
     if (typeof input === 'undefined') {
-        input = new URL(new URL('assets/rln_wasm_bg-4d82d6a4.wasm', import.meta.url).href, import.meta.url);
+        input = new URL(new URL('assets/rln_wasm_bg-6f96f821.wasm', import.meta.url).href, import.meta.url);
     }
     const imports = getImports();
 
@@ -2689,123 +2810,114 @@ function writeUIntLE(buf, value, offset, byteLength, noAssert) {
 }
 
 const verificationKey = {
-    "protocol": "groth16",
-    "curve": "bn128",
-    "nPublic": 6,
-    "vk_alpha_1": [
-        "1805378556360488226980822394597799963030511477964155500103132920745199284516",
-        "11990395240534218699464972016456017378439762088320057798320175886595281336136",
-        "1"
+    protocol: "groth16",
+    curve: "bn128",
+    nPublic: 6,
+    vk_alpha_1: [
+        "20124996762962216725442980738609010303800849578410091356605067053491763969391",
+        "9118593021526896828671519912099489027245924097793322973632351264852174143923",
+        "1",
     ],
-    "vk_beta_2": [
+    vk_beta_2: [
         [
-            "11031529986141021025408838211017932346992429731488270384177563837022796743627",
-            "16042159910707312759082561183373181639420894978640710177581040523252926273854"
+            "4693952934005375501364248788849686435240706020501681709396105298107971354382",
+            "14346958885444710485362620645446987998958218205939139994511461437152241966681",
         ],
         [
-            "20112698439519222240302944148895052359035104222313380895334495118294612255131",
-            "19441583024670359810872018179190533814486480928824742448673677460151702019379"
+            "16851772916911573982706166384196538392731905827088356034885868448550849804972",
+            "823612331030938060799959717749043047845343400798220427319188951998582076532",
         ],
-        [
-            "1",
-            "0"
-        ]
+        ["1", "0"],
     ],
-    "vk_gamma_2": [
+    vk_gamma_2: [
         [
             "10857046999023057135944570762232829481370756359578518086990519993285655852781",
-            "11559732032986387107991004021392285783925812861821192530917403151452391805634"
+            "11559732032986387107991004021392285783925812861821192530917403151452391805634",
         ],
         [
             "8495653923123431417604973247489272438418190587263600148770280649306958101930",
-            "4082367875863433681332203403145435568316851327593401208105741076214120093531"
+            "4082367875863433681332203403145435568316851327593401208105741076214120093531",
         ],
-        [
-            "1",
-            "0"
-        ]
+        ["1", "0"],
     ],
-    "vk_delta_2": [
+    vk_delta_2: [
         [
-            "1948496782571164085469528023647105317580208688174386157591917599801657832035",
-            "20445814069256658101339037520922621162739470138213615104905368409238414511981"
+            "8353516066399360694538747105302262515182301251524941126222712285088022964076",
+            "9329524012539638256356482961742014315122377605267454801030953882967973561832",
         ],
         [
-            "10024680869920840984813249386422727863826862577760330492647062850849851925340",
-            "10512156247842686783409460795717734694774542185222602679117887145206209285142"
+            "16805391589556134376869247619848130874761233086443465978238468412168162326401",
+            "10111259694977636294287802909665108497237922060047080343914303287629927847739",
         ],
-        [
-            "1",
-            "0"
-        ]
+        ["1", "0"],
     ],
-    "vk_alphabeta_12": [
+    vk_alphabeta_12: [
         [
             [
-                "5151991366823434428398919091000210787450832786814248297320989361921939794156",
-                "15735191313289001022885148627913534790382722933676436876510746491415970766821"
+                "12608968655665301215455851857466367636344427685631271961542642719683786103711",
+                "9849575605876329747382930567422916152871921500826003490242628251047652318086",
             ],
             [
-                "3387907257437913904447588318761906430938415556102110876587455322225272831272",
-                "1998779853452712881084781956683721603875246565720647583735935725110674288056"
+                "6322029441245076030714726551623552073612922718416871603535535085523083939021",
+                "8700115492541474338049149013125102281865518624059015445617546140629435818912",
             ],
             [
-                "14280074182991498185075387990446437410077692353432005297922275464876153151820",
-                "17092408446352310039633488224969232803092763095456307462247653153107223117633"
-            ]
+                "10674973475340072635573101639867487770811074181475255667220644196793546640210",
+                "2926286967251299230490668407790788696102889214647256022788211245826267484824",
+            ],
         ],
         [
             [
-                "4359046709531668109201634396816565829237358165496082832279660960675584351266",
-                "4511888308846208349307186938266411423935335853916317436093178288331845821336"
+                "9660441540778523475944706619139394922744328902833875392144658911530830074820",
+                "19548113127774514328631808547691096362144426239827206966690021428110281506546",
             ],
             [
-                "11429499807090785857812316277335883295048773373068683863667725283965356423273",
-                "16232274853200678548795010078253506586114563833318973594428907292096178657392"
+                "1870837942477655969123169532603615788122896469891695773961478956740992497097",
+                "12536105729661705698805725105036536744930776470051238187456307227425796690780",
             ],
             [
-                "18068999605870933925311275504102553573815570223888590384919752303726860800970",
-                "17309569111965782732372130116757295842160193489132771344011460471298173784984"
-            ]
-        ]
+                "21811903352654147452884857281720047789720483752548991551595462057142824037334",
+                "19021616763967199151052893283384285352200445499680068407023236283004353578353",
+            ],
+        ],
     ],
-    "IC": [
+    IC: [
         [
-            "18693301901828818437917730940595978397160482710354161265484535387752523310572",
-            "17985273354976640088538673802000794244421192643855111089693820179790551470769",
-            "1"
+            "11992897507809711711025355300535923222599547639134311050809253678876341466909",
+            "17181525095924075896332561978747020491074338784673526378866503154966799128110",
+            "1",
         ],
         [
-            "21164641723988537620541455173278629777250883365474191521194244273980931825942",
-            "998385854410718613441067082771678946155853656328717326195057262123686425518",
-            "1"
+            "17018665030246167677911144513385572506766200776123272044534328594850561667818",
+            "18601114175490465275436712413925513066546725461375425769709566180981674884464",
+            "1",
         ],
         [
-            "21666968581672145768705229094968410656430989593283335488162701230986314747515",
-            "17996457608540683483506630273632100555125353447506062045735279661096094677264",
-            "1"
+            "18799470100699658367834559797874857804183288553462108031963980039244731716542",
+            "13064227487174191981628537974951887429496059857753101852163607049188825592007",
+            "1",
         ],
         [
-            "20137761979695192602424300886442379728165712610493092740175904438282083668117",
-            "19184814924890679891263780109959113289320127263583260218200636509492157834679",
-            "1"
+            "17432501889058124609368103715904104425610382063762621017593209214189134571156",
+            "13406815149699834788256141097399354592751313348962590382887503595131085938635",
+            "1",
         ],
         [
-            "10943171273393803842589314082509655332154393332394322726077270895078286354146",
-            "10872472035685319847811233167729172672344935625121511932198535224727331126439",
-            "1"
+            "10320964835612716439094703312987075811498239445882526576970512041988148264481",
+            "9024164961646353611176283204118089412001502110138072989569118393359029324867",
+            "1",
         ],
         [
-            "13049169779481227658517545034348883391527506091990880778783387628208561946597",
-            "10083689369261379027228809473568899816311684698866922944902456565434209079955",
-            "1"
+            "718355081067365548229685160476620267257521491773976402837645005858953849298",
+            "14635482993933988261008156660773180150752190597753512086153001683711587601974",
+            "1",
         ],
         [
-            "19633516378466409167014413361365552102431118630694133723053441455184566611083",
-            "8059525100726933978719058611146131904598011633549012007359165766216730722269",
-            "1"
-        ]
-    ]
+            "11777720285956632126519898515392071627539405001940313098390150593689568177535",
+            "8483603647274280691250972408211651407952870456587066148445913156086740744515",
+            "1",
+        ],
+    ],
 };
 
 // File generated with https://github.com/iden3/circom 
@@ -3128,12 +3240,12 @@ function buildBigIntFromUint8Array(array) {
 const stringEncoder = new TextEncoder();
 const DEPTH = 20;
 async function loadWitnessCalculator() {
-    const url = new URL(new URL('assets/rln-fb4d7b4b.wasm', import.meta.url).href, import.meta.url);
+    const url = new URL(new URL('assets/rln-6ded2896.wasm', import.meta.url).href, import.meta.url);
     const response = await fetch(url);
     return await builder(new Uint8Array(await response.arrayBuffer()), false);
 }
 async function loadZkey() {
-    const url = new URL(new URL('assets/rln_final-a641c06e.zkey', import.meta.url).href, import.meta.url);
+    const url = new URL(new URL('assets/rln_final-8b299152.zkey', import.meta.url).href, import.meta.url);
     const response = await fetch(url);
     return new Uint8Array(await response.arrayBuffer());
 }
@@ -3150,17 +3262,21 @@ async function create$1() {
     const zkRLN = newRLN(DEPTH, zkey, vkey);
     return new RLNInstance(zkRLN, witnessCalculator);
 }
-class MembershipKey {
-    constructor(IDKey, IDCommitment, IDCommitmentBigInt) {
-        this.IDKey = IDKey;
+class IdentityCredential {
+    constructor(IDTrapdoor, IDNullifier, IDSecretHash, IDCommitment, IDCommitmentBigInt) {
+        this.IDTrapdoor = IDTrapdoor;
+        this.IDNullifier = IDNullifier;
+        this.IDSecretHash = IDSecretHash;
         this.IDCommitment = IDCommitment;
         this.IDCommitmentBigInt = IDCommitmentBigInt;
     }
     static fromBytes(memKeys) {
-        const idKey = memKeys.subarray(0, 32);
-        const idCommitment = memKeys.subarray(32);
+        const idTrapdoor = memKeys.subarray(0, 32);
+        const idNullifier = memKeys.subarray(32, 64);
+        const idSecretHash = memKeys.subarray(64, 96);
+        const idCommitment = memKeys.subarray(96);
         const idCommitmentBigInt = buildBigIntFromUint8Array(idCommitment);
-        return new MembershipKey(idKey, idCommitment, idCommitmentBigInt);
+        return new IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment, idCommitmentBigInt);
     }
 }
 const proofOffset = 128;
@@ -3170,6 +3286,14 @@ const shareXOffset = epochOffset + 32;
 const shareYOffset = shareXOffset + 32;
 const nullifierOffset = shareYOffset + 32;
 const rlnIdentifierOffset = nullifierOffset + 32;
+class ProofMetadata {
+    constructor(nullifier, shareX, shareY, externalNullifier) {
+        this.nullifier = nullifier;
+        this.shareX = shareX;
+        this.shareY = shareY;
+        this.externalNullifier = externalNullifier;
+    }
+}
 class Proof {
     constructor(proofBytes) {
         if (proofBytes.length < rlnIdentifierOffset)
@@ -3183,27 +3307,52 @@ class Proof {
         this.nullifier = proofBytes.subarray(shareYOffset, nullifierOffset);
         this.rlnIdentifier = proofBytes.subarray(nullifierOffset, rlnIdentifierOffset);
     }
+    extractMetadata() {
+        const externalNullifier = poseidonHash(this.epoch, this.rlnIdentifier);
+        return new ProofMetadata(this.nullifier, this.shareX, this.shareY, externalNullifier);
+    }
 }
 function proofToBytes(p) {
     return concatenate(p.proof, p.merkleRoot, p.epoch, p.shareX, p.shareY, p.nullifier, p.rlnIdentifier);
 }
+function poseidonHash(...input) {
+    const inputLen = writeUIntLE(new Uint8Array(8), input.length, 0, 8);
+    const lenPrefixedData = concatenate(inputLen, ...input);
+    return poseidonHash$1(lenPrefixedData);
+}
+function sha256$2(input) {
+    const inputLen = writeUIntLE(new Uint8Array(8), input.length, 0, 8);
+    const lenPrefixedData = concatenate(inputLen, input);
+    return hash$1(lenPrefixedData);
+}
 class RLNInstance {
     constructor(zkRLN, witnessCalculator) {
         this.zkRLN = zkRLN;
         this.witnessCalculator = witnessCalculator;
     }
-    generateMembershipKey() {
-        const memKeys = generateMembershipKey(this.zkRLN);
-        return MembershipKey.fromBytes(memKeys);
+    generateIdentityCredentials() {
+        const memKeys = generateExtendedMembershipKey(this.zkRLN); // TODO: rename this function in zerokit rln-wasm
+        return IdentityCredential.fromBytes(memKeys);
     }
-    generateSeededMembershipKey(seed) {
+    generateSeededIdentityCredential(seed) {
         const seedBytes = stringEncoder.encode(seed);
-        const memKeys = generateSeededMembershipKey(this.zkRLN, seedBytes);
-        return MembershipKey.fromBytes(memKeys);
+        // TODO: rename this function in zerokit rln-wasm
+        const memKeys = generateSeededExtendedMembershipKey(this.zkRLN, seedBytes);
+        return IdentityCredential.fromBytes(memKeys);
     }
     insertMember(idCommitment) {
         insertMember(this.zkRLN, idCommitment);
     }
+    insertMembers(index, ...idCommitments) {
+        // serializes a seq of IDCommitments to a byte seq
+        // the order of serialization is |id_commitment_len<8>|id_commitment<var>|
+        const idCommitmentLen = writeUIntLE(new Uint8Array(8), idCommitments.length, 0, 8);
+        const idCommitmentBytes = concatenate(idCommitmentLen, ...idCommitments);
+        setLeavesFrom(this.zkRLN, index, idCommitmentBytes);
+    }
+    deleteMember(index) {
+        deleteLeaf(this.zkRLN, index);
+    }
     getMerkleRoot() {
         return getRoot(this.zkRLN);
     }
@@ -3215,7 +3364,7 @@ class RLNInstance {
         // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
         return concatenate(idKey, memIndexBytes, epoch, msgLen, uint8Msg);
     }
-    async generateRLNProof(msg, index, epoch, idKey) {
+    async generateRLNProof(msg, index, epoch, idSecretHash) {
         if (epoch == undefined) {
             epoch = epochIntToBytes(dateToEpoch(new Date()));
         }
@@ -3224,11 +3373,11 @@ class RLNInstance {
         }
         if (epoch.length != 32)
             throw "invalid epoch";
-        if (idKey.length != 32)
-            throw "invalid id key";
+        if (idSecretHash.length != 32)
+            throw "invalid id secret hash";
         if (index < 0)
             throw "index must be >= 0";
-        const serialized_msg = this.serializeMessage(msg, index, epoch, idKey);
+        const serialized_msg = this.serializeMessage(msg, index, epoch, idSecretHash);
         const rlnWitness = getSerializedRLNWitness(this.zkRLN, serialized_msg);
         const inputs = RLNWitnessToJson(this.zkRLN, rlnWitness);
         const calculatedWitness = await this.witnessCalculator.calculateWitness(inputs, false); // no sanity check being used in zerokit
@@ -3247,7 +3396,7 @@ class RLNInstance {
         const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
         return verifyRLNProof(this.zkRLN, concatenate(pBytes, msgLen, msg));
     }
-    verifyWithRoots(proof, msg) {
+    verifyWithRoots(proof, msg, ...roots) {
         let pBytes;
         if (proof instanceof Uint8Array) {
             pBytes = proof;
@@ -3257,9 +3406,8 @@ class RLNInstance {
         }
         // calculate message length
         const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-        // obtain root
-        const root = getRoot(this.zkRLN);
-        return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg), root);
+        const rootsBytes = concatenate(...roots);
+        return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg), rootsBytes);
     }
     verifyWithNoRoot(proof, msg) {
         let pBytes;
@@ -3278,9 +3426,12 @@ class RLNInstance {
 var rln = /*#__PURE__*/Object.freeze({
 	__proto__: null,
 	create: create$1,
-	MembershipKey: MembershipKey,
+	IdentityCredential: IdentityCredential,
+	ProofMetadata: ProofMetadata,
 	Proof: Proof,
 	proofToBytes: proofToBytes,
+	poseidonHash: poseidonHash,
+	sha256: sha256$2,
 	RLNInstance: RLNInstance
 });
 
@@ -27014,8 +27165,11 @@ class RLNContract {
     get members() {
         return this._members;
     }
-    async fetchMembers(rlnInstance, fromBlock) {
-        const registeredMemberEvents = await this.contract.queryFilter(this.membersFilter, fromBlock);
+    async fetchMembers(rlnInstance, options = {}) {
+        const registeredMemberEvents = await queryFilter(this.contract, {
+            ...options,
+            membersFilter: this.membersFilter,
+        });
         for (const event of registeredMemberEvents) {
             this.addMemberFromEvent(rlnInstance, event);
         }
@@ -27033,16 +27187,141 @@ class RLNContract {
         const idCommitment = zeroPad(arrayify(pubkey), 32);
         rlnInstance.insertMember(idCommitment);
     }
-    async registerMember(rlnInstance, signature) {
-        const membershipKey = await rlnInstance.generateSeededMembershipKey(signature);
+    async registerWithSignature(rlnInstance, signature) {
+        const identityCredential = await rlnInstance.generateSeededIdentityCredential(signature);
+        return this.registerWithKey(identityCredential);
+    }
+    async registerWithKey(credential) {
         const depositValue = await this.contract.MEMBERSHIP_DEPOSIT();
-        const txRegisterResponse = await this.contract.register(membershipKey.IDCommitmentBigInt, {
+        const txRegisterResponse = await this.contract.register(credential.IDCommitmentBigInt, {
             value: depositValue,
         });
         const txRegisterReceipt = await txRegisterResponse.wait();
         return txRegisterReceipt?.events?.[0];
     }
 }
+// these value should be tested on other networks
+const FETCH_CHUNK = 5;
+const BLOCK_RANGE = 3000;
+async function queryFilter(contract, options) {
+    const { fromBlock, membersFilter, fetchRange = BLOCK_RANGE, fetchChunks = FETCH_CHUNK, } = options;
+    if (!fromBlock) {
+        return contract.queryFilter(membersFilter);
+    }
+    if (!contract.signer.provider) {
+        throw Error("No provider found on the contract's signer.");
+    }
+    const toBlock = await contract.signer.provider.getBlockNumber();
+    if (toBlock - fromBlock < fetchRange) {
+        return contract.queryFilter(membersFilter);
+    }
+    const events = [];
+    const chunks = splitToChunks(fromBlock, toBlock, fetchRange);
+    for (const portion of takeN(chunks, fetchChunks)) {
+        const promises = portion.map(([left, right]) => ignoreErrors(contract.queryFilter(membersFilter, left, right), []));
+        const fetchedEvents = await Promise.all(promises);
+        events.push(fetchedEvents.flatMap((v) => v));
+    }
+    return events.flatMap((v) => v);
+}
+function splitToChunks(from, to, step) {
+    const chunks = [];
+    let left = from;
+    while (left < to) {
+        const right = left + step < to ? left + step : to;
+        chunks.push([left, right]);
+        left = right;
+    }
+    return chunks;
+}
+function* takeN(array, size) {
+    let start = 0;
+    let skip = size;
+    while (skip < array.length) {
+        const portion = array.slice(start, skip);
+        yield portion;
+        start = skip;
+        skip += size;
+    }
+}
+function ignoreErrors(promise, defaultValue) {
+    return promise.catch((err) => {
+        console.error(`Ignoring an error during query: ${err?.message}`);
+        return defaultValue;
+    });
+}
+
+class RootPerBlock {
+    constructor(root, blockNumber) {
+        this.root = root;
+        this.blockNumber = blockNumber;
+    }
+}
+const maxBufferSize = 20;
+class MerkleRootTracker {
+    constructor(acceptableRootWindowSize, initialRoot) {
+        this.acceptableRootWindowSize = acceptableRootWindowSize;
+        this.validMerkleRoots = new Array();
+        this.merkleRootBuffer = new Array();
+        this.pushRoot(0, initialRoot);
+    }
+    backFill(fromBlockNumber) {
+        if (this.validMerkleRoots.length == 0)
+            return;
+        let numBlocks = 0;
+        for (let i = this.validMerkleRoots.length - 1; i >= 0; i--) {
+            if (this.validMerkleRoots[i].blockNumber >= fromBlockNumber) {
+                numBlocks++;
+            }
+        }
+        if (numBlocks == 0)
+            return;
+        const olderBlock = fromBlockNumber < this.validMerkleRoots[0].blockNumber;
+        // Remove last roots
+        let rootsToPop = numBlocks;
+        if (this.validMerkleRoots.length < rootsToPop) {
+            rootsToPop = this.validMerkleRoots.length;
+        }
+        this.validMerkleRoots = this.validMerkleRoots.slice(0, this.validMerkleRoots.length - rootsToPop);
+        if (this.merkleRootBuffer.length == 0)
+            return;
+        if (olderBlock) {
+            const idx = this.merkleRootBuffer.findIndex((x) => x.blockNumber == fromBlockNumber);
+            if (idx > -1) {
+                this.merkleRootBuffer = this.merkleRootBuffer.slice(0, idx);
+            }
+        }
+        // Backfill the tree's acceptable roots
+        let rootsToRestore = this.acceptableRootWindowSize - this.validMerkleRoots.length;
+        if (this.merkleRootBuffer.length < rootsToRestore) {
+            rootsToRestore = this.merkleRootBuffer.length;
+        }
+        for (let i = 0; i < rootsToRestore; i++) {
+            const x = this.merkleRootBuffer.pop();
+            if (x)
+                this.validMerkleRoots.unshift(x);
+        }
+    }
+    pushRoot(blockNumber, root) {
+        this.validMerkleRoots.push(new RootPerBlock(root, blockNumber));
+        // Maintain valid merkle root window
+        if (this.validMerkleRoots.length > this.acceptableRootWindowSize) {
+            const x = this.validMerkleRoots.shift();
+            if (x)
+                this.merkleRootBuffer.push(x);
+        }
+        // Maintain merkle root buffer
+        if (this.merkleRootBuffer.length > maxBufferSize) {
+            this.merkleRootBuffer.shift();
+        }
+    }
+    roots() {
+        return this.validMerkleRoots.map((x) => x.root);
+    }
+    buffer() {
+        return this.merkleRootBuffer.map((x) => x.root);
+    }
+}
 
 // reexport the create function, dynamically imported from rln.ts
 async function create() {
@@ -27053,4 +27332,4 @@ async function create() {
     return await rlnModule.create();
 }
 
-export { GOERLI_CONTRACT, MembershipKey, Proof, RLNContract, RLNDecoder, RLNEncoder, RLNInstance, RLN_ABI, create };
+export { GOERLI_CONTRACT, IdentityCredential, MerkleRootTracker, Proof, ProofMetadata, RLNContract, RLNDecoder, RLNEncoder, RLNInstance, RLN_ABI, create };