@waku/rln 0.0.5 → 0.0.7

package/bundle/rln-4592cf99.js

@@ -0,0 +1,1147 @@
+let wasm;
+
+const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachedUint8Memory0 = new Uint8Array();
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+const heap = new Array(32).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+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 getObject(idx) { return heap[idx]; }
+
+function dropObject(idx) {
+    if (idx < 36) 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 encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length);
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len);
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let cachedInt32Memory0 = new Int32Array();
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+/**
+*/
+function init_panic_hook() {
+    wasm.init_panic_hook();
+}
+
+/**
+* @param {number} tree_height
+* @param {Uint8Array} zkey
+* @param {Uint8Array} vk
+* @returns {number}
+*/
+function newRLN(tree_height, zkey, vk) {
+    const ret = wasm.newRLN(tree_height, addHeapObject(zkey), addHeapObject(vk));
+    return ret;
+}
+
+/**
+* @param {number} ctx
+* @param {Uint8Array} input
+* @returns {Uint8Array}
+*/
+function getSerializedRLNWitness(ctx, input) {
+    const ret = wasm.getSerializedRLNWitness(ctx, addHeapObject(input));
+    return takeObject(ret);
+}
+
+/**
+* @param {number} ctx
+* @param {Uint8Array} input
+*/
+function insertMember(ctx, input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.insertMember(retptr, ctx, 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 {Uint8Array} serialized_witness
+* @returns {object}
+*/
+function RLNWitnessToJson(ctx, serialized_witness) {
+    const ret = wasm.RLNWitnessToJson(ctx, addHeapObject(serialized_witness));
+    return takeObject(ret);
+}
+
+let cachedUint32Memory0 = new Uint32Array();
+
+function getUint32Memory0() {
+    if (cachedUint32Memory0.byteLength === 0) {
+        cachedUint32Memory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32Memory0;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4);
+    const mem = getUint32Memory0();
+    for (let i = 0; i < array.length; i++) {
+        mem[ptr / 4 + i] = addHeapObject(array[i]);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+/**
+* @param {number} ctx
+* @param {(bigint)[]} calculated_witness
+* @param {Uint8Array} serialized_witness
+* @returns {Uint8Array}
+*/
+function generate_rln_proof_with_witness(ctx, calculated_witness, serialized_witness) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArrayJsValueToWasm0(calculated_witness, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.generate_rln_proof_with_witness(retptr, ctx, ptr0, len0, 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);
+    }
+}
+
+/**
+* @param {number} ctx
+* @returns {Uint8Array}
+*/
+function generateMembershipKey(ctx) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.generateMembershipKey(retptr, ctx);
+        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 {number} ctx
+* @param {Uint8Array} proof
+* @returns {boolean}
+*/
+function verifyProof(ctx, proof) {
+    const ret = wasm.verifyProof(ctx, addHeapObject(proof));
+    return ret !== 0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+async function load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function getImports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
+    imports.wbg.__wbindgen_is_string = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'string';
+        return ret;
+    };
+    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;
+    };
+    imports.wbg.__wbg_BigInt_d0c7d465bfa30d3b = function(arg0) {
+        const ret = BigInt(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));
+        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_set_c943d600fa71e4dd = function(arg0, arg1, arg2) {
+        getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+    };
+    imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
+        const ret = new Error();
+        return addHeapObject(ret);
+    };
+    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;
+    };
+    imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
+        try {
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(arg0, arg1);
+        }
+    };
+    imports.wbg.__wbg_randomFillSync_065afffde01daa66 = 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) {
+        getObject(arg0).getRandomValues(getObject(arg1));
+    }, arguments) };
+    imports.wbg.__wbg_process_0cc2ada8524d6f83 = function(arg0) {
+        const ret = getObject(arg0).process;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_versions_c11acceab27a6c87 = function(arg0) {
+        const ret = getObject(arg0).versions;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_node_7ff1ce49caf23815 = function(arg0) {
+        const ret = getObject(arg0).node;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_static_accessor_NODE_MODULE_cf6401cc1091279e = function() {
+        const ret = module;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_require_a746e79b322b9336 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).require(getStringFromWasm0(arg1, arg2));
+        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.__wbg_new_1d9a920c6bfc44a8 = function() {
+        const ret = new Array();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newnoargs_b5b063fc6c2f0376 = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_268f7b7dd3430798 = function() {
+        const ret = new Map();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_call_97ae9d8645dc388b = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_new_0b9bfdd97583284e = function() {
+        const ret = new Object();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_self_6d479506f72c6a71 = function() { return handleError(function () {
+        const ret = self.self;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_window_f2557cc78490aceb = function() { return handleError(function () {
+        const ret = window.window;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_globalThis_7f206bda628d5286 = function() { return handleError(function () {
+        const ret = globalThis.globalThis;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_global_ba75c50d1cf384f4 = function() { return handleError(function () {
+        const ret = global.global;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_set_a68214f35c417fa9 = function(arg0, arg1, arg2) {
+        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+    };
+    imports.wbg.__wbg_toString_d9cd5f001405e8ff = 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));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_set_933729cf5b66ac11 = 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) {
+        const ret = Object.fromEntries(getObject(arg0));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_buffer_3f3d764d4747d564 = function(arg0) {
+        const ret = getObject(arg0).buffer;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_d9aa266703cb98be = function(arg0, arg1, arg2) {
+        const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_8c3f0052272a457a = function(arg0) {
+        const ret = new Uint8Array(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_set_83db9690f9353e79 = function(arg0, arg1, arg2) {
+        getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+    };
+    imports.wbg.__wbg_length_9e1ae1900cb0fbd5 = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_newwithlength_f5933855e4f48a19 = function(arg0) {
+        const ret = new Uint8Array(arg0 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_subarray_58ad4efbb5bcb886 = 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;
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_memory = function() {
+        const ret = wasm.memory;
+        return addHeapObject(ret);
+    };
+
+    return imports;
+}
+
+function finalizeInit(instance, module) {
+    wasm = instance.exports;
+    init.__wbindgen_wasm_module = module;
+    cachedInt32Memory0 = new Int32Array();
+    cachedUint32Memory0 = new Uint32Array();
+    cachedUint8Memory0 = new Uint8Array();
+
+
+    return wasm;
+}
+
+async function init(input) {
+    if (typeof input === 'undefined') {
+        input = new URL(new URL('assets/rln_wasm_bg-0185b546.wasm', import.meta.url).href, import.meta.url);
+    }
+    const imports = getImports();
+
+    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);
+
+    return finalizeInit(instance, module);
+}
+
+var protocol = "groth16";
+var curve = "bn128";
+var nPublic = 6;
+var vk_alpha_1 = [
+	"1805378556360488226980822394597799963030511477964155500103132920745199284516",
+	"11990395240534218699464972016456017378439762088320057798320175886595281336136",
+	"1"
+];
+var vk_beta_2 = [
+	[
+		"11031529986141021025408838211017932346992429731488270384177563837022796743627",
+		"16042159910707312759082561183373181639420894978640710177581040523252926273854"
+	],
+	[
+		"20112698439519222240302944148895052359035104222313380895334495118294612255131",
+		"19441583024670359810872018179190533814486480928824742448673677460151702019379"
+	],
+	[
+		"1",
+		"0"
+	]
+];
+var vk_gamma_2 = [
+	[
+		"10857046999023057135944570762232829481370756359578518086990519993285655852781",
+		"11559732032986387107991004021392285783925812861821192530917403151452391805634"
+	],
+	[
+		"8495653923123431417604973247489272438418190587263600148770280649306958101930",
+		"4082367875863433681332203403145435568316851327593401208105741076214120093531"
+	],
+	[
+		"1",
+		"0"
+	]
+];
+var vk_delta_2 = [
+	[
+		"1948496782571164085469528023647105317580208688174386157591917599801657832035",
+		"20445814069256658101339037520922621162739470138213615104905368409238414511981"
+	],
+	[
+		"10024680869920840984813249386422727863826862577760330492647062850849851925340",
+		"10512156247842686783409460795717734694774542185222602679117887145206209285142"
+	],
+	[
+		"1",
+		"0"
+	]
+];
+var vk_alphabeta_12 = [
+	[
+		[
+			"5151991366823434428398919091000210787450832786814248297320989361921939794156",
+			"15735191313289001022885148627913534790382722933676436876510746491415970766821"
+		],
+		[
+			"3387907257437913904447588318761906430938415556102110876587455322225272831272",
+			"1998779853452712881084781956683721603875246565720647583735935725110674288056"
+		],
+		[
+			"14280074182991498185075387990446437410077692353432005297922275464876153151820",
+			"17092408446352310039633488224969232803092763095456307462247653153107223117633"
+		]
+	],
+	[
+		[
+			"4359046709531668109201634396816565829237358165496082832279660960675584351266",
+			"4511888308846208349307186938266411423935335853916317436093178288331845821336"
+		],
+		[
+			"11429499807090785857812316277335883295048773373068683863667725283965356423273",
+			"16232274853200678548795010078253506586114563833318973594428907292096178657392"
+		],
+		[
+			"18068999605870933925311275504102553573815570223888590384919752303726860800970",
+			"17309569111965782732372130116757295842160193489132771344011460471298173784984"
+		]
+	]
+];
+var IC = [
+	[
+		"18693301901828818437917730940595978397160482710354161265484535387752523310572",
+		"17985273354976640088538673802000794244421192643855111089693820179790551470769",
+		"1"
+	],
+	[
+		"21164641723988537620541455173278629777250883365474191521194244273980931825942",
+		"998385854410718613441067082771678946155853656328717326195057262123686425518",
+		"1"
+	],
+	[
+		"21666968581672145768705229094968410656430989593283335488162701230986314747515",
+		"17996457608540683483506630273632100555125353447506062045735279661096094677264",
+		"1"
+	],
+	[
+		"20137761979695192602424300886442379728165712610493092740175904438282083668117",
+		"19184814924890679891263780109959113289320127263583260218200636509492157834679",
+		"1"
+	],
+	[
+		"10943171273393803842589314082509655332154393332394322726077270895078286354146",
+		"10872472035685319847811233167729172672344935625121511932198535224727331126439",
+		"1"
+	],
+	[
+		"13049169779481227658517545034348883391527506091990880778783387628208561946597",
+		"10083689369261379027228809473568899816311684698866922944902456565434209079955",
+		"1"
+	],
+	[
+		"19633516378466409167014413361365552102431118630694133723053441455184566611083",
+		"8059525100726933978719058611146131904598011633549012007359165766216730722269",
+		"1"
+	]
+];
+var verificationKey = {
+	protocol: protocol,
+	curve: curve,
+	nPublic: nPublic,
+	vk_alpha_1: vk_alpha_1,
+	vk_beta_2: vk_beta_2,
+	vk_gamma_2: vk_gamma_2,
+	vk_delta_2: vk_delta_2,
+	vk_alphabeta_12: vk_alphabeta_12,
+	IC: IC
+};
+
+// File generated with https://github.com/iden3/circom 
+// following the instructions from:
+// https://github.com/vacp2p/zerokit/tree/master/rln#compiling-circuits
+async function builder(code, options) {
+    options = options || {};
+    let wasmModule;
+    try {
+        wasmModule = await WebAssembly.compile(code);
+    }
+    catch (err) {
+        console.log(err);
+        console.log("\nTry to run circom --c in order to generate c++ code instead\n");
+        throw new Error(err);
+    }
+    let wc;
+    let errStr = "";
+    let msgStr = "";
+    const instance = await WebAssembly.instantiate(wasmModule, {
+        runtime: {
+            exceptionHandler: function (code) {
+                let err;
+                if (code == 1) {
+                    err = "Signal not found.\n";
+                }
+                else if (code == 2) {
+                    err = "Too many signals set.\n";
+                }
+                else if (code == 3) {
+                    err = "Signal already set.\n";
+                }
+                else if (code == 4) {
+                    err = "Assert Failed.\n";
+                }
+                else if (code == 5) {
+                    err = "Not enough memory.\n";
+                }
+                else if (code == 6) {
+                    err = "Input signal array access exceeds the size.\n";
+                }
+                else {
+                    err = "Unknown error.\n";
+                }
+                throw new Error(err + errStr);
+            },
+            printErrorMessage: function () {
+                errStr += getMessage() + "\n";
+                // console.error(getMessage());
+            },
+            writeBufferMessage: function () {
+                const msg = getMessage();
+                // Any calls to `log()` will always end with a `\n`, so that's when we print and reset
+                if (msg === "\n") {
+                    console.log(msgStr);
+                    msgStr = "";
+                }
+                else {
+                    // If we've buffered other content, put a space in between the items
+                    if (msgStr !== "") {
+                        msgStr += " ";
+                    }
+                    // Then append the message to the message we are creating
+                    msgStr += msg;
+                }
+            },
+            showSharedRWMemory: function () {
+                printSharedRWMemory();
+            }
+        }
+    });
+    const sanityCheck = options;
+    //        options &&
+    //        (
+    //            options.sanityCheck ||
+    //            options.logGetSignal ||
+    //            options.logSetSignal ||
+    //            options.logStartComponent ||
+    //            options.logFinishComponent
+    //        );
+    wc = new WitnessCalculator(instance, sanityCheck);
+    return wc;
+    function getMessage() {
+        var message = "";
+        var c = instance.exports.getMessageChar();
+        while (c != 0) {
+            message += String.fromCharCode(c);
+            c = instance.exports.getMessageChar();
+        }
+        return message;
+    }
+    function printSharedRWMemory() {
+        const shared_rw_memory_size = instance.exports.getFieldNumLen32();
+        const arr = new Uint32Array(shared_rw_memory_size);
+        for (let j = 0; j < shared_rw_memory_size; j++) {
+            arr[shared_rw_memory_size - 1 - j] = instance.exports.readSharedRWMemory(j);
+        }
+        // If we've buffered other content, put a space in between the items
+        if (msgStr !== "") {
+            msgStr += " ";
+        }
+        // Then append the value to the message we are creating
+        msgStr += (fromArray32(arr).toString());
+    }
+}
+class WitnessCalculator {
+    constructor(instance, sanityCheck) {
+        this.instance = instance;
+        this.version = this.instance.exports.getVersion();
+        this.n32 = this.instance.exports.getFieldNumLen32();
+        this.instance.exports.getRawPrime();
+        const arr = new Uint32Array(this.n32);
+        for (let i = 0; i < this.n32; i++) {
+            arr[this.n32 - 1 - i] = this.instance.exports.readSharedRWMemory(i);
+        }
+        this.prime = fromArray32(arr);
+        this.witnessSize = this.instance.exports.getWitnessSize();
+        this.sanityCheck = sanityCheck;
+    }
+    circom_version() {
+        return this.instance.exports.getVersion();
+    }
+    async _doCalculateWitness(input, sanityCheck) {
+        //input is assumed to be a map from signals to arrays of bigints
+        this.instance.exports.init((this.sanityCheck || sanityCheck) ? 1 : 0);
+        const keys = Object.keys(input);
+        var input_counter = 0;
+        keys.forEach((k) => {
+            const h = fnvHash(k);
+            const hMSB = parseInt(h.slice(0, 8), 16);
+            const hLSB = parseInt(h.slice(8, 16), 16);
+            const fArr = flatArray(input[k]);
+            let signalSize = this.instance.exports.getInputSignalSize(hMSB, hLSB);
+            if (signalSize < 0) {
+                throw new Error(`Signal ${k} not found\n`);
+            }
+            if (fArr.length < signalSize) {
+                throw new Error(`Not enough values for input signal ${k}\n`);
+            }
+            if (fArr.length > signalSize) {
+                throw new Error(`Too many values for input signal ${k}\n`);
+            }
+            for (let i = 0; i < fArr.length; i++) {
+                const arrFr = toArray32(BigInt(fArr[i]) % this.prime, this.n32);
+                for (let j = 0; j < this.n32; j++) {
+                    this.instance.exports.writeSharedRWMemory(j, arrFr[this.n32 - 1 - j]);
+                }
+                try {
+                    this.instance.exports.setInputSignal(hMSB, hLSB, i);
+                    input_counter++;
+                }
+                catch (err) {
+                    // console.log(`After adding signal ${i} of ${k}`)
+                    throw new Error(err);
+                }
+            }
+        });
+        if (input_counter < this.instance.exports.getInputSize()) {
+            throw new Error(`Not all inputs have been set. Only ${input_counter} out of ${this.instance.exports.getInputSize()}`);
+        }
+    }
+    async calculateWitness(input, sanityCheck) {
+        const w = [];
+        await this._doCalculateWitness(input, sanityCheck);
+        for (let i = 0; i < this.witnessSize; i++) {
+            this.instance.exports.getWitness(i);
+            const arr = new Uint32Array(this.n32);
+            for (let j = 0; j < this.n32; j++) {
+                arr[this.n32 - 1 - j] = this.instance.exports.readSharedRWMemory(j);
+            }
+            w.push(fromArray32(arr));
+        }
+        return w;
+    }
+    async calculateBinWitness(input, sanityCheck) {
+        const buff32 = new Uint32Array(this.witnessSize * this.n32);
+        const buff = new Uint8Array(buff32.buffer);
+        await this._doCalculateWitness(input, sanityCheck);
+        for (let i = 0; i < this.witnessSize; i++) {
+            this.instance.exports.getWitness(i);
+            const pos = i * this.n32;
+            for (let j = 0; j < this.n32; j++) {
+                buff32[pos + j] = this.instance.exports.readSharedRWMemory(j);
+            }
+        }
+        return buff;
+    }
+    async calculateWTNSBin(input, sanityCheck) {
+        const buff32 = new Uint32Array(this.witnessSize * this.n32 + this.n32 + 11);
+        const buff = new Uint8Array(buff32.buffer);
+        await this._doCalculateWitness(input, sanityCheck);
+        //"wtns"
+        buff[0] = "w".charCodeAt(0);
+        buff[1] = "t".charCodeAt(0);
+        buff[2] = "n".charCodeAt(0);
+        buff[3] = "s".charCodeAt(0);
+        //version 2
+        buff32[1] = 2;
+        //number of sections: 2
+        buff32[2] = 2;
+        //id section 1
+        buff32[3] = 1;
+        const n8 = this.n32 * 4;
+        //id section 1 length in 64bytes
+        const idSection1length = 8 + n8;
+        const idSection1lengthHex = idSection1length.toString(16);
+        buff32[4] = parseInt(idSection1lengthHex.slice(0, 8), 16);
+        buff32[5] = parseInt(idSection1lengthHex.slice(8, 16), 16);
+        //this.n32
+        buff32[6] = n8;
+        //prime number
+        this.instance.exports.getRawPrime();
+        var pos = 7;
+        for (let j = 0; j < this.n32; j++) {
+            buff32[pos + j] = this.instance.exports.readSharedRWMemory(j);
+        }
+        pos += this.n32;
+        // witness size
+        buff32[pos] = this.witnessSize;
+        pos++;
+        //id section 2
+        buff32[pos] = 2;
+        pos++;
+        // section 2 length
+        const idSection2length = n8 * this.witnessSize;
+        const idSection2lengthHex = idSection2length.toString(16);
+        buff32[pos] = parseInt(idSection2lengthHex.slice(0, 8), 16);
+        buff32[pos + 1] = parseInt(idSection2lengthHex.slice(8, 16), 16);
+        pos += 2;
+        for (let i = 0; i < this.witnessSize; i++) {
+            this.instance.exports.getWitness(i);
+            for (let j = 0; j < this.n32; j++) {
+                buff32[pos + j] = this.instance.exports.readSharedRWMemory(j);
+            }
+            pos += this.n32;
+        }
+        return buff;
+    }
+}
+function toArray32(rem, size) {
+    const res = []; //new Uint32Array(size); //has no unshift
+    const radix = BigInt(0x100000000);
+    while (rem) {
+        res.unshift(Number(rem % radix));
+        rem = rem / radix;
+    }
+    if (size) {
+        var i = size - res.length;
+        while (i > 0) {
+            res.unshift(0);
+            i--;
+        }
+    }
+    return res;
+}
+function fromArray32(arr) {
+    var res = BigInt(0);
+    const radix = BigInt(0x100000000);
+    for (let i = 0; i < arr.length; i++) {
+        res = res * radix + BigInt(arr[i]);
+    }
+    return res;
+}
+function flatArray(a) {
+    var res = [];
+    fillArray(res, a);
+    return res;
+    function fillArray(res, a) {
+        if (Array.isArray(a)) {
+            for (let i = 0; i < a.length; i++) {
+                fillArray(res, a[i]);
+            }
+        }
+        else {
+            res.push(a);
+        }
+    }
+}
+function fnvHash(str) {
+    const uint64_max = BigInt(2) ** BigInt(64);
+    let hash = BigInt("0xCBF29CE484222325");
+    for (var i = 0; i < str.length; i++) {
+        hash ^= BigInt(str[i].charCodeAt());
+        hash *= BigInt(0x100000001B3);
+        hash %= uint64_max;
+    }
+    let shash = hash.toString(16);
+    let n = 16 - shash.length;
+    shash = '0'.repeat(n).concat(shash);
+    return shash;
+}
+
+/**
+ * Concatenate Uint8Arrays
+ * @param input
+ * @returns concatenation of all Uint8Array received as input
+ */
+function concatenate(...input) {
+    let totalLength = 0;
+    for (const arr of input) {
+        totalLength += arr.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of input) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+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 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 response = await fetch(url);
+    return new Uint8Array(await response.arrayBuffer());
+}
+/**
+ * Create an instance of RLN
+ * @returns RLNInstance
+ */
+async function create() {
+    await init();
+    init_panic_hook();
+    const witnessCalculator = await loadWitnessCalculator();
+    const zkey = await loadZkey();
+    const vkey = stringEncoder.encode(JSON.stringify(verificationKey));
+    const zkRLN = newRLN(DEPTH, zkey, vkey);
+    return new RLNInstance(zkRLN, witnessCalculator);
+}
+class MembershipKey {
+    constructor(memKeys) {
+        this.IDKey = memKeys.subarray(0, 32);
+        this.IDCommitment = memKeys.subarray(32);
+    }
+}
+// Adapted from https://github.com/feross/buffer
+function checkInt(buf, value, offset, ext, max, min) {
+    if (value > max || value < min)
+        throw new RangeError('"value" argument is out of bounds');
+    if (offset + ext > buf.length)
+        throw new RangeError("Index out of range");
+}
+const writeUIntLE = function writeUIntLE(buf, value, offset, byteLength, noAssert) {
+    value = +value;
+    offset = offset >>> 0;
+    byteLength = byteLength >>> 0;
+    if (!noAssert) {
+        const maxBytes = Math.pow(2, 8 * byteLength) - 1;
+        checkInt(buf, value, offset, byteLength, maxBytes, 0);
+    }
+    let mul = 1;
+    let i = 0;
+    buf[offset] = value & 0xff;
+    while (++i < byteLength && (mul *= 0x100)) {
+        buf[offset + i] = (value / mul) & 0xff;
+    }
+    return buf;
+};
+const DefaultEpochUnitSeconds = 10; // the rln-relay epoch length in seconds
+function toEpoch(timestamp, epochUnitSeconds = DefaultEpochUnitSeconds) {
+    const unix = Math.floor(timestamp.getTime() / 1000 / epochUnitSeconds);
+    return writeUIntLE(new Uint8Array(32), unix, 0, 8);
+}
+const proofOffset = 128;
+const rootOffset = proofOffset + 32;
+const epochOffset = rootOffset + 32;
+const shareXOffset = epochOffset + 32;
+const shareYOffset = shareXOffset + 32;
+const nullifierOffset = shareYOffset + 32;
+const rlnIdentifierOffset = nullifierOffset + 32;
+class RateLimitProof {
+    constructor(proofBytes) {
+        if (proofBytes.length < rlnIdentifierOffset)
+            throw "invalid proof";
+        // parse the proof as proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32>
+        this.proof = proofBytes.subarray(0, proofOffset);
+        this.merkleRoot = proofBytes.subarray(proofOffset, rootOffset);
+        this.epoch = proofBytes.subarray(rootOffset, epochOffset);
+        this.shareX = proofBytes.subarray(epochOffset, shareXOffset);
+        this.shareY = proofBytes.subarray(shareXOffset, shareYOffset);
+        this.nullifier = proofBytes.subarray(shareYOffset, nullifierOffset);
+        this.rlnIdentifier = proofBytes.subarray(nullifierOffset, rlnIdentifierOffset);
+    }
+    toBytes() {
+        return concatenate(this.proof, this.merkleRoot, this.epoch, this.shareX, this.shareY, this.nullifier, this.rlnIdentifier);
+    }
+}
+class RLNInstance {
+    constructor(zkRLN, witnessCalculator) {
+        this.zkRLN = zkRLN;
+        this.witnessCalculator = witnessCalculator;
+    }
+    generateMembershipKey() {
+        const memKeys = generateMembershipKey(this.zkRLN);
+        return new MembershipKey(memKeys);
+    }
+    insertMember(idCommitment) {
+        insertMember(this.zkRLN, idCommitment);
+    }
+    serializeMessage(uint8Msg, memIndex, epoch, idKey) {
+        // calculate message length
+        const msgLen = writeUIntLE(new Uint8Array(8), uint8Msg.length, 0, 8);
+        // Converting index to LE bytes
+        const memIndexBytes = writeUIntLE(new Uint8Array(8), memIndex, 0, 8);
+        // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
+        return concatenate(idKey, memIndexBytes, epoch, msgLen, uint8Msg);
+    }
+    async generateProof(msg, index, epoch, idKey) {
+        if (epoch == undefined) {
+            epoch = toEpoch(new Date());
+        }
+        else if (epoch instanceof Date) {
+            epoch = toEpoch(epoch);
+        }
+        if (epoch.length != 32)
+            throw "invalid epoch";
+        if (idKey.length != 32)
+            throw "invalid id key";
+        if (index < 0)
+            throw "index must be >= 0";
+        const serialized_msg = this.serializeMessage(msg, index, epoch, idKey);
+        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
+        const proofBytes = generate_rln_proof_with_witness(this.zkRLN, calculatedWitness, rlnWitness);
+        return new RateLimitProof(proofBytes);
+    }
+    verifyProof(proof) {
+        if (proof instanceof RateLimitProof) {
+            proof = proof.toBytes();
+        }
+        return verifyProof(this.zkRLN, proof);
+    }
+}
+
+export { MembershipKey, RLNInstance, RateLimitProof, create, toEpoch };