@waku/rln 0.1.6-16328a3.0 → 0.1.6-383e0b2.0

package/bundle/_virtual/index2.js

@@ -1,5 +1,5 @@
 import { getAugmentedNamespace } from './_commonjsHelpers.js';
-import * as index from '../node_modules/@chainsafe/bls-keystore/node_modules/uuid/dist/esm-browser/index.js';
+import * as index from '../packages/rln/node_modules/@chainsafe/bls-keystore/node_modules/uuid/dist/esm-browser/index.js';
 
 var require$$0 = /*@__PURE__*/getAugmentedNamespace(index);
 

package/bundle/_virtual/utils.js

@@ -1,3 +1,3 @@
-var utils = {exports: {}};
+var utils = {};
 
-export { utils as __module };
+export { utils as __exports };

package/bundle/_virtual/utils2.js

@@ -1,3 +1,3 @@
-var utils = {};
+var utils = {exports: {}};
 
-export { utils as __exports };
+export { utils as __module };

package/bundle/index.js

@@ -1,8 +1,7 @@
 export { RLNDecoder, RLNEncoder } from './packages/rln/dist/codec.js';
 export { RLN_ABI } from './packages/rln/dist/contract/abi.js';
 export { RLNContract } from './packages/rln/dist/contract/rln_contract.js';
-export { DEFAULT_RATE_LIMIT, LINEA_CONTRACT, RATE_LIMIT_PARAMS, RATE_LIMIT_TIERS } from './packages/rln/dist/contract/constants.js';
-export { MembershipState } from './packages/rln/dist/contract/types.js';
+export { LINEA_CONTRACT } from './packages/rln/dist/contract/constants.js';
 export { RLNBaseContract } from './packages/rln/dist/contract/rln_base_contract.js';
 export { createRLN } from './packages/rln/dist/create.js';
 export { RLNCredentialsManager } from './packages/rln/dist/credentials_manager.js';

package/bundle/node_modules/@ethersproject/keccak256/lib.esm/index.js

@@ -1,4 +1,4 @@
-import sha3 from '../../../js-sha3/src/sha3.js';
+import sha3 from '../node_modules/js-sha3/src/sha3.js';
 import { arrayify } from '../../bytes/lib.esm/index.js';
 
 function keccak256(data) {

package/bundle/node_modules/{js-sha3 → @ethersproject/keccak256/node_modules/js-sha3}/src/sha3.js

@@ -1,5 +1,5 @@
-import { getDefaultExportFromCjs, commonjsGlobal } from '../../../_virtual/_commonjsHelpers.js';
-import { __module as sha3$1 } from '../../../_virtual/sha3.js';
+import { getDefaultExportFromCjs, commonjsGlobal } from '../../../../../../_virtual/_commonjsHelpers.js';
+import { __module as sha3$1 } from '../../../../../../_virtual/sha3.js';
 
 /**
  * [js-sha3]{@link https://github.com/emn178/js-sha3}

package/bundle/node_modules/@noble/hashes/esm/_assert.js

@@ -1,11 +1,37 @@
-import { abytes as abytes$1 } from './utils.js';
-
 /**
  * Internal assertion helpers.
  * @module
- * @deprecated
  */
-/** @deprecated Use import from `noble/hashes/utils` module */
-const abytes = abytes$1;
+/** Asserts something is positive integer. */
+function anumber(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error('positive integer expected, got ' + n);
+}
+/** Is number an Uint8Array? Copied from utils for perf. */
+function isBytes(a) {
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+/** Asserts something is Uint8Array. */
+function abytes(b, ...lengths) {
+    if (!isBytes(b))
+        throw new Error('Uint8Array expected');
+    if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance, checkFinished = true) {
+    if (instance.destroyed)
+        throw new Error('Hash instance has been destroyed');
+    if (checkFinished && instance.finished)
+        throw new Error('Hash#digest() has already been called');
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+    abytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error('digestInto() expects output buffer of length at least ' + min);
+    }
+}
 
-export { abytes };
+export { abytes, aexists, anumber, aoutput };

package/bundle/node_modules/@noble/hashes/esm/_md.js

@@ -1,4 +1,5 @@
-import { Hash, createView, aexists, toBytes, abytes, aoutput, clean } from './utils.js';
+import { aexists, aoutput } from './_assert.js';
+import { Hash, createView, toBytes } from './utils.js';
 
 /**
  * Internal Merkle-Damgard hash utils.
@@ -32,22 +33,21 @@ function Maj(a, b, c) {
 class HashMD extends Hash {
     constructor(blockLen, outputLen, padOffset, isLE) {
         super();
-        this.finished = false;
-        this.length = 0;
-        this.pos = 0;
-        this.destroyed = false;
         this.blockLen = blockLen;
         this.outputLen = outputLen;
         this.padOffset = padOffset;
         this.isLE = isLE;
+        this.finished = false;
+        this.length = 0;
+        this.pos = 0;
+        this.destroyed = false;
         this.buffer = new Uint8Array(blockLen);
         this.view = createView(this.buffer);
     }
     update(data) {
         aexists(this);
-        data = toBytes(data);
-        abytes(data);
         const { view, buffer, blockLen } = this;
+        data = toBytes(data);
         const len = data.length;
         for (let pos = 0; pos < len;) {
             const take = Math.min(blockLen - this.pos, len - pos);
@@ -81,7 +81,7 @@ class HashMD extends Hash {
         let { pos } = this;
         // append the bit '1' to the message
         buffer[pos++] = 0b10000000;
-        clean(this.buffer.subarray(pos));
+        this.buffer.subarray(pos).fill(0);
         // we have less than padOffset left in buffer, so we cannot put length in
         // current block, need process it and pad again
         if (this.padOffset > blockLen - pos) {
@@ -119,25 +119,14 @@ class HashMD extends Hash {
         to || (to = new this.constructor());
         to.set(...this.get());
         const { blockLen, buffer, length, finished, destroyed, pos } = this;
-        to.destroyed = destroyed;
-        to.finished = finished;
         to.length = length;
         to.pos = pos;
+        to.finished = finished;
+        to.destroyed = destroyed;
         if (length % blockLen)
             to.buffer.set(buffer);
         return to;
     }
-    clone() {
-        return this._cloneInto();
-    }
 }
-/**
- * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
- * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
- */
-/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
-const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
-    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
-]);
 
-export { Chi, HashMD, Maj, SHA256_IV, setBigUint64 };
+export { Chi, HashMD, Maj, setBigUint64 };

package/bundle/node_modules/@noble/hashes/esm/_u64.js

@@ -11,10 +11,9 @@ function fromBig(n, le = false) {
     return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
 }
 function split(lst, le = false) {
-    const len = lst.length;
-    let Ah = new Uint32Array(len);
-    let Al = new Uint32Array(len);
-    for (let i = 0; i < len; i++) {
+    let Ah = new Uint32Array(lst.length);
+    let Al = new Uint32Array(lst.length);
+    for (let i = 0; i < lst.length; i++) {
         const { h, l } = fromBig(lst[i], le);
         [Ah[i], Al[i]] = [h, l];
     }

package/bundle/node_modules/@noble/hashes/esm/sha256.js

@@ -1,4 +1,5 @@
-import { sha256 as sha256$1 } from './sha2.js';
+import { HashMD, Chi, Maj } from './_md.js';
+import { wrapConstructor, rotr } from './utils.js';
 
 /**
  * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
@@ -8,9 +9,105 @@ import { sha256 as sha256$1 } from './sha2.js';
  *
  * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
  * @module
- * @deprecated
  */
-/** @deprecated Use import from `noble/hashes/sha2` module */
-const sha256 = sha256$1;
+/** Round constants: first 32 bits of fractional parts of the cube roots of the first 64 primes 2..311). */
+// prettier-ignore
+const SHA256_K = /* @__PURE__ */ new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+/** Initial state: first 32 bits of fractional parts of the square roots of the first 8 primes 2..19. */
+// prettier-ignore
+const SHA256_IV = /* @__PURE__ */ new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+]);
+/**
+ * Temporary buffer, not used to store anything between runs.
+ * Named this way because it matches specification.
+ */
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+class SHA256 extends HashMD {
+    constructor() {
+        super(64, 32, 8, false);
+        // We cannot use array here since array allows indexing by variable
+        // which means optimizer/compiler cannot use registers.
+        this.A = SHA256_IV[0] | 0;
+        this.B = SHA256_IV[1] | 0;
+        this.C = SHA256_IV[2] | 0;
+        this.D = SHA256_IV[3] | 0;
+        this.E = SHA256_IV[4] | 0;
+        this.F = SHA256_IV[5] | 0;
+        this.G = SHA256_IV[6] | 0;
+        this.H = SHA256_IV[7] | 0;
+    }
+    get() {
+        const { A, B, C, D, E, F, G, H } = this;
+        return [A, B, C, D, E, F, G, H];
+    }
+    // prettier-ignore
+    set(A, B, C, D, E, F, G, H) {
+        this.A = A | 0;
+        this.B = B | 0;
+        this.C = C | 0;
+        this.D = D | 0;
+        this.E = E | 0;
+        this.F = F | 0;
+        this.G = G | 0;
+        this.H = H | 0;
+    }
+    process(view, offset) {
+        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
+        for (let i = 0; i < 16; i++, offset += 4)
+            SHA256_W[i] = view.getUint32(offset, false);
+        for (let i = 16; i < 64; i++) {
+            const W15 = SHA256_W[i - 15];
+            const W2 = SHA256_W[i - 2];
+            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);
+            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);
+            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
+        }
+        // Compression function main loop, 64 rounds
+        let { A, B, C, D, E, F, G, H } = this;
+        for (let i = 0; i < 64; i++) {
+            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+            const T2 = (sigma0 + Maj(A, B, C)) | 0;
+            H = G;
+            G = F;
+            F = E;
+            E = (D + T1) | 0;
+            D = C;
+            C = B;
+            B = A;
+            A = (T1 + T2) | 0;
+        }
+        // Add the compressed chunk to the current hash value
+        A = (A + this.A) | 0;
+        B = (B + this.B) | 0;
+        C = (C + this.C) | 0;
+        D = (D + this.D) | 0;
+        E = (E + this.E) | 0;
+        F = (F + this.F) | 0;
+        G = (G + this.G) | 0;
+        H = (H + this.H) | 0;
+        this.set(A, B, C, D, E, F, G, H);
+    }
+    roundClean() {
+        SHA256_W.fill(0);
+    }
+    destroy() {
+        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+        this.buffer.fill(0);
+    }
+}
+/** SHA2-256 hash function */
+const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 
-export { sha256 };
+export { SHA256, sha256 };

package/bundle/node_modules/@noble/hashes/esm/sha3.js

@@ -1,5 +1,6 @@
+import { anumber, aexists, abytes, aoutput } from './_assert.js';
 import { rotlSH, rotlSL, rotlBH, rotlBL, split } from './_u64.js';
-import { createHasher, Hash, anumber, u32, swap32IfBE, aexists, toBytes, abytes, aoutput, clean } from './utils.js';
+import { wrapConstructor, Hash, u32, isLE, byteSwap32, toBytes } from './utils.js';
 
 /**
  * SHA3 (keccak) hash function, based on a new "Sponge function" design.
@@ -12,18 +13,16 @@ import { createHasher, Hash, anumber, u32, swap32IfBE, aexists, toBytes, abytes,
  * Check out `sha3-addons` module for cSHAKE, k12, and others.
  * @module
  */
-// No __PURE__ annotations in sha3 header:
-// EVERYTHING is in fact used on every export.
 // Various per round constants calculations
-const _0n = BigInt(0);
-const _1n = BigInt(1);
-const _2n = BigInt(2);
-const _7n = BigInt(7);
-const _256n = BigInt(256);
-const _0x71n = BigInt(0x71);
 const SHA3_PI = [];
 const SHA3_ROTL = [];
 const _SHA3_IOTA = [];
+const _0n = /* @__PURE__ */ BigInt(0);
+const _1n = /* @__PURE__ */ BigInt(1);
+const _2n = /* @__PURE__ */ BigInt(2);
+const _7n = /* @__PURE__ */ BigInt(7);
+const _256n = /* @__PURE__ */ BigInt(256);
+const _0x71n = /* @__PURE__ */ BigInt(0x71);
 for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
     // Pi
     [x, y] = [y, (2 * x + 3 * y) % 5];
@@ -39,9 +38,7 @@ for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
     }
     _SHA3_IOTA.push(t);
 }
-const IOTAS = split(_SHA3_IOTA, true);
-const SHA3_IOTA_H = IOTAS[0];
-const SHA3_IOTA_L = IOTAS[1];
+const [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
 // Left rotation (without 0, 32, 64)
 const rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));
 const rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));
@@ -89,47 +86,44 @@ function keccakP(s, rounds = 24) {
         s[0] ^= SHA3_IOTA_H[round];
         s[1] ^= SHA3_IOTA_L[round];
     }
-    clean(B);
+    B.fill(0);
 }
 /** Keccak sponge function. */
 class Keccak extends Hash {
     // NOTE: we accept arguments in bytes instead of bits here.
     constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
         super();
-        this.pos = 0;
-        this.posOut = 0;
-        this.finished = false;
-        this.destroyed = false;
-        this.enableXOF = false;
         this.blockLen = blockLen;
         this.suffix = suffix;
         this.outputLen = outputLen;
         this.enableXOF = enableXOF;
         this.rounds = rounds;
+        this.pos = 0;
+        this.posOut = 0;
+        this.finished = false;
+        this.destroyed = false;
         // Can be passed from user as dkLen
         anumber(outputLen);
         // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
         // 0 < blockLen < 200
-        if (!(0 < blockLen && blockLen < 200))
-            throw new Error('only keccak-f1600 function is supported');
+        if (0 >= this.blockLen || this.blockLen >= 200)
+            throw new Error('Sha3 supports only keccak-f1600 function');
         this.state = new Uint8Array(200);
         this.state32 = u32(this.state);
     }
-    clone() {
-        return this._cloneInto();
-    }
     keccak() {
-        swap32IfBE(this.state32);
+        if (!isLE)
+            byteSwap32(this.state32);
         keccakP(this.state32, this.rounds);
-        swap32IfBE(this.state32);
+        if (!isLE)
+            byteSwap32(this.state32);
         this.posOut = 0;
         this.pos = 0;
     }
     update(data) {
         aexists(this);
-        data = toBytes(data);
-        abytes(data);
         const { blockLen, state } = this;
+        data = toBytes(data);
         const len = data.length;
         for (let pos = 0; pos < len;) {
             const take = Math.min(blockLen - this.pos, len - pos);
@@ -191,7 +185,7 @@ class Keccak extends Hash {
     }
     destroy() {
         this.destroyed = true;
-        clean(this.state);
+        this.state.fill(0);
     }
     _cloneInto(to) {
         const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
@@ -209,8 +203,8 @@ class Keccak extends Hash {
         return to;
     }
 }
-const gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
+const gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
 /** keccak-256 hash function. Different from SHA3-256. */
-const keccak_256 = /* @__PURE__ */ (() => gen(0x01, 136, 256 / 8))();
+const keccak_256 = /* @__PURE__ */ gen(0x01, 136, 256 / 8);
 
 export { Keccak, keccakP, keccak_256 };

package/bundle/node_modules/@noble/hashes/esm/utils.js

@@ -1,3 +1,5 @@
+import { abytes } from './_assert.js';
+
 /**
  * Utilities for hex, bytes, CSPRNG.
  * @module
@@ -9,55 +11,10 @@
 // from `crypto` to `cryptoNode`, which imports native module.
 // Makes the utils un-importable in browsers without a bundler.
 // Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
-/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
-function isBytes(a) {
-    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
-}
-/** Asserts something is positive integer. */
-function anumber(n) {
-    if (!Number.isSafeInteger(n) || n < 0)
-        throw new Error('positive integer expected, got ' + n);
-}
-/** Asserts something is Uint8Array. */
-function abytes(b, ...lengths) {
-    if (!isBytes(b))
-        throw new Error('Uint8Array expected');
-    if (lengths.length > 0 && !lengths.includes(b.length))
-        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
-}
-/** Asserts something is hash */
-function ahash(h) {
-    if (typeof h !== 'function' || typeof h.create !== 'function')
-        throw new Error('Hash should be wrapped by utils.createHasher');
-    anumber(h.outputLen);
-    anumber(h.blockLen);
-}
-/** Asserts a hash instance has not been destroyed / finished */
-function aexists(instance, checkFinished = true) {
-    if (instance.destroyed)
-        throw new Error('Hash instance has been destroyed');
-    if (checkFinished && instance.finished)
-        throw new Error('Hash#digest() has already been called');
-}
-/** Asserts output is properly-sized byte array */
-function aoutput(out, instance) {
-    abytes(out);
-    const min = instance.outputLen;
-    if (out.length < min) {
-        throw new Error('digestInto() expects output buffer of length at least ' + min);
-    }
-}
-/** Cast u8 / u16 / u32 to u32. */
 function u32(arr) {
     return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
 }
-/** Zeroize a byte array. Warning: JS provides no guarantees. */
-function clean(...arrays) {
-    for (let i = 0; i < arrays.length; i++) {
-        arrays[i].fill(0);
-    }
-}
-/** Create DataView of an array for easy byte-level manipulation. */
+// Cast array to view
 function createView(arr) {
     return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
@@ -67,7 +24,7 @@ function rotr(word, shift) {
 }
 /** Is current platform little-endian? Most are. Big-Endian platform: IBM */
 const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
-/** The byte swap operation for uint32 */
+// The byte swap operation for uint32
 function byteSwap(word) {
     return (((word << 24) & 0xff000000) |
         ((word << 8) & 0xff0000) |
@@ -79,26 +36,15 @@ function byteSwap32(arr) {
     for (let i = 0; i < arr.length; i++) {
         arr[i] = byteSwap(arr[i]);
     }
-    return arr;
 }
-const swap32IfBE = isLE
-    ? (u) => u
-    : byteSwap32;
-// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
-const hasHexBuiltin = /* @__PURE__ */ (() => 
-// @ts-ignore
-typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
 // Array where index 0xf0 (240) is mapped to string 'f0'
 const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
 /**
- * Convert byte array to hex string. Uses built-in function, when available.
+ * Convert byte array to hex string.
  * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
  */
 function bytesToHex(bytes) {
     abytes(bytes);
-    // @ts-ignore
-    if (hasHexBuiltin)
-        return bytes.toHex();
     // pre-caching improves the speed 6x
     let hex = '';
     for (let i = 0; i < bytes.length; i++) {
@@ -118,15 +64,12 @@ function asciiToBase16(ch) {
     return;
 }
 /**
- * Convert hex string to byte array. Uses built-in function, when available.
+ * Convert hex string to byte array.
  * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
  */
 function hexToBytes(hex) {
     if (typeof hex !== 'string')
         throw new Error('hex string expected, got ' + typeof hex);
-    // @ts-ignore
-    if (hasHexBuiltin)
-        return Uint8Array.fromHex(hex);
     const hl = hex.length;
     const al = hl / 2;
     if (hl % 2)
@@ -144,12 +87,12 @@ function hexToBytes(hex) {
     return array;
 }
 /**
- * Converts string to bytes using UTF8 encoding.
- * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+ * Convert JS string to byte array.
+ * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
  */
 function utf8ToBytes(str) {
     if (typeof str !== 'string')
-        throw new Error('string expected');
+        throw new Error('utf8ToBytes expected string, got ' + typeof str);
     return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
 }
 /**
@@ -163,7 +106,9 @@ function toBytes(data) {
     abytes(data);
     return data;
 }
-/** Copies several Uint8Arrays into one. */
+/**
+ * Copies several Uint8Arrays into one.
+ */
 function concatBytes(...arrays) {
     let sum = 0;
     for (let i = 0; i < arrays.length; i++) {
@@ -181,9 +126,13 @@ function concatBytes(...arrays) {
 }
 /** For runtime check if class implements interface */
 class Hash {
+    // Safe version that clones internal state
+    clone() {
+        return this._cloneInto();
+    }
 }
 /** Wraps hash function, creating an interface on top of it */
-function createHasher(hashCons) {
+function wrapConstructor(hashCons) {
     const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
     const tmp = hashCons();
     hashC.outputLen = tmp.outputLen;
@@ -192,4 +141,4 @@ function createHasher(hashCons) {
     return hashC;
 }
 
-export { Hash, abytes, aexists, ahash, anumber, aoutput, byteSwap, byteSwap32, bytesToHex, clean, concatBytes, createHasher, createView, hexToBytes, isBytes, isLE, rotr, swap32IfBE, toBytes, u32, utf8ToBytes };
+export { Hash, byteSwap, byteSwap32, bytesToHex, concatBytes, createView, hexToBytes, isLE, rotr, toBytes, u32, utf8ToBytes, wrapConstructor };

package/bundle/node_modules/bn.js/lib/bn.js

@@ -1818,7 +1818,6 @@ bn.exports;
 	      this.words[i] = carry;
 	      this.length++;
 	    }
-	    this.length = num === 0 ? 1 : this.length;
 
 	    return isNegNum ? this.ineg() : this;
 	  };

package/bundle/node_modules/ethereum-cryptography/esm/sha256.js

@@ -1,4 +1,4 @@
-import { sha256 as sha256$1 } from '../../@noble/hashes/esm/sha2.js';
+import { sha256 as sha256$1 } from '../../@noble/hashes/esm/sha256.js';
 import { wrapHash } from './utils.js';
 
 const sha256 = wrapHash(sha256$1);

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

@@ -12,7 +12,6 @@ const LINEA_CONTRACT = {
  */
 const RATE_LIMIT_TIERS = {
     LOW: 20, // Suggested minimum rate - 20 messages per epoch
-    MEDIUM: 200,
     HIGH: 600 // Suggested maximum rate - 600 messages per epoch
 };
 // Global rate limit parameters