@waku/rln 0.1.1-891ee34 → 0.1.1-9b1e818

package/bundle/index.js

@@ -1871,6 +1871,18 @@ function fromString(string, encoding = 'utf8') {
     return base.decoder.decode(`${base.prefix}${string}`); // eslint-disable-line @typescript-eslint/restrict-template-expressions
 }
 
+/**
+ * Convert input to a byte array.
+ *
+ * Handles both `0x` prefixed and non-prefixed strings.
+ */
+function hexToBytes$2(hex) {
+    if (typeof hex === "string") {
+        const _hex = hex.replace(/^0x/i, "");
+        return fromString(_hex.toLowerCase(), "base16");
+    }
+    return hex;
+}
 /**
  * Encode utf-8 string to byte array.
  */
@@ -1907,7 +1919,7 @@ class RlnMessage {
         this.rlnInstance = rlnInstance;
         this.msg = msg;
         this.rateLimitProof = rateLimitProof;
-        this.pubSubTopic = "";
+        this.pubsubTopic = "";
     }
     verify(roots) {
         return this.rateLimitProof
@@ -1973,6 +1985,9 @@ class RLNEncoder {
         console.timeEnd("proof_gen_timer");
         return proof;
     }
+    get pubsubTopic() {
+        return this.encoder.pubsubTopic;
+    }
     get contentTopic() {
         return this.encoder.contentTopic;
     }
@@ -1985,6 +2000,9 @@ class RLNDecoder {
         this.rlnInstance = rlnInstance;
         this.decoder = decoder;
     }
+    get pubsubTopic() {
+        return this.decoder.pubsubTopic;
+    }
     get contentTopic() {
         return this.decoder.contentTopic;
     }
@@ -1993,26 +2011,79 @@ 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);
     }
 }
 
-const RLN_ABI = [
-    "function MEMBERSHIP_DEPOSIT() public view returns(uint256)",
-    "function register(uint256 pubkey) external payable",
-    "function withdraw(uint256 secret, uint256 _pubkeyIndex, address payable receiver) external",
-    "event MemberRegistered(uint256 pubkey, uint256 index)",
-    "event MemberWithdrawn(uint256 pubkey, uint256 index)",
+// ref https://github.com/waku-org/waku-rln-contract/blob/19fded82bca07e7b535b429dc507cfb83f10dfcf/deployments/sepolia/WakuRlnRegistry_Implementation.json#L3
+const RLN_REGISTRY_ABI = [
+    "error IncompatibleStorage()",
+    "error IncompatibleStorageIndex()",
+    "error NoStorageContractAvailable()",
+    "error StorageAlreadyExists(address storageAddress)",
+    "event AdminChanged(address previousAdmin, address newAdmin)",
+    "event BeaconUpgraded(address indexed beacon)",
+    "event Initialized(uint8 version)",
+    "event NewStorageContract(uint16 index, address storageAddress)",
+    "event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)",
+    "event Upgraded(address indexed implementation)",
+    "function forceProgress()",
+    "function initialize(address _poseidonHasher)",
+    "function newStorage()",
+    "function nextStorageIndex() view returns (uint16)",
+    "function owner() view returns (address)",
+    "function poseidonHasher() view returns (address)",
+    "function proxiableUUID() view returns (bytes32)",
+    "function register(uint16 storageIndex, uint256 commitment)",
+    "function register(uint256[] commitments)",
+    "function register(uint16 storageIndex, uint256[] commitments)",
+    "function registerStorage(address storageAddress)",
+    "function renounceOwnership()",
+    "function storages(uint16) view returns (address)",
+    "function transferOwnership(address newOwner)",
+    "function upgradeTo(address newImplementation)",
+    "function upgradeToAndCall(address newImplementation, bytes data) payable",
+    "function usingStorageIndex() view returns (uint16)",
+];
+// ref https://github.com/waku-org/waku-rln-contract/blob/19fded82bca07e7b535b429dc507cfb83f10dfcf/deployments/sepolia/WakuRlnStorage_0.json#L3
+const RLN_STORAGE_ABI = [
+    "constructor(address _poseidonHasher, uint16 _contractIndex)",
+    "error DuplicateIdCommitment()",
+    "error FullTree()",
+    "error InvalidIdCommitment(uint256 idCommitment)",
+    "error NotImplemented()",
+    "event MemberRegistered(uint256 idCommitment, uint256 index)",
+    "event MemberWithdrawn(uint256 idCommitment, uint256 index)",
+    "event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)",
+    "function DEPTH() view returns (uint256)",
+    "function MEMBERSHIP_DEPOSIT() view returns (uint256)",
+    "function SET_SIZE() view returns (uint256)",
+    "function contractIndex() view returns (uint16)",
+    "function deployedBlockNumber() view returns (uint32)",
+    "function idCommitmentIndex() view returns (uint256)",
+    "function isValidCommitment(uint256 idCommitment) view returns (bool)",
+    "function memberExists(uint256) view returns (bool)",
+    "function members(uint256) view returns (uint256)",
+    "function owner() view returns (address)",
+    "function poseidonHasher() view returns (address)",
+    "function register(uint256[] idCommitments)",
+    "function register(uint256 idCommitment) payable",
+    "function renounceOwnership()",
+    "function slash(uint256 idCommitment, address receiver, uint256[8] proof) pure",
+    "function stakedAmounts(uint256) view returns (uint256)",
+    "function transferOwnership(address newOwner)",
+    "function verifier() view returns (address)",
+    "function withdraw() pure",
+    "function withdrawalBalance(address) view returns (uint256)",
 ];
 const SEPOLIA_CONTRACT = {
     chainId: 11155111,
-    startBlock: 3193048,
-    address: "0x9C09146844C1326c2dBC41c451766C7138F88155",
-    abi: RLN_ABI,
+    address: "0xF471d71E9b1455bBF4b85d475afb9BB0954A29c4",
+    abi: RLN_REGISTRY_ABI,
 };
 
 var lib = {};
@@ -23851,6 +23922,19 @@ function buildBigIntFromUint8Array(array) {
     const dataView = new DataView(array.buffer);
     return dataView.getBigUint64(0, true);
 }
+/**
+ * Fills with zeros to set length
+ * @param array little endian Uint8Array
+ * @param length amount to pad
+ * @returns little endian Uint8Array padded with zeros to set length
+ */
+function zeroPadLE(array, length) {
+    const result = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = array[i] || 0;
+    }
+    return result;
+}
 
 const U32_MASK64 = BigInt(2 ** 32 - 1);
 const _32n = BigInt(32);
@@ -24475,11 +24559,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"),
@@ -24493,6 +24577,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) {
@@ -24525,10 +24620,23 @@ heap.push(undefined, null, true, false);
 
 function getObject(idx) { return heap[idx]; }
 
-const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+let heap_next = heap.length;
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
 
-cachedTextDecoder.decode();
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
 
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }
 let cachedUint8Memory0 = null;
 
 function getUint8Memory0() {
@@ -24539,11 +24647,10 @@ function getUint8Memory0() {
 }
 
 function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
     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;
@@ -24553,21 +24660,9 @@ function addHeapObject(obj) {
     return idx;
 }
 
-function dropObject(idx) {
-    if (idx < 132) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
 let WASM_VECTOR_LEN = 0;
 
-const cachedTextEncoder = new TextEncoder('utf-8');
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
 
 const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
     ? function (arg, view) {
@@ -24586,14 +24681,14 @@ function passStringToWasm0(arg, malloc, realloc) {
 
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length);
+        const ptr = malloc(buf.length) >>> 0;
         getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
         WASM_VECTOR_LEN = buf.length;
         return ptr;
     }
 
     let len = arg.length;
-    let ptr = malloc(len);
+    let ptr = malloc(len) >>> 0;
 
     const mem = getUint8Memory0();
 
@@ -24609,7 +24704,7 @@ function passStringToWasm0(arg, malloc, realloc) {
         if (offset !== 0) {
             arg = arg.slice(offset);
         }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        ptr = realloc(ptr, len, len = offset + arg.length * 3) >>> 0;
         const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
         const ret = encodeString(arg, view);
 
@@ -24832,7 +24927,7 @@ function getUint32Memory0() {
 }
 
 function passArrayJsValueToWasm0(array, malloc) {
-    const ptr = malloc(array.length * 4);
+    const ptr = malloc(array.length * 4) >>> 0;
     const mem = getUint32Memory0();
     for (let i = 0; i < array.length; i++) {
         mem[ptr / 4 + i] = addHeapObject(array[i]);
@@ -25016,11 +25111,7 @@ function handleError(f, args) {
     }
 }
 
-function getArrayU8FromWasm0(ptr, len) {
-    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
-async function load(module, imports) {
+async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
@@ -25051,17 +25142,9 @@ async function load(module, imports) {
     }
 }
 
-function getImports() {
+function __wbg_get_imports() {
     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);
     };
@@ -25072,33 +25155,46 @@ function getImports() {
     imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
         const obj = getObject(arg1);
         const ret = typeof(obj) === 'string' ? obj : undefined;
-        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
-    imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
-        const ret = arg0;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_number_new = function(arg0) {
-        const ret = arg0;
+    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
-        const ret = BigInt.asUintN(64, arg0);
-        return addHeapObject(ret);
+    imports.wbg.__wbindgen_is_string = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'string';
+        return ret;
     };
     imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
         const ret = getObject(arg0);
         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_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;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+    };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
+        const ret = arg0;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
+        const ret = BigInt.asUintN(64, arg0);
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_set_20cbc34131e76824 = function(arg0, arg1, arg2) {
         getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
@@ -25109,54 +25205,47 @@ function getImports() {
     };
     imports.wbg.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
         const ret = getObject(arg1).stack;
-        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;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
     imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
         try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
             console.error(getStringFromWasm0(arg0, arg1));
         } finally {
-            wasm.__wbindgen_free(arg0, arg1);
+            wasm.__wbindgen_free(deferred0_0, deferred0_1);
         }
     };
     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_805f1c3d65988a5a = function() { return handleError(function (arg0, arg1) {
-        getObject(arg0).getRandomValues(getObject(arg1));
-    }, arguments) };
-    imports.wbg.__wbg_crypto_e1d53a1d73fb10b8 = function(arg0) {
+    imports.wbg.__wbg_crypto_70a96de3b6b73dac = 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) {
+    imports.wbg.__wbg_process_dd1577445152112e = function(arg0) {
         const ret = getObject(arg0).process;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_versions_ab37218d2f0b24a8 = function(arg0) {
+    imports.wbg.__wbg_versions_58036bec3add9e6f = function(arg0) {
         const ret = getObject(arg0).versions;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_node_080f4b19d15bc1fe = function(arg0) {
+    imports.wbg.__wbg_node_6a9d28205ed5b0d8 = function(arg0) {
         const ret = getObject(arg0).node;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_msCrypto_6e7d3e1f92610cbb = function(arg0) {
+    imports.wbg.__wbg_msCrypto_adbc770ec9eca9c7 = function(arg0) {
         const ret = getObject(arg0).msCrypto;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_require_78a3dcfbdba9cbce = function() { return handleError(function () {
+    imports.wbg.__wbg_require_f05d779769764e82 = function() { return handleError(function () {
         const ret = module.require;
         return addHeapObject(ret);
     }, arguments) };
@@ -25164,94 +25253,100 @@ function getImports() {
         const ret = typeof(getObject(arg0)) === 'function';
         return ret;
     };
-    imports.wbg.__wbg_new_b525de17f44a8943 = function() {
+    imports.wbg.__wbg_getRandomValues_3774744e221a22ad = function() { return handleError(function (arg0, arg1) {
+        getObject(arg0).getRandomValues(getObject(arg1));
+    }, arguments) };
+    imports.wbg.__wbg_randomFillSync_e950366c42764a07 = function() { return handleError(function (arg0, arg1) {
+        getObject(arg0).randomFillSync(takeObject(arg1));
+    }, arguments) };
+    imports.wbg.__wbg_new_18bc2084e9a3e1ff = function() {
         const ret = new Array();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_newnoargs_2b8b6bd7753c76ba = function(arg0, arg1) {
+    imports.wbg.__wbg_newnoargs_e643855c6572a4a8 = function(arg0, arg1) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_f841cc6f2098f4b5 = function() {
+    imports.wbg.__wbg_new_b6fd0149e79ffce8 = function() {
         const ret = new Map();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_call_95d1ea488d03e4e8 = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_call_f96b398515635514 = function() { return handleError(function (arg0, arg1) {
         const ret = getObject(arg0).call(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_new_f9876326328f45ed = function() {
+    imports.wbg.__wbg_new_7befa02319b36069 = function() {
         const ret = new Object();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_self_e7c1f827057f6584 = function() { return handleError(function () {
+    imports.wbg.__wbg_self_b9aad7f1c618bfaf = function() { return handleError(function () {
         const ret = self.self;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_window_a09ec664e14b1b81 = function() { return handleError(function () {
+    imports.wbg.__wbg_window_55e469842c98b086 = function() { return handleError(function () {
         const ret = window.window;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_globalThis_87cbb8506fecf3a9 = function() { return handleError(function () {
+    imports.wbg.__wbg_globalThis_d0957e302752547e = function() { return handleError(function () {
         const ret = globalThis.globalThis;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_global_c85a9259e621f3db = function() { return handleError(function () {
+    imports.wbg.__wbg_global_ae2f87312b8987fb = function() { return handleError(function () {
         const ret = global.global;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_set_17224bc548dd1d7b = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_set_aee8682c7ee9ac44 = function(arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
     };
-    imports.wbg.__wbg_toString_91b13ec0b518b06b = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_toString_27ba0397f8cf84a6 = function() { return handleError(function (arg0, arg1) {
         const ret = getObject(arg0).toString(arg1);
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_call_9495de66fdbe016b = function() { return handleError(function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_call_35782e9a1aa5e091 = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_set_388c4c6422704173 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_set_6c1b2b7b73337778 = function(arg0, arg1, arg2) {
         const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_fromEntries_47a432d7604fc06a = function() { return handleError(function (arg0) {
+    imports.wbg.__wbg_fromEntries_10a57760b5d7d9b8 = function() { return handleError(function (arg0) {
         const ret = Object.fromEntries(getObject(arg0));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_buffer_cf65c07de34b9a08 = function(arg0) {
+    imports.wbg.__wbg_buffer_fcbfb6d88b2732e9 = function(arg0) {
         const ret = getObject(arg0).buffer;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_newwithbyteoffsetandlength_9fb2f11355ecadf5 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_newwithbyteoffsetandlength_92c251989c485785 = function(arg0, arg1, arg2) {
         const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_537b7341ce90bb31 = function(arg0) {
+    imports.wbg.__wbg_new_bc5d9aad3f9ac80e = function(arg0) {
         const ret = new Uint8Array(getObject(arg0));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_set_17499e8aa4003ebd = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_set_4b3aa8445ac1e91c = function(arg0, arg1, arg2) {
         getObject(arg0).set(getObject(arg1), arg2 >>> 0);
     };
-    imports.wbg.__wbg_length_27a2afe8ab42b09f = function(arg0) {
+    imports.wbg.__wbg_length_d9c4ded7e708c6a1 = function(arg0) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_newwithlength_b56c882b57805732 = function(arg0) {
+    imports.wbg.__wbg_newwithlength_89eca18f2603a999 = function(arg0) {
         const ret = new Uint8Array(arg0 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_subarray_7526649b91a252a6 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_subarray_7649d027b2b141b3 = function(arg0, arg1, arg2) {
         const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
         const ret = debugString(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;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
     imports.wbg.__wbindgen_throw = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
@@ -25264,9 +25359,9 @@ function getImports() {
     return imports;
 }
 
-function finalizeInit(instance, module) {
+function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
-    init.__wbindgen_wasm_module = module;
+    __wbg_init.__wbindgen_wasm_module = module;
     cachedInt32Memory0 = null;
     cachedUint32Memory0 = null;
     cachedUint8Memory0 = null;
@@ -25275,19 +25370,21 @@ function finalizeInit(instance, module) {
     return wasm;
 }
 
-async function init(input) {
+async function __wbg_init(input) {
+    if (wasm !== undefined) return wasm;
+
     if (typeof input === 'undefined') {
-        input = new URL(new URL('assets/rln_wasm_bg-6f96f821.wasm', import.meta.url).href, import.meta.url);
+        input = new URL(new URL('assets/rln_wasm_bg-a503e304.wasm', import.meta.url).href, import.meta.url);
     }
-    const imports = getImports();
+    const imports = __wbg_get_imports();
 
     if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
         input = fetch(input);
     }
 
-    const { instance, module } = await load(await input, imports);
+    const { instance, module } = await __wbg_load(await input, imports);
 
-    return finalizeInit(instance, module);
+    return __wbg_finalize_init(instance, module);
 }
 
 const verificationKey = {
@@ -25726,7 +25823,7 @@ async function loadZkey() {
  * @returns RLNInstance
  */
 async function create$1() {
-    await init();
+    await __wbg_init?.();
     init_panic_hook();
     const witnessCalculator = await loadWitnessCalculator();
     const zkey = await loadZkey();
@@ -49692,27 +49789,51 @@ class MerkleRootTracker {
 }
 
 class RLNContract {
-    constructor(rlnInstance, { address, provider }) {
-        this._members = [];
-        const initialRoot = rlnInstance.getMerkleRoot();
-        this._contract = new Contract(address, RLN_ABI, provider);
-        this.merkleRootTracker = new MerkleRootTracker(5, initialRoot);
-        this.membersFilter = this.contract.filters.MemberRegistered();
-    }
     static async init(rlnInstance, options) {
         const rlnContract = new RLNContract(rlnInstance, options);
+        await rlnContract.initStorageContract(options.provider);
         await rlnContract.fetchMembers(rlnInstance);
         rlnContract.subscribeToMembers(rlnInstance);
         return rlnContract;
     }
+    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() {
-        return this._contract;
+        if (!this.storageContract) {
+            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) {
+            throw Error("Members filter was not initialized.");
+        }
+        return this._membersFilter;
     }
     async fetchMembers(rlnInstance, options = {}) {
         const registeredMemberEvents = await queryFilter(this.contract, {
+            fromBlock: this.deployBlock,
             ...options,
             membersFilter: this.membersFilter,
         });
@@ -49729,11 +49850,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 {
@@ -49744,21 +49865,24 @@ class RLNContract {
                 eventsPerBlock.push(evt);
                 toInsertTable.set(evt.blockNumber, eventsPerBlock);
             }
-            this.removeMembers(rlnInstance, toRemoveTable);
-            this.insertMembers(rlnInstance, toInsertTable);
         });
+        this.removeMembers(rlnInstance, toRemoveTable);
+        this.insertMembers(rlnInstance, toInsertTable);
     }
     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 = zeroPadLE(hexToBytes$2(_idCommitment?._hex), 32);
                 rlnInstance.insertMember(idCommitment);
-                this.members.push({ index, pubkey });
+                this._members.set(index.toNumber(), {
+                    index,
+                    idCommitment: _idCommitment?._hex,
+                });
             });
             const currentRoot = rlnInstance.getMerkleRoot();
             this.merkleRootTracker.pushRoot(blockNumber, currentRoot);
@@ -49768,9 +49892,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);
             });
@@ -49778,19 +49901,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) {
-        const depositValue = await this.contract.MEMBERSHIP_DEPOSIT();
-        const txRegisterResponse = await this.contract.register(credential.IDCommitmentBigInt, {
-            value: depositValue,
-        });
+        if (this.storageIndex === undefined) {
+            throw Error("Cannot register credential, no storage contract index found.");
+        }
+        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();
@@ -49856,4 +49988,4 @@ async function create() {
     return await rlnModule.create();
 }
 
-export { IdentityCredential, Keystore, MerkleRootTracker, Proof, ProofMetadata, RLNContract, RLNDecoder, RLNEncoder, RLNInstance, RLN_ABI, SEPOLIA_CONTRACT, create };
+export { IdentityCredential, Keystore, MerkleRootTracker, Proof, ProofMetadata, RLNContract, RLNDecoder, RLNEncoder, RLNInstance, RLN_REGISTRY_ABI, RLN_STORAGE_ABI, SEPOLIA_CONTRACT, create };