@waku/rln 0.1.1-9b1e818 → 0.1.1-bafbe01

package/bundle/index.js

@@ -1639,7 +1639,7 @@ const encodingLength = (int) => {
  * @param {Code} code
  * @param {Uint8Array} digest
  */
-const create$2 = (code, digest) => {
+const create$1 = (code, digest) => {
   const size = digest.byteLength;
   const sizeOffset = encodingLength(code);
   const digestOffset = sizeOffset + encodingLength(size);
@@ -1692,7 +1692,7 @@ const encode$3 = coerce;
  * @param {Uint8Array} input
  * @returns {Digest.Digest<typeof code, number>}
  */
-const digest = (input) => create$2(code, encode$3(input));
+const digest = (input) => create$1(code, encode$3(input));
 
 const identity = { code, name, encode: encode$3, digest };
 
@@ -1741,9 +1741,9 @@ class Hasher {
     if (input instanceof Uint8Array) {
       const result = this.encode(input);
       return result instanceof Uint8Array
-        ? create$2(this.code, result)
+        ? create$1(this.code, result)
         /* c8 ignore next 1 */
-        : result.then(digest => create$2(this.code, digest))
+        : result.then(digest => create$1(this.code, digest))
     } else {
       throw Error('Unknown type, must be binary type')
       /* c8 ignore next 1 */
@@ -1980,9 +1980,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.idSecretHash);
-        console.timeEnd("proof_gen_timer");
         return proof;
     }
     get pubsubTopic() {
@@ -2086,6 +2084,14 @@ const SEPOLIA_CONTRACT = {
     abi: RLN_REGISTRY_ABI,
 };
 
+async function createRLN() {
+    // A dependency graph that contains any wasm must all be imported
+    // asynchronously. This file does the single async import, so
+    // that no one else needs to worry about it again.
+    const rlnModule = await Promise.resolve().then(function () { return rln; });
+    return rlnModule.create();
+}
+
 var lib = {};
 
 var types = {};
@@ -25387,626 +25393,9 @@ async function __wbg_init(input) {
     return __wbg_finalize_init(instance, module);
 }
 
-const verificationKey = {
-    protocol: "groth16",
-    curve: "bn128",
-    nPublic: 6,
-    vk_alpha_1: [
-        "20124996762962216725442980738609010303800849578410091356605067053491763969391",
-        "9118593021526896828671519912099489027245924097793322973632351264852174143923",
-        "1",
-    ],
-    vk_beta_2: [
-        [
-            "4693952934005375501364248788849686435240706020501681709396105298107971354382",
-            "14346958885444710485362620645446987998958218205939139994511461437152241966681",
-        ],
-        [
-            "16851772916911573982706166384196538392731905827088356034885868448550849804972",
-            "823612331030938060799959717749043047845343400798220427319188951998582076532",
-        ],
-        ["1", "0"],
-    ],
-    vk_gamma_2: [
-        [
-            "10857046999023057135944570762232829481370756359578518086990519993285655852781",
-            "11559732032986387107991004021392285783925812861821192530917403151452391805634",
-        ],
-        [
-            "8495653923123431417604973247489272438418190587263600148770280649306958101930",
-            "4082367875863433681332203403145435568316851327593401208105741076214120093531",
-        ],
-        ["1", "0"],
-    ],
-    vk_delta_2: [
-        [
-            "8353516066399360694538747105302262515182301251524941126222712285088022964076",
-            "9329524012539638256356482961742014315122377605267454801030953882967973561832",
-        ],
-        [
-            "16805391589556134376869247619848130874761233086443465978238468412168162326401",
-            "10111259694977636294287802909665108497237922060047080343914303287629927847739",
-        ],
-        ["1", "0"],
-    ],
-    vk_alphabeta_12: [
-        [
-            [
-                "12608968655665301215455851857466367636344427685631271961542642719683786103711",
-                "9849575605876329747382930567422916152871921500826003490242628251047652318086",
-            ],
-            [
-                "6322029441245076030714726551623552073612922718416871603535535085523083939021",
-                "8700115492541474338049149013125102281865518624059015445617546140629435818912",
-            ],
-            [
-                "10674973475340072635573101639867487770811074181475255667220644196793546640210",
-                "2926286967251299230490668407790788696102889214647256022788211245826267484824",
-            ],
-        ],
-        [
-            [
-                "9660441540778523475944706619139394922744328902833875392144658911530830074820",
-                "19548113127774514328631808547691096362144426239827206966690021428110281506546",
-            ],
-            [
-                "1870837942477655969123169532603615788122896469891695773961478956740992497097",
-                "12536105729661705698805725105036536744930776470051238187456307227425796690780",
-            ],
-            [
-                "21811903352654147452884857281720047789720483752548991551595462057142824037334",
-                "19021616763967199151052893283384285352200445499680068407023236283004353578353",
-            ],
-        ],
-    ],
-    IC: [
-        [
-            "11992897507809711711025355300535923222599547639134311050809253678876341466909",
-            "17181525095924075896332561978747020491074338784673526378866503154966799128110",
-            "1",
-        ],
-        [
-            "17018665030246167677911144513385572506766200776123272044534328594850561667818",
-            "18601114175490465275436712413925513066546725461375425769709566180981674884464",
-            "1",
-        ],
-        [
-            "18799470100699658367834559797874857804183288553462108031963980039244731716542",
-            "13064227487174191981628537974951887429496059857753101852163607049188825592007",
-            "1",
-        ],
-        [
-            "17432501889058124609368103715904104425610382063762621017593209214189134571156",
-            "13406815149699834788256141097399354592751313348962590382887503595131085938635",
-            "1",
-        ],
-        [
-            "10320964835612716439094703312987075811498239445882526576970512041988148264481",
-            "9024164961646353611176283204118089412001502110138072989569118393359029324867",
-            "1",
-        ],
-        [
-            "718355081067365548229685160476620267257521491773976402837645005858953849298",
-            "14635482993933988261008156660773180150752190597753512086153001683711587601974",
-            "1",
-        ],
-        [
-            "11777720285956632126519898515392071627539405001940313098390150593689568177535",
-            "8483603647274280691250972408211651407952870456587066148445913156086740744515",
-            "1",
-        ],
-    ],
-};
+var bn = {exports: {}};
 
-// 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-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-8b299152.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$1() {
-    await __wbg_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 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 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 IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment, idCommitmentBigInt);
-    }
-}
-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 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)
-            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);
-    }
-    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;
-    }
-    generateIdentityCredentials() {
-        const memKeys = generateExtendedMembershipKey(this.zkRLN); // TODO: rename this function in zerokit rln-wasm
-        return IdentityCredential.fromBytes(memKeys);
-    }
-    generateSeededIdentityCredential(seed) {
-        const seedBytes = stringEncoder.encode(seed);
-        // 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);
-    }
-    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 generateRLNProof(msg, index, epoch, idSecretHash) {
-        if (epoch == undefined) {
-            epoch = epochIntToBytes(dateToEpoch(new Date()));
-        }
-        else if (epoch instanceof Date) {
-            epoch = epochIntToBytes(dateToEpoch(epoch));
-        }
-        if (epoch.length != 32)
-            throw "invalid epoch";
-        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, 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
-        const proofBytes = generate_rln_proof_with_witness(this.zkRLN, calculatedWitness, rlnWitness);
-        return new Proof(proofBytes);
-    }
-    verifyRLNProof(proof, msg) {
-        let pBytes;
-        if (proof instanceof Uint8Array) {
-            pBytes = proof;
-        }
-        else {
-            pBytes = proofToBytes(proof);
-        }
-        // calculate message length
-        const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-        return verifyRLNProof(this.zkRLN, concatenate(pBytes, msgLen, msg));
-    }
-    verifyWithRoots(proof, msg, ...roots) {
-        let pBytes;
-        if (proof instanceof Uint8Array) {
-            pBytes = proof;
-        }
-        else {
-            pBytes = proofToBytes(proof);
-        }
-        // calculate message length
-        const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-        const rootsBytes = concatenate(...roots);
-        return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg), rootsBytes);
-    }
-    verifyWithNoRoot(proof, msg) {
-        let pBytes;
-        if (proof instanceof Uint8Array) {
-            pBytes = proof;
-        }
-        else {
-            pBytes = proofToBytes(proof);
-        }
-        // calculate message length
-        const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
-        return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg), new Uint8Array());
-    }
-}
-
-var rln = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	create: create$1,
-	IdentityCredential: IdentityCredential,
-	ProofMetadata: ProofMetadata,
-	Proof: Proof,
-	proofToBytes: proofToBytes,
-	poseidonHash: poseidonHash,
-	sha256: sha256$2,
-	RLNInstance: RLNInstance
-});
-
-var bn = {exports: {}};
-
-var _nodeResolve_empty = {};
+var _nodeResolve_empty = {};
 
 var _nodeResolve_empty$1 = /*#__PURE__*/Object.freeze({
 	__proto__: null,
@@ -40986,7 +40375,7 @@ const logger$q = new Logger(version$b);
 function ripemd160(data) {
     return "0x" + (hash.ripemd160().update(arrayify(data)).digest("hex"));
 }
-function sha256$1(data) {
+function sha256$2(data) {
     return "0x" + (hash.sha256().update(arrayify(data)).digest("hex"));
 }
 function sha512(data) {
@@ -41131,7 +40520,7 @@ function bytes32(value) {
     return hexZeroPad(hexlify(value), 32);
 }
 function base58check(data) {
-    return Base58.encode(concat([data, hexDataSlice(sha256$1(sha256$1(data)), 0, 4)]));
+    return Base58.encode(concat([data, hexDataSlice(sha256$2(sha256$2(data)), 0, 4)]));
 }
 function getWordlist(wordlist) {
     if (wordlist == null) {
@@ -41171,7 +40560,7 @@ class HDNode {
             defineReadOnly(this, "publicKey", hexlify(publicKey));
         }
         defineReadOnly(this, "parentFingerprint", parentFingerprint);
-        defineReadOnly(this, "fingerprint", hexDataSlice(ripemd160(sha256$1(this.publicKey)), 0, 4));
+        defineReadOnly(this, "fingerprint", hexDataSlice(ripemd160(sha256$2(this.publicKey)), 0, 4));
         defineReadOnly(this, "address", computeAddress(this.publicKey));
         defineReadOnly(this, "chainCode", chainCode);
         defineReadOnly(this, "index", index);
@@ -41377,7 +40766,7 @@ function mnemonicToEntropy(mnemonic, wordlist) {
     const entropyBits = 32 * words.length / 3;
     const checksumBits = words.length / 3;
     const checksumMask = getUpperMask(checksumBits);
-    const checksum = arrayify(sha256$1(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
+    const checksum = arrayify(sha256$2(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
     if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
         throw new Error("invalid checksum");
     }
@@ -41409,7 +40798,7 @@ function entropyToMnemonic(entropy, wordlist) {
     }
     // Compute the checksum bits
     const checksumBits = entropy.length / 4;
-    const checksum = arrayify(sha256$1(entropy))[0] & getUpperMask(checksumBits);
+    const checksum = arrayify(sha256$2(entropy))[0] & getUpperMask(checksumBits);
     // Shift the checksum into the word indices
     indices[indices.length - 1] <<= checksumBits;
     indices[indices.length - 1] |= (checksum >> (8 - checksumBits));
@@ -44888,7 +44277,7 @@ function bytes32ify(value) {
 }
 // Compute the Base58Check encoded data (checksum is first 4 bytes of sha256d)
 function base58Encode(data) {
-    return Base58.encode(concat([data, hexDataSlice(sha256$1(sha256$1(data)), 0, 4)]));
+    return Base58.encode(concat([data, hexDataSlice(sha256$2(sha256$2(data)), 0, 4)]));
 }
 const matcherIpfs = new RegExp("^(ipfs):/\/(.*)$", "i");
 const matchers = [
@@ -49494,8 +48883,8 @@ function pack(types, values) {
 function keccak256(types, values) {
     return keccak256$1(pack(types, values));
 }
-function sha256(types, values) {
-    return sha256$1(pack(types, values));
+function sha256$1(types, values) {
+    return sha256$2(pack(types, values));
 }
 
 const version$1 = "units/5.7.0";
@@ -49652,13 +49041,13 @@ var utils = /*#__PURE__*/Object.freeze({
 	computeHmac: computeHmac,
 	keccak256: keccak256$1,
 	ripemd160: ripemd160,
-	sha256: sha256$1,
+	sha256: sha256$2,
 	sha512: sha512,
 	randomBytes: randomBytes,
 	shuffled: shuffled,
 	solidityPack: pack,
 	solidityKeccak256: keccak256,
-	soliditySha256: sha256,
+	soliditySha256: sha256$1,
 	splitSignature: splitSignature,
 	joinSignature: joinSignature,
 	accessListify: accessListify,
@@ -49716,6 +49105,126 @@ try {
 }
 catch (error) { }
 
+const extractMetaMaskAccount = async () => {
+    const ethereum = window.ethereum;
+    if (!ethereum) {
+        throw Error("Missing or invalid Ethereum provider. Please install a Web3 wallet such as MetaMask.");
+    }
+    await ethereum.request({ method: "eth_requestAccounts" });
+    return new Web3Provider(ethereum, "any");
+};
+
+const verificationKey = {
+    protocol: "groth16",
+    curve: "bn128",
+    nPublic: 6,
+    vk_alpha_1: [
+        "20124996762962216725442980738609010303800849578410091356605067053491763969391",
+        "9118593021526896828671519912099489027245924097793322973632351264852174143923",
+        "1",
+    ],
+    vk_beta_2: [
+        [
+            "4693952934005375501364248788849686435240706020501681709396105298107971354382",
+            "14346958885444710485362620645446987998958218205939139994511461437152241966681",
+        ],
+        [
+            "16851772916911573982706166384196538392731905827088356034885868448550849804972",
+            "823612331030938060799959717749043047845343400798220427319188951998582076532",
+        ],
+        ["1", "0"],
+    ],
+    vk_gamma_2: [
+        [
+            "10857046999023057135944570762232829481370756359578518086990519993285655852781",
+            "11559732032986387107991004021392285783925812861821192530917403151452391805634",
+        ],
+        [
+            "8495653923123431417604973247489272438418190587263600148770280649306958101930",
+            "4082367875863433681332203403145435568316851327593401208105741076214120093531",
+        ],
+        ["1", "0"],
+    ],
+    vk_delta_2: [
+        [
+            "8353516066399360694538747105302262515182301251524941126222712285088022964076",
+            "9329524012539638256356482961742014315122377605267454801030953882967973561832",
+        ],
+        [
+            "16805391589556134376869247619848130874761233086443465978238468412168162326401",
+            "10111259694977636294287802909665108497237922060047080343914303287629927847739",
+        ],
+        ["1", "0"],
+    ],
+    vk_alphabeta_12: [
+        [
+            [
+                "12608968655665301215455851857466367636344427685631271961542642719683786103711",
+                "9849575605876329747382930567422916152871921500826003490242628251047652318086",
+            ],
+            [
+                "6322029441245076030714726551623552073612922718416871603535535085523083939021",
+                "8700115492541474338049149013125102281865518624059015445617546140629435818912",
+            ],
+            [
+                "10674973475340072635573101639867487770811074181475255667220644196793546640210",
+                "2926286967251299230490668407790788696102889214647256022788211245826267484824",
+            ],
+        ],
+        [
+            [
+                "9660441540778523475944706619139394922744328902833875392144658911530830074820",
+                "19548113127774514328631808547691096362144426239827206966690021428110281506546",
+            ],
+            [
+                "1870837942477655969123169532603615788122896469891695773961478956740992497097",
+                "12536105729661705698805725105036536744930776470051238187456307227425796690780",
+            ],
+            [
+                "21811903352654147452884857281720047789720483752548991551595462057142824037334",
+                "19021616763967199151052893283384285352200445499680068407023236283004353578353",
+            ],
+        ],
+    ],
+    IC: [
+        [
+            "11992897507809711711025355300535923222599547639134311050809253678876341466909",
+            "17181525095924075896332561978747020491074338784673526378866503154966799128110",
+            "1",
+        ],
+        [
+            "17018665030246167677911144513385572506766200776123272044534328594850561667818",
+            "18601114175490465275436712413925513066546725461375425769709566180981674884464",
+            "1",
+        ],
+        [
+            "18799470100699658367834559797874857804183288553462108031963980039244731716542",
+            "13064227487174191981628537974951887429496059857753101852163607049188825592007",
+            "1",
+        ],
+        [
+            "17432501889058124609368103715904104425610382063762621017593209214189134571156",
+            "13406815149699834788256141097399354592751313348962590382887503595131085938635",
+            "1",
+        ],
+        [
+            "10320964835612716439094703312987075811498239445882526576970512041988148264481",
+            "9024164961646353611176283204118089412001502110138072989569118393359029324867",
+            "1",
+        ],
+        [
+            "718355081067365548229685160476620267257521491773976402837645005858953849298",
+            "14635482993933988261008156660773180150752190597753512086153001683711587601974",
+            "1",
+        ],
+        [
+            "11777720285956632126519898515392071627539405001940313098390150593689568177535",
+            "8483603647274280691250972408211651407952870456587066148445913156086740744515",
+            "1",
+        ],
+    ],
+};
+
 class RootPerBlock {
     constructor(root, blockNumber) {
         this.root = root;
@@ -49979,13 +49488,522 @@ function ignoreErrors(promise, defaultValue) {
     });
 }
 
-// reexport the create function, dynamically imported from rln.ts
+// 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-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-8b299152.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() {
-    // A dependency graph that contains any wasm must all be imported
-    // asynchronously. This file does the single async import, so
-    // that no one else needs to worry about it again.
-    const rlnModule = await Promise.resolve().then(function () { return rln; });
-    return await rlnModule.create();
+    await __wbg_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 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 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 IdentityCredential(idTrapdoor, idNullifier, idSecretHash, idCommitment, idCommitmentBigInt);
+    }
+}
+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 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)
+            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);
+    }
+    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(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;
+        this._contract = null;
+    }
+    get contract() {
+        return this._contract;
+    }
+    async start(options = {}) {
+        const provider = options.provider || (await extractMetaMaskAccount());
+        const registryAddress = options.registryAddress || SEPOLIA_CONTRACT.address;
+        this._contract = await RLNContract.init(this, {
+            registryAddress,
+            provider,
+        });
+    }
+    generateIdentityCredentials() {
+        const memKeys = generateExtendedMembershipKey(this.zkRLN); // TODO: rename this function in zerokit rln-wasm
+        return IdentityCredential.fromBytes(memKeys);
+    }
+    generateSeededIdentityCredential(seed) {
+        const seedBytes = stringEncoder.encode(seed);
+        // 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);
+    }
+    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 generateRLNProof(msg, index, epoch, idSecretHash) {
+        if (epoch == undefined) {
+            epoch = epochIntToBytes(dateToEpoch(new Date()));
+        }
+        else if (epoch instanceof Date) {
+            epoch = epochIntToBytes(dateToEpoch(epoch));
+        }
+        if (epoch.length != 32)
+            throw "invalid epoch";
+        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, 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
+        const proofBytes = generate_rln_proof_with_witness(this.zkRLN, calculatedWitness, rlnWitness);
+        return new Proof(proofBytes);
+    }
+    verifyRLNProof(proof, msg) {
+        let pBytes;
+        if (proof instanceof Uint8Array) {
+            pBytes = proof;
+        }
+        else {
+            pBytes = proofToBytes(proof);
+        }
+        // calculate message length
+        const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+        return verifyRLNProof(this.zkRLN, concatenate(pBytes, msgLen, msg));
+    }
+    verifyWithRoots(proof, msg, ...roots) {
+        let pBytes;
+        if (proof instanceof Uint8Array) {
+            pBytes = proof;
+        }
+        else {
+            pBytes = proofToBytes(proof);
+        }
+        // calculate message length
+        const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+        const rootsBytes = concatenate(...roots);
+        return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg), rootsBytes);
+    }
+    verifyWithNoRoot(proof, msg) {
+        let pBytes;
+        if (proof instanceof Uint8Array) {
+            pBytes = proof;
+        }
+        else {
+            pBytes = proofToBytes(proof);
+        }
+        // calculate message length
+        const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+        return verifyWithRoots(this.zkRLN, concatenate(pBytes, msgLen, msg), new Uint8Array());
+    }
+}
+
+var rln = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	create: create,
+	IdentityCredential: IdentityCredential,
+	ProofMetadata: ProofMetadata,
+	Proof: Proof,
+	proofToBytes: proofToBytes,
+	poseidonHash: poseidonHash,
+	sha256: sha256,
+	RLNInstance: RLNInstance
+});
 
-export { IdentityCredential, Keystore, MerkleRootTracker, Proof, ProofMetadata, RLNContract, RLNDecoder, RLNEncoder, RLNInstance, RLN_REGISTRY_ABI, RLN_STORAGE_ABI, SEPOLIA_CONTRACT, create };
+export { IdentityCredential, Keystore, MerkleRootTracker, Proof, ProofMetadata, RLNContract, RLNDecoder, RLNEncoder, RLNInstance, RLN_REGISTRY_ABI, RLN_STORAGE_ABI, SEPOLIA_CONTRACT, createRLN };