@waku/rln 0.1.8-e224c05.0 → 0.1.8-e800af3.0

package/bundle/packages/rln/dist/resources/verification_key.js

@@ -0,0 +1,112 @@
+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"
+    ]
+  ]
+};
+
+export { verificationKey as default };

package/bundle/packages/rln/dist/resources/witness_calculator.js

@@ -1,6 +1,6 @@
 // File generated with https://github.com/iden3/circom
 // following the instructions from:
-// https://github.com/vacp2p/zerokit/tree/master/rln#advanced-custom-circuit-compilation
+// https://github.com/vacp2p/zerokit/tree/master/rln#compiling-circuits
 
 async function builder(code, options) {
   options = options || {};

package/bundle/packages/rln/dist/rln.js

@@ -1,3 +1,8 @@
+import { createEncoder, createDecoder } from '../../core/dist/lib/message/version_0.js';
+import '../../core/dist/lib/filter/filter.js';
+import '../../core/dist/lib/light_push/light_push.js';
+import '../../core/dist/lib/store/store.js';
+import '../../core/dist/lib/connection_manager/connection_manager.js';
 import '../../../node_modules/multiformats/dist/src/bases/base10.js';
 import '../../../node_modules/multiformats/dist/src/bases/base16.js';
 import '../../../node_modules/multiformats/dist/src/bases/base2.js';
@@ -10,9 +15,12 @@ import '../../../node_modules/multiformats/dist/src/bases/base8.js';
 import '../../../node_modules/multiformats/dist/src/bases/identity.js';
 import '../../../node_modules/multiformats/dist/src/codecs/json.js';
 import { Logger } from '../../utils/dist/logger.js';
-import __wbg_init, { initPanicHook, newRLN } from '../../../node_modules/@waku/zerokit-rln-wasm/rln_wasm.js';
+import '../../core/dist/lib/metadata/metadata.js';
+import __wbg_init, { init_panic_hook, newRLN } from '../../../node_modules/@waku/zerokit-rln-wasm/rln_wasm.js';
+import { createRLNEncoder, createRLNDecoder } from './codec.js';
 import { DEFAULT_RATE_LIMIT } from './contract/constants.js';
 import { RLNCredentialsManager } from './credentials_manager.js';
+import verificationKey from './resources/verification_key.js';
 import { builder } from './resources/witness_calculator.js';
 import { Zerokit } from './zerokit.js';
 
@@ -25,11 +33,15 @@ class RLNInstance extends RLNCredentialsManager {
      */
     static async create() {
         try {
-            await __wbg_init();
-            initPanicHook();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await __wbg_init?.();
+            init_panic_hook();
             const witnessCalculator = await RLNInstance.loadWitnessCalculator();
             const zkey = await RLNInstance.loadZkey();
-            const zkRLN = newRLN(zkey);
+            const stringEncoder = new TextEncoder();
+            const vkey = stringEncoder.encode(JSON.stringify(verificationKey));
+            const DEPTH = 20;
+            const zkRLN = newRLN(DEPTH, zkey, vkey);
             const zerokit = new Zerokit(zkRLN, witnessCalculator, DEFAULT_RATE_LIMIT);
             return new RLNInstance(zerokit);
         }
@@ -42,6 +54,26 @@ class RLNInstance extends RLNCredentialsManager {
         super(zerokit);
         this.zerokit = zerokit;
     }
+    async createEncoder(options) {
+        const { credentials: decryptedCredentials } = await RLNInstance.decryptCredentialsIfNeeded(options.credentials);
+        const credentials = decryptedCredentials || this.credentials;
+        if (!credentials) {
+            throw Error("Failed to create Encoder: missing RLN credentials. Use createRLNEncoder directly.");
+        }
+        await this.verifyCredentialsAgainstContract(credentials);
+        return createRLNEncoder({
+            encoder: createEncoder(options),
+            rlnInstance: this,
+            index: credentials.membership.treeIndex,
+            credential: credentials.identity
+        });
+    }
+    createDecoder(contentTopic, routingInfo) {
+        return createRLNDecoder({
+            rlnInstance: this,
+            decoder: createDecoder(contentTopic, routingInfo)
+        });
+    }
     static async loadWitnessCalculator() {
         try {
             const url = new URL("./resources/rln.wasm", import.meta.url);

package/bundle/packages/rln/dist/root_tracker.js

@@ -0,0 +1,76 @@
+class RootPerBlock {
+    root;
+    blockNumber;
+    constructor(root, blockNumber) {
+        this.root = root;
+        this.blockNumber = blockNumber;
+    }
+}
+const maxBufferSize = 20;
+class MerkleRootTracker {
+    acceptableRootWindowSize;
+    validMerkleRoots = new Array();
+    merkleRootBuffer = new Array();
+    constructor(acceptableRootWindowSize, initialRoot) {
+        this.acceptableRootWindowSize = acceptableRootWindowSize;
+        this.pushRoot(0, initialRoot);
+    }
+    backFill(fromBlockNumber) {
+        if (this.validMerkleRoots.length == 0)
+            return;
+        let numBlocks = 0;
+        for (let i = this.validMerkleRoots.length - 1; i >= 0; i--) {
+            if (this.validMerkleRoots[i].blockNumber >= fromBlockNumber) {
+                numBlocks++;
+            }
+        }
+        if (numBlocks == 0)
+            return;
+        const olderBlock = fromBlockNumber < this.validMerkleRoots[0].blockNumber;
+        // Remove last roots
+        let rootsToPop = numBlocks;
+        if (this.validMerkleRoots.length < rootsToPop) {
+            rootsToPop = this.validMerkleRoots.length;
+        }
+        this.validMerkleRoots = this.validMerkleRoots.slice(0, this.validMerkleRoots.length - rootsToPop);
+        if (this.merkleRootBuffer.length == 0)
+            return;
+        if (olderBlock) {
+            const idx = this.merkleRootBuffer.findIndex((x) => x.blockNumber == fromBlockNumber);
+            if (idx > -1) {
+                this.merkleRootBuffer = this.merkleRootBuffer.slice(0, idx);
+            }
+        }
+        // Backfill the tree's acceptable roots
+        let rootsToRestore = this.acceptableRootWindowSize - this.validMerkleRoots.length;
+        if (this.merkleRootBuffer.length < rootsToRestore) {
+            rootsToRestore = this.merkleRootBuffer.length;
+        }
+        for (let i = 0; i < rootsToRestore; i++) {
+            const x = this.merkleRootBuffer.pop();
+            if (x)
+                this.validMerkleRoots.unshift(x);
+        }
+    }
+    pushRoot(blockNumber, root) {
+        this.validMerkleRoots.push(new RootPerBlock(root, blockNumber));
+        // Maintain valid merkle root window
+        if (this.validMerkleRoots.length > this.acceptableRootWindowSize) {
+            const x = this.validMerkleRoots.shift();
+            if (x)
+                this.merkleRootBuffer.push(x);
+        }
+        // Maintain merkle root buffer
+        if (this.merkleRootBuffer.length > maxBufferSize) {
+            this.merkleRootBuffer.shift();
+        }
+    }
+    roots() {
+        return this.validMerkleRoots.map((x) => x.root);
+    }
+    buffer() {
+        return this.merkleRootBuffer.map((x) => x.root);
+    }
+}
+
+export { MerkleRootTracker };

package/bundle/packages/rln/dist/utils/bytes.js

@@ -1,44 +1,52 @@
 class BytesUtils {
     /**
-     * Concatenate Uint8Arrays
-     * @param input
-     * @returns concatenation of all Uint8Array received as input
+     * Switches endianness of a byte array
      */
-    static 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;
+    static switchEndianness(bytes) {
+        return new Uint8Array([...bytes].reverse());
+    }
+    /**
+     * Builds a BigInt from a big-endian Uint8Array
+     * @param bytes The big-endian bytes to convert
+     * @returns The resulting BigInt in big-endian format
+     */
+    static buildBigIntFromUint8ArrayBE(bytes) {
+        let result = 0n;
+        for (let i = 0; i < bytes.length; i++) {
+            result = (result << 8n) + BigInt(bytes[i]);
         }
         return result;
     }
     /**
-     * Convert a Uint8Array to a BigInt with configurable input endianness
-     * @param bytes - The byte array to convert
-     * @param inputEndianness - Endianness of the input bytes ('big' or 'little')
-     * @returns BigInt representation of the bytes
+     * Switches endianness of a bigint value
+     * @param value The bigint value to switch endianness for
+     * @returns The bigint value with reversed endianness
      */
-    static toBigInt(bytes, inputEndianness = "little") {
-        if (bytes.length === 0) {
-            return 0n;
-        }
-        // Create a copy to avoid modifying the original array
-        const workingBytes = new Uint8Array(bytes);
-        // Reverse bytes if input is little-endian to work with big-endian internally
-        if (inputEndianness === "little") {
-            workingBytes.reverse();
+    static switchEndiannessBigInt(value) {
+        // Convert bigint to byte array
+        const bytes = [];
+        let tempValue = value;
+        while (tempValue > 0n) {
+            bytes.push(Number(tempValue & 0xffn));
+            tempValue >>= 8n;
         }
-        // Convert to BigInt
-        let result = 0n;
-        for (let i = 0; i < workingBytes.length; i++) {
-            result = (result << 8n) | BigInt(workingBytes[i]);
+        // Reverse bytes and convert back to bigint
+        return bytes
+            .reverse()
+            .reduce((acc, byte) => (acc << 8n) + BigInt(byte), 0n);
+    }
+    /**
+     * Converts a big-endian bigint to a 32-byte big-endian Uint8Array
+     * @param value The big-endian bigint to convert
+     * @returns A 32-byte big-endian Uint8Array
+     */
+    static bigIntToUint8Array32BE(value) {
+        const bytes = new Uint8Array(32);
+        for (let i = 31; i >= 0; i--) {
+            bytes[i] = Number(value & 0xffn);
+            value >>= 8n;
         }
-        return result;
+        return bytes;
     }
     /**
      * Writes an unsigned integer to a buffer in little-endian format
@@ -59,6 +67,19 @@ class BytesUtils {
         }
         return buf;
     }
+    /**
+     * Fills with zeros to set length
+     * @param array little endian Uint8Array
+     * @param length amount to pad
+     * @returns little endian Uint8Array padded with zeros to set length
+     */
+    static zeroPadLE(array, length) {
+        const result = new Uint8Array(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = array[i] || 0;
+        }
+        return result;
+    }
     // Adapted from https://github.com/feross/buffer
     static checkInt(buf, value, offset, ext, max, min) {
         if (value > max || value < min)
@@ -66,6 +87,24 @@ class BytesUtils {
         if (offset + ext > buf.length)
             throw new RangeError("Index out of range");
     }
+    /**
+     * Concatenate Uint8Arrays
+     * @param input
+     * @returns concatenation of all Uint8Array received as input
+     */
+    static 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;
+    }
 }
 
 export { BytesUtils };

package/bundle/packages/rln/dist/utils/epoch.js

@@ -11,4 +11,26 @@ import '../../../../node_modules/multiformats/dist/src/bases/identity.js';
 import '../../../../node_modules/multiformats/dist/src/codecs/json.js';
 import { Logger } from '../../../utils/dist/logger.js';
 
-new Logger("waku:rln:epoch");
+const DefaultEpochUnitSeconds = 10; // the rln-relay epoch length in seconds
+const log = new Logger("waku:rln:epoch");
+function dateToEpoch(timestamp, epochUnitSeconds = DefaultEpochUnitSeconds) {
+    const time = timestamp.getTime();
+    const epoch = Math.floor(time / 1000 / epochUnitSeconds);
+    log.info("generated epoch", epoch);
+    return epoch;
+}
+function epochIntToBytes(epoch) {
+    const bytes = new Uint8Array(32);
+    const db = new DataView(bytes.buffer);
+    db.setUint32(0, epoch, true);
+    log.info("encoded epoch", epoch, bytes);
+    return bytes;
+}
+function epochBytesToInt(bytes) {
+    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const epoch = dv.getUint32(0, true);
+    log.info("decoded epoch", epoch, bytes);
+    return epoch;
+}
+
+export { dateToEpoch, epochBytesToInt, epochIntToBytes };

package/bundle/packages/rln/dist/utils/hash.js

@@ -0,0 +1,10 @@
+import { poseidonHash as poseidonHash$1 } from '../../../../node_modules/@waku/zerokit-rln-wasm/rln_wasm.js';
+import { BytesUtils } from './bytes.js';
+
+function poseidonHash(...input) {
+    const inputLen = BytesUtils.writeUIntLE(new Uint8Array(8), input.length, 0, 8);
+    const lenPrefixedData = BytesUtils.concatenate(inputLen, ...input);
+    return poseidonHash$1(lenPrefixedData);
+}
+
+export { poseidonHash };

package/bundle/packages/rln/dist/zerokit.js

@@ -1,6 +1,9 @@
-import { generateSeededExtendedMembershipKey } from '../../../node_modules/@waku/zerokit-rln-wasm/rln_wasm.js';
-import { DEFAULT_RATE_LIMIT } from './contract/constants.js';
+import { generateExtendedMembershipKey, generateSeededExtendedMembershipKey, insertMember, setLeavesFrom, deleteLeaf, getRoot, getSerializedRLNWitness, RLNWitnessToJson, generate_rln_proof_with_witness, verifyRLNProof, verifyWithRoots } from '../../../node_modules/@waku/zerokit-rln-wasm/rln_wasm.js';
+import { DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from './contract/constants.js';
 import { IdentityCredential } from './identity.js';
+import { Proof, proofToBytes } from './proof.js';
+import { BytesUtils } from './utils/bytes.js';
+import { epochIntToBytes, dateToEpoch } from './utils/epoch.js';
 
 class Zerokit {
     zkRLN;
@@ -20,12 +23,106 @@ class Zerokit {
     get rateLimit() {
         return this._rateLimit;
     }
+    generateIdentityCredentials() {
+        const memKeys = generateExtendedMembershipKey(this.zkRLN); // TODO: rename this function in zerokit rln-wasm
+        return IdentityCredential.fromBytes(memKeys);
+    }
     generateSeededIdentityCredential(seed) {
         const stringEncoder = new TextEncoder();
         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 = BytesUtils.writeUIntLE(new Uint8Array(8), idCommitments.length, 0, 8);
+        const idCommitmentBytes = BytesUtils.concatenate(idCommitmentLen, ...idCommitments);
+        setLeavesFrom(this.zkRLN, index, idCommitmentBytes);
+    }
+    deleteMember(index) {
+        deleteLeaf(this.zkRLN, index);
+    }
+    getMerkleRoot() {
+        return getRoot(this.zkRLN);
+    }
+    serializeMessage(uint8Msg, memIndex, epoch, idKey, rateLimit) {
+        // calculate message length
+        const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), uint8Msg.length, 0, 8);
+        const memIndexBytes = BytesUtils.writeUIntLE(new Uint8Array(8), memIndex, 0, 8);
+        const rateLimitBytes = BytesUtils.writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
+        // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> | rate_limit<8> ]
+        return BytesUtils.concatenate(idKey, memIndexBytes, epoch, msgLen, uint8Msg, rateLimitBytes);
+    }
+    async generateRLNProof(msg, index, epoch, idSecretHash, rateLimit) {
+        if (epoch === undefined) {
+            epoch = epochIntToBytes(dateToEpoch(new Date()));
+        }
+        else if (epoch instanceof Date) {
+            epoch = epochIntToBytes(dateToEpoch(epoch));
+        }
+        const effectiveRateLimit = rateLimit ?? this.rateLimit;
+        if (epoch.length !== 32)
+            throw new Error("invalid epoch");
+        if (idSecretHash.length !== 32)
+            throw new Error("invalid id secret hash");
+        if (index < 0)
+            throw new Error("index must be >= 0");
+        if (effectiveRateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
+            effectiveRateLimit > RATE_LIMIT_PARAMS.MAX_RATE) {
+            throw new Error(`Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`);
+        }
+        const serialized_msg = this.serializeMessage(msg, index, epoch, idSecretHash, effectiveRateLimit);
+        const rlnWitness = getSerializedRLNWitness(this.zkRLN, serialized_msg);
+        const inputs = RLNWitnessToJson(this.zkRLN, rlnWitness);
+        const calculatedWitness = await this.witnessCalculator.calculateWitness(inputs, false);
+        const proofBytes = generate_rln_proof_with_witness(this.zkRLN, calculatedWitness, rlnWitness);
+        return new Proof(proofBytes);
+    }
+    verifyRLNProof(proof, msg, rateLimit) {
+        let pBytes;
+        if (proof instanceof Uint8Array) {
+            pBytes = proof;
+        }
+        else {
+            pBytes = proofToBytes(proof);
+        }
+        // calculate message length
+        const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+        const rateLimitBytes = BytesUtils.writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
+        return verifyRLNProof(this.zkRLN, BytesUtils.concatenate(pBytes, msgLen, msg, rateLimitBytes));
+    }
+    verifyWithRoots(proof, msg, roots, rateLimit) {
+        let pBytes;
+        if (proof instanceof Uint8Array) {
+            pBytes = proof;
+        }
+        else {
+            pBytes = proofToBytes(proof);
+        }
+        // calculate message length
+        const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+        const rateLimitBytes = BytesUtils.writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
+        const rootsBytes = BytesUtils.concatenate(...roots);
+        return verifyWithRoots(this.zkRLN, BytesUtils.concatenate(pBytes, msgLen, msg, rateLimitBytes), rootsBytes);
+    }
+    verifyWithNoRoot(proof, msg, rateLimit) {
+        let pBytes;
+        if (proof instanceof Uint8Array) {
+            pBytes = proof;
+        }
+        else {
+            pBytes = proofToBytes(proof);
+        }
+        // calculate message length
+        const msgLen = BytesUtils.writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+        const rateLimitBytes = BytesUtils.writeUIntLE(new Uint8Array(8), rateLimit ?? this.rateLimit, 0, 8);
+        return verifyWithRoots(this.zkRLN, BytesUtils.concatenate(pBytes, msgLen, msg, rateLimitBytes), new Uint8Array());
+    }
 }
 
 export { Zerokit };

package/bundle/packages/utils/dist/bytes/index.js

@@ -0,0 +1,31 @@
+import { fromString } from '../../../../node_modules/uint8arrays/dist/src/from-string.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base10.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base16.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base2.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base256emoji.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base32.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base36.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base58.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base64.js';
+import '../../../../node_modules/multiformats/dist/src/bases/base8.js';
+import '../../../../node_modules/multiformats/dist/src/bases/identity.js';
+import '../../../../node_modules/multiformats/dist/src/codecs/json.js';
+
+/**
+ * Convert input to a byte array.
+ *
+ * Handles both `0x` prefixed and non-prefixed strings.
+ */
+function hexToBytes(hex) {
+    if (typeof hex === "string") {
+        const _hex = hex.replace(/^0x/i, "");
+        return fromString(_hex.toLowerCase(), "base16");
+    }
+    return hex;
+}
+/**
+ * Encode utf-8 string to byte array.
+ */
+const utf8ToBytes = (s) => fromString(s, "utf8");
+
+export { hexToBytes, utf8ToBytes };

package/bundle/resources/verification_key.d.ts

@@ -0,0 +1,13 @@
+declare const verificationKey: {
+  protocol: string;
+  curve: string;
+  nPublic: number;
+  vk_alpha_1: string[];
+  vk_beta_2: string[][];
+  vk_gamma_2: string[][];
+  vk_delta_2: string[][];
+  vk_alphabeta_12: string[][][];
+  IC: string[][];
+};
+
+export default verificationKey;