@0xpolygonid/js-sdk 1.9.2 → 1.9.4

package/dist/browser/umd/index.js

@@ -208,6 +208,1841 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
+    // copied from utils
+    function isBytes$1(a) {
+        return (a instanceof Uint8Array ||
+            (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+    }
+    function bytes$1(b, ...lengths) {
+        if (!isBytes$1(b))
+            throw new Error('Uint8Array expected');
+        if (lengths.length > 0 && !lengths.includes(b.length))
+            throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
+    }
+    function exists$1(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');
+    }
+    function output$1(out, instance) {
+        bytes$1(out);
+        const min = instance.outputLen;
+        if (out.length < min) {
+            throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+        }
+    }
+
+    const crypto$4 = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
+
+    /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    // We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+    // node.js versions earlier than v19 don't declare it in global scope.
+    // For node.js, package.json#exports field mapping rewrites import
+    // 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.
+    // Cast array to view
+    const createView$1 = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+    /**
+     * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+     */
+    function utf8ToBytes$2(str) {
+        if (typeof str !== 'string')
+            throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+        return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+    }
+    /**
+     * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+     * Warning: when Uint8Array is passed, it would NOT get copied.
+     * Keep in mind for future mutable operations.
+     */
+    function toBytes$1(data) {
+        if (typeof data === 'string')
+            data = utf8ToBytes$2(data);
+        bytes$1(data);
+        return data;
+    }
+    // For runtime check if class implements interface
+    let Hash$1 = class Hash {
+        // Safe version that clones internal state
+        clone() {
+            return this._cloneInto();
+        }
+    };
+    function wrapConstructor$1(hashCons) {
+        const hashC = (msg) => hashCons().update(toBytes$1(msg)).digest();
+        const tmp = hashCons();
+        hashC.outputLen = tmp.outputLen;
+        hashC.blockLen = tmp.blockLen;
+        hashC.create = () => hashCons();
+        return hashC;
+    }
+    /**
+     * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.
+     */
+    function randomBytes$1(bytesLength = 32) {
+        if (crypto$4 && typeof crypto$4.getRandomValues === 'function') {
+            return crypto$4.getRandomValues(new Uint8Array(bytesLength));
+        }
+        throw new Error('crypto.getRandomValues must be defined');
+    }
+
+    // Polyfill for Safari 14
+    function setBigUint64$1(view, byteOffset, value, isLE) {
+        if (typeof view.setBigUint64 === 'function')
+            return view.setBigUint64(byteOffset, value, isLE);
+        const _32n = BigInt(32);
+        const _u32_max = BigInt(0xffffffff);
+        const wh = Number((value >> _32n) & _u32_max);
+        const wl = Number(value & _u32_max);
+        const h = isLE ? 4 : 0;
+        const l = isLE ? 0 : 4;
+        view.setUint32(byteOffset + h, wh, isLE);
+        view.setUint32(byteOffset + l, wl, isLE);
+    }
+    /**
+     * Merkle-Damgard hash construction base class.
+     * Could be used to create MD5, RIPEMD, SHA1, SHA2.
+     */
+    class HashMD extends Hash$1 {
+        constructor(blockLen, outputLen, padOffset, isLE) {
+            super();
+            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$1(this.buffer);
+        }
+        update(data) {
+            exists$1(this);
+            const { view, buffer, blockLen } = this;
+            data = toBytes$1(data);
+            const len = data.length;
+            for (let pos = 0; pos < len;) {
+                const take = Math.min(blockLen - this.pos, len - pos);
+                // Fast path: we have at least one block in input, cast it to view and process
+                if (take === blockLen) {
+                    const dataView = createView$1(data);
+                    for (; blockLen <= len - pos; pos += blockLen)
+                        this.process(dataView, pos);
+                    continue;
+                }
+                buffer.set(data.subarray(pos, pos + take), this.pos);
+                this.pos += take;
+                pos += take;
+                if (this.pos === blockLen) {
+                    this.process(view, 0);
+                    this.pos = 0;
+                }
+            }
+            this.length += data.length;
+            this.roundClean();
+            return this;
+        }
+        digestInto(out) {
+            exists$1(this);
+            output$1(out, this);
+            this.finished = true;
+            // Padding
+            // We can avoid allocation of buffer for padding completely if it
+            // was previously not allocated here. But it won't change performance.
+            const { buffer, view, blockLen, isLE } = this;
+            let { pos } = this;
+            // append the bit '1' to the message
+            buffer[pos++] = 0b10000000;
+            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) {
+                this.process(view, 0);
+                pos = 0;
+            }
+            // Pad until full block byte with zeros
+            for (let i = pos; i < blockLen; i++)
+                buffer[i] = 0;
+            // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
+            // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
+            // So we just write lowest 64 bits of that value.
+            setBigUint64$1(view, blockLen - 8, BigInt(this.length * 8), isLE);
+            this.process(view, 0);
+            const oview = createView$1(out);
+            const len = this.outputLen;
+            // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT
+            if (len % 4)
+                throw new Error('_sha2: outputLen should be aligned to 32bit');
+            const outLen = len / 4;
+            const state = this.get();
+            if (outLen > state.length)
+                throw new Error('_sha2: outputLen bigger than state');
+            for (let i = 0; i < outLen; i++)
+                oview.setUint32(4 * i, state[i], isLE);
+        }
+        digest() {
+            const { buffer, outputLen } = this;
+            this.digestInto(buffer);
+            const res = buffer.slice(0, outputLen);
+            this.destroy();
+            return res;
+        }
+        _cloneInto(to) {
+            to || (to = new this.constructor());
+            to.set(...this.get());
+            const { blockLen, buffer, length, finished, destroyed, pos } = this;
+            to.length = length;
+            to.pos = pos;
+            to.finished = finished;
+            to.destroyed = destroyed;
+            if (length % blockLen)
+                to.buffer.set(buffer);
+            return to;
+        }
+    }
+
+    const U32_MASK64$1 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+    const _32n$1 = /* @__PURE__ */ BigInt(32);
+    // We are not using BigUint64Array, because they are extremely slow as per 2022
+    function fromBig$1(n, le = false) {
+        if (le)
+            return { h: Number(n & U32_MASK64$1), l: Number((n >> _32n$1) & U32_MASK64$1) };
+        return { h: Number((n >> _32n$1) & U32_MASK64$1) | 0, l: Number(n & U32_MASK64$1) | 0 };
+    }
+    function split$2(lst, le = false) {
+        let Ah = new Uint32Array(lst.length);
+        let Al = new Uint32Array(lst.length);
+        for (let i = 0; i < lst.length; i++) {
+            const { h, l } = fromBig$1(lst[i], le);
+            [Ah[i], Al[i]] = [h, l];
+        }
+        return [Ah, Al];
+    }
+    const toBig = (h, l) => (BigInt(h >>> 0) << _32n$1) | BigInt(l >>> 0);
+    // for Shift in [0, 32)
+    const shrSH = (h, _l, s) => h >>> s;
+    const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+    // Right rotate for Shift in [1, 32)
+    const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
+    const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+    // Right rotate for Shift in (32, 64), NOTE: 32 is special case.
+    const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
+    const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
+    // Right rotate for shift===32 (just swaps l&h)
+    const rotr32H = (_h, l) => l;
+    const rotr32L = (h, _l) => h;
+    // Left rotate for Shift in [1, 32)
+    const rotlSH$1 = (h, l, s) => (h << s) | (l >>> (32 - s));
+    const rotlSL$1 = (h, l, s) => (l << s) | (h >>> (32 - s));
+    // Left rotate for Shift in (32, 64), NOTE: 32 is special case.
+    const rotlBH$1 = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+    const rotlBL$1 = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+    // JS uses 32-bit signed integers for bitwise operations which means we cannot
+    // simple take carry out of low bit sum by shift, we need to use division.
+    function add$1(Ah, Al, Bh, Bl) {
+        const l = (Al >>> 0) + (Bl >>> 0);
+        return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
+    }
+    // Addition with more than 2 elements
+    const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+    const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
+    const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+    const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
+    const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+    const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
+    // prettier-ignore
+    const u64 = {
+        fromBig: fromBig$1, split: split$2, toBig,
+        shrSH, shrSL,
+        rotrSH, rotrSL, rotrBH, rotrBL,
+        rotr32H, rotr32L,
+        rotlSH: rotlSH$1, rotlSL: rotlSL$1, rotlBH: rotlBH$1, rotlBL: rotlBL$1,
+        add: add$1, add3L, add3H, add4L, add4H, add5H, add5L,
+    };
+
+    // Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):
+    // prettier-ignore
+    const [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => u64.split([
+        '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',
+        '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',
+        '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',
+        '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',
+        '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',
+        '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',
+        '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',
+        '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',
+        '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',
+        '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',
+        '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',
+        '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',
+        '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',
+        '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',
+        '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',
+        '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',
+        '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',
+        '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',
+        '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',
+        '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'
+    ].map(n => BigInt(n))))();
+    // Temporary buffer, not used to store anything between runs
+    const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+    const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+    let SHA512$2 = class SHA512 extends HashMD {
+        constructor() {
+            super(128, 64, 16, false);
+            // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.
+            // Also looks cleaner and easier to verify with spec.
+            // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
+            // h -- high 32 bits, l -- low 32 bits
+            this.Ah = 0x6a09e667 | 0;
+            this.Al = 0xf3bcc908 | 0;
+            this.Bh = 0xbb67ae85 | 0;
+            this.Bl = 0x84caa73b | 0;
+            this.Ch = 0x3c6ef372 | 0;
+            this.Cl = 0xfe94f82b | 0;
+            this.Dh = 0xa54ff53a | 0;
+            this.Dl = 0x5f1d36f1 | 0;
+            this.Eh = 0x510e527f | 0;
+            this.El = 0xade682d1 | 0;
+            this.Fh = 0x9b05688c | 0;
+            this.Fl = 0x2b3e6c1f | 0;
+            this.Gh = 0x1f83d9ab | 0;
+            this.Gl = 0xfb41bd6b | 0;
+            this.Hh = 0x5be0cd19 | 0;
+            this.Hl = 0x137e2179 | 0;
+        }
+        // prettier-ignore
+        get() {
+            const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+            return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+        }
+        // prettier-ignore
+        set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+            this.Ah = Ah | 0;
+            this.Al = Al | 0;
+            this.Bh = Bh | 0;
+            this.Bl = Bl | 0;
+            this.Ch = Ch | 0;
+            this.Cl = Cl | 0;
+            this.Dh = Dh | 0;
+            this.Dl = Dl | 0;
+            this.Eh = Eh | 0;
+            this.El = El | 0;
+            this.Fh = Fh | 0;
+            this.Fl = Fl | 0;
+            this.Gh = Gh | 0;
+            this.Gl = Gl | 0;
+            this.Hh = Hh | 0;
+            this.Hl = Hl | 0;
+        }
+        process(view, offset) {
+            // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array
+            for (let i = 0; i < 16; i++, offset += 4) {
+                SHA512_W_H[i] = view.getUint32(offset);
+                SHA512_W_L[i] = view.getUint32((offset += 4));
+            }
+            for (let i = 16; i < 80; i++) {
+                // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
+                const W15h = SHA512_W_H[i - 15] | 0;
+                const W15l = SHA512_W_L[i - 15] | 0;
+                const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);
+                const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);
+                // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)
+                const W2h = SHA512_W_H[i - 2] | 0;
+                const W2l = SHA512_W_L[i - 2] | 0;
+                const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);
+                const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);
+                // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];
+                const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+                const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+                SHA512_W_H[i] = SUMh | 0;
+                SHA512_W_L[i] = SUMl | 0;
+            }
+            let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+            // Compression function main loop, 80 rounds
+            for (let i = 0; i < 80; i++) {
+                // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)
+                const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);
+                const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);
+                //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+                const CHIh = (Eh & Fh) ^ (~Eh & Gh);
+                const CHIl = (El & Fl) ^ (~El & Gl);
+                // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]
+                // prettier-ignore
+                const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+                const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+                const T1l = T1ll | 0;
+                // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
+                const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);
+                const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);
+                const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);
+                const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);
+                Hh = Gh | 0;
+                Hl = Gl | 0;
+                Gh = Fh | 0;
+                Gl = Fl | 0;
+                Fh = Eh | 0;
+                Fl = El | 0;
+                ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+                Dh = Ch | 0;
+                Dl = Cl | 0;
+                Ch = Bh | 0;
+                Cl = Bl | 0;
+                Bh = Ah | 0;
+                Bl = Al | 0;
+                const All = u64.add3L(T1l, sigma0l, MAJl);
+                Ah = u64.add3H(All, T1h, sigma0h, MAJh);
+                Al = All | 0;
+            }
+            // Add the compressed chunk to the current hash value
+            ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+            ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+            ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+            ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+            ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+            ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+            ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+            ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+            this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+        }
+        roundClean() {
+            SHA512_W_H.fill(0);
+            SHA512_W_L.fill(0);
+        }
+        destroy() {
+            this.buffer.fill(0);
+            this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+    };
+    const sha512$1 = /* @__PURE__ */ wrapConstructor$1(() => new SHA512$2());
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    // 100 lines of code in the file are duplicated from noble-hashes (utils).
+    // This is OK: `abstract` directory does not use noble-hashes.
+    // User may opt-in into using different hashing library. This way, noble-hashes
+    // won't be included into their bundle.
+    BigInt(0);
+    const _1n$a = BigInt(1);
+    const _2n$7 = BigInt(2);
+    function isBytes(a) {
+        return (a instanceof Uint8Array ||
+            (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+    }
+    function abytes(item) {
+        if (!isBytes(item))
+            throw new Error('Uint8Array expected');
+    }
+    // Array where index 0xf0 (240) is mapped to string 'f0'
+    const hexes$1 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+    /**
+     * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+     */
+    function bytesToHex$3(bytes) {
+        abytes(bytes);
+        // pre-caching improves the speed 6x
+        let hex = '';
+        for (let i = 0; i < bytes.length; i++) {
+            hex += hexes$1[bytes[i]];
+        }
+        return hex;
+    }
+    function hexToNumber$1(hex) {
+        if (typeof hex !== 'string')
+            throw new Error('hex string expected, got ' + typeof hex);
+        // Big Endian
+        return BigInt(hex === '' ? '0' : `0x${hex}`);
+    }
+    // We use optimized technique to convert hex string to byte array
+    const asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
+    function asciiToBase16(char) {
+        if (char >= asciis._0 && char <= asciis._9)
+            return char - asciis._0;
+        if (char >= asciis._A && char <= asciis._F)
+            return char - (asciis._A - 10);
+        if (char >= asciis._a && char <= asciis._f)
+            return char - (asciis._a - 10);
+        return;
+    }
+    /**
+     * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+     */
+    function hexToBytes$3(hex) {
+        if (typeof hex !== 'string')
+            throw new Error('hex string expected, got ' + typeof hex);
+        const hl = hex.length;
+        const al = hl / 2;
+        if (hl % 2)
+            throw new Error('padded hex string expected, got unpadded hex of length ' + hl);
+        const array = new Uint8Array(al);
+        for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+            const n1 = asciiToBase16(hex.charCodeAt(hi));
+            const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+            if (n1 === undefined || n2 === undefined) {
+                const char = hex[hi] + hex[hi + 1];
+                throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+            }
+            array[ai] = n1 * 16 + n2;
+        }
+        return array;
+    }
+    // BE: Big Endian, LE: Little Endian
+    function bytesToNumberBE$1(bytes) {
+        return hexToNumber$1(bytesToHex$3(bytes));
+    }
+    function bytesToNumberLE$1(bytes) {
+        abytes(bytes);
+        return hexToNumber$1(bytesToHex$3(Uint8Array.from(bytes).reverse()));
+    }
+    function numberToBytesBE$1(n, len) {
+        return hexToBytes$3(n.toString(16).padStart(len * 2, '0'));
+    }
+    function numberToBytesLE$1(n, len) {
+        return numberToBytesBE$1(n, len).reverse();
+    }
+    /**
+     * Takes hex string or Uint8Array, converts to Uint8Array.
+     * Validates output length.
+     * Will throw error for other types.
+     * @param title descriptive title for an error e.g. 'private key'
+     * @param hex hex string or Uint8Array
+     * @param expectedLength optional, will compare to result array's length
+     * @returns
+     */
+    function ensureBytes$1(title, hex, expectedLength) {
+        let res;
+        if (typeof hex === 'string') {
+            try {
+                res = hexToBytes$3(hex);
+            }
+            catch (e) {
+                throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
+            }
+        }
+        else if (isBytes(hex)) {
+            // Uint8Array.from() instead of hash.slice() because node.js Buffer
+            // is instance of Uint8Array, and its slice() creates **mutable** copy
+            res = Uint8Array.from(hex);
+        }
+        else {
+            throw new Error(`${title} must be hex string or Uint8Array`);
+        }
+        const len = res.length;
+        if (typeof expectedLength === 'number' && len !== expectedLength)
+            throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
+        return res;
+    }
+    /**
+     * Copies several Uint8Arrays into one.
+     */
+    function concatBytes$2(...arrays) {
+        let sum = 0;
+        for (let i = 0; i < arrays.length; i++) {
+            const a = arrays[i];
+            abytes(a);
+            sum += a.length;
+        }
+        const res = new Uint8Array(sum);
+        for (let i = 0, pad = 0; i < arrays.length; i++) {
+            const a = arrays[i];
+            res.set(a, pad);
+            pad += a.length;
+        }
+        return res;
+    }
+    /**
+     * Calculate mask for N bits. Not using ** operator with bigints because of old engines.
+     * Same as BigInt(`0b${Array(i).fill('1').join('')}`)
+     */
+    const bitMask$1 = (n) => (_2n$7 << BigInt(n - 1)) - _1n$a;
+    // Validating curves and fields
+    const validatorFns$1 = {
+        bigint: (val) => typeof val === 'bigint',
+        function: (val) => typeof val === 'function',
+        boolean: (val) => typeof val === 'boolean',
+        string: (val) => typeof val === 'string',
+        stringOrUint8Array: (val) => typeof val === 'string' || isBytes(val),
+        isSafeInteger: (val) => Number.isSafeInteger(val),
+        array: (val) => Array.isArray(val),
+        field: (val, object) => object.Fp.isValid(val),
+        hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),
+    };
+    // type Record<K extends string | number | symbol, T> = { [P in K]: T; }
+    function validateObject$1(object, validators, optValidators = {}) {
+        const checkField = (fieldName, type, isOptional) => {
+            const checkVal = validatorFns$1[type];
+            if (typeof checkVal !== 'function')
+                throw new Error(`Invalid validator "${type}", expected function`);
+            const val = object[fieldName];
+            if (isOptional && val === undefined)
+                return;
+            if (!checkVal(val, object)) {
+                throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
+            }
+        };
+        for (const [fieldName, type] of Object.entries(validators))
+            checkField(fieldName, type, false);
+        for (const [fieldName, type] of Object.entries(optValidators))
+            checkField(fieldName, type, true);
+        return object;
+    }
+    // validate type tests
+    // const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };
+    // const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!
+    // // Should fail type-check
+    // const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });
+    // const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });
+    // const z3 = validateObject(o, { test: 'boolean', z: 'bug' });
+    // const z4 = validateObject(o, { a: 'boolean', z: 'bug' });
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    // Utilities for modular arithmetics and finite fields
+    // prettier-ignore
+    const _0n$7 = BigInt(0), _1n$9 = BigInt(1), _2n$6 = BigInt(2), _3n$2 = BigInt(3);
+    // prettier-ignore
+    const _4n$1 = BigInt(4), _5n$2 = BigInt(5), _8n$2 = BigInt(8);
+    // prettier-ignore
+    BigInt(9); BigInt(16);
+    // Calculates a modulo b
+    function mod$2(a, b) {
+        const result = a % b;
+        return result >= _0n$7 ? result : b + result;
+    }
+    /**
+     * Efficiently raise num to power and do modular division.
+     * Unsafe in some contexts: uses ladder, so can expose bigint bits.
+     * @example
+     * pow(2n, 6n, 11n) // 64n % 11n == 9n
+     */
+    // TODO: use field version && remove
+    function pow$2(num, power, modulo) {
+        if (modulo <= _0n$7 || power < _0n$7)
+            throw new Error('Expected power/modulo > 0');
+        if (modulo === _1n$9)
+            return _0n$7;
+        let res = _1n$9;
+        while (power > _0n$7) {
+            if (power & _1n$9)
+                res = (res * num) % modulo;
+            num = (num * num) % modulo;
+            power >>= _1n$9;
+        }
+        return res;
+    }
+    // Does x ^ (2 ^ power) mod p. pow2(30, 4) == 30 ^ (2 ^ 4)
+    function pow2$1(x, power, modulo) {
+        let res = x;
+        while (power-- > _0n$7) {
+            res *= res;
+            res %= modulo;
+        }
+        return res;
+    }
+    // Inverses number over modulo
+    function invert$1(number, modulo) {
+        if (number === _0n$7 || modulo <= _0n$7) {
+            throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);
+        }
+        // Euclidean GCD https://brilliant.org/wiki/extended-euclidean-algorithm/
+        // Fermat's little theorem "CT-like" version inv(n) = n^(m-2) mod m is 30x slower.
+        let a = mod$2(number, modulo);
+        let b = modulo;
+        // prettier-ignore
+        let x = _0n$7, u = _1n$9;
+        while (a !== _0n$7) {
+            // JIT applies optimization if those two lines follow each other
+            const q = b / a;
+            const r = b % a;
+            const m = x - u * q;
+            // prettier-ignore
+            b = a, a = r, x = u, u = m;
+        }
+        const gcd = b;
+        if (gcd !== _1n$9)
+            throw new Error('invert: does not exist');
+        return mod$2(x, modulo);
+    }
+    /**
+     * Tonelli-Shanks square root search algorithm.
+     * 1. https://eprint.iacr.org/2012/685.pdf (page 12)
+     * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks
+     * Will start an infinite loop if field order P is not prime.
+     * @param P field order
+     * @returns function that takes field Fp (created from P) and number n
+     */
+    function tonelliShanks$1(P) {
+        // Legendre constant: used to calculate Legendre symbol (a | p),
+        // which denotes the value of a^((p-1)/2) (mod p).
+        // (a | p) ≡ 1    if a is a square (mod p)
+        // (a | p) ≡ -1   if a is not a square (mod p)
+        // (a | p) ≡ 0    if a ≡ 0 (mod p)
+        const legendreC = (P - _1n$9) / _2n$6;
+        let Q, S, Z;
+        // Step 1: By factoring out powers of 2 from p - 1,
+        // find q and s such that p - 1 = q*(2^s) with q odd
+        for (Q = P - _1n$9, S = 0; Q % _2n$6 === _0n$7; Q /= _2n$6, S++)
+            ;
+        // Step 2: Select a non-square z such that (z | p) ≡ -1 and set c ≡ zq
+        for (Z = _2n$6; Z < P && pow$2(Z, legendreC, P) !== P - _1n$9; Z++)
+            ;
+        // Fast-path
+        if (S === 1) {
+            const p1div4 = (P + _1n$9) / _4n$1;
+            return function tonelliFast(Fp, n) {
+                const root = Fp.pow(n, p1div4);
+                if (!Fp.eql(Fp.sqr(root), n))
+                    throw new Error('Cannot find square root');
+                return root;
+            };
+        }
+        // Slow-path
+        const Q1div2 = (Q + _1n$9) / _2n$6;
+        return function tonelliSlow(Fp, n) {
+            // Step 0: Check that n is indeed a square: (n | p) should not be ≡ -1
+            if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))
+                throw new Error('Cannot find square root');
+            let r = S;
+            // TODO: will fail at Fp2/etc
+            let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q); // will update both x and b
+            let x = Fp.pow(n, Q1div2); // first guess at the square root
+            let b = Fp.pow(n, Q); // first guess at the fudge factor
+            while (!Fp.eql(b, Fp.ONE)) {
+                if (Fp.eql(b, Fp.ZERO))
+                    return Fp.ZERO; // https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm (4. If t = 0, return r = 0)
+                // Find m such b^(2^m)==1
+                let m = 1;
+                for (let t2 = Fp.sqr(b); m < r; m++) {
+                    if (Fp.eql(t2, Fp.ONE))
+                        break;
+                    t2 = Fp.sqr(t2); // t2 *= t2
+                }
+                // NOTE: r-m-1 can be bigger than 32, need to convert to bigint before shift, otherwise there will be overflow
+                const ge = Fp.pow(g, _1n$9 << BigInt(r - m - 1)); // ge = 2^(r-m-1)
+                g = Fp.sqr(ge); // g = ge * ge
+                x = Fp.mul(x, ge); // x *= ge
+                b = Fp.mul(b, g); // b *= g
+                r = m;
+            }
+            return x;
+        };
+    }
+    function FpSqrt$1(P) {
+        // NOTE: different algorithms can give different roots, it is up to user to decide which one they want.
+        // For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).
+        // P ≡ 3 (mod 4)
+        // √n = n^((P+1)/4)
+        if (P % _4n$1 === _3n$2) {
+            // Not all roots possible!
+            // const ORDER =
+            //   0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn;
+            // const NUM = 72057594037927816n;
+            const p1div4 = (P + _1n$9) / _4n$1;
+            return function sqrt3mod4(Fp, n) {
+                const root = Fp.pow(n, p1div4);
+                // Throw if root**2 != n
+                if (!Fp.eql(Fp.sqr(root), n))
+                    throw new Error('Cannot find square root');
+                return root;
+            };
+        }
+        // Atkin algorithm for q ≡ 5 (mod 8), https://eprint.iacr.org/2012/685.pdf (page 10)
+        if (P % _8n$2 === _5n$2) {
+            const c1 = (P - _5n$2) / _8n$2;
+            return function sqrt5mod8(Fp, n) {
+                const n2 = Fp.mul(n, _2n$6);
+                const v = Fp.pow(n2, c1);
+                const nv = Fp.mul(n, v);
+                const i = Fp.mul(Fp.mul(nv, _2n$6), v);
+                const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
+                if (!Fp.eql(Fp.sqr(root), n))
+                    throw new Error('Cannot find square root');
+                return root;
+            };
+        }
+        // Other cases: Tonelli-Shanks algorithm
+        return tonelliShanks$1(P);
+    }
+    // Little-endian check for first LE bit (last BE bit);
+    const isNegativeLE = (num, modulo) => (mod$2(num, modulo) & _1n$9) === _1n$9;
+    // prettier-ignore
+    const FIELD_FIELDS$1 = [
+        'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',
+        'eql', 'add', 'sub', 'mul', 'pow', 'div',
+        'addN', 'subN', 'mulN', 'sqrN'
+    ];
+    function validateField$1(field) {
+        const initial = {
+            ORDER: 'bigint',
+            MASK: 'bigint',
+            BYTES: 'isSafeInteger',
+            BITS: 'isSafeInteger',
+        };
+        const opts = FIELD_FIELDS$1.reduce((map, val) => {
+            map[val] = 'function';
+            return map;
+        }, initial);
+        return validateObject$1(field, opts);
+    }
+    // Generic field functions
+    /**
+     * Same as `pow` but for Fp: non-constant-time.
+     * Unsafe in some contexts: uses ladder, so can expose bigint bits.
+     */
+    function FpPow$1(f, num, power) {
+        // Should have same speed as pow for bigints
+        // TODO: benchmark!
+        if (power < _0n$7)
+            throw new Error('Expected power > 0');
+        if (power === _0n$7)
+            return f.ONE;
+        if (power === _1n$9)
+            return num;
+        let p = f.ONE;
+        let d = num;
+        while (power > _0n$7) {
+            if (power & _1n$9)
+                p = f.mul(p, d);
+            d = f.sqr(d);
+            power >>= _1n$9;
+        }
+        return p;
+    }
+    /**
+     * Efficiently invert an array of Field elements.
+     * `inv(0)` will return `undefined` here: make sure to throw an error.
+     */
+    function FpInvertBatch$1(f, nums) {
+        const tmp = new Array(nums.length);
+        // Walk from first to last, multiply them by each other MOD p
+        const lastMultiplied = nums.reduce((acc, num, i) => {
+            if (f.is0(num))
+                return acc;
+            tmp[i] = acc;
+            return f.mul(acc, num);
+        }, f.ONE);
+        // Invert last element
+        const inverted = f.inv(lastMultiplied);
+        // Walk from last to first, multiply them by inverted each other MOD p
+        nums.reduceRight((acc, num, i) => {
+            if (f.is0(num))
+                return acc;
+            tmp[i] = f.mul(acc, tmp[i]);
+            return f.mul(acc, num);
+        }, inverted);
+        return tmp;
+    }
+    // CURVE.n lengths
+    function nLength$1(n, nBitLength) {
+        // Bit size, byte size of CURVE.n
+        const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;
+        const nByteLength = Math.ceil(_nBitLength / 8);
+        return { nBitLength: _nBitLength, nByteLength };
+    }
+    /**
+     * Initializes a finite field over prime. **Non-primes are not supported.**
+     * Do not init in loop: slow. Very fragile: always run a benchmark on a change.
+     * Major performance optimizations:
+     * * a) denormalized operations like mulN instead of mul
+     * * b) same object shape: never add or remove keys
+     * * c) Object.freeze
+     * @param ORDER prime positive bigint
+     * @param bitLen how many bits the field consumes
+     * @param isLE (def: false) if encoding / decoding should be in little-endian
+     * @param redef optional faster redefinitions of sqrt and other methods
+     */
+    function Field$1(ORDER, bitLen, isLE = false, redef = {}) {
+        if (ORDER <= _0n$7)
+            throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
+        const { nBitLength: BITS, nByteLength: BYTES } = nLength$1(ORDER, bitLen);
+        if (BYTES > 2048)
+            throw new Error('Field lengths over 2048 bytes are not supported');
+        const sqrtP = FpSqrt$1(ORDER);
+        const f = Object.freeze({
+            ORDER,
+            BITS,
+            BYTES,
+            MASK: bitMask$1(BITS),
+            ZERO: _0n$7,
+            ONE: _1n$9,
+            create: (num) => mod$2(num, ORDER),
+            isValid: (num) => {
+                if (typeof num !== 'bigint')
+                    throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);
+                return _0n$7 <= num && num < ORDER; // 0 is valid element, but it's not invertible
+            },
+            is0: (num) => num === _0n$7,
+            isOdd: (num) => (num & _1n$9) === _1n$9,
+            neg: (num) => mod$2(-num, ORDER),
+            eql: (lhs, rhs) => lhs === rhs,
+            sqr: (num) => mod$2(num * num, ORDER),
+            add: (lhs, rhs) => mod$2(lhs + rhs, ORDER),
+            sub: (lhs, rhs) => mod$2(lhs - rhs, ORDER),
+            mul: (lhs, rhs) => mod$2(lhs * rhs, ORDER),
+            pow: (num, power) => FpPow$1(f, num, power),
+            div: (lhs, rhs) => mod$2(lhs * invert$1(rhs, ORDER), ORDER),
+            // Same as above, but doesn't normalize
+            sqrN: (num) => num * num,
+            addN: (lhs, rhs) => lhs + rhs,
+            subN: (lhs, rhs) => lhs - rhs,
+            mulN: (lhs, rhs) => lhs * rhs,
+            inv: (num) => invert$1(num, ORDER),
+            sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
+            invertBatch: (lst) => FpInvertBatch$1(f, lst),
+            // TODO: do we really need constant cmov?
+            // We don't have const-time bigints anyway, so probably will be not very useful
+            cmov: (a, b, c) => (c ? b : a),
+            toBytes: (num) => (isLE ? numberToBytesLE$1(num, BYTES) : numberToBytesBE$1(num, BYTES)),
+            fromBytes: (bytes) => {
+                if (bytes.length !== BYTES)
+                    throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes.length}`);
+                return isLE ? bytesToNumberLE$1(bytes) : bytesToNumberBE$1(bytes);
+            },
+        });
+        return Object.freeze(f);
+    }
+    function FpSqrtEven(Fp, elm) {
+        if (!Fp.isOdd)
+            throw new Error(`Field doesn't have isOdd`);
+        const root = Fp.sqrt(elm);
+        return Fp.isOdd(root) ? Fp.neg(root) : root;
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    // Abelian group utilities
+    const _0n$6 = BigInt(0);
+    const _1n$8 = BigInt(1);
+    // Elliptic curve multiplication of Point by scalar. Fragile.
+    // Scalars should always be less than curve order: this should be checked inside of a curve itself.
+    // Creates precomputation tables for fast multiplication:
+    // - private scalar is split by fixed size windows of W bits
+    // - every window point is collected from window's table & added to accumulator
+    // - since windows are different, same point inside tables won't be accessed more than once per calc
+    // - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)
+    // - +1 window is neccessary for wNAF
+    // - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication
+    // TODO: Research returning 2d JS array of windows, instead of a single window. This would allow
+    // windows to be in different memory locations
+    function wNAF$1(c, bits) {
+        const constTimeNegate = (condition, item) => {
+            const neg = item.negate();
+            return condition ? neg : item;
+        };
+        const opts = (W) => {
+            const windows = Math.ceil(bits / W) + 1; // +1, because
+            const windowSize = 2 ** (W - 1); // -1 because we skip zero
+            return { windows, windowSize };
+        };
+        return {
+            constTimeNegate,
+            // non-const time multiplication ladder
+            unsafeLadder(elm, n) {
+                let p = c.ZERO;
+                let d = elm;
+                while (n > _0n$6) {
+                    if (n & _1n$8)
+                        p = p.add(d);
+                    d = d.double();
+                    n >>= _1n$8;
+                }
+                return p;
+            },
+            /**
+             * Creates a wNAF precomputation window. Used for caching.
+             * Default window size is set by `utils.precompute()` and is equal to 8.
+             * Number of precomputed points depends on the curve size:
+             * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+             * - 𝑊 is the window size
+             * - 𝑛 is the bitlength of the curve order.
+             * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+             * @returns precomputed point tables flattened to a single array
+             */
+            precomputeWindow(elm, W) {
+                const { windows, windowSize } = opts(W);
+                const points = [];
+                let p = elm;
+                let base = p;
+                for (let window = 0; window < windows; window++) {
+                    base = p;
+                    points.push(base);
+                    // =1, because we skip zero
+                    for (let i = 1; i < windowSize; i++) {
+                        base = base.add(p);
+                        points.push(base);
+                    }
+                    p = base.double();
+                }
+                return points;
+            },
+            /**
+             * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+             * @param W window size
+             * @param precomputes precomputed tables
+             * @param n scalar (we don't check here, but should be less than curve order)
+             * @returns real and fake (for const-time) points
+             */
+            wNAF(W, precomputes, n) {
+                // TODO: maybe check that scalar is less than group order? wNAF behavious is undefined otherwise
+                // But need to carefully remove other checks before wNAF. ORDER == bits here
+                const { windows, windowSize } = opts(W);
+                let p = c.ZERO;
+                let f = c.BASE;
+                const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.
+                const maxNumber = 2 ** W;
+                const shiftBy = BigInt(W);
+                for (let window = 0; window < windows; window++) {
+                    const offset = window * windowSize;
+                    // Extract W bits.
+                    let wbits = Number(n & mask);
+                    // Shift number by W bits.
+                    n >>= shiftBy;
+                    // If the bits are bigger than max size, we'll split those.
+                    // +224 => 256 - 32
+                    if (wbits > windowSize) {
+                        wbits -= maxNumber;
+                        n += _1n$8;
+                    }
+                    // This code was first written with assumption that 'f' and 'p' will never be infinity point:
+                    // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,
+                    // there is negate now: it is possible that negated element from low value
+                    // would be the same as high element, which will create carry into next window.
+                    // It's not obvious how this can fail, but still worth investigating later.
+                    // Check if we're onto Zero point.
+                    // Add random point inside current window to f.
+                    const offset1 = offset;
+                    const offset2 = offset + Math.abs(wbits) - 1; // -1 because we skip zero
+                    const cond1 = window % 2 !== 0;
+                    const cond2 = wbits < 0;
+                    if (wbits === 0) {
+                        // The most important part for const-time getPublicKey
+                        f = f.add(constTimeNegate(cond1, precomputes[offset1]));
+                    }
+                    else {
+                        p = p.add(constTimeNegate(cond2, precomputes[offset2]));
+                    }
+                }
+                // JIT-compiler should not eliminate f here, since it will later be used in normalizeZ()
+                // Even if the variable is still unused, there are some checks which will
+                // throw an exception, so compiler needs to prove they won't happen, which is hard.
+                // At this point there is a way to F be infinity-point even if p is not,
+                // which makes it less const-time: around 1 bigint multiply.
+                return { p, f };
+            },
+            wNAFCached(P, precomputesMap, n, transform) {
+                // @ts-ignore
+                const W = P._WINDOW_SIZE || 1;
+                // Calculate precomputes on a first run, reuse them after
+                let comp = precomputesMap.get(P);
+                if (!comp) {
+                    comp = this.precomputeWindow(P, W);
+                    if (W !== 1) {
+                        precomputesMap.set(P, transform(comp));
+                    }
+                }
+                return this.wNAF(W, comp, n);
+            },
+        };
+    }
+    function validateBasic$1(curve) {
+        validateField$1(curve.Fp);
+        validateObject$1(curve, {
+            n: 'bigint',
+            h: 'bigint',
+            Gx: 'field',
+            Gy: 'field',
+        }, {
+            nBitLength: 'isSafeInteger',
+            nByteLength: 'isSafeInteger',
+        });
+        // Set defaults
+        return Object.freeze({
+            ...nLength$1(curve.n, curve.nBitLength),
+            ...curve,
+            ...{ p: curve.Fp.ORDER },
+        });
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    // Twisted Edwards curve. The formula is: ax² + y² = 1 + dx²y²
+    // Be friendly to bad ECMAScript parsers by not using bigint literals
+    // prettier-ignore
+    const _0n$5 = BigInt(0), _1n$7 = BigInt(1), _2n$5 = BigInt(2), _8n$1 = BigInt(8);
+    // verification rule is either zip215 or rfc8032 / nist186-5. Consult fromHex:
+    const VERIFY_DEFAULT = { zip215: true };
+    function validateOpts$1(curve) {
+        const opts = validateBasic$1(curve);
+        validateObject$1(curve, {
+            hash: 'function',
+            a: 'bigint',
+            d: 'bigint',
+            randomBytes: 'function',
+        }, {
+            adjustScalarBytes: 'function',
+            domain: 'function',
+            uvRatio: 'function',
+            mapToCurve: 'function',
+        });
+        // Set defaults
+        return Object.freeze({ ...opts });
+    }
+    // It is not generic twisted curve for now, but ed25519/ed448 generic implementation
+    function twistedEdwards(curveDef) {
+        const CURVE = validateOpts$1(curveDef);
+        const { Fp, n: CURVE_ORDER, prehash: prehash, hash: cHash, randomBytes, nByteLength, h: cofactor, } = CURVE;
+        const MASK = _2n$5 << (BigInt(nByteLength * 8) - _1n$7);
+        const modP = Fp.create; // Function overrides
+        // sqrt(u/v)
+        const uvRatio = CURVE.uvRatio ||
+            ((u, v) => {
+                try {
+                    return { isValid: true, value: Fp.sqrt(u * Fp.inv(v)) };
+                }
+                catch (e) {
+                    return { isValid: false, value: _0n$5 };
+                }
+            });
+        const adjustScalarBytes = CURVE.adjustScalarBytes || ((bytes) => bytes); // NOOP
+        const domain = CURVE.domain ||
+            ((data, ctx, phflag) => {
+                if (ctx.length || phflag)
+                    throw new Error('Contexts/pre-hash are not supported');
+                return data;
+            }); // NOOP
+        const inBig = (n) => typeof n === 'bigint' && _0n$5 < n; // n in [1..]
+        const inRange = (n, max) => inBig(n) && inBig(max) && n < max; // n in [1..max-1]
+        const in0MaskRange = (n) => n === _0n$5 || inRange(n, MASK); // n in [0..MASK-1]
+        function assertInRange(n, max) {
+            // n in [1..max-1]
+            if (inRange(n, max))
+                return n;
+            throw new Error(`Expected valid scalar < ${max}, got ${typeof n} ${n}`);
+        }
+        function assertGE0(n) {
+            // n in [0..CURVE_ORDER-1]
+            return n === _0n$5 ? n : assertInRange(n, CURVE_ORDER); // GE = prime subgroup, not full group
+        }
+        const pointPrecomputes = new Map();
+        function isPoint(other) {
+            if (!(other instanceof Point))
+                throw new Error('ExtendedPoint expected');
+        }
+        // Extended Point works in extended coordinates: (x, y, z, t) ∋ (x=x/z, y=y/z, t=xy).
+        // https://en.wikipedia.org/wiki/Twisted_Edwards_curve#Extended_coordinates
+        class Point {
+            constructor(ex, ey, ez, et) {
+                this.ex = ex;
+                this.ey = ey;
+                this.ez = ez;
+                this.et = et;
+                if (!in0MaskRange(ex))
+                    throw new Error('x required');
+                if (!in0MaskRange(ey))
+                    throw new Error('y required');
+                if (!in0MaskRange(ez))
+                    throw new Error('z required');
+                if (!in0MaskRange(et))
+                    throw new Error('t required');
+            }
+            get x() {
+                return this.toAffine().x;
+            }
+            get y() {
+                return this.toAffine().y;
+            }
+            static fromAffine(p) {
+                if (p instanceof Point)
+                    throw new Error('extended point not allowed');
+                const { x, y } = p || {};
+                if (!in0MaskRange(x) || !in0MaskRange(y))
+                    throw new Error('invalid affine point');
+                return new Point(x, y, _1n$7, modP(x * y));
+            }
+            static normalizeZ(points) {
+                const toInv = Fp.invertBatch(points.map((p) => p.ez));
+                return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
+            }
+            // "Private method", don't use it directly
+            _setWindowSize(windowSize) {
+                this._WINDOW_SIZE = windowSize;
+                pointPrecomputes.delete(this);
+            }
+            // Not required for fromHex(), which always creates valid points.
+            // Could be useful for fromAffine().
+            assertValidity() {
+                const { a, d } = CURVE;
+                if (this.is0())
+                    throw new Error('bad point: ZERO'); // TODO: optimize, with vars below?
+                // Equation in affine coordinates: ax² + y² = 1 + dx²y²
+                // Equation in projective coordinates (X/Z, Y/Z, Z):  (aX² + Y²)Z² = Z⁴ + dX²Y²
+                const { ex: X, ey: Y, ez: Z, et: T } = this;
+                const X2 = modP(X * X); // X²
+                const Y2 = modP(Y * Y); // Y²
+                const Z2 = modP(Z * Z); // Z²
+                const Z4 = modP(Z2 * Z2); // Z⁴
+                const aX2 = modP(X2 * a); // aX²
+                const left = modP(Z2 * modP(aX2 + Y2)); // (aX² + Y²)Z²
+                const right = modP(Z4 + modP(d * modP(X2 * Y2))); // Z⁴ + dX²Y²
+                if (left !== right)
+                    throw new Error('bad point: equation left != right (1)');
+                // In Extended coordinates we also have T, which is x*y=T/Z: check X*Y == Z*T
+                const XY = modP(X * Y);
+                const ZT = modP(Z * T);
+                if (XY !== ZT)
+                    throw new Error('bad point: equation left != right (2)');
+            }
+            // Compare one point to another.
+            equals(other) {
+                isPoint(other);
+                const { ex: X1, ey: Y1, ez: Z1 } = this;
+                const { ex: X2, ey: Y2, ez: Z2 } = other;
+                const X1Z2 = modP(X1 * Z2);
+                const X2Z1 = modP(X2 * Z1);
+                const Y1Z2 = modP(Y1 * Z2);
+                const Y2Z1 = modP(Y2 * Z1);
+                return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+            }
+            is0() {
+                return this.equals(Point.ZERO);
+            }
+            negate() {
+                // Flips point sign to a negative one (-x, y in affine coords)
+                return new Point(modP(-this.ex), this.ey, this.ez, modP(-this.et));
+            }
+            // Fast algo for doubling Extended Point.
+            // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#doubling-dbl-2008-hwcd
+            // Cost: 4M + 4S + 1*a + 6add + 1*2.
+            double() {
+                const { a } = CURVE;
+                const { ex: X1, ey: Y1, ez: Z1 } = this;
+                const A = modP(X1 * X1); // A = X12
+                const B = modP(Y1 * Y1); // B = Y12
+                const C = modP(_2n$5 * modP(Z1 * Z1)); // C = 2*Z12
+                const D = modP(a * A); // D = a*A
+                const x1y1 = X1 + Y1;
+                const E = modP(modP(x1y1 * x1y1) - A - B); // E = (X1+Y1)2-A-B
+                const G = D + B; // G = D+B
+                const F = G - C; // F = G-C
+                const H = D - B; // H = D-B
+                const X3 = modP(E * F); // X3 = E*F
+                const Y3 = modP(G * H); // Y3 = G*H
+                const T3 = modP(E * H); // T3 = E*H
+                const Z3 = modP(F * G); // Z3 = F*G
+                return new Point(X3, Y3, Z3, T3);
+            }
+            // Fast algo for adding 2 Extended Points.
+            // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#addition-add-2008-hwcd
+            // Cost: 9M + 1*a + 1*d + 7add.
+            add(other) {
+                isPoint(other);
+                const { a, d } = CURVE;
+                const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
+                const { ex: X2, ey: Y2, ez: Z2, et: T2 } = other;
+                // Faster algo for adding 2 Extended Points when curve's a=-1.
+                // http://hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html#addition-add-2008-hwcd-4
+                // Cost: 8M + 8add + 2*2.
+                // Note: It does not check whether the `other` point is valid.
+                if (a === BigInt(-1)) {
+                    const A = modP((Y1 - X1) * (Y2 + X2));
+                    const B = modP((Y1 + X1) * (Y2 - X2));
+                    const F = modP(B - A);
+                    if (F === _0n$5)
+                        return this.double(); // Same point. Tests say it doesn't affect timing
+                    const C = modP(Z1 * _2n$5 * T2);
+                    const D = modP(T1 * _2n$5 * Z2);
+                    const E = D + C;
+                    const G = B + A;
+                    const H = D - C;
+                    const X3 = modP(E * F);
+                    const Y3 = modP(G * H);
+                    const T3 = modP(E * H);
+                    const Z3 = modP(F * G);
+                    return new Point(X3, Y3, Z3, T3);
+                }
+                const A = modP(X1 * X2); // A = X1*X2
+                const B = modP(Y1 * Y2); // B = Y1*Y2
+                const C = modP(T1 * d * T2); // C = T1*d*T2
+                const D = modP(Z1 * Z2); // D = Z1*Z2
+                const E = modP((X1 + Y1) * (X2 + Y2) - A - B); // E = (X1+Y1)*(X2+Y2)-A-B
+                const F = D - C; // F = D-C
+                const G = D + C; // G = D+C
+                const H = modP(B - a * A); // H = B-a*A
+                const X3 = modP(E * F); // X3 = E*F
+                const Y3 = modP(G * H); // Y3 = G*H
+                const T3 = modP(E * H); // T3 = E*H
+                const Z3 = modP(F * G); // Z3 = F*G
+                return new Point(X3, Y3, Z3, T3);
+            }
+            subtract(other) {
+                return this.add(other.negate());
+            }
+            wNAF(n) {
+                return wnaf.wNAFCached(this, pointPrecomputes, n, Point.normalizeZ);
+            }
+            // Constant-time multiplication.
+            multiply(scalar) {
+                const { p, f } = this.wNAF(assertInRange(scalar, CURVE_ORDER));
+                return Point.normalizeZ([p, f])[0];
+            }
+            // Non-constant-time multiplication. Uses double-and-add algorithm.
+            // It's faster, but should only be used when you don't care about
+            // an exposed private key e.g. sig verification.
+            // Does NOT allow scalars higher than CURVE.n.
+            multiplyUnsafe(scalar) {
+                let n = assertGE0(scalar); // 0 <= scalar < CURVE.n
+                if (n === _0n$5)
+                    return I;
+                if (this.equals(I) || n === _1n$7)
+                    return this;
+                if (this.equals(G))
+                    return this.wNAF(n).p;
+                return wnaf.unsafeLadder(this, n);
+            }
+            // Checks if point is of small order.
+            // If you add something to small order point, you will have "dirty"
+            // point with torsion component.
+            // Multiplies point by cofactor and checks if the result is 0.
+            isSmallOrder() {
+                return this.multiplyUnsafe(cofactor).is0();
+            }
+            // Multiplies point by curve order and checks if the result is 0.
+            // Returns `false` is the point is dirty.
+            isTorsionFree() {
+                return wnaf.unsafeLadder(this, CURVE_ORDER).is0();
+            }
+            // Converts Extended point to default (x, y) coordinates.
+            // Can accept precomputed Z^-1 - for example, from invertBatch.
+            toAffine(iz) {
+                const { ex: x, ey: y, ez: z } = this;
+                const is0 = this.is0();
+                if (iz == null)
+                    iz = is0 ? _8n$1 : Fp.inv(z); // 8 was chosen arbitrarily
+                const ax = modP(x * iz);
+                const ay = modP(y * iz);
+                const zz = modP(z * iz);
+                if (is0)
+                    return { x: _0n$5, y: _1n$7 };
+                if (zz !== _1n$7)
+                    throw new Error('invZ was invalid');
+                return { x: ax, y: ay };
+            }
+            clearCofactor() {
+                const { h: cofactor } = CURVE;
+                if (cofactor === _1n$7)
+                    return this;
+                return this.multiplyUnsafe(cofactor);
+            }
+            // Converts hash string or Uint8Array to Point.
+            // Uses algo from RFC8032 5.1.3.
+            static fromHex(hex, zip215 = false) {
+                const { d, a } = CURVE;
+                const len = Fp.BYTES;
+                hex = ensureBytes$1('pointHex', hex, len); // copy hex to a new array
+                const normed = hex.slice(); // copy again, we'll manipulate it
+                const lastByte = hex[len - 1]; // select last byte
+                normed[len - 1] = lastByte & ~0x80; // clear last bit
+                const y = bytesToNumberLE$1(normed);
+                if (y === _0n$5) ;
+                else {
+                    // RFC8032 prohibits >= p, but ZIP215 doesn't
+                    if (zip215)
+                        assertInRange(y, MASK); // zip215=true [1..P-1] (2^255-19-1 for ed25519)
+                    else
+                        assertInRange(y, Fp.ORDER); // zip215=false [1..MASK-1] (2^256-1 for ed25519)
+                }
+                // Ed25519: x² = (y²-1)/(dy²+1) mod p. Ed448: x² = (y²-1)/(dy²-1) mod p. Generic case:
+                // ax²+y²=1+dx²y² => y²-1=dx²y²-ax² => y²-1=x²(dy²-a) => x²=(y²-1)/(dy²-a)
+                const y2 = modP(y * y); // denominator is always non-0 mod p.
+                const u = modP(y2 - _1n$7); // u = y² - 1
+                const v = modP(d * y2 - a); // v = d y² + 1.
+                let { isValid, value: x } = uvRatio(u, v); // √(u/v)
+                if (!isValid)
+                    throw new Error('Point.fromHex: invalid y coordinate');
+                const isXOdd = (x & _1n$7) === _1n$7; // There are 2 square roots. Use x_0 bit to select proper
+                const isLastByteOdd = (lastByte & 0x80) !== 0; // x_0, last bit
+                if (!zip215 && x === _0n$5 && isLastByteOdd)
+                    // if x=0 and x_0 = 1, fail
+                    throw new Error('Point.fromHex: x=0 and x_0=1');
+                if (isLastByteOdd !== isXOdd)
+                    x = modP(-x); // if x_0 != x mod 2, set x = p-x
+                return Point.fromAffine({ x, y });
+            }
+            static fromPrivateKey(privKey) {
+                return getExtendedPublicKey(privKey).point;
+            }
+            toRawBytes() {
+                const { x, y } = this.toAffine();
+                const bytes = numberToBytesLE$1(y, Fp.BYTES); // each y has 2 x values (x, -y)
+                bytes[bytes.length - 1] |= x & _1n$7 ? 0x80 : 0; // when compressing, it's enough to store y
+                return bytes; // and use the last byte to encode sign of x
+            }
+            toHex() {
+                return bytesToHex$3(this.toRawBytes()); // Same as toRawBytes, but returns string.
+            }
+        }
+        Point.BASE = new Point(CURVE.Gx, CURVE.Gy, _1n$7, modP(CURVE.Gx * CURVE.Gy));
+        Point.ZERO = new Point(_0n$5, _1n$7, _1n$7, _0n$5); // 0, 1, 1, 0
+        const { BASE: G, ZERO: I } = Point;
+        const wnaf = wNAF$1(Point, nByteLength * 8);
+        function modN(a) {
+            return mod$2(a, CURVE_ORDER);
+        }
+        // Little-endian SHA512 with modulo n
+        function modN_LE(hash) {
+            return modN(bytesToNumberLE$1(hash));
+        }
+        /** Convenience method that creates public key and other stuff. RFC8032 5.1.5 */
+        function getExtendedPublicKey(key) {
+            const len = nByteLength;
+            key = ensureBytes$1('private key', key, len);
+            // Hash private key with curve's hash function to produce uniformingly random input
+            // Check byte lengths: ensure(64, h(ensure(32, key)))
+            const hashed = ensureBytes$1('hashed private key', cHash(key), 2 * len);
+            const head = adjustScalarBytes(hashed.slice(0, len)); // clear first half bits, produce FE
+            const prefix = hashed.slice(len, 2 * len); // second half is called key prefix (5.1.6)
+            const scalar = modN_LE(head); // The actual private scalar
+            const point = G.multiply(scalar); // Point on Edwards curve aka public key
+            const pointBytes = point.toRawBytes(); // Uint8Array representation
+            return { head, prefix, scalar, point, pointBytes };
+        }
+        // Calculates EdDSA pub key. RFC8032 5.1.5. Privkey is hashed. Use first half with 3 bits cleared
+        function getPublicKey(privKey) {
+            return getExtendedPublicKey(privKey).pointBytes;
+        }
+        // int('LE', SHA512(dom2(F, C) || msgs)) mod N
+        function hashDomainToScalar(context = new Uint8Array(), ...msgs) {
+            const msg = concatBytes$2(...msgs);
+            return modN_LE(cHash(domain(msg, ensureBytes$1('context', context), !!prehash)));
+        }
+        /** Signs message with privateKey. RFC8032 5.1.6 */
+        function sign(msg, privKey, options = {}) {
+            msg = ensureBytes$1('message', msg);
+            if (prehash)
+                msg = prehash(msg); // for ed25519ph etc.
+            const { prefix, scalar, pointBytes } = getExtendedPublicKey(privKey);
+            const r = hashDomainToScalar(options.context, prefix, msg); // r = dom2(F, C) || prefix || PH(M)
+            const R = G.multiply(r).toRawBytes(); // R = rG
+            const k = hashDomainToScalar(options.context, R, pointBytes, msg); // R || A || PH(M)
+            const s = modN(r + k * scalar); // S = (r + k * s) mod L
+            assertGE0(s); // 0 <= s < l
+            const res = concatBytes$2(R, numberToBytesLE$1(s, Fp.BYTES));
+            return ensureBytes$1('result', res, nByteLength * 2); // 64-byte signature
+        }
+        const verifyOpts = VERIFY_DEFAULT;
+        function verify(sig, msg, publicKey, options = verifyOpts) {
+            const { context, zip215 } = options;
+            const len = Fp.BYTES; // Verifies EdDSA signature against message and public key. RFC8032 5.1.7.
+            sig = ensureBytes$1('signature', sig, 2 * len); // An extended group equation is checked.
+            msg = ensureBytes$1('message', msg);
+            if (prehash)
+                msg = prehash(msg); // for ed25519ph, etc
+            const s = bytesToNumberLE$1(sig.slice(len, 2 * len));
+            // zip215: true is good for consensus-critical apps and allows points < 2^256
+            // zip215: false follows RFC8032 / NIST186-5 and restricts points to CURVE.p
+            let A, R, SB;
+            try {
+                A = Point.fromHex(publicKey, zip215);
+                R = Point.fromHex(sig.slice(0, len), zip215);
+                SB = G.multiplyUnsafe(s); // 0 <= s < l is done inside
+            }
+            catch (error) {
+                return false;
+            }
+            if (!zip215 && A.isSmallOrder())
+                return false;
+            const k = hashDomainToScalar(context, R.toRawBytes(), A.toRawBytes(), msg);
+            const RkA = R.add(A.multiplyUnsafe(k));
+            // [8][S]B = [8]R + [8][k]A'
+            return RkA.subtract(SB).clearCofactor().equals(Point.ZERO);
+        }
+        G._setWindowSize(8); // Enable precomputes. Slows down first publicKey computation by 20ms.
+        const utils = {
+            getExtendedPublicKey,
+            // ed25519 private keys are uniform 32b. No need to check for modulo bias, like in secp256k1.
+            randomPrivateKey: () => randomBytes(Fp.BYTES),
+            /**
+             * We're doing scalar multiplication (used in getPublicKey etc) with precomputed BASE_POINT
+             * values. This slows down first getPublicKey() by milliseconds (see Speed section),
+             * but allows to speed-up subsequent getPublicKey() calls up to 20x.
+             * @param windowSize 2, 4, 8, 16
+             */
+            precompute(windowSize = 8, point = Point.BASE) {
+                point._setWindowSize(windowSize);
+                point.multiply(BigInt(3));
+                return point;
+            },
+        };
+        return {
+            CURVE,
+            getPublicKey,
+            sign,
+            verify,
+            ExtendedPoint: Point,
+            utils,
+        };
+    }
+
+    /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    /**
+     * ed25519 Twisted Edwards curve with following addons:
+     * - X25519 ECDH
+     * - Ristretto cofactor elimination
+     * - Elligator hash-to-group / point indistinguishability
+     */
+    const ED25519_P = BigInt('57896044618658097711785492504343953926634992332820282019728792003956564819949');
+    // √(-1) aka √(a) aka 2^((p-1)/4)
+    const ED25519_SQRT_M1 = BigInt('19681161376707505956807079304988542015446066515923890162744021073123829784752');
+    // prettier-ignore
+    BigInt(0); const _1n$6 = BigInt(1), _2n$4 = BigInt(2), _5n$1 = BigInt(5);
+    // prettier-ignore
+    const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
+    function ed25519_pow_2_252_3(x) {
+        const P = ED25519_P;
+        const x2 = (x * x) % P;
+        const b2 = (x2 * x) % P; // x^3, 11
+        const b4 = (pow2$1(b2, _2n$4, P) * b2) % P; // x^15, 1111
+        const b5 = (pow2$1(b4, _1n$6, P) * x) % P; // x^31
+        const b10 = (pow2$1(b5, _5n$1, P) * b5) % P;
+        const b20 = (pow2$1(b10, _10n, P) * b10) % P;
+        const b40 = (pow2$1(b20, _20n, P) * b20) % P;
+        const b80 = (pow2$1(b40, _40n, P) * b40) % P;
+        const b160 = (pow2$1(b80, _80n, P) * b80) % P;
+        const b240 = (pow2$1(b160, _80n, P) * b80) % P;
+        const b250 = (pow2$1(b240, _10n, P) * b10) % P;
+        const pow_p_5_8 = (pow2$1(b250, _2n$4, P) * x) % P;
+        // ^ To pow to (p+3)/8, multiply it by x.
+        return { pow_p_5_8, b2 };
+    }
+    function adjustScalarBytes(bytes) {
+        // Section 5: For X25519, in order to decode 32 random bytes as an integer scalar,
+        // set the three least significant bits of the first byte
+        bytes[0] &= 248; // 0b1111_1000
+        // and the most significant bit of the last to zero,
+        bytes[31] &= 127; // 0b0111_1111
+        // set the second most significant bit of the last byte to 1
+        bytes[31] |= 64; // 0b0100_0000
+        return bytes;
+    }
+    // sqrt(u/v)
+    function uvRatio(u, v) {
+        const P = ED25519_P;
+        const v3 = mod$2(v * v * v, P); // v³
+        const v7 = mod$2(v3 * v3 * v, P); // v⁷
+        // (p+3)/8 and (p-5)/8
+        const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
+        let x = mod$2(u * v3 * pow, P); // (uv³)(uv⁷)^(p-5)/8
+        const vx2 = mod$2(v * x * x, P); // vx²
+        const root1 = x; // First root candidate
+        const root2 = mod$2(x * ED25519_SQRT_M1, P); // Second root candidate
+        const useRoot1 = vx2 === u; // If vx² = u (mod p), x is a square root
+        const useRoot2 = vx2 === mod$2(-u, P); // If vx² = -u, set x <-- x * 2^((p-1)/4)
+        const noRoot = vx2 === mod$2(-u * ED25519_SQRT_M1, P); // There is no valid root, vx² = -u√(-1)
+        if (useRoot1)
+            x = root1;
+        if (useRoot2 || noRoot)
+            x = root2; // We return root2 anyway, for const-time
+        if (isNegativeLE(x, P))
+            x = mod$2(-x, P);
+        return { isValid: useRoot1 || useRoot2, value: x };
+    }
+    const Fp$1 = Field$1(ED25519_P, undefined, true);
+    const ed25519Defaults = {
+        // Param: a
+        a: BigInt(-1), // Fp.create(-1) is proper; our way still works and is faster
+        // d is equal to -121665/121666 over finite field.
+        // Negative number is P - number, and division is invert(number, P)
+        d: BigInt('37095705934669439343138083508754565189542113879843219016388785533085940283555'),
+        // Finite field 𝔽p over which we'll do calculations; 2n**255n - 19n
+        Fp: Fp$1,
+        // Subgroup order: how many points curve has
+        // 2n**252n + 27742317777372353535851937790883648493n;
+        n: BigInt('7237005577332262213973186563042994240857116359379907606001950938285454250989'),
+        // Cofactor
+        h: BigInt(8),
+        // Base point (x, y) aka generator point
+        Gx: BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'),
+        Gy: BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'),
+        hash: sha512$1,
+        randomBytes: randomBytes$1,
+        adjustScalarBytes,
+        // dom2
+        // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.
+        // Constant-time, u/√v
+        uvRatio,
+    };
+    const ed25519$1 = /* @__PURE__ */ twistedEdwards(ed25519Defaults);
+    // Hash To Curve Elligator2 Map (NOTE: different from ristretto255 elligator)
+    // NOTE: very important part is usage of FpSqrtEven for ELL2_C1_EDWARDS, since
+    // SageMath returns different root first and everything falls apart
+    const ELL2_C1 = (Fp$1.ORDER + BigInt(3)) / BigInt(8); // 1. c1 = (q + 3) / 8       # Integer arithmetic
+    Fp$1.pow(_2n$4, ELL2_C1); // 2. c2 = 2^c1
+    Fp$1.sqrt(Fp$1.neg(Fp$1.ONE)); // 3. c3 = sqrt(-1)
+    (Fp$1.ORDER - BigInt(5)) / BigInt(8); // 4. c4 = (q - 5) / 8       # Integer arithmetic
+    BigInt(486662);
+    FpSqrtEven(Fp$1, Fp$1.neg(BigInt(486664))); // sgn0(c1) MUST equal 0
+    // √(ad - 1)
+    BigInt('25063068953384623474111414158702152701244531502492656460079210482610430750235');
+    // 1 / √(a-d)
+    BigInt('54469307008909316920995813868745141605393597292927456921205312896311721017578');
+    // 1-d²
+    BigInt('1159843021668779879193775521855586647937357759715417654439879720876111806838');
+    // (d-1)²
+    BigInt('40440834346308536858101042469323190826248399146238708352240133220865137265952');
+    BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
+
+    /* eslint-disable @typescript-eslint/strict-boolean-expressions */
+    function parse$2(string, encoding, opts) {
+      var _opts$out;
+
+      if (opts === void 0) {
+        opts = {};
+      }
+
+      // Build the character lookup table:
+      if (!encoding.codes) {
+        encoding.codes = {};
+
+        for (var i = 0; i < encoding.chars.length; ++i) {
+          encoding.codes[encoding.chars[i]] = i;
+        }
+      } // The string must have a whole number of bytes:
+
+
+      if (!opts.loose && string.length * encoding.bits & 7) {
+        throw new SyntaxError('Invalid padding');
+      } // Count the padding bytes:
+
+
+      var end = string.length;
+
+      while (string[end - 1] === '=') {
+        --end; // If we get a whole number of bytes, there is too much padding:
+
+        if (!opts.loose && !((string.length - end) * encoding.bits & 7)) {
+          throw new SyntaxError('Invalid padding');
+        }
+      } // Allocate the output:
+
+
+      var out = new ((_opts$out = opts.out) != null ? _opts$out : Uint8Array)(end * encoding.bits / 8 | 0); // Parse the data:
+
+      var bits = 0; // Number of bits currently in the buffer
+
+      var buffer = 0; // Bits waiting to be written out, MSB first
+
+      var written = 0; // Next byte to write
+
+      for (var _i = 0; _i < end; ++_i) {
+        // Read one character from the string:
+        var value = encoding.codes[string[_i]];
+
+        if (value === undefined) {
+          throw new SyntaxError('Invalid character ' + string[_i]);
+        } // Append the bits to the buffer:
+
+
+        buffer = buffer << encoding.bits | value;
+        bits += encoding.bits; // Write out some bits if the buffer has a byte's worth:
+
+        if (bits >= 8) {
+          bits -= 8;
+          out[written++] = 0xff & buffer >> bits;
+        }
+      } // Verify that we have received just enough bits:
+
+
+      if (bits >= encoding.bits || 0xff & buffer << 8 - bits) {
+        throw new SyntaxError('Unexpected end of data');
+      }
+
+      return out;
+    }
+    function stringify$1(data, encoding, opts) {
+      if (opts === void 0) {
+        opts = {};
+      }
+
+      var _opts = opts,
+          _opts$pad = _opts.pad,
+          pad = _opts$pad === void 0 ? true : _opts$pad;
+      var mask = (1 << encoding.bits) - 1;
+      var out = '';
+      var bits = 0; // Number of bits currently in the buffer
+
+      var buffer = 0; // Bits waiting to be written out, MSB first
+
+      for (var i = 0; i < data.length; ++i) {
+        // Slurp data into the buffer:
+        buffer = buffer << 8 | 0xff & data[i];
+        bits += 8; // Write out as much as we can:
+
+        while (bits > encoding.bits) {
+          bits -= encoding.bits;
+          out += encoding.chars[mask & buffer >> bits];
+        }
+      } // Partial character:
+
+
+      if (bits) {
+        out += encoding.chars[mask & buffer << encoding.bits - bits];
+      } // Add padding characters until we hit a byte boundary:
+
+
+      if (pad) {
+        while (out.length * encoding.bits & 7) {
+          out += '=';
+        }
+      }
+
+      return out;
+    }
+    var base64Encoding = {
+      chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+      bits: 6
+    };
+    var base64UrlEncoding = {
+      chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
+      bits: 6
+    };
+    var base64$3 = {
+      parse: function parse$1(string, opts) {
+        return parse$2(string, base64Encoding, opts);
+      },
+      stringify: function stringify$1$1(data, opts) {
+        return stringify$1(data, base64Encoding, opts);
+      }
+    };
+    var base64url$1 = {
+      parse: function parse$1(string, opts) {
+        return parse$2(string, base64UrlEncoding, opts);
+      },
+      stringify: function stringify$1$1(data, opts) {
+        return stringify$1(data, base64UrlEncoding, opts);
+      }
+    };
+
+    const byteEncoder = new TextEncoder();
+    const byteDecoder = new TextDecoder();
+    function bytesToBase64url$1(b, opts = { pad: false }) {
+        return base64url$1.stringify(b, opts);
+    }
+    function base64ToBytes$1(s, opts = { loose: true }) {
+        return base64$3.parse(s, opts);
+    }
+    function bytesToBase64(b, opts = { pad: false }) {
+        return base64$3.stringify(b, opts);
+    }
+    function base64UrlToBytes(s, opts = { loose: true }) {
+        const inputBase64Url = s.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+        return base64url$1.parse(inputBase64Url, opts);
+    }
+    function base58ToBytes$1(s) {
+        return yE(s);
+    }
+    function bytesToBase58$1(b) {
+        return uE(b);
+    }
+    function hexToBytes$2(s) {
+        const input = s.startsWith('0x') ? s.substring(2) : s;
+        return b$5.decodeString(input.toLowerCase());
+    }
+    function encodeBase64url(s, opts = { pad: false }) {
+        return base64url$1.stringify(byteEncoder.encode(s), opts);
+    }
+    function decodeBase64url$1(s, opts = { loose: true }) {
+        return byteDecoder.decode(base64url$1.parse(s, opts));
+    }
+    function bytesToHex$2(b) {
+        return b$5.encodeString(b);
+    }
+
+    function mergeObjects(credSubject, otherCredSubject) {
+        let result = {};
+        const credSubjectKeys = Object.keys(credSubject);
+        for (const key of credSubjectKeys) {
+            if (typeof otherCredSubject[key] !== 'undefined') {
+                if (typeof credSubject[key] !== 'object' && typeof otherCredSubject[key] !== 'object') {
+                    throw new Error('Invalid query');
+                }
+                const subjectProperty = credSubject[key];
+                const otherSubjectProperty = otherCredSubject[key];
+                const propertyOperators = Object.keys(subjectProperty);
+                const subjectPropertyResult = {};
+                for (const operatorKey of propertyOperators) {
+                    if (typeof otherSubjectProperty[operatorKey] !== 'undefined') {
+                        const operatorValue1 = subjectProperty[operatorKey];
+                        const operatorValue2 = otherSubjectProperty[operatorKey];
+                        subjectPropertyResult[operatorKey] = [
+                            ...new Set([
+                                ...(subjectPropertyResult[operatorKey] ?? []),
+                                operatorValue1,
+                                ...(Array.isArray(operatorValue2) ? operatorValue2 : [operatorValue2])
+                            ])
+                        ];
+                    }
+                    else {
+                        subjectPropertyResult[operatorKey] = subjectProperty[operatorKey];
+                    }
+                }
+                result[key] = {
+                    ...otherCredSubject[key],
+                    ...subjectPropertyResult
+                };
+            }
+        }
+        // Add remaining keys from obj2
+        result = { ...credSubject, ...otherCredSubject, ...result };
+        return result;
+    }
+
+    const i$1=32,n$1=1,o$1=new Uint8Array(65),h$2="empty",l$2=32,w$2=BigInt("21888242871839275222246405745257275088548364400416034343698204186575808495617");w$2-BigInt("1");function g$2(t,e,i,s){if("a"===i&&!s)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof e?t!==e||!s:!e.has(t))throw new TypeError("Cannot read private member from an object whose class did not declare it");return "m"===i?s:"a"===i?s.call(t):s?s.value:e.get(t)}function v$2(t,e,i,s,n){if("m"===s)throw new TypeError("Private method is not writable");if("a"===s&&!n)throw new TypeError("Private accessor was defined without a setter");if("function"==typeof e?t!==e||!n:!e.has(t))throw new TypeError("Cannot write private member to an object whose class did not declare it");return "a"===s?n.call(t,i):n?n.value=i:e.set(t,i),i}const p$2=t=>t<w$2,b$3=(t,e)=>t.every(((t,i)=>t===e[i])),m$2=t=>t.slice().reverse(),x$2=t=>"0b"+t.reduce(((t,e)=>t+e.toString(2).padStart(8,"0")),""),A$2=(t,e)=>0!=(t[parseInt((e/8).toString())]&1<<e%8),I$2=(t,e)=>0!=(t[t.length-parseInt(""+e/8)-1]&1<<e%8),k$1=(t,e)=>{t[t.length-parseInt(""+e/8)-1]|=1<<e%8;},S$2="0123456789abcdef",R$1=t=>{const e=new Array(2*t.length);let i=0;return t.forEach((t=>{e[i]=S$2[parseInt((t>>4).toString(10))],e[i+1]=S$2[parseInt((15&t).toString(10))],i+=2;})),e.join("")},B$2=t=>new Uint8Array(2*t.length).map(((e,i)=>t.charCodeAt(i))),N$1=(t,e)=>{const i=new Array(t);for(let s=0;s<t;s+=1)i[s]=A$2(e,s);return i},U$1=t=>{const e=new ArrayBuffer(i$1*t.length),s=new Uint8Array(e);return t.forEach(((t,e)=>{s.set(t.value,e*i$1);})),s},K$2=t=>{const e=BigInt(256),s=new Uint8Array(i$1);let n=0;for(;t>BigInt(0);)s[31-n]=Number(t%e),t/=e,n+=1;return s};let V$1 = class V{constructor(t){if(t?.length){if(t.length!==i$1)throw new Error(`Expected 32 bytes, found ${t.length} bytes`);this.bytes=t;}else this.bytes=new Uint8Array(i$1);}get value(){return this.bytes}set value(t){if(t.length!==i$1)throw `Expected 32 bytes, found ${t.length} bytes`;this.bytes=m$2(t);}string(){return this.bigInt().toString(10)}hex(){return R$1(this.bytes)}equals(t){return b$3(this.value,t.value)}bigInt(){const t=m$2(this.value);return BigInt(x$2(t))}static fromString(t){try{return V.fromBigInt(BigInt(t))}catch(e){const i=JSON.parse(t),s=Uint8Array.from(Object.values(i.bytes));return new V(s)}}static fromBigInt(t){if(!p$2(t))throw new Error("NewBigIntFromHashBytes: Value not inside the Finite Field");const e=K$2(t);return new V(m$2(e))}static fromHex(e){return e?new V(b$5.decodeString(e)):M$2}toJSON(){return this.string()}};const M$2=new V$1,O$1=t=>V$1.fromString(t),_$1=t=>{const i=$$2.hash(t);return V$1.fromBigInt(i)},J$1=(t,i)=>{const s=$$2.hash([...i,t]);return V$1.fromBigInt(s)},P$1=(t,e)=>{for(let i=t.length;i<e;i+=1)t.push(M$2);return t};var T$2,H$1;let j$1 = class j{constructor(t){T$2.set(this,void 0),H$1.set(this,void 0),this.prefix=t,v$2(this,T$2,{},"f"),v$2(this,H$1,M$2,"f");}async get(t){const e=new Uint8Array([...this.prefix,...t]);return g$2(this,T$2,"f")[e.toString()]?g$2(this,T$2,"f")[e.toString()]:void 0}async put(t,e){const i=new Uint8Array([...this.prefix,...t]);g$2(this,T$2,"f")[i.toString()]=e;}async getRoot(){return g$2(this,H$1,"f")}async setRoot(t){v$2(this,H$1,t,"f");}};T$2=new WeakMap,H$1=new WeakMap;const z$2=async(t,e)=>J$1(BigInt(1),[t.bigInt(),e.bigInt()]),C$2=(t,e,i)=>{const s=new Uint8Array(65),n=K$2(e.bigInt()),r=K$2(i.bigInt());s[0]=t;for(let t=1;t<33;t+=1)s[t]=n[t-1];for(let t=33;t<=65;t+=1)s[t]=r[t-33];return s};var q$1,F$1,D$1,G$1;let Q$1 = class Q{constructor(t,e){q$1.set(this,void 0),this.type=1,this.entry=[t,e],v$2(this,q$1,M$2,"f");}async getKey(){return g$2(this,q$1,"f")===M$2?await z$2(this.entry[0],this.entry[1]):g$2(this,q$1,"f")}get value(){return C$2(this.type,this.entry[0],this.entry[1])}get string(){return `Leaf I:${this.entry[0]} D:${this.entry[1]}`}};q$1=new WeakMap;let X$1 = class X{constructor(t,e){F$1.set(this,void 0),this.type=0,this.childL=t,this.childR=e,v$2(this,F$1,M$2,"f");}async getKey(){return g$2(this,F$1,"f")===M$2?_$1([this.childL.bigInt(),this.childR.bigInt()]):g$2(this,F$1,"f")}get value(){return C$2(this.type,this.childL,this.childR)}get string(){return `Middle L:${this.childL} R:${this.childR}`}};F$1=new WeakMap;let Y$1 = class Y{constructor(){D$1.set(this,void 0),this.type=2,v$2(this,D$1,M$2,"f");}async getKey(){return M$2}get value(){return o$1}get string(){return h$2}};D$1=new WeakMap;let Z$1 = class Z{constructor(t){this._prefix=t,G$1.set(this,void 0);const e=localStorage.getItem(R$1(t));if(e){const t=JSON.parse(e);v$2(this,G$1,new V$1(Uint8Array.from(t)),"f");}else v$2(this,G$1,M$2,"f");}async get(t){const e=new Uint8Array([...this._prefix,...t]),i=R$1(e),s=localStorage.getItem(i);if(null===s)return;const n=JSON.parse(s);switch(n.type){case 2:return new Y$1;case 0:const t=new V$1(Uint8Array.from(n.childL)),e=new V$1(Uint8Array.from(n.childR));return new X$1(t,e);case 1:const i=new V$1(Uint8Array.from(n.entry[0])),s=new V$1(Uint8Array.from(n.entry[1]));return new Q$1(i,s)}throw `error: value found for key ${R$1(e)} is not of type Node`}async put(t,e){const i=new Uint8Array([...this._prefix,...t]),s=R$1(i),n={type:e.type};e instanceof X$1?(n.childL=Array.from(e.childL.bytes),n.childR=Array.from(e.childR.bytes)):e instanceof Q$1&&(n.entry=[Array.from(e.entry[0].bytes),Array.from(e.entry[1].bytes)]);const r=JSON.stringify(n);localStorage.setItem(s,r);}async getRoot(){return g$2(this,G$1,"f")}async setRoot(t){v$2(this,G$1,t,"f"),localStorage.setItem(R$1(this._prefix),JSON.stringify(Array.from(t.bytes)));}};function tt$1(t){return new Promise(((e,i)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>i(t.error);}))}function et$1(t,e){const i=indexedDB.open(t);i.onupgradeneeded=()=>i.result.createObjectStore(e);const s=tt$1(i);return (t,i)=>s.then((s=>i(s.transaction(e,t).objectStore(e))))}let it$1;function st$1(){return it$1||(it$1=et$1("keyval-store","keyval")),it$1}function nt$1(t,e=st$1()){return e("readonly",(e=>tt$1(e.get(t))))}function rt$1(t,e,i=st$1()){return i("readwrite",(i=>(i.put(e,t),tt$1(i.transaction))))}var at$1;G$1=new WeakMap;let lt$2 = class lt{constructor(t,e){this._prefix=t,at$1.set(this,void 0),v$2(this,at$1,M$2,"f"),this._prefixHash=R$1(t),this._store=et$1(`${e??lt.storageName}-db`,lt.storageName);}async get(t){const e=new Uint8Array([...this._prefix,...t]),i=R$1(e),s=await nt$1(i,this._store);if(null!=s){if(2===s.type)return new Y$1;if(0===s.type){const t=new V$1(Uint8Array.from(s.childL.bytes)),e=new V$1(Uint8Array.from(s.childR.bytes));return new X$1(t,e)}if(1===s.type){const t=new V$1(Uint8Array.from(s.entry[0].bytes)),e=new V$1(Uint8Array.from(s.entry[1].bytes));return new Q$1(t,e)}throw new Error(`error: value found for key ${i} is not of type Node`)}}async put(t,e){const i=new Uint8Array([...this._prefix,...t]),s=R$1(i);await rt$1(s,e,this._store);}async getRoot(){if(!g$2(this,at$1,"f").equals(M$2))return g$2(this,at$1,"f");const t=await nt$1(this._prefixHash,this._store);return v$2(this,at$1,t?new V$1(t.bytes):M$2,"f"),g$2(this,at$1,"f")}async setRoot(t){await rt$1(this._prefixHash,t,this._store),v$2(this,at$1,t,"f");}};at$1=new WeakMap,lt$2.storageName="merkle-tree";const vt$1=t=>t.map((t=>t.bigInt())),pt$1=t=>{const e=vt$1(t.data.value);let i=!0;return e.forEach((t=>{p$2(t)||(i=!1);})),i},mt$1="Key not found in the MerkleTree",At$1="reached maximum level of the merkle tree",It$1="found an invalid node in the DB",Rt$1="the entry index already exists in the tree",Lt$1="Merkle Tree not writable",Bt$1="key not found";let Nt$1 = class Nt{constructor(t=M$2,e=[],i=M$2,s=M$2,n=!1,r=M$2,a=M$2,o=0){this.root=t,this.siblings=e,this.oldKey=i,this.oldValue=s,this.isOld0=n,this.key=r,this.value=a,this.fnc=o;}};let Ut$1 = class Ut{constructor(t=M$2,e=M$2,i=[],s=M$2,n=M$2,r=M$2,a=M$2,o=!1,h=0){this.oldRoot=t,this.newRoot=e,this.siblings=i,this.oldKey=s,this.oldValue=n,this.newKey=r,this.newValue=a,this.isOld0=o,this.fnc=h;}};const Et$1="non-existence proof being checked against hIndex equal to nodeAux";let Kt$1 = class Kt{constructor(t){this.existence=t?.existence??!1,this.depth=t?.siblings.length??0,this.nodeAux=t?.nodeAux;const{siblings:e,notEmpties:i}=this.reduceSiblings(t?.siblings);this.siblings=e,this.notEmpties=i;}bytes(){let t=2+this.notEmpties.length+l$2*this.siblings.length;void 0!==this.nodeAux&&(t+=64);const e=new ArrayBuffer(t),i=new Uint8Array(e);this.existence||(i[0]|=1),i[1]=this.depth,i.set(this.notEmpties,2);const s=U$1(this.siblings);return i.set(s,this.notEmpties.length+2),void 0!==this.nodeAux&&(i[0]|=2,i.set(this.nodeAux.key.value,i.length-64),i.set(this.nodeAux.value.value,i.length-32)),i}toJSON(){return {existence:this.existence,siblings:this.allSiblings().map((t=>t.toJSON())),nodeAux:this.nodeAux?{key:this.nodeAux.key.toJSON(),value:this.nodeAux.value.toJSON()}:void 0}}reduceSiblings(t){const e=[],i=new Uint8Array(30);if(!t)return {siblings:e,notEmpties:i};for(let s=0;s<t.length;s++){const n=t[s];JSON.stringify(t[s])!==JSON.stringify(M$2)&&(k$1(i,s),e.push(n));}return {notEmpties:i,siblings:e}}static fromJSON(t){let e;t.nodeAux&&(e={key:V$1.fromString(t.nodeAux.key),value:V$1.fromString(t.nodeAux.value)});const i=t.existence??!1,s=t.siblings.map((t=>V$1.fromString(t)));return new Kt({existence:i,nodeAux:e,siblings:s})}allSiblings(){return Kt.buildAllSiblings(this.depth,this.notEmpties,this.siblings)}static buildAllSiblings(t,e,i){let s=0;const n=[];for(let r=0;r<t;r+=1)I$2(e,r)?(n.push(i[s]),s+=1):n.push(M$2);return n}};const Mt$1=async(t,e,i,s)=>{try{const n=await Wt$1(e,i,s);return b$3(t.value,n.value)}catch(t){if(t===Et$1)return !1;throw t}},Wt$1=async(t,e,i)=>{const s=V$1.fromBigInt(e),n=V$1.fromBigInt(i);let r;if(t.existence)r=await z$2(s,n);else if(void 0===t.nodeAux)r=M$2;else {const e=t.nodeAux;if(b$3(s.value,e.key.value))throw Et$1;r=await z$2(e.key,e.value);}const a=t.allSiblings(),o=N$1(a.length,s.value);for(let t=a.length-1;t>=0;t-=1)r=o[t]?await new X$1(a[t],r).getKey():await new X$1(r,a[t]).getKey();return r};var $t$1,Ot$1,_t$1,Jt$1;let Pt$1 = class Pt{constructor(t,e,i){$t$1.set(this,void 0),Ot$1.set(this,void 0),_t$1.set(this,void 0),Jt$1.set(this,void 0),v$2(this,$t$1,t,"f"),v$2(this,_t$1,e,"f"),v$2(this,Jt$1,i,"f");}async root(){return g$2(this,Ot$1,"f")||v$2(this,Ot$1,await g$2(this,$t$1,"f").getRoot(),"f"),g$2(this,Ot$1,"f")}get maxLevels(){return g$2(this,Jt$1,"f")}async add(t,e){if(!g$2(this,_t$1,"f"))throw Lt$1;v$2(this,Ot$1,await this.root(),"f");const i=V$1.fromBigInt(t),s=V$1.fromBigInt(e),n=new Q$1(i,s),r=N$1(this.maxLevels,i.value),a=await this.addLeaf(n,g$2(this,Ot$1,"f"),0,r);v$2(this,Ot$1,a,"f"),await g$2(this,$t$1,"f").setRoot(g$2(this,Ot$1,"f"));}async updateNode(t){if(!g$2(this,_t$1,"f"))throw Lt$1;if(2===t.type)return await t.getKey();const e=await t.getKey();return await g$2(this,$t$1,"f").put(e.value,t),e}async addNode(t){if(!g$2(this,_t$1,"f"))throw Lt$1;if(2===t.type)return await t.getKey();const e=await t.getKey();return await g$2(this,$t$1,"f").put(e.value,t),e}async addEntry(t){if(!g$2(this,_t$1,"f"))throw Lt$1;if(!pt$1(t))throw "elements not inside the finite field over r";v$2(this,Ot$1,await g$2(this,$t$1,"f").getRoot(),"f");const e=await t.hIndex(),i=await t.hValue(),s=new Q$1(e,i),n=N$1(this.maxLevels,e.value),r=await this.addLeaf(s,g$2(this,Ot$1,"f"),0,n);v$2(this,Ot$1,r,"f"),await g$2(this,$t$1,"f").setRoot(g$2(this,Ot$1,"f"));}async pushLeaf(t,e,i,s,n){if(i>g$2(this,Jt$1,"f")-2)throw new Error(At$1);let r;if(s[i]===n[i]){const a=await this.pushLeaf(t,e,i+1,s,n);return r=s[i]?new X$1(new V$1,a):new X$1(a,new V$1),await this.addNode(r)}const a=await e.getKey(),o=await t.getKey();return r=s[i]?new X$1(a,o):new X$1(o,a),await this.addNode(t),await this.addNode(r)}async addLeaf(t,e,i,s){if(i>g$2(this,Jt$1,"f")-1)throw new Error(At$1);const n=await this.getNode(e);if(void 0===n)throw Bt$1;switch(n.type){case 2:return this.addNode(t);case 1:{const e=n.entry[0],r=t.entry[0];if(b$3(e.value,r.value))throw Rt$1;const a=N$1(this.maxLevels,e.value);return this.pushLeaf(t,n,i,s,a)}case 0:{let e;if(s[i]){const r=await this.addLeaf(t,n.childR,i+1,s);e=new X$1(n.childL,r);}else {const r=await this.addLeaf(t,n.childL,i+1,s);e=new X$1(r,n.childR);}return this.addNode(e)}default:throw It$1}}async get(t){const e=V$1.fromBigInt(t),i=N$1(this.maxLevels,e.value);let s=await this.root();const n=[];for(let t=0;t<this.maxLevels;t++){const e=await this.getNode(s);if(void 0===e)throw mt$1;switch(e.type){case 2:return {key:BigInt("0"),value:BigInt("0"),siblings:n};case 1:return {key:e.entry[0].bigInt(),value:e.entry[1].bigInt(),siblings:n};case 0:i[t]?(s=e.childR,n.push(e.childL)):(s=e.childL,n.push(e.childR));break;default:throw It$1}}throw new Error(At$1)}async update(t,e){if(!g$2(this,_t$1,"f"))throw Lt$1;if(!p$2(t))throw "key not inside the finite field";if(!p$2(e))throw "key not inside the finite field";const i=V$1.fromBigInt(t),s=V$1.fromBigInt(e),n=N$1(this.maxLevels,i.value),r=new Ut$1;r.fnc=1,r.oldRoot=await this.root(),r.oldKey=i,r.newKey=i,r.newValue=s;let a=await this.root();const o=[];for(let t=0;t<this.maxLevels;t+=1){const e=await this.getNode(a);if(void 0===e)throw Bt$1;switch(e.type){case 2:throw mt$1;case 1:if(b$3(i.value,e.entry[0].value)){r.oldValue=e.entry[1],r.siblings=P$1([...o],this.maxLevels);const t=new Q$1(i,s);await this.updateNode(t);const a=await this.recalculatePathUntilRoot(n,t,o);return v$2(this,Ot$1,a,"f"),await g$2(this,$t$1,"f").setRoot(a),r.newRoot=a,r}break;case 0:n[t]?(a=e.childR,o.push(e.childL)):(a=e.childL,o.push(e.childR));break;default:throw It$1}}throw mt$1}async getNode(t){return b$3(t.value,M$2.value)?new Y$1:await g$2(this,$t$1,"f").get(t.value)}async recalculatePathUntilRoot(t,e,i){for(let s=i.length-1;s>=0;s-=1){const n=await e.getKey();e=t[s]?new X$1(i[s],n):new X$1(n,i[s]),await this.addNode(e);}return await e.getKey()}async delete(t){if(!g$2(this,_t$1,"f"))throw Lt$1;const e=V$1.fromBigInt(t),i=N$1(this.maxLevels,e.value);let s=g$2(this,Ot$1,"f");const n=[];for(let t=0;t<g$2(this,Jt$1,"f");t+=1){const r=await this.getNode(s);if(void 0===r)throw Bt$1;switch(r.type){case 2:throw mt$1;case 1:if(b$3(e.bytes,r.entry[0].value))return void await this.rmAndUpload(i,e,n);throw mt$1;case 0:i[t]?(s=r.childR,n.push(r.childL)):(s=r.childL,n.push(r.childR));break;default:throw It$1}}throw mt$1}async rmAndUpload(t,e,i){if(0===i.length)return v$2(this,Ot$1,M$2,"f"),void await g$2(this,$t$1,"f").setRoot(g$2(this,Ot$1,"f"));const s=i[i.length-1];i.length<2&&(v$2(this,Ot$1,i[0],"f"),await g$2(this,$t$1,"f").setRoot(g$2(this,Ot$1,"f")));for(let e=i.length-2;e>=0;e-=1){if(!b$3(i[e].value,M$2.value)){let n;n=t[e]?new X$1(i[e],s):new X$1(s,i[e]),await this.addNode(n);const r=await this.recalculatePathUntilRoot(t,n,i.slice(0,e));v$2(this,Ot$1,r,"f"),await g$2(this,$t$1,"f").setRoot(g$2(this,Ot$1,"f"));break}if(0===e){v$2(this,Ot$1,s,"f"),await g$2(this,$t$1,"f").setRoot(g$2(this,Ot$1,"f"));break}}}async recWalk(t,e){const i=await this.getNode(t);if(void 0===i)throw Bt$1;switch(i.type){case 2:case 1:await e(i);break;case 0:await e(i),await this.recWalk(i.childL,e),await this.recWalk(i.childR,e);break;default:throw It$1}}async walk(t,e){b$3(t.value,M$2.value)&&(t=await this.root()),await this.recWalk(t,e);}async generateCircomVerifierProof(t,e){const i=await this.generateSCVerifierProof(t,e);return i.siblings=P$1(i.siblings,this.maxLevels),i}async generateSCVerifierProof(t,e){b$3(e.value,M$2.value)&&(e=await this.root());const{proof:i,value:s}=await this.generateProof(t,e),n=new Nt$1;return n.root=e,n.siblings=i.allSiblings(),void 0!==i.nodeAux?(n.oldKey=i.nodeAux.key,n.oldValue=i.nodeAux.value):(n.oldKey=M$2,n.oldValue=M$2),n.key=V$1.fromBigInt(t),n.value=V$1.fromBigInt(s),i.existence?n.fnc=0:n.fnc=1,n}async generateProof(t,e){let i;const s=V$1.fromBigInt(t),n=N$1(this.maxLevels,s.value);e||(e=await this.root());let r=e,a=0,o=!1;const h=[];let l;for(a=0;a<this.maxLevels;a+=1){const t=await this.getNode(r);if(void 0===t)throw Bt$1;switch(t.type){case 2:return {proof:new Kt$1({existence:o,nodeAux:l,siblings:h}),value:BigInt("0")};case 1:return b$3(s.value,t.entry[0].value)?(o=!0,{proof:new Kt$1({existence:o,nodeAux:l,siblings:h}),value:t.entry[1].bigInt()}):(l={key:t.entry[0],value:t.entry[1]},{proof:new Kt$1({existence:o,nodeAux:l,siblings:h}),value:t.entry[1].bigInt()});case 0:n[a]?(r=t.childR,i=t.childL):(r=t.childL,i=t.childR);break;default:throw It$1}h.push(i);}throw mt$1}async addAndGetCircomProof(t,e){const i=new Ut$1;i.fnc=2,i.oldRoot=await this.root();let s=BigInt("0"),n=BigInt("0"),r=[];try{const e=await this.get(t);s=e.key,n=e.value,r=e.siblings;}catch(t){if(t!==mt$1)throw t}if(void 0===s||void 0===n)throw "key/value undefined";return i.oldKey=V$1.fromBigInt(s),i.oldValue=V$1.fromBigInt(n),b$3(i.oldKey.value,M$2.value)&&(i.isOld0=!0),i.siblings=P$1(r,this.maxLevels),await this.add(t,e),i.newKey=V$1.fromBigInt(t),i.newValue=V$1.fromBigInt(e),i.newRoot=await this.root(),i}async graphViz(t){let e=0;await this.walk(t,(async t=>{const i=await t.getKey();let s,n;switch(t.type){case 2:break;case 1:console.log(`"${i.string()}" [style=filled]`);break;case 0:s=[t.childL.string(),t.childR.string()],n="",s.forEach(((t,i)=>{"0"===t&&(s[i]=`empty${e}`,n+=`"${s[i]}" [style=dashed,label=0];\n`,e+=1);})),console.log(`"${i.string()}" -> {"${s[1]}"}`),console.log(n);}})),console.log("}\n");}async printGraphViz(t){b$3(t.value,M$2.value)&&(t=await this.root()),console.log(`--------\nGraphViz of the MerkleTree with RootKey ${t.bigInt().toString(10)}\n`),await this.graphViz(M$2),console.log(`End of GraphViz of the MerkleTree with RootKey ${t.bigInt().toString(10)}\n--------\n`);}};$t$1=new WeakMap,Ot$1=new WeakMap,_t$1=new WeakMap,Jt$1=new WeakMap;
+
+    /**
+     * Checks if state is genesis state
+     *
+     * @param {string} did - did
+     * @param {bigint|string} state  - hash on bigInt or hex string format
+     * @returns boolean
+     */
+    function isGenesisState(did, state) {
+        if (typeof state === 'string') {
+            state = V$1.fromHex(state).bigInt();
+        }
+        const id = W$2.idFromDID(did);
+        const { method, blockchain, networkId } = W$2.decodePartsFromId(id);
+        const type = P$2(method, blockchain, networkId);
+        const idFromState = k$2.idGenesisFromIdenState(type, state);
+        return id.bigInt().toString() === idFromState.bigInt().toString();
+    }
+    const buildVerifierId = (address, info) => {
+        address = address.replace('0x', '');
+        const ethAddrBytes = b$5.decodeString(address);
+        const ethAddr = ethAddrBytes.slice(0, 20);
+        const genesis = O$2(ethAddr);
+        const tp = P$2(info.method, info.blockchain, info.networkId);
+        return new k$2(tp, genesis);
+    };
+    const validateDIDDocumentAuth = async (did, resolverURL, state) => {
+        const vm = await resolveDIDDocumentAuth(did, resolverURL, state);
+        if (!vm) {
+            throw new Error(`can't resolve DID document`);
+        }
+        // published or genesis
+        if (!vm.published &&
+            !isGenesisState(did, state.bigInt())) {
+            throw new Error(`issuer state not published and not genesis`);
+        }
+    };
+    const resolveDIDDocumentAuth = async (did, resolveURL, state) => {
+        let url = `${resolveURL}/${did.string().replace(/:/g, '%3A')}`;
+        if (state) {
+            url += `?state=${state.hex()}`;
+        }
+        const resp = await fetch(url);
+        const didResolutionRes = (await resp.json());
+        return didResolutionRes.didDocument?.verificationMethod?.find((i) => i.type === 'Iden3StateInfo2023');
+    };
+
     var commonjsGlobal$1 = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
     function getDefaultExportFromCjs$1 (x) {
@@ -239,6 +2074,506 @@ var PolygonIdSdk = (function (exports) {
     	return a;
     }
 
+    var pubsub = {exports: {}};
+
+    /**
+     * Copyright (c) 2010,2011,2012,2013,2014 Morgan Roderick http://roderick.dk
+     * License: MIT - http://mrgnrdrck.mit-license.org
+     *
+     * https://github.com/mroderick/PubSubJS
+     */
+
+    (function (module, exports) {
+    	(function (root, factory){
+
+    	    var PubSub = {};
+
+    	    if (root.PubSub) {
+    	        PubSub = root.PubSub;
+    	        console.warn("PubSub already loaded, using existing version");
+    	    } else {
+    	        root.PubSub = PubSub;
+    	        factory(PubSub);
+    	    }
+    	    // CommonJS and Node.js module support
+    	    {
+    	        if (module !== undefined && module.exports) {
+    	            exports = module.exports = PubSub; // Node.js specific `module.exports`
+    	        }
+    	        exports.PubSub = PubSub; // CommonJS module 1.1.1 spec
+    	        module.exports = exports = PubSub; // CommonJS
+    	    }
+
+    	}(( typeof window === 'object' && window ) || commonjsGlobal$1, function (PubSub){
+
+    	    var messages = {},
+    	        lastUid = -1,
+    	        ALL_SUBSCRIBING_MSG = '*';
+
+    	    function hasKeys(obj){
+    	        var key;
+
+    	        for (key in obj){
+    	            if ( Object.prototype.hasOwnProperty.call(obj, key) ){
+    	                return true;
+    	            }
+    	        }
+    	        return false;
+    	    }
+
+    	    /**
+    	     * Returns a function that throws the passed exception, for use as argument for setTimeout
+    	     * @alias throwException
+    	     * @function
+    	     * @param { Object } ex An Error object
+    	     */
+    	    function throwException( ex ){
+    	        return function reThrowException(){
+    	            throw ex;
+    	        };
+    	    }
+
+    	    function callSubscriberWithDelayedExceptions( subscriber, message, data ){
+    	        try {
+    	            subscriber( message, data );
+    	        } catch( ex ){
+    	            setTimeout( throwException( ex ), 0);
+    	        }
+    	    }
+
+    	    function callSubscriberWithImmediateExceptions( subscriber, message, data ){
+    	        subscriber( message, data );
+    	    }
+
+    	    function deliverMessage( originalMessage, matchedMessage, data, immediateExceptions ){
+    	        var subscribers = messages[matchedMessage],
+    	            callSubscriber = immediateExceptions ? callSubscriberWithImmediateExceptions : callSubscriberWithDelayedExceptions,
+    	            s;
+
+    	        if ( !Object.prototype.hasOwnProperty.call( messages, matchedMessage ) ) {
+    	            return;
+    	        }
+
+    	        for (s in subscribers){
+    	            if ( Object.prototype.hasOwnProperty.call(subscribers, s)){
+    	                callSubscriber( subscribers[s], originalMessage, data );
+    	            }
+    	        }
+    	    }
+
+    	    function createDeliveryFunction( message, data, immediateExceptions ){
+    	        return function deliverNamespaced(){
+    	            var topic = String( message ),
+    	                position = topic.lastIndexOf( '.' );
+
+    	            // deliver the message as it is now
+    	            deliverMessage(message, message, data, immediateExceptions);
+
+    	            // trim the hierarchy and deliver message to each level
+    	            while( position !== -1 ){
+    	                topic = topic.substr( 0, position );
+    	                position = topic.lastIndexOf('.');
+    	                deliverMessage( message, topic, data, immediateExceptions );
+    	            }
+
+    	            deliverMessage(message, ALL_SUBSCRIBING_MSG, data, immediateExceptions);
+    	        };
+    	    }
+
+    	    function hasDirectSubscribersFor( message ) {
+    	        var topic = String( message ),
+    	            found = Boolean(Object.prototype.hasOwnProperty.call( messages, topic ) && hasKeys(messages[topic]));
+
+    	        return found;
+    	    }
+
+    	    function messageHasSubscribers( message ){
+    	        var topic = String( message ),
+    	            found = hasDirectSubscribersFor(topic) || hasDirectSubscribersFor(ALL_SUBSCRIBING_MSG),
+    	            position = topic.lastIndexOf( '.' );
+
+    	        while ( !found && position !== -1 ){
+    	            topic = topic.substr( 0, position );
+    	            position = topic.lastIndexOf( '.' );
+    	            found = hasDirectSubscribersFor(topic);
+    	        }
+
+    	        return found;
+    	    }
+
+    	    function publish( message, data, sync, immediateExceptions ){
+    	        message = (typeof message === 'symbol') ? message.toString() : message;
+
+    	        var deliver = createDeliveryFunction( message, data, immediateExceptions ),
+    	            hasSubscribers = messageHasSubscribers( message );
+
+    	        if ( !hasSubscribers ){
+    	            return false;
+    	        }
+
+    	        if ( sync === true ){
+    	            deliver();
+    	        } else {
+    	            setTimeout( deliver, 0 );
+    	        }
+    	        return true;
+    	    }
+
+    	    /**
+    	     * Publishes the message, passing the data to it's subscribers
+    	     * @function
+    	     * @alias publish
+    	     * @param { String } message The message to publish
+    	     * @param {} data The data to pass to subscribers
+    	     * @return { Boolean }
+    	     */
+    	    PubSub.publish = function( message, data ){
+    	        return publish( message, data, false, PubSub.immediateExceptions );
+    	    };
+
+    	    /**
+    	     * Publishes the message synchronously, passing the data to it's subscribers
+    	     * @function
+    	     * @alias publishSync
+    	     * @param { String } message The message to publish
+    	     * @param {} data The data to pass to subscribers
+    	     * @return { Boolean }
+    	     */
+    	    PubSub.publishSync = function( message, data ){
+    	        return publish( message, data, true, PubSub.immediateExceptions );
+    	    };
+
+    	    /**
+    	     * Subscribes the passed function to the passed message. Every returned token is unique and should be stored if you need to unsubscribe
+    	     * @function
+    	     * @alias subscribe
+    	     * @param { String } message The message to subscribe to
+    	     * @param { Function } func The function to call when a new message is published
+    	     * @return { String }
+    	     */
+    	    PubSub.subscribe = function( message, func ){
+    	        if ( typeof func !== 'function'){
+    	            return false;
+    	        }
+
+    	        message = (typeof message === 'symbol') ? message.toString() : message;
+
+    	        // message is not registered yet
+    	        if ( !Object.prototype.hasOwnProperty.call( messages, message ) ){
+    	            messages[message] = {};
+    	        }
+
+    	        // forcing token as String, to allow for future expansions without breaking usage
+    	        // and allow for easy use as key names for the 'messages' object
+    	        var token = 'uid_' + String(++lastUid);
+    	        messages[message][token] = func;
+
+    	        // return token for unsubscribing
+    	        return token;
+    	    };
+
+    	    PubSub.subscribeAll = function( func ){
+    	        return PubSub.subscribe(ALL_SUBSCRIBING_MSG, func);
+    	    };
+
+    	    /**
+    	     * Subscribes the passed function to the passed message once
+    	     * @function
+    	     * @alias subscribeOnce
+    	     * @param { String } message The message to subscribe to
+    	     * @param { Function } func The function to call when a new message is published
+    	     * @return { PubSub }
+    	     */
+    	    PubSub.subscribeOnce = function( message, func ){
+    	        var token = PubSub.subscribe( message, function(){
+    	            // before func apply, unsubscribe message
+    	            PubSub.unsubscribe( token );
+    	            func.apply( this, arguments );
+    	        });
+    	        return PubSub;
+    	    };
+
+    	    /**
+    	     * Clears all subscriptions
+    	     * @function
+    	     * @public
+    	     * @alias clearAllSubscriptions
+    	     */
+    	    PubSub.clearAllSubscriptions = function clearAllSubscriptions(){
+    	        messages = {};
+    	    };
+
+    	    /**
+    	     * Clear subscriptions by the topic
+    	     * @function
+    	     * @public
+    	     * @alias clearAllSubscriptions
+    	     * @return { int }
+    	     */
+    	    PubSub.clearSubscriptions = function clearSubscriptions(topic){
+    	        var m;
+    	        for (m in messages){
+    	            if (Object.prototype.hasOwnProperty.call(messages, m) && m.indexOf(topic) === 0){
+    	                delete messages[m];
+    	            }
+    	        }
+    	    };
+
+    	    /**
+    	       Count subscriptions by the topic
+    	     * @function
+    	     * @public
+    	     * @alias countSubscriptions
+    	     * @return { Array }
+    	    */
+    	    PubSub.countSubscriptions = function countSubscriptions(topic){
+    	        var m;
+    	        // eslint-disable-next-line no-unused-vars
+    	        var token;
+    	        var count = 0;
+    	        for (m in messages) {
+    	            if (Object.prototype.hasOwnProperty.call(messages, m) && m.indexOf(topic) === 0) {
+    	                for (token in messages[m]) {
+    	                    count++;
+    	                }
+    	                break;
+    	            }
+    	        }
+    	        return count;
+    	    };
+
+
+    	    /**
+    	       Gets subscriptions by the topic
+    	     * @function
+    	     * @public
+    	     * @alias getSubscriptions
+    	    */
+    	    PubSub.getSubscriptions = function getSubscriptions(topic){
+    	        var m;
+    	        var list = [];
+    	        for (m in messages){
+    	            if (Object.prototype.hasOwnProperty.call(messages, m) && m.indexOf(topic) === 0){
+    	                list.push(m);
+    	            }
+    	        }
+    	        return list;
+    	    };
+
+    	    /**
+    	     * Removes subscriptions
+    	     *
+    	     * - When passed a token, removes a specific subscription.
+    	     *
+    		 * - When passed a function, removes all subscriptions for that function
+    	     *
+    		 * - When passed a topic, removes all subscriptions for that topic (hierarchy)
+    	     * @function
+    	     * @public
+    	     * @alias subscribeOnce
+    	     * @param { String | Function } value A token, function or topic to unsubscribe from
+    	     * @example // Unsubscribing with a token
+    	     * var token = PubSub.subscribe('mytopic', myFunc);
+    	     * PubSub.unsubscribe(token);
+    	     * @example // Unsubscribing with a function
+    	     * PubSub.unsubscribe(myFunc);
+    	     * @example // Unsubscribing from a topic
+    	     * PubSub.unsubscribe('mytopic');
+    	     */
+    	    PubSub.unsubscribe = function(value){
+    	        var descendantTopicExists = function(topic) {
+    	                var m;
+    	                for ( m in messages ){
+    	                    if ( Object.prototype.hasOwnProperty.call(messages, m) && m.indexOf(topic) === 0 ){
+    	                        // a descendant of the topic exists:
+    	                        return true;
+    	                    }
+    	                }
+
+    	                return false;
+    	            },
+    	            isTopic    = typeof value === 'string' && ( Object.prototype.hasOwnProperty.call(messages, value) || descendantTopicExists(value) ),
+    	            isToken    = !isTopic && typeof value === 'string',
+    	            isFunction = typeof value === 'function',
+    	            result = false,
+    	            m, message, t;
+
+    	        if (isTopic){
+    	            PubSub.clearSubscriptions(value);
+    	            return;
+    	        }
+
+    	        for ( m in messages ){
+    	            if ( Object.prototype.hasOwnProperty.call( messages, m ) ){
+    	                message = messages[m];
+
+    	                if ( isToken && message[value] ){
+    	                    delete message[value];
+    	                    result = value;
+    	                    // tokens are unique, so we can just stop here
+    	                    break;
+    	                }
+
+    	                if (isFunction) {
+    	                    for ( t in message ){
+    	                        if (Object.prototype.hasOwnProperty.call(message, t) && message[t] === value){
+    	                            delete message[t];
+    	                            result = true;
+    	                        }
+    	                    }
+    	                }
+    	            }
+    	        }
+
+    	        return result;
+    	    };
+    	})); 
+    } (pubsub, pubsub.exports));
+
+    var pubsubExports = pubsub.exports;
+    var PubSub = /*@__PURE__*/getDefaultExportFromCjs$1(pubsubExports);
+
+    const SDK_EVENTS = {
+        TX_RECEIPT_ACCEPTED: 'TX_RECEIPT_ACCEPTED'
+    };
+    /**
+     * Represents a message bus that allows publishing and subscribing to topics.
+     */
+    class MessageBus {
+        /**
+         * Private constructor for the MessageBus class.
+         */
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        constructor() { }
+        /**
+         * Returns the singleton instance of the MessageBus class.
+         * If the instance doesn't exist, it creates a new one.
+         * @returns The singleton instance of the MessageBus class.
+         */
+        static getInstance() {
+            // If the instance doesn't exist, create it
+            if (!MessageBus.instance) {
+                MessageBus.instance = new MessageBus();
+            }
+            // Return the instance
+            return MessageBus.instance;
+        }
+        /**
+         * Publishes a message to the specified topic.
+         *
+         * @template T - The type of data being published.
+         * @param {SdkTopic} topic - The topic to publish the message to.
+         * @param {T} data - The data to be published.
+         * @returns {boolean} - Returns true if the message was successfully published, false otherwise.
+         */
+        publish(topic, data) {
+            return PubSub.publish(topic.toString(), data);
+        }
+        /**
+         * Subscribes to a specific topic and registers a callback function to be executed when a message is published.
+         *
+         * @param topic - The topic to subscribe to.
+         * @param callback - The callback function to be executed when a message is published.
+         */
+        subscribe(topic, callback) {
+            return PubSub.subscribe(topic.toString(), (_, data) => callback(data));
+        }
+        /**
+         * Subscribes to a specific topic and registers a callback function to be executed when a message is published.
+         * The callback function is executed only once.
+         *
+         * @param topic - The topic to subscribe to.
+         * @param callback - The callback function to be executed when a message is published.
+         */
+        subscribeOnce(topic, callback) {
+            PubSub.subscribeOnce(topic.toString(), (_, data) => callback(data));
+        }
+        /**
+         * Unsubscribes from a specific topic in the message bus.
+         *
+         * @param topic - The topic to unsubscribe from.
+         * @returns A string or boolean indicating the success of the unsubscribe operation.
+         */
+        unsubscribe(topic) {
+            return PubSub.unsubscribe(topic.toString());
+        }
+    }
+
+    const bigIntCompare = (a, b) => {
+        if (a < b)
+            return -1;
+        if (a > b)
+            return 1;
+        return 0;
+    };
+
+    /**
+     * Provider for Ed25519 keys
+     * @public
+     * @class Ed25519Provider
+     * @implements IKeyProvider interface
+     */
+    class Ed25519Provider {
+        /**
+         * Creates an instance of Ed25519Provider.
+         * @param {KmsKeyType} keyType - kms key type
+         * @param {AbstractPrivateKeyStore} keyStore - key store for kms
+         */
+        constructor(keyType, _keyStore) {
+            this.keyType = keyType;
+            this._keyStore = _keyStore;
+        }
+        /**
+         * generates a ed25519 key from a seed phrase
+         * @param {Uint8Array} seed - byte array seed
+         * @returns {Promise<KmsKeyId>} kms key identifier
+         */
+        async newPrivateKeyFromSeed(seed) {
+            if (seed.length !== 32) {
+                throw new Error('Seed should be 32 bytes');
+            }
+            const publicKey = ed25519$1.getPublicKey(seed);
+            const kmsId = {
+                type: this.keyType,
+                id: keyPath(this.keyType, bytesToHex$2(publicKey))
+            };
+            await this._keyStore.importKey({
+                alias: kmsId.id,
+                key: bytesToHex$2(seed)
+            });
+            return kmsId;
+        }
+        /**
+         * Gets public key by kmsKeyId
+         * @param {KmsKeyId} keyId - key identifier
+         * @returns {Promise<string>} Public key as a hex string
+         */
+        async publicKey(keyId) {
+            const privateKeyHex = await this.privateKey(keyId);
+            const publicKey = ed25519$1.getPublicKey(privateKeyHex);
+            return bytesToHex$2(publicKey);
+        }
+        /**
+         * signs prepared payload of size,
+         * with a key id
+         * @param {KmsKeyId} keyId  - key identifier
+         * @param {Uint8Array} data - data to sign (32 bytes)
+         * @returns {Promise<Uint8Array>} signature
+         */
+        async sign(keyId, data) {
+            const privateKeyHex = await this.privateKey(keyId);
+            return ed25519$1.sign(data, privateKeyHex);
+        }
+        /**
+         * Retrieves the private key for a given keyId from the key store.
+         * @param {KmsKeyId} keyId - The identifier of the key to retrieve.
+         * @returns {Promise<string>} The private key associated with the keyId.
+         */
+        async privateKey(keyId) {
+            return this._keyStore.get({ alias: keyId.id });
+        }
+    }
+
     var elliptic$1 = {};
 
     var name = "elliptic";
@@ -7052,7 +9387,7 @@ var PolygonIdSdk = (function (exports) {
       for (var j = 0; j < 80; j++) {
         var T = sum32(
           rotl32(
-            sum32_4(A, f$3(j, B, C, D), msg[r[j] + start], K$2(j)),
+            sum32_4(A, f$3(j, B, C, D), msg[r[j] + start], K$1(j)),
             s$1[j]),
           E);
         A = E;
@@ -7099,7 +9434,7 @@ var PolygonIdSdk = (function (exports) {
         return x ^ (y | (~z));
     }
 
-    function K$2(j) {
+    function K$1(j) {
       if (j <= 15)
         return 0x00000000;
       else if (j <= 31)
@@ -9629,7 +11964,7 @@ var PolygonIdSdk = (function (exports) {
         base58flickr: base58flickr
     });
 
-    const base64$2 = rfc4648({
+    const base64$1 = rfc4648({
       prefix: 'm',
       name: 'base64',
       alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
@@ -9641,7 +11976,7 @@ var PolygonIdSdk = (function (exports) {
       alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
       bitsPerChar: 6
     });
-    const base64url$1 = rfc4648({
+    const base64url = rfc4648({
       prefix: 'u',
       name: 'base64url',
       alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
@@ -9654,11 +11989,11 @@ var PolygonIdSdk = (function (exports) {
       bitsPerChar: 6
     });
 
-    var base64$3 = /*#__PURE__*/Object.freeze({
+    var base64$2 = /*#__PURE__*/Object.freeze({
         __proto__: null,
-        base64: base64$2,
+        base64: base64$1,
         base64pad: base64pad,
-        base64url: base64url$1,
+        base64url: base64url,
         base64urlpad: base64urlpad
     });
 
@@ -9709,7 +12044,7 @@ var PolygonIdSdk = (function (exports) {
       ...base32$1,
       ...base36$1,
       ...base58,
-      ...base64$3,
+      ...base64$2,
       ...base256emoji$1
     };
 
@@ -13027,27 +15362,27 @@ var PolygonIdSdk = (function (exports) {
     var bech32 = dist$1.bech32 = getLibraryFromEncoding('bech32');
     dist$1.bech32m = getLibraryFromEncoding('bech32m');
 
-    function bytesToBase64url$1(b) {
+    function bytesToBase64url(b) {
       return toString$6(b, 'base64url');
     }
-    function base64ToBytes$1(s) {
+    function base64ToBytes(s) {
       const inputBase64Url = s.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
       return fromString$1(inputBase64Url, 'base64url');
     }
-    function base58ToBytes$1(s) {
+    function base58ToBytes(s) {
       return fromString$1(s, 'base58btc');
     }
-    function bytesToBase58$1(b) {
+    function bytesToBase58(b) {
       return toString$6(b, 'base58btc');
     }
-    function hexToBytes$2(s) {
+    function hexToBytes$1(s) {
       const input = s.startsWith('0x') ? s.substring(2) : s;
       return fromString$1(input.toLowerCase(), 'base16');
     }
-    function decodeBase64url$1(s) {
-      return toString$6(base64ToBytes$1(s));
+    function decodeBase64url(s) {
+      return toString$6(base64ToBytes(s));
     }
-    function bytesToHex$2(b) {
+    function bytesToHex$1(b) {
       return toString$6(b, 'base16');
     }
     function stringToBytes$1(s) {
@@ -13070,7 +15405,7 @@ var PolygonIdSdk = (function (exports) {
         jose[64] = recoveryParam;
       }
 
-      return bytesToBase64url$1(jose);
+      return bytesToBase64url(jose);
     }
     function leftpad(data, size = 64) {
       if (data.length === size) return data;
@@ -13146,1137 +15481,451 @@ var PolygonIdSdk = (function (exports) {
             if (carry > 0) this._length[j] -= 0x0100000000 * carry;
           }
 
-          return this;
-        };
-
-        this.digest = () => {
-          if (this._finalized) throw new Error('Digest already called');
-          this._finalized = true;
-
-          const digest = this._digest(); // reset state
-
-
-          this._block.fill(0);
-
-          this._blockOffset = 0;
-
-          for (let i = 0; i < 4; ++i) this._length[i] = 0;
-
-          return digest;
-        };
-
-        this._update = () => {
-          const words = new Array(16);
-          const temp = new DataView(this._block.buffer);
-
-          for (let j = 0; j < 16; ++j) words[j] = words[j] = temp.getInt32(j * 4, true);
-
-          let al = this._a | 0;
-          let bl = this._b | 0;
-          let cl = this._c | 0;
-          let dl = this._d | 0;
-          let el = this._e | 0;
-          let ar = this._a | 0;
-          let br = this._b | 0;
-          let cr = this._c | 0;
-          let dr = this._d | 0;
-          let er = this._e | 0; // computation
-
-          for (let i = 0; i < 80; i += 1) {
-            let tl;
-            let tr;
-
-            if (i < 16) {
-              tl = fn1(al, bl, cl, dl, el, words[zl$1[i]], hl$1[0], sl$1[i]);
-              tr = fn5(ar, br, cr, dr, er, words[zr$1[i]], hr$1[0], sr$1[i]);
-            } else if (i < 32) {
-              tl = fn2(al, bl, cl, dl, el, words[zl$1[i]], hl$1[1], sl$1[i]);
-              tr = fn4(ar, br, cr, dr, er, words[zr$1[i]], hr$1[1], sr$1[i]);
-            } else if (i < 48) {
-              tl = fn3(al, bl, cl, dl, el, words[zl$1[i]], hl$1[2], sl$1[i]);
-              tr = fn3(ar, br, cr, dr, er, words[zr$1[i]], hr$1[2], sr$1[i]);
-            } else if (i < 64) {
-              tl = fn4(al, bl, cl, dl, el, words[zl$1[i]], hl$1[3], sl$1[i]);
-              tr = fn2(ar, br, cr, dr, er, words[zr$1[i]], hr$1[3], sr$1[i]);
-            } else {
-              // if (i<80) {
-              tl = fn5(al, bl, cl, dl, el, words[zl$1[i]], hl$1[4], sl$1[i]);
-              tr = fn1(ar, br, cr, dr, er, words[zr$1[i]], hr$1[4], sr$1[i]);
-            }
-
-            al = el;
-            el = dl;
-            dl = rotl(cl, 10);
-            cl = bl;
-            bl = tl;
-            ar = er;
-            er = dr;
-            dr = rotl(cr, 10);
-            cr = br;
-            br = tr;
-          } // update state
-
-
-          const t = this._b + cl + dr | 0;
-          this._b = this._c + dl + er | 0;
-          this._c = this._d + el + ar | 0;
-          this._d = this._e + al + br | 0;
-          this._e = this._a + bl + cr | 0;
-          this._a = t;
-        };
-
-        this._digest = () => {
-          // create padding and handle blocks
-          this._block[this._blockOffset++] = 0x80;
-
-          if (this._blockOffset > 56) {
-            this._block.fill(0, this._blockOffset, 64);
-
-            this._update();
-
-            this._blockOffset = 0;
-          }
-
-          this._block.fill(0, this._blockOffset, 56);
-
-          const temp = new DataView(this._block.buffer);
-          temp.setUint32(56, this._length[0], true);
-          temp.setUint32(60, this._length[1], true);
-          this._block = new Uint8Array(temp.buffer);
-
-          this._update(); // produce result
-
-
-          const buffer = new DataView(new Uint8Array(20).buffer);
-          buffer.setInt32(0, this._a, true);
-          buffer.setInt32(4, this._b, true);
-          buffer.setInt32(8, this._c, true);
-          buffer.setInt32(12, this._d, true);
-          buffer.setInt32(16, this._e, true);
-          return new Uint8Array(buffer.buffer);
-        };
-
-        this._block = new Uint8Array(blockSize);
-        this._blockSize = blockSize;
-        this._blockOffset = 0;
-        this._length = [0, 0, 0, 0];
-        this._finalized = false;
-      }
-
-    }
-
-    function sha256$1(payload) {
-      const data = typeof payload === 'string' ? fromString$1(payload) : payload;
-      return sha256$2.hash(data);
-    }
-    function keccak(data) {
-      return new Uint8Array(sha3$2.keccak_256.arrayBuffer(data));
-    }
-    function toEthereumAddress(hexPublicKey) {
-      const hashInput = fromString$1(hexPublicKey.slice(2), 'base16');
-      return `0x${toString$6(keccak(hashInput).slice(-20), 'base16')}`;
-    }
-    function ripemd160(data) {
-      return new Ripemd160().update(data).digest();
-    }
-
-    const secp256k1$1$1 = new elliptic.ec('secp256k1');
-    /**
-     *  Creates a configured signer function for signing data using the ES256K (secp256k1 + sha256) algorithm.
-     *
-     *  The signing function itself takes the data as a `Uint8Array` or `string` and returns a `base64Url`-encoded signature
-     *
-     *  @example
-     *  ```typescript
-     *  const sign: Signer = ES256KSigner(process.env.PRIVATE_KEY)
-     *  const signature: string = await sign(data)
-     *  ```
-     *
-     *  @param    {String}    privateKey   a private key as `Uint8Array`
-     *  @param    {Boolean}   recoverable  an optional flag to add the recovery param to the generated signatures
-     *  @return   {Function}               a configured signer function `(data: string | Uint8Array): Promise<string>`
-     */
-
-    function ES256KSigner(privateKey, recoverable = false) {
-      const privateKeyBytes = privateKey;
-
-      if (privateKeyBytes.length !== 32) {
-        throw new Error(`bad_key: Invalid private key format. Expecting 32 bytes, but got ${privateKeyBytes.length}`);
-      }
-
-      const keyPair = secp256k1$1$1.keyFromPrivate(privateKeyBytes);
-      return function (data) {
-        try {
-          const {
-            r,
-            s,
-            recoveryParam
-          } = keyPair.sign(sha256$1(data));
-          return Promise.resolve(toJose({
-            r: leftpad(r.toString('hex')),
-            s: leftpad(s.toString('hex')),
-            recoveryParam
-          }, recoverable));
-        } catch (e) {
-          return Promise.reject(e);
-        }
-      };
-    }
-
-    new elliptic.ec('p256');
-
-    const publicKeyToAddress$1 = (publicKey, otherAddress) => {
-      // Use the same version/prefix byte as the given address.
-      const version = toString$6(base58ToBytes$1(otherAddress).slice(0, 1), 'hex');
-      const publicKeyBuffer = fromString$1(publicKey, 'hex');
-      const publicKeyHash = ripemd160(sha256$1(publicKeyBuffer));
-      const step1 = version + toString$6(publicKeyHash, 'hex');
-      const step2 = sha256$1(fromString$1(step1, 'hex'));
-      const step3 = sha256$1(step2);
-      const checksum = toString$6(step3, 'hex').substring(0, 8);
-      const step4 = step1 + checksum;
-      return bytesToBase58$1(fromString$1(step4, 'hex'));
-    };
-
-    const EC = elliptic.ec;
-    const publicKeyToAddress = (publicKey, prefix) => {
-      const ec = new EC('secp256k1');
-      const compressedPublicKey = ec.keyFromPublic(publicKey, 'hex').getPublic().encode('hex', true);
-      const publicKeyBuffer = fromString$1(compressedPublicKey, 'hex');
-      const hash = ripemd160(sha256$1(publicKeyBuffer));
-      const words = bech32.toWords(hash);
-      return bech32.encode(prefix, words).replace(prefix, '');
-    };
-
-    const verifyBlockchainAccountId = (publicKey, blockchainAccountId) => {
-      if (blockchainAccountId) {
-        const chain = blockchainAccountId.split(':');
-
-        switch (chain[0]) {
-          case 'bip122':
-            chain[chain.length - 1] = publicKeyToAddress$1(publicKey, chain[chain.length - 1]);
-            break;
-
-          case 'cosmos':
-            chain[chain.length - 1] = publicKeyToAddress(publicKey, chain[1]);
-            break;
-
-          case 'eip155':
-            chain[chain.length - 1] = toEthereumAddress(publicKey);
-            break;
-
-          default:
-            return false;
-        }
-
-        return chain.join(':').toLowerCase() === blockchainAccountId.toLowerCase();
-      }
-
-      return false;
-    };
-
-    const secp256k1$2 = new elliptic.ec('secp256k1');
-    const secp256r1 = new elliptic.ec('p256'); // converts a JOSE signature to it's components
-
-    function toSignatureObject(signature, recoverable = false) {
-      const rawSig = base64ToBytes$1(signature);
-
-      if (rawSig.length !== (recoverable ? 65 : 64)) {
-        throw new Error('wrong signature length');
-      }
-
-      const r = bytesToHex$2(rawSig.slice(0, 32));
-      const s = bytesToHex$2(rawSig.slice(32, 64));
-      const sigObj = {
-        r,
-        s
-      };
-
-      if (recoverable) {
-        sigObj.recoveryParam = rawSig[64];
-      }
-
-      return sigObj;
-    }
-
-    function extractPublicKeyBytes$1(pk) {
-      if (pk.publicKeyBase58) {
-        return base58ToBytes$1(pk.publicKeyBase58);
-      } else if (pk.publicKeyBase64) {
-        return base64ToBytes$1(pk.publicKeyBase64);
-      } else if (pk.publicKeyHex) {
-        return hexToBytes$2(pk.publicKeyHex);
-      } else if (pk.publicKeyJwk && pk.publicKeyJwk.crv === 'secp256k1' && pk.publicKeyJwk.x && pk.publicKeyJwk.y) {
-        return hexToBytes$2(secp256k1$2.keyFromPublic({
-          x: bytesToHex$2(base64ToBytes$1(pk.publicKeyJwk.x)),
-          y: bytesToHex$2(base64ToBytes$1(pk.publicKeyJwk.y))
-        }).getPublic('hex'));
-      } else if (pk.publicKeyJwk && pk.publicKeyJwk.crv === 'P-256' && pk.publicKeyJwk.x && pk.publicKeyJwk.y) {
-        return hexToBytes$2(secp256r1.keyFromPublic({
-          x: bytesToHex$2(base64ToBytes$1(pk.publicKeyJwk.x)),
-          y: bytesToHex$2(base64ToBytes$1(pk.publicKeyJwk.y))
-        }).getPublic('hex'));
-      } else if (pk.publicKeyJwk && pk.publicKeyJwk.kty === 'OKP' && pk.publicKeyJwk.crv === 'Ed25519' && pk.publicKeyJwk.x) {
-        return base64ToBytes$1(pk.publicKeyJwk.x);
-      } else if (pk.publicKeyMultibase) {
-        const {
-          base16,
-          base58btc,
-          base64,
-          base64url
-        } = bases;
-        const baseDecoder = base16.decoder.or(base58btc.decoder.or(base64.decoder.or(base64url.decoder)));
-        return baseDecoder.decode(pk.publicKeyMultibase);
-      }
-
-      return new Uint8Array();
-    }
-
-    function verifyES256(data, signature, authenticators) {
-      const hash = sha256$1(data);
-      const sigObj = toSignatureObject(signature);
-      const fullPublicKeys = authenticators.filter(({
-        ethereumAddress,
-        blockchainAccountId
-      }) => {
-        return typeof ethereumAddress === 'undefined' && typeof blockchainAccountId === 'undefined';
-      });
-      const signer = fullPublicKeys.find(pk => {
-        try {
-          const pubBytes = extractPublicKeyBytes$1(pk);
-          return secp256r1.keyFromPublic(pubBytes).verify(hash, sigObj);
-        } catch (err) {
-          return false;
-        }
-      });
-      if (!signer) throw new Error('invalid_signature: Signature invalid for JWT');
-      return signer;
-    }
-    function verifyES256K(data, signature, authenticators) {
-      const hash = sha256$1(data);
-      const sigObj = toSignatureObject(signature);
-      const fullPublicKeys = authenticators.filter(({
-        ethereumAddress,
-        blockchainAccountId
-      }) => {
-        return typeof ethereumAddress === 'undefined' && typeof blockchainAccountId === 'undefined';
-      });
-      const blockchainAddressKeys = authenticators.filter(({
-        ethereumAddress,
-        blockchainAccountId
-      }) => {
-        return typeof ethereumAddress !== 'undefined' || typeof blockchainAccountId !== 'undefined';
-      });
-      let signer = fullPublicKeys.find(pk => {
-        try {
-          const pubBytes = extractPublicKeyBytes$1(pk);
-          return secp256k1$2.keyFromPublic(pubBytes).verify(hash, sigObj);
-        } catch (err) {
-          return false;
-        }
-      });
-
-      if (!signer && blockchainAddressKeys.length > 0) {
-        signer = verifyRecoverableES256K(data, signature, blockchainAddressKeys);
-      }
-
-      if (!signer) throw new Error('invalid_signature: Signature invalid for JWT');
-      return signer;
-    }
-    function verifyRecoverableES256K(data, signature, authenticators) {
-      let signatures;
-
-      if (signature.length > 86) {
-        signatures = [toSignatureObject(signature, true)];
-      } else {
-        const so = toSignatureObject(signature, false);
-        signatures = [{ ...so,
-          recoveryParam: 0
-        }, { ...so,
-          recoveryParam: 1
-        }];
-      }
-
-      const checkSignatureAgainstSigner = sigObj => {
-        const hash = sha256$1(data); // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-        const recoveredKey = secp256k1$2.recoverPubKey(hash, sigObj, sigObj.recoveryParam);
-        const recoveredPublicKeyHex = recoveredKey.encode('hex');
-        const recoveredCompressedPublicKeyHex = recoveredKey.encode('hex', true);
-        const recoveredAddress = toEthereumAddress(recoveredPublicKeyHex).toLowerCase();
-        const signer = authenticators.find(pk => {
-          var _pk$ethereumAddress, _pk$blockchainAccount, _pk$blockchainAccount2;
-
-          const keyHex = bytesToHex$2(extractPublicKeyBytes$1(pk));
-          return keyHex === recoveredPublicKeyHex || keyHex === recoveredCompressedPublicKeyHex || ((_pk$ethereumAddress = pk.ethereumAddress) == null ? void 0 : _pk$ethereumAddress.toLowerCase()) === recoveredAddress || ((_pk$blockchainAccount = pk.blockchainAccountId) == null ? void 0 : (_pk$blockchainAccount2 = _pk$blockchainAccount.split('@eip155')) == null ? void 0 : _pk$blockchainAccount2[0].toLowerCase()) === recoveredAddress || // CAIP-2
-          verifyBlockchainAccountId(recoveredPublicKeyHex, pk.blockchainAccountId) // CAIP-10
-          ;
-        });
-        return signer;
-      };
-
-      const signer = signatures.map(checkSignatureAgainstSigner).filter(key => typeof key !== 'undefined');
-      if (signer.length === 0) throw new Error('invalid_signature: Signature invalid for JWT');
-      return signer[0];
-    }
-    function verifyEd25519(data, signature, authenticators) {
-      const clear = stringToBytes$1(data);
-      const sig = base64ToBytes$1(signature);
-      const signer = authenticators.find(pk => {
-        return ed25519.verify(extractPublicKeyBytes$1(pk), clear, sig);
-      });
-      if (!signer) throw new Error('invalid_signature: Signature invalid for JWT');
-      return signer;
-    }
-    const algorithms = {
-      ES256: verifyES256,
-      ES256K: verifyES256K,
-      // This is a non-standard algorithm but retained for backwards compatibility
-      // see https://github.com/decentralized-identity/did-jwt/issues/146
-      'ES256K-R': verifyRecoverableES256K,
-      // This is actually incorrect but retained for backwards compatibility
-      // see https://github.com/decentralized-identity/did-jwt/issues/130
-      Ed25519: verifyEd25519,
-      EdDSA: verifyEd25519
-    };
-
-    function VerifierAlgorithm(alg) {
-      const impl = algorithms[alg];
-      if (!impl) throw new Error(`not_supported: Unsupported algorithm ${alg}`);
-      return impl;
-    }
-
-    VerifierAlgorithm.toSignatureObject = toSignatureObject;
-
-    function decodeJWS(jws) {
-      const parts = jws.match(/^([a-zA-Z0-9_-]+)\.([a-zA-Z0-9_-]+)\.([a-zA-Z0-9_-]+)$/);
-
-      if (parts) {
-        return {
-          header: JSON.parse(decodeBase64url$1(parts[1])),
-          payload: parts[2],
-          signature: parts[3],
-          data: `${parts[1]}.${parts[2]}`
-        };
-      }
-
-      throw new Error('invalid_argument: Incorrect format JWS');
-    }
-
-    function verifyJWSDecoded({
-      header,
-      data,
-      signature
-    }, pubKeys) {
-      if (!Array.isArray(pubKeys)) pubKeys = [pubKeys];
-      const signer = VerifierAlgorithm(header.alg)(data, signature, pubKeys);
-      return signer;
-    }
-    /**
-     *  Verifies given JWS. If the JWS is valid, returns the public key that was
-     *  used to sign the JWS, or throws an `Error` if none of the `pubKeys` match.
-     *
-     *  @example
-     *  const pubKey = verifyJWS('eyJ0eXAiOiJKV1QiLCJhbGciOiJFUzI1NksifQ.eyJyZXF1Z....', { publicKeyHex: '0x12341...' })
-     *
-     *  @param    {String}                          jws         A JWS string to verify
-     *  @param    {Array<VerificationMethod> | VerificationMethod}    pubKeys     The public keys used to verify the JWS
-     *  @return   {VerificationMethod}                       The public key used to sign the JWS
-     */
-
-
-    function verifyJWS(jws, pubKeys) {
-      const jwsDecoded = decodeJWS(jws);
-      return verifyJWSDecoded(jwsDecoded, pubKeys);
-    }
-
-    typeof Symbol !== "undefined" ? Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator")) : "@@iterator";
-
-    /* eslint-disable @typescript-eslint/strict-boolean-expressions */
-    function parse$2(string, encoding, opts) {
-      var _opts$out;
-
-      if (opts === void 0) {
-        opts = {};
-      }
-
-      // Build the character lookup table:
-      if (!encoding.codes) {
-        encoding.codes = {};
-
-        for (var i = 0; i < encoding.chars.length; ++i) {
-          encoding.codes[encoding.chars[i]] = i;
-        }
-      } // The string must have a whole number of bytes:
-
-
-      if (!opts.loose && string.length * encoding.bits & 7) {
-        throw new SyntaxError('Invalid padding');
-      } // Count the padding bytes:
-
-
-      var end = string.length;
-
-      while (string[end - 1] === '=') {
-        --end; // If we get a whole number of bytes, there is too much padding:
-
-        if (!opts.loose && !((string.length - end) * encoding.bits & 7)) {
-          throw new SyntaxError('Invalid padding');
-        }
-      } // Allocate the output:
-
-
-      var out = new ((_opts$out = opts.out) != null ? _opts$out : Uint8Array)(end * encoding.bits / 8 | 0); // Parse the data:
-
-      var bits = 0; // Number of bits currently in the buffer
-
-      var buffer = 0; // Bits waiting to be written out, MSB first
-
-      var written = 0; // Next byte to write
-
-      for (var _i = 0; _i < end; ++_i) {
-        // Read one character from the string:
-        var value = encoding.codes[string[_i]];
-
-        if (value === undefined) {
-          throw new SyntaxError('Invalid character ' + string[_i]);
-        } // Append the bits to the buffer:
-
-
-        buffer = buffer << encoding.bits | value;
-        bits += encoding.bits; // Write out some bits if the buffer has a byte's worth:
-
-        if (bits >= 8) {
-          bits -= 8;
-          out[written++] = 0xff & buffer >> bits;
-        }
-      } // Verify that we have received just enough bits:
-
-
-      if (bits >= encoding.bits || 0xff & buffer << 8 - bits) {
-        throw new SyntaxError('Unexpected end of data');
-      }
-
-      return out;
-    }
-    function stringify$1(data, encoding, opts) {
-      if (opts === void 0) {
-        opts = {};
-      }
-
-      var _opts = opts,
-          _opts$pad = _opts.pad,
-          pad = _opts$pad === void 0 ? true : _opts$pad;
-      var mask = (1 << encoding.bits) - 1;
-      var out = '';
-      var bits = 0; // Number of bits currently in the buffer
+          return this;
+        };
 
-      var buffer = 0; // Bits waiting to be written out, MSB first
+        this.digest = () => {
+          if (this._finalized) throw new Error('Digest already called');
+          this._finalized = true;
 
-      for (var i = 0; i < data.length; ++i) {
-        // Slurp data into the buffer:
-        buffer = buffer << 8 | 0xff & data[i];
-        bits += 8; // Write out as much as we can:
+          const digest = this._digest(); // reset state
 
-        while (bits > encoding.bits) {
-          bits -= encoding.bits;
-          out += encoding.chars[mask & buffer >> bits];
-        }
-      } // Partial character:
 
+          this._block.fill(0);
 
-      if (bits) {
-        out += encoding.chars[mask & buffer << encoding.bits - bits];
-      } // Add padding characters until we hit a byte boundary:
+          this._blockOffset = 0;
 
+          for (let i = 0; i < 4; ++i) this._length[i] = 0;
 
-      if (pad) {
-        while (out.length * encoding.bits & 7) {
-          out += '=';
-        }
-      }
+          return digest;
+        };
 
-      return out;
-    }
-    var base64Encoding = {
-      chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
-      bits: 6
-    };
-    var base64UrlEncoding = {
-      chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
-      bits: 6
-    };
-    var base64$1 = {
-      parse: function parse$1(string, opts) {
-        return parse$2(string, base64Encoding, opts);
-      },
-      stringify: function stringify$1$1(data, opts) {
-        return stringify$1(data, base64Encoding, opts);
-      }
-    };
-    var base64url = {
-      parse: function parse$1(string, opts) {
-        return parse$2(string, base64UrlEncoding, opts);
-      },
-      stringify: function stringify$1$1(data, opts) {
-        return stringify$1(data, base64UrlEncoding, opts);
-      }
-    };
+        this._update = () => {
+          const words = new Array(16);
+          const temp = new DataView(this._block.buffer);
 
-    const byteEncoder = new TextEncoder();
-    const byteDecoder = new TextDecoder();
-    function bytesToBase64url(b, opts = { pad: false }) {
-        return base64url.stringify(b, opts);
-    }
-    function base64ToBytes(s, opts = { loose: true }) {
-        return base64$1.parse(s, opts);
-    }
-    function bytesToBase64(b, opts = { pad: false }) {
-        return base64$1.stringify(b, opts);
-    }
-    function base64UrlToBytes(s, opts = { loose: true }) {
-        const inputBase64Url = s.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
-        return base64url.parse(inputBase64Url, opts);
-    }
-    function base58ToBytes(s) {
-        return yE(s);
-    }
-    function bytesToBase58(b) {
-        return uE(b);
-    }
-    function hexToBytes$1(s) {
-        const input = s.startsWith('0x') ? s.substring(2) : s;
-        return b$5.decodeString(input.toLowerCase());
-    }
-    function encodeBase64url(s, opts = { pad: false }) {
-        return base64url.stringify(byteEncoder.encode(s), opts);
-    }
-    function decodeBase64url(s, opts = { loose: true }) {
-        return byteDecoder.decode(base64url.parse(s, opts));
-    }
-    function bytesToHex$1(b) {
-        return b$5.encodeString(b);
-    }
+          for (let j = 0; j < 16; ++j) words[j] = words[j] = temp.getInt32(j * 4, true);
 
-    function mergeObjects(credSubject, otherCredSubject) {
-        let result = {};
-        const credSubjectKeys = Object.keys(credSubject);
-        for (const key of credSubjectKeys) {
-            if (typeof otherCredSubject[key] !== 'undefined') {
-                if (typeof credSubject[key] !== 'object' && typeof otherCredSubject[key] !== 'object') {
-                    throw new Error('Invalid query');
-                }
-                const subjectProperty = credSubject[key];
-                const otherSubjectProperty = otherCredSubject[key];
-                const propertyOperators = Object.keys(subjectProperty);
-                const subjectPropertyResult = {};
-                for (const operatorKey of propertyOperators) {
-                    if (typeof otherSubjectProperty[operatorKey] !== 'undefined') {
-                        const operatorValue1 = subjectProperty[operatorKey];
-                        const operatorValue2 = otherSubjectProperty[operatorKey];
-                        subjectPropertyResult[operatorKey] = [
-                            ...new Set([
-                                ...(subjectPropertyResult[operatorKey] ?? []),
-                                operatorValue1,
-                                ...(Array.isArray(operatorValue2) ? operatorValue2 : [operatorValue2])
-                            ])
-                        ];
-                    }
-                    else {
-                        subjectPropertyResult[operatorKey] = subjectProperty[operatorKey];
-                    }
-                }
-                result[key] = {
-                    ...otherCredSubject[key],
-                    ...subjectPropertyResult
-                };
-            }
-        }
-        // Add remaining keys from obj2
-        result = { ...credSubject, ...otherCredSubject, ...result };
-        return result;
-    }
+          let al = this._a | 0;
+          let bl = this._b | 0;
+          let cl = this._c | 0;
+          let dl = this._d | 0;
+          let el = this._e | 0;
+          let ar = this._a | 0;
+          let br = this._b | 0;
+          let cr = this._c | 0;
+          let dr = this._d | 0;
+          let er = this._e | 0; // computation
 
-    const i$1=32,n$1=1,o$1=new Uint8Array(65),h$2="empty",l$2=32,w$2=BigInt("21888242871839275222246405745257275088548364400416034343698204186575808495617");w$2-BigInt("1");function g$2(t,e,i,s){if("a"===i&&!s)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof e?t!==e||!s:!e.has(t))throw new TypeError("Cannot read private member from an object whose class did not declare it");return "m"===i?s:"a"===i?s.call(t):s?s.value:e.get(t)}function v$2(t,e,i,s,n){if("m"===s)throw new TypeError("Private method is not writable");if("a"===s&&!n)throw new TypeError("Private accessor was defined without a setter");if("function"==typeof e?t!==e||!n:!e.has(t))throw new TypeError("Cannot write private member to an object whose class did not declare it");return "a"===s?n.call(t,i):n?n.value=i:e.set(t,i),i}const p$2=t=>t<w$2,b$3=(t,e)=>t.every(((t,i)=>t===e[i])),m$2=t=>t.slice().reverse(),x$2=t=>"0b"+t.reduce(((t,e)=>t+e.toString(2).padStart(8,"0")),""),A$2=(t,e)=>0!=(t[parseInt((e/8).toString())]&1<<e%8),I$2=(t,e)=>0!=(t[t.length-parseInt(""+e/8)-1]&1<<e%8),k$1=(t,e)=>{t[t.length-parseInt(""+e/8)-1]|=1<<e%8;},S$2="0123456789abcdef",R$1=t=>{const e=new Array(2*t.length);let i=0;return t.forEach((t=>{e[i]=S$2[parseInt((t>>4).toString(10))],e[i+1]=S$2[parseInt((15&t).toString(10))],i+=2;})),e.join("")},B$2=t=>new Uint8Array(2*t.length).map(((e,i)=>t.charCodeAt(i))),N$1=(t,e)=>{const i=new Array(t);for(let s=0;s<t;s+=1)i[s]=A$2(e,s);return i},U$1=t=>{const e=new ArrayBuffer(i$1*t.length),s=new Uint8Array(e);return t.forEach(((t,e)=>{s.set(t.value,e*i$1);})),s},K$1=t=>{const e=BigInt(256),s=new Uint8Array(i$1);let n=0;for(;t>BigInt(0);)s[31-n]=Number(t%e),t/=e,n+=1;return s};let V$1 = class V{constructor(t){if(t?.length){if(t.length!==i$1)throw new Error(`Expected 32 bytes, found ${t.length} bytes`);this.bytes=t;}else this.bytes=new Uint8Array(i$1);}get value(){return this.bytes}set value(t){if(t.length!==i$1)throw `Expected 32 bytes, found ${t.length} bytes`;this.bytes=m$2(t);}string(){return this.bigInt().toString(10)}hex(){return R$1(this.bytes)}equals(t){return b$3(this.value,t.value)}bigInt(){const t=m$2(this.value);return BigInt(x$2(t))}static fromString(t){try{return V.fromBigInt(BigInt(t))}catch(e){const i=JSON.parse(t),s=Uint8Array.from(Object.values(i.bytes));return new V(s)}}static fromBigInt(t){if(!p$2(t))throw new Error("NewBigIntFromHashBytes: Value not inside the Finite Field");const e=K$1(t);return new V(m$2(e))}static fromHex(e){return e?new V(b$5.decodeString(e)):M$2}toJSON(){return this.string()}};const M$2=new V$1,O$1=t=>V$1.fromString(t),_$1=t=>{const i=$$2.hash(t);return V$1.fromBigInt(i)},J$1=(t,i)=>{const s=$$2.hash([...i,t]);return V$1.fromBigInt(s)},P$1=(t,e)=>{for(let i=t.length;i<e;i+=1)t.push(M$2);return t};var T$2,H$1;let j$1 = class j{constructor(t){T$2.set(this,void 0),H$1.set(this,void 0),this.prefix=t,v$2(this,T$2,{},"f"),v$2(this,H$1,M$2,"f");}async get(t){const e=new Uint8Array([...this.prefix,...t]);return g$2(this,T$2,"f")[e.toString()]?g$2(this,T$2,"f")[e.toString()]:void 0}async put(t,e){const i=new Uint8Array([...this.prefix,...t]);g$2(this,T$2,"f")[i.toString()]=e;}async getRoot(){return g$2(this,H$1,"f")}async setRoot(t){v$2(this,H$1,t,"f");}};T$2=new WeakMap,H$1=new WeakMap;const z$2=async(t,e)=>J$1(BigInt(1),[t.bigInt(),e.bigInt()]),C$2=(t,e,i)=>{const s=new Uint8Array(65),n=K$1(e.bigInt()),r=K$1(i.bigInt());s[0]=t;for(let t=1;t<33;t+=1)s[t]=n[t-1];for(let t=33;t<=65;t+=1)s[t]=r[t-33];return s};var q$1,F$1,D$1,G$1;let Q$1 = class Q{constructor(t,e){q$1.set(this,void 0),this.type=1,this.entry=[t,e],v$2(this,q$1,M$2,"f");}async getKey(){return g$2(this,q$1,"f")===M$2?await z$2(this.entry[0],this.entry[1]):g$2(this,q$1,"f")}get value(){return C$2(this.type,this.entry[0],this.entry[1])}get string(){return `Leaf I:${this.entry[0]} D:${this.entry[1]}`}};q$1=new WeakMap;let X$1 = class X{constructor(t,e){F$1.set(this,void 0),this.type=0,this.childL=t,this.childR=e,v$2(this,F$1,M$2,"f");}async getKey(){return g$2(this,F$1,"f")===M$2?_$1([this.childL.bigInt(),this.childR.bigInt()]):g$2(this,F$1,"f")}get value(){return C$2(this.type,this.childL,this.childR)}get string(){return `Middle L:${this.childL} R:${this.childR}`}};F$1=new WeakMap;let Y$1 = class Y{constructor(){D$1.set(this,void 0),this.type=2,v$2(this,D$1,M$2,"f");}async getKey(){return M$2}get value(){return o$1}get string(){return h$2}};D$1=new WeakMap;let Z$1 = class Z{constructor(t){this._prefix=t,G$1.set(this,void 0);const e=localStorage.getItem(R$1(t));if(e){const t=JSON.parse(e);v$2(this,G$1,new V$1(Uint8Array.from(t)),"f");}else v$2(this,G$1,M$2,"f");}async get(t){const e=new Uint8Array([...this._prefix,...t]),i=R$1(e),s=localStorage.getItem(i);if(null===s)return;const n=JSON.parse(s);switch(n.type){case 2:return new Y$1;case 0:const t=new V$1(Uint8Array.from(n.childL)),e=new V$1(Uint8Array.from(n.childR));return new X$1(t,e);case 1:const i=new V$1(Uint8Array.from(n.entry[0])),s=new V$1(Uint8Array.from(n.entry[1]));return new Q$1(i,s)}throw `error: value found for key ${R$1(e)} is not of type Node`}async put(t,e){const i=new Uint8Array([...this._prefix,...t]),s=R$1(i),n={type:e.type};e instanceof X$1?(n.childL=Array.from(e.childL.bytes),n.childR=Array.from(e.childR.bytes)):e instanceof Q$1&&(n.entry=[Array.from(e.entry[0].bytes),Array.from(e.entry[1].bytes)]);const r=JSON.stringify(n);localStorage.setItem(s,r);}async getRoot(){return g$2(this,G$1,"f")}async setRoot(t){v$2(this,G$1,t,"f"),localStorage.setItem(R$1(this._prefix),JSON.stringify(Array.from(t.bytes)));}};function tt$1(t){return new Promise(((e,i)=>{t.oncomplete=t.onsuccess=()=>e(t.result),t.onabort=t.onerror=()=>i(t.error);}))}function et$1(t,e){const i=indexedDB.open(t);i.onupgradeneeded=()=>i.result.createObjectStore(e);const s=tt$1(i);return (t,i)=>s.then((s=>i(s.transaction(e,t).objectStore(e))))}let it$1;function st$1(){return it$1||(it$1=et$1("keyval-store","keyval")),it$1}function nt$1(t,e=st$1()){return e("readonly",(e=>tt$1(e.get(t))))}function rt$1(t,e,i=st$1()){return i("readwrite",(i=>(i.put(e,t),tt$1(i.transaction))))}var at$1;G$1=new WeakMap;let lt$2 = class lt{constructor(t,e){this._prefix=t,at$1.set(this,void 0),v$2(this,at$1,M$2,"f"),this._prefixHash=R$1(t),this._store=et$1(`${e??lt.storageName}-db`,lt.storageName);}async get(t){const e=new Uint8Array([...this._prefix,...t]),i=R$1(e),s=await nt$1(i,this._store);if(null!=s){if(2===s.type)return new Y$1;if(0===s.type){const t=new V$1(Uint8Array.from(s.childL.bytes)),e=new V$1(Uint8Array.from(s.childR.bytes));return new X$1(t,e)}if(1===s.type){const t=new V$1(Uint8Array.from(s.entry[0].bytes)),e=new V$1(Uint8Array.from(s.entry[1].bytes));return new Q$1(t,e)}throw new Error(`error: value found for key ${i} is not of type Node`)}}async put(t,e){const i=new Uint8Array([...this._prefix,...t]),s=R$1(i);await rt$1(s,e,this._store);}async getRoot(){if(!g$2(this,at$1,"f").equals(M$2))return g$2(this,at$1,"f");const t=await nt$1(this._prefixHash,this._store);return v$2(this,at$1,t?new V$1(t.bytes):M$2,"f"),g$2(this,at$1,"f")}async setRoot(t){await rt$1(this._prefixHash,t,this._store),v$2(this,at$1,t,"f");}};at$1=new WeakMap,lt$2.storageName="merkle-tree";const vt$1=t=>t.map((t=>t.bigInt())),pt$1=t=>{const e=vt$1(t.data.value);let i=!0;return e.forEach((t=>{p$2(t)||(i=!1);})),i},mt$1="Key not found in the MerkleTree",At$1="reached maximum level of the merkle tree",It$1="found an invalid node in the DB",Rt$1="the entry index already exists in the tree",Lt$1="Merkle Tree not writable",Bt$1="key not found";let Nt$1 = class Nt{constructor(t=M$2,e=[],i=M$2,s=M$2,n=!1,r=M$2,a=M$2,o=0){this.root=t,this.siblings=e,this.oldKey=i,this.oldValue=s,this.isOld0=n,this.key=r,this.value=a,this.fnc=o;}};let Ut$1 = class Ut{constructor(t=M$2,e=M$2,i=[],s=M$2,n=M$2,r=M$2,a=M$2,o=!1,h=0){this.oldRoot=t,this.newRoot=e,this.siblings=i,this.oldKey=s,this.oldValue=n,this.newKey=r,this.newValue=a,this.isOld0=o,this.fnc=h;}};const Et$1="non-existence proof being checked against hIndex equal to nodeAux";let Kt$1 = class Kt{constructor(t){this.existence=t?.existence??!1,this.depth=t?.siblings.length??0,this.nodeAux=t?.nodeAux;const{siblings:e,notEmpties:i}=this.reduceSiblings(t?.siblings);this.siblings=e,this.notEmpties=i;}bytes(){let t=2+this.notEmpties.length+l$2*this.siblings.length;void 0!==this.nodeAux&&(t+=64);const e=new ArrayBuffer(t),i=new Uint8Array(e);this.existence||(i[0]|=1),i[1]=this.depth,i.set(this.notEmpties,2);const s=U$1(this.siblings);return i.set(s,this.notEmpties.length+2),void 0!==this.nodeAux&&(i[0]|=2,i.set(this.nodeAux.key.value,i.length-64),i.set(this.nodeAux.value.value,i.length-32)),i}toJSON(){return {existence:this.existence,siblings:this.allSiblings().map((t=>t.toJSON())),nodeAux:this.nodeAux?{key:this.nodeAux.key.toJSON(),value:this.nodeAux.value.toJSON()}:void 0}}reduceSiblings(t){const e=[],i=new Uint8Array(30);if(!t)return {siblings:e,notEmpties:i};for(let s=0;s<t.length;s++){const n=t[s];JSON.stringify(t[s])!==JSON.stringify(M$2)&&(k$1(i,s),e.push(n));}return {notEmpties:i,siblings:e}}static fromJSON(t){let e;t.nodeAux&&(e={key:V$1.fromString(t.nodeAux.key),value:V$1.fromString(t.nodeAux.value)});const i=t.existence??!1,s=t.siblings.map((t=>V$1.fromString(t)));return new Kt({existence:i,nodeAux:e,siblings:s})}allSiblings(){return Kt.buildAllSiblings(this.depth,this.notEmpties,this.siblings)}static buildAllSiblings(t,e,i){let s=0;const n=[];for(let r=0;r<t;r+=1)I$2(e,r)?(n.push(i[s]),s+=1):n.push(M$2);return n}};const Mt$1=async(t,e,i,s)=>{try{const n=await Wt$1(e,i,s);return b$3(t.value,n.value)}catch(t){if(t===Et$1)return !1;throw t}},Wt$1=async(t,e,i)=>{const s=V$1.fromBigInt(e),n=V$1.fromBigInt(i);let r;if(t.existence)r=await z$2(s,n);else if(void 0===t.nodeAux)r=M$2;else {const e=t.nodeAux;if(b$3(s.value,e.key.value))throw Et$1;r=await z$2(e.key,e.value);}const a=t.allSiblings(),o=N$1(a.length,s.value);for(let t=a.length-1;t>=0;t-=1)r=o[t]?await new X$1(a[t],r).getKey():await new X$1(r,a[t]).getKey();return r};var $t$1,Ot$1,_t$1,Jt$1;let Pt$1 = class Pt{constructor(t,e,i){$t$1.set(this,void 0),Ot$1.set(this,void 0),_t$1.set(this,void 0),Jt$1.set(this,void 0),v$2(this,$t$1,t,"f"),v$2(this,_t$1,e,"f"),v$2(this,Jt$1,i,"f");}async root(){return g$2(this,Ot$1,"f")||v$2(this,Ot$1,await g$2(this,$t$1,"f").getRoot(),"f"),g$2(this,Ot$1,"f")}get maxLevels(){return g$2(this,Jt$1,"f")}async add(t,e){if(!g$2(this,_t$1,"f"))throw Lt$1;v$2(this,Ot$1,await this.root(),"f");const i=V$1.fromBigInt(t),s=V$1.fromBigInt(e),n=new Q$1(i,s),r=N$1(this.maxLevels,i.value),a=await this.addLeaf(n,g$2(this,Ot$1,"f"),0,r);v$2(this,Ot$1,a,"f"),await g$2(this,$t$1,"f").setRoot(g$2(this,Ot$1,"f"));}async updateNode(t){if(!g$2(this,_t$1,"f"))throw Lt$1;if(2===t.type)return await t.getKey();const e=await t.getKey();return await g$2(this,$t$1,"f").put(e.value,t),e}async addNode(t){if(!g$2(this,_t$1,"f"))throw Lt$1;if(2===t.type)return await t.getKey();const e=await t.getKey();return await g$2(this,$t$1,"f").put(e.value,t),e}async addEntry(t){if(!g$2(this,_t$1,"f"))throw Lt$1;if(!pt$1(t))throw "elements not inside the finite field over r";v$2(this,Ot$1,await g$2(this,$t$1,"f").getRoot(),"f");const e=await t.hIndex(),i=await t.hValue(),s=new Q$1(e,i),n=N$1(this.maxLevels,e.value),r=await this.addLeaf(s,g$2(this,Ot$1,"f"),0,n);v$2(this,Ot$1,r,"f"),await g$2(this,$t$1,"f").setRoot(g$2(this,Ot$1,"f"));}async pushLeaf(t,e,i,s,n){if(i>g$2(this,Jt$1,"f")-2)throw new Error(At$1);let r;if(s[i]===n[i]){const a=await this.pushLeaf(t,e,i+1,s,n);return r=s[i]?new X$1(new V$1,a):new X$1(a,new V$1),await this.addNode(r)}const a=await e.getKey(),o=await t.getKey();return r=s[i]?new X$1(a,o):new X$1(o,a),await this.addNode(t),await this.addNode(r)}async addLeaf(t,e,i,s){if(i>g$2(this,Jt$1,"f")-1)throw new Error(At$1);const n=await this.getNode(e);if(void 0===n)throw Bt$1;switch(n.type){case 2:return this.addNode(t);case 1:{const e=n.entry[0],r=t.entry[0];if(b$3(e.value,r.value))throw Rt$1;const a=N$1(this.maxLevels,e.value);return this.pushLeaf(t,n,i,s,a)}case 0:{let e;if(s[i]){const r=await this.addLeaf(t,n.childR,i+1,s);e=new X$1(n.childL,r);}else {const r=await this.addLeaf(t,n.childL,i+1,s);e=new X$1(r,n.childR);}return this.addNode(e)}default:throw It$1}}async get(t){const e=V$1.fromBigInt(t),i=N$1(this.maxLevels,e.value);let s=await this.root();const n=[];for(let t=0;t<this.maxLevels;t++){const e=await this.getNode(s);if(void 0===e)throw mt$1;switch(e.type){case 2:return {key:BigInt("0"),value:BigInt("0"),siblings:n};case 1:return {key:e.entry[0].bigInt(),value:e.entry[1].bigInt(),siblings:n};case 0:i[t]?(s=e.childR,n.push(e.childL)):(s=e.childL,n.push(e.childR));break;default:throw It$1}}throw new Error(At$1)}async update(t,e){if(!g$2(this,_t$1,"f"))throw Lt$1;if(!p$2(t))throw "key not inside the finite field";if(!p$2(e))throw "key not inside the finite field";const i=V$1.fromBigInt(t),s=V$1.fromBigInt(e),n=N$1(this.maxLevels,i.value),r=new Ut$1;r.fnc=1,r.oldRoot=await this.root(),r.oldKey=i,r.newKey=i,r.newValue=s;let a=await this.root();const o=[];for(let t=0;t<this.maxLevels;t+=1){const e=await this.getNode(a);if(void 0===e)throw Bt$1;switch(e.type){case 2:throw mt$1;case 1:if(b$3(i.value,e.entry[0].value)){r.oldValue=e.entry[1],r.siblings=P$1([...o],this.maxLevels);const t=new Q$1(i,s);await this.updateNode(t);const a=await this.recalculatePathUntilRoot(n,t,o);return v$2(this,Ot$1,a,"f"),await g$2(this,$t$1,"f").setRoot(a),r.newRoot=a,r}break;case 0:n[t]?(a=e.childR,o.push(e.childL)):(a=e.childL,o.push(e.childR));break;default:throw It$1}}throw mt$1}async getNode(t){return b$3(t.value,M$2.value)?new Y$1:await g$2(this,$t$1,"f").get(t.value)}async recalculatePathUntilRoot(t,e,i){for(let s=i.length-1;s>=0;s-=1){const n=await e.getKey();e=t[s]?new X$1(i[s],n):new X$1(n,i[s]),await this.addNode(e);}return await e.getKey()}async delete(t){if(!g$2(this,_t$1,"f"))throw Lt$1;const e=V$1.fromBigInt(t),i=N$1(this.maxLevels,e.value);let s=g$2(this,Ot$1,"f");const n=[];for(let t=0;t<g$2(this,Jt$1,"f");t+=1){const r=await this.getNode(s);if(void 0===r)throw Bt$1;switch(r.type){case 2:throw mt$1;case 1:if(b$3(e.bytes,r.entry[0].value))return void await this.rmAndUpload(i,e,n);throw mt$1;case 0:i[t]?(s=r.childR,n.push(r.childL)):(s=r.childL,n.push(r.childR));break;default:throw It$1}}throw mt$1}async rmAndUpload(t,e,i){if(0===i.length)return v$2(this,Ot$1,M$2,"f"),void await g$2(this,$t$1,"f").setRoot(g$2(this,Ot$1,"f"));const s=i[i.length-1];i.length<2&&(v$2(this,Ot$1,i[0],"f"),await g$2(this,$t$1,"f").setRoot(g$2(this,Ot$1,"f")));for(let e=i.length-2;e>=0;e-=1){if(!b$3(i[e].value,M$2.value)){let n;n=t[e]?new X$1(i[e],s):new X$1(s,i[e]),await this.addNode(n);const r=await this.recalculatePathUntilRoot(t,n,i.slice(0,e));v$2(this,Ot$1,r,"f"),await g$2(this,$t$1,"f").setRoot(g$2(this,Ot$1,"f"));break}if(0===e){v$2(this,Ot$1,s,"f"),await g$2(this,$t$1,"f").setRoot(g$2(this,Ot$1,"f"));break}}}async recWalk(t,e){const i=await this.getNode(t);if(void 0===i)throw Bt$1;switch(i.type){case 2:case 1:await e(i);break;case 0:await e(i),await this.recWalk(i.childL,e),await this.recWalk(i.childR,e);break;default:throw It$1}}async walk(t,e){b$3(t.value,M$2.value)&&(t=await this.root()),await this.recWalk(t,e);}async generateCircomVerifierProof(t,e){const i=await this.generateSCVerifierProof(t,e);return i.siblings=P$1(i.siblings,this.maxLevels),i}async generateSCVerifierProof(t,e){b$3(e.value,M$2.value)&&(e=await this.root());const{proof:i,value:s}=await this.generateProof(t,e),n=new Nt$1;return n.root=e,n.siblings=i.allSiblings(),void 0!==i.nodeAux?(n.oldKey=i.nodeAux.key,n.oldValue=i.nodeAux.value):(n.oldKey=M$2,n.oldValue=M$2),n.key=V$1.fromBigInt(t),n.value=V$1.fromBigInt(s),i.existence?n.fnc=0:n.fnc=1,n}async generateProof(t,e){let i;const s=V$1.fromBigInt(t),n=N$1(this.maxLevels,s.value);e||(e=await this.root());let r=e,a=0,o=!1;const h=[];let l;for(a=0;a<this.maxLevels;a+=1){const t=await this.getNode(r);if(void 0===t)throw Bt$1;switch(t.type){case 2:return {proof:new Kt$1({existence:o,nodeAux:l,siblings:h}),value:BigInt("0")};case 1:return b$3(s.value,t.entry[0].value)?(o=!0,{proof:new Kt$1({existence:o,nodeAux:l,siblings:h}),value:t.entry[1].bigInt()}):(l={key:t.entry[0],value:t.entry[1]},{proof:new Kt$1({existence:o,nodeAux:l,siblings:h}),value:t.entry[1].bigInt()});case 0:n[a]?(r=t.childR,i=t.childL):(r=t.childL,i=t.childR);break;default:throw It$1}h.push(i);}throw mt$1}async addAndGetCircomProof(t,e){const i=new Ut$1;i.fnc=2,i.oldRoot=await this.root();let s=BigInt("0"),n=BigInt("0"),r=[];try{const e=await this.get(t);s=e.key,n=e.value,r=e.siblings;}catch(t){if(t!==mt$1)throw t}if(void 0===s||void 0===n)throw "key/value undefined";return i.oldKey=V$1.fromBigInt(s),i.oldValue=V$1.fromBigInt(n),b$3(i.oldKey.value,M$2.value)&&(i.isOld0=!0),i.siblings=P$1(r,this.maxLevels),await this.add(t,e),i.newKey=V$1.fromBigInt(t),i.newValue=V$1.fromBigInt(e),i.newRoot=await this.root(),i}async graphViz(t){let e=0;await this.walk(t,(async t=>{const i=await t.getKey();let s,n;switch(t.type){case 2:break;case 1:console.log(`"${i.string()}" [style=filled]`);break;case 0:s=[t.childL.string(),t.childR.string()],n="",s.forEach(((t,i)=>{"0"===t&&(s[i]=`empty${e}`,n+=`"${s[i]}" [style=dashed,label=0];\n`,e+=1);})),console.log(`"${i.string()}" -> {"${s[1]}"}`),console.log(n);}})),console.log("}\n");}async printGraphViz(t){b$3(t.value,M$2.value)&&(t=await this.root()),console.log(`--------\nGraphViz of the MerkleTree with RootKey ${t.bigInt().toString(10)}\n`),await this.graphViz(M$2),console.log(`End of GraphViz of the MerkleTree with RootKey ${t.bigInt().toString(10)}\n--------\n`);}};$t$1=new WeakMap,Ot$1=new WeakMap,_t$1=new WeakMap,Jt$1=new WeakMap;
+          for (let i = 0; i < 80; i += 1) {
+            let tl;
+            let tr;
 
-    /**
-     * Checks if state is genesis state
-     *
-     * @param {string} did - did
-     * @param {bigint|string} state  - hash on bigInt or hex string format
-     * @returns boolean
-     */
-    function isGenesisState(did, state) {
-        if (typeof state === 'string') {
-            state = V$1.fromHex(state).bigInt();
-        }
-        const id = W$2.idFromDID(did);
-        const { method, blockchain, networkId } = W$2.decodePartsFromId(id);
-        const type = P$2(method, blockchain, networkId);
-        const idFromState = k$2.idGenesisFromIdenState(type, state);
-        return id.bigInt().toString() === idFromState.bigInt().toString();
-    }
-    const buildVerifierId = (address, info) => {
-        address = address.replace('0x', '');
-        const ethAddrBytes = b$5.decodeString(address);
-        const ethAddr = ethAddrBytes.slice(0, 20);
-        const genesis = O$2(ethAddr);
-        const tp = P$2(info.method, info.blockchain, info.networkId);
-        return new k$2(tp, genesis);
-    };
-    const validateDIDDocumentAuth = async (did, resolverURL, state) => {
-        const vm = await resolveDIDDocumentAuth(did, resolverURL, state);
-        if (!vm) {
-            throw new Error(`can't resolve DID document`);
-        }
-        // published or genesis
-        if (!vm.published &&
-            !isGenesisState(did, state.bigInt())) {
-            throw new Error(`issuer state not published and not genesis`);
-        }
-    };
-    const resolveDIDDocumentAuth = async (did, resolveURL, state) => {
-        let url = `${resolveURL}/${did.string().replace(/:/g, '%3A')}`;
-        if (state) {
-            url += `?state=${state.hex()}`;
-        }
-        const resp = await fetch(url);
-        const didResolutionRes = (await resp.json());
-        return didResolutionRes.didDocument?.verificationMethod?.find((i) => i.type === 'Iden3StateInfo2023');
-    };
+            if (i < 16) {
+              tl = fn1(al, bl, cl, dl, el, words[zl$1[i]], hl$1[0], sl$1[i]);
+              tr = fn5(ar, br, cr, dr, er, words[zr$1[i]], hr$1[0], sr$1[i]);
+            } else if (i < 32) {
+              tl = fn2(al, bl, cl, dl, el, words[zl$1[i]], hl$1[1], sl$1[i]);
+              tr = fn4(ar, br, cr, dr, er, words[zr$1[i]], hr$1[1], sr$1[i]);
+            } else if (i < 48) {
+              tl = fn3(al, bl, cl, dl, el, words[zl$1[i]], hl$1[2], sl$1[i]);
+              tr = fn3(ar, br, cr, dr, er, words[zr$1[i]], hr$1[2], sr$1[i]);
+            } else if (i < 64) {
+              tl = fn4(al, bl, cl, dl, el, words[zl$1[i]], hl$1[3], sl$1[i]);
+              tr = fn2(ar, br, cr, dr, er, words[zr$1[i]], hr$1[3], sr$1[i]);
+            } else {
+              // if (i<80) {
+              tl = fn5(al, bl, cl, dl, el, words[zl$1[i]], hl$1[4], sl$1[i]);
+              tr = fn1(ar, br, cr, dr, er, words[zr$1[i]], hr$1[4], sr$1[i]);
+            }
 
-    var pubsub = {exports: {}};
+            al = el;
+            el = dl;
+            dl = rotl(cl, 10);
+            cl = bl;
+            bl = tl;
+            ar = er;
+            er = dr;
+            dr = rotl(cr, 10);
+            cr = br;
+            br = tr;
+          } // update state
 
-    /**
-     * Copyright (c) 2010,2011,2012,2013,2014 Morgan Roderick http://roderick.dk
-     * License: MIT - http://mrgnrdrck.mit-license.org
-     *
-     * https://github.com/mroderick/PubSubJS
-     */
 
-    (function (module, exports) {
-    	(function (root, factory){
+          const t = this._b + cl + dr | 0;
+          this._b = this._c + dl + er | 0;
+          this._c = this._d + el + ar | 0;
+          this._d = this._e + al + br | 0;
+          this._e = this._a + bl + cr | 0;
+          this._a = t;
+        };
 
-    	    var PubSub = {};
+        this._digest = () => {
+          // create padding and handle blocks
+          this._block[this._blockOffset++] = 0x80;
 
-    	    if (root.PubSub) {
-    	        PubSub = root.PubSub;
-    	        console.warn("PubSub already loaded, using existing version");
-    	    } else {
-    	        root.PubSub = PubSub;
-    	        factory(PubSub);
-    	    }
-    	    // CommonJS and Node.js module support
-    	    {
-    	        if (module !== undefined && module.exports) {
-    	            exports = module.exports = PubSub; // Node.js specific `module.exports`
-    	        }
-    	        exports.PubSub = PubSub; // CommonJS module 1.1.1 spec
-    	        module.exports = exports = PubSub; // CommonJS
-    	    }
+          if (this._blockOffset > 56) {
+            this._block.fill(0, this._blockOffset, 64);
 
-    	}(( typeof window === 'object' && window ) || commonjsGlobal$1, function (PubSub){
+            this._update();
 
-    	    var messages = {},
-    	        lastUid = -1,
-    	        ALL_SUBSCRIBING_MSG = '*';
+            this._blockOffset = 0;
+          }
 
-    	    function hasKeys(obj){
-    	        var key;
+          this._block.fill(0, this._blockOffset, 56);
 
-    	        for (key in obj){
-    	            if ( Object.prototype.hasOwnProperty.call(obj, key) ){
-    	                return true;
-    	            }
-    	        }
-    	        return false;
-    	    }
+          const temp = new DataView(this._block.buffer);
+          temp.setUint32(56, this._length[0], true);
+          temp.setUint32(60, this._length[1], true);
+          this._block = new Uint8Array(temp.buffer);
 
-    	    /**
-    	     * Returns a function that throws the passed exception, for use as argument for setTimeout
-    	     * @alias throwException
-    	     * @function
-    	     * @param { Object } ex An Error object
-    	     */
-    	    function throwException( ex ){
-    	        return function reThrowException(){
-    	            throw ex;
-    	        };
-    	    }
+          this._update(); // produce result
 
-    	    function callSubscriberWithDelayedExceptions( subscriber, message, data ){
-    	        try {
-    	            subscriber( message, data );
-    	        } catch( ex ){
-    	            setTimeout( throwException( ex ), 0);
-    	        }
-    	    }
 
-    	    function callSubscriberWithImmediateExceptions( subscriber, message, data ){
-    	        subscriber( message, data );
-    	    }
+          const buffer = new DataView(new Uint8Array(20).buffer);
+          buffer.setInt32(0, this._a, true);
+          buffer.setInt32(4, this._b, true);
+          buffer.setInt32(8, this._c, true);
+          buffer.setInt32(12, this._d, true);
+          buffer.setInt32(16, this._e, true);
+          return new Uint8Array(buffer.buffer);
+        };
 
-    	    function deliverMessage( originalMessage, matchedMessage, data, immediateExceptions ){
-    	        var subscribers = messages[matchedMessage],
-    	            callSubscriber = immediateExceptions ? callSubscriberWithImmediateExceptions : callSubscriberWithDelayedExceptions,
-    	            s;
+        this._block = new Uint8Array(blockSize);
+        this._blockSize = blockSize;
+        this._blockOffset = 0;
+        this._length = [0, 0, 0, 0];
+        this._finalized = false;
+      }
 
-    	        if ( !Object.prototype.hasOwnProperty.call( messages, matchedMessage ) ) {
-    	            return;
-    	        }
+    }
 
-    	        for (s in subscribers){
-    	            if ( Object.prototype.hasOwnProperty.call(subscribers, s)){
-    	                callSubscriber( subscribers[s], originalMessage, data );
-    	            }
-    	        }
-    	    }
+    function sha256$1(payload) {
+      const data = typeof payload === 'string' ? fromString$1(payload) : payload;
+      return sha256$2.hash(data);
+    }
+    function keccak(data) {
+      return new Uint8Array(sha3$2.keccak_256.arrayBuffer(data));
+    }
+    function toEthereumAddress(hexPublicKey) {
+      const hashInput = fromString$1(hexPublicKey.slice(2), 'base16');
+      return `0x${toString$6(keccak(hashInput).slice(-20), 'base16')}`;
+    }
+    function ripemd160(data) {
+      return new Ripemd160().update(data).digest();
+    }
 
-    	    function createDeliveryFunction( message, data, immediateExceptions ){
-    	        return function deliverNamespaced(){
-    	            var topic = String( message ),
-    	                position = topic.lastIndexOf( '.' );
+    const secp256k1$1$1 = new elliptic.ec('secp256k1');
+    /**
+     *  Creates a configured signer function for signing data using the ES256K (secp256k1 + sha256) algorithm.
+     *
+     *  The signing function itself takes the data as a `Uint8Array` or `string` and returns a `base64Url`-encoded signature
+     *
+     *  @example
+     *  ```typescript
+     *  const sign: Signer = ES256KSigner(process.env.PRIVATE_KEY)
+     *  const signature: string = await sign(data)
+     *  ```
+     *
+     *  @param    {String}    privateKey   a private key as `Uint8Array`
+     *  @param    {Boolean}   recoverable  an optional flag to add the recovery param to the generated signatures
+     *  @return   {Function}               a configured signer function `(data: string | Uint8Array): Promise<string>`
+     */
 
-    	            // deliver the message as it is now
-    	            deliverMessage(message, message, data, immediateExceptions);
+    function ES256KSigner(privateKey, recoverable = false) {
+      const privateKeyBytes = privateKey;
 
-    	            // trim the hierarchy and deliver message to each level
-    	            while( position !== -1 ){
-    	                topic = topic.substr( 0, position );
-    	                position = topic.lastIndexOf('.');
-    	                deliverMessage( message, topic, data, immediateExceptions );
-    	            }
+      if (privateKeyBytes.length !== 32) {
+        throw new Error(`bad_key: Invalid private key format. Expecting 32 bytes, but got ${privateKeyBytes.length}`);
+      }
 
-    	            deliverMessage(message, ALL_SUBSCRIBING_MSG, data, immediateExceptions);
-    	        };
-    	    }
+      const keyPair = secp256k1$1$1.keyFromPrivate(privateKeyBytes);
+      return function (data) {
+        try {
+          const {
+            r,
+            s,
+            recoveryParam
+          } = keyPair.sign(sha256$1(data));
+          return Promise.resolve(toJose({
+            r: leftpad(r.toString('hex')),
+            s: leftpad(s.toString('hex')),
+            recoveryParam
+          }, recoverable));
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      };
+    }
 
-    	    function hasDirectSubscribersFor( message ) {
-    	        var topic = String( message ),
-    	            found = Boolean(Object.prototype.hasOwnProperty.call( messages, topic ) && hasKeys(messages[topic]));
+    new elliptic.ec('p256');
 
-    	        return found;
-    	    }
+    const publicKeyToAddress$1 = (publicKey, otherAddress) => {
+      // Use the same version/prefix byte as the given address.
+      const version = toString$6(base58ToBytes(otherAddress).slice(0, 1), 'hex');
+      const publicKeyBuffer = fromString$1(publicKey, 'hex');
+      const publicKeyHash = ripemd160(sha256$1(publicKeyBuffer));
+      const step1 = version + toString$6(publicKeyHash, 'hex');
+      const step2 = sha256$1(fromString$1(step1, 'hex'));
+      const step3 = sha256$1(step2);
+      const checksum = toString$6(step3, 'hex').substring(0, 8);
+      const step4 = step1 + checksum;
+      return bytesToBase58(fromString$1(step4, 'hex'));
+    };
 
-    	    function messageHasSubscribers( message ){
-    	        var topic = String( message ),
-    	            found = hasDirectSubscribersFor(topic) || hasDirectSubscribersFor(ALL_SUBSCRIBING_MSG),
-    	            position = topic.lastIndexOf( '.' );
+    const EC = elliptic.ec;
+    const publicKeyToAddress = (publicKey, prefix) => {
+      const ec = new EC('secp256k1');
+      const compressedPublicKey = ec.keyFromPublic(publicKey, 'hex').getPublic().encode('hex', true);
+      const publicKeyBuffer = fromString$1(compressedPublicKey, 'hex');
+      const hash = ripemd160(sha256$1(publicKeyBuffer));
+      const words = bech32.toWords(hash);
+      return bech32.encode(prefix, words).replace(prefix, '');
+    };
 
-    	        while ( !found && position !== -1 ){
-    	            topic = topic.substr( 0, position );
-    	            position = topic.lastIndexOf( '.' );
-    	            found = hasDirectSubscribersFor(topic);
-    	        }
+    const verifyBlockchainAccountId = (publicKey, blockchainAccountId) => {
+      if (blockchainAccountId) {
+        const chain = blockchainAccountId.split(':');
 
-    	        return found;
-    	    }
+        switch (chain[0]) {
+          case 'bip122':
+            chain[chain.length - 1] = publicKeyToAddress$1(publicKey, chain[chain.length - 1]);
+            break;
 
-    	    function publish( message, data, sync, immediateExceptions ){
-    	        message = (typeof message === 'symbol') ? message.toString() : message;
+          case 'cosmos':
+            chain[chain.length - 1] = publicKeyToAddress(publicKey, chain[1]);
+            break;
 
-    	        var deliver = createDeliveryFunction( message, data, immediateExceptions ),
-    	            hasSubscribers = messageHasSubscribers( message );
+          case 'eip155':
+            chain[chain.length - 1] = toEthereumAddress(publicKey);
+            break;
 
-    	        if ( !hasSubscribers ){
-    	            return false;
-    	        }
+          default:
+            return false;
+        }
 
-    	        if ( sync === true ){
-    	            deliver();
-    	        } else {
-    	            setTimeout( deliver, 0 );
-    	        }
-    	        return true;
-    	    }
+        return chain.join(':').toLowerCase() === blockchainAccountId.toLowerCase();
+      }
 
-    	    /**
-    	     * Publishes the message, passing the data to it's subscribers
-    	     * @function
-    	     * @alias publish
-    	     * @param { String } message The message to publish
-    	     * @param {} data The data to pass to subscribers
-    	     * @return { Boolean }
-    	     */
-    	    PubSub.publish = function( message, data ){
-    	        return publish( message, data, false, PubSub.immediateExceptions );
-    	    };
+      return false;
+    };
 
-    	    /**
-    	     * Publishes the message synchronously, passing the data to it's subscribers
-    	     * @function
-    	     * @alias publishSync
-    	     * @param { String } message The message to publish
-    	     * @param {} data The data to pass to subscribers
-    	     * @return { Boolean }
-    	     */
-    	    PubSub.publishSync = function( message, data ){
-    	        return publish( message, data, true, PubSub.immediateExceptions );
-    	    };
+    const secp256k1$2 = new elliptic.ec('secp256k1');
+    const secp256r1 = new elliptic.ec('p256'); // converts a JOSE signature to it's components
 
-    	    /**
-    	     * Subscribes the passed function to the passed message. Every returned token is unique and should be stored if you need to unsubscribe
-    	     * @function
-    	     * @alias subscribe
-    	     * @param { String } message The message to subscribe to
-    	     * @param { Function } func The function to call when a new message is published
-    	     * @return { String }
-    	     */
-    	    PubSub.subscribe = function( message, func ){
-    	        if ( typeof func !== 'function'){
-    	            return false;
-    	        }
+    function toSignatureObject(signature, recoverable = false) {
+      const rawSig = base64ToBytes(signature);
 
-    	        message = (typeof message === 'symbol') ? message.toString() : message;
+      if (rawSig.length !== (recoverable ? 65 : 64)) {
+        throw new Error('wrong signature length');
+      }
 
-    	        // message is not registered yet
-    	        if ( !Object.prototype.hasOwnProperty.call( messages, message ) ){
-    	            messages[message] = {};
-    	        }
+      const r = bytesToHex$1(rawSig.slice(0, 32));
+      const s = bytesToHex$1(rawSig.slice(32, 64));
+      const sigObj = {
+        r,
+        s
+      };
 
-    	        // forcing token as String, to allow for future expansions without breaking usage
-    	        // and allow for easy use as key names for the 'messages' object
-    	        var token = 'uid_' + String(++lastUid);
-    	        messages[message][token] = func;
+      if (recoverable) {
+        sigObj.recoveryParam = rawSig[64];
+      }
 
-    	        // return token for unsubscribing
-    	        return token;
-    	    };
+      return sigObj;
+    }
 
-    	    PubSub.subscribeAll = function( func ){
-    	        return PubSub.subscribe(ALL_SUBSCRIBING_MSG, func);
-    	    };
+    function extractPublicKeyBytes$1(pk) {
+      if (pk.publicKeyBase58) {
+        return base58ToBytes(pk.publicKeyBase58);
+      } else if (pk.publicKeyBase64) {
+        return base64ToBytes(pk.publicKeyBase64);
+      } else if (pk.publicKeyHex) {
+        return hexToBytes$1(pk.publicKeyHex);
+      } else if (pk.publicKeyJwk && pk.publicKeyJwk.crv === 'secp256k1' && pk.publicKeyJwk.x && pk.publicKeyJwk.y) {
+        return hexToBytes$1(secp256k1$2.keyFromPublic({
+          x: bytesToHex$1(base64ToBytes(pk.publicKeyJwk.x)),
+          y: bytesToHex$1(base64ToBytes(pk.publicKeyJwk.y))
+        }).getPublic('hex'));
+      } else if (pk.publicKeyJwk && pk.publicKeyJwk.crv === 'P-256' && pk.publicKeyJwk.x && pk.publicKeyJwk.y) {
+        return hexToBytes$1(secp256r1.keyFromPublic({
+          x: bytesToHex$1(base64ToBytes(pk.publicKeyJwk.x)),
+          y: bytesToHex$1(base64ToBytes(pk.publicKeyJwk.y))
+        }).getPublic('hex'));
+      } else if (pk.publicKeyJwk && pk.publicKeyJwk.kty === 'OKP' && pk.publicKeyJwk.crv === 'Ed25519' && pk.publicKeyJwk.x) {
+        return base64ToBytes(pk.publicKeyJwk.x);
+      } else if (pk.publicKeyMultibase) {
+        const {
+          base16,
+          base58btc,
+          base64,
+          base64url
+        } = bases;
+        const baseDecoder = base16.decoder.or(base58btc.decoder.or(base64.decoder.or(base64url.decoder)));
+        return baseDecoder.decode(pk.publicKeyMultibase);
+      }
 
-    	    /**
-    	     * Subscribes the passed function to the passed message once
-    	     * @function
-    	     * @alias subscribeOnce
-    	     * @param { String } message The message to subscribe to
-    	     * @param { Function } func The function to call when a new message is published
-    	     * @return { PubSub }
-    	     */
-    	    PubSub.subscribeOnce = function( message, func ){
-    	        var token = PubSub.subscribe( message, function(){
-    	            // before func apply, unsubscribe message
-    	            PubSub.unsubscribe( token );
-    	            func.apply( this, arguments );
-    	        });
-    	        return PubSub;
-    	    };
+      return new Uint8Array();
+    }
 
-    	    /**
-    	     * Clears all subscriptions
-    	     * @function
-    	     * @public
-    	     * @alias clearAllSubscriptions
-    	     */
-    	    PubSub.clearAllSubscriptions = function clearAllSubscriptions(){
-    	        messages = {};
-    	    };
+    function verifyES256(data, signature, authenticators) {
+      const hash = sha256$1(data);
+      const sigObj = toSignatureObject(signature);
+      const fullPublicKeys = authenticators.filter(({
+        ethereumAddress,
+        blockchainAccountId
+      }) => {
+        return typeof ethereumAddress === 'undefined' && typeof blockchainAccountId === 'undefined';
+      });
+      const signer = fullPublicKeys.find(pk => {
+        try {
+          const pubBytes = extractPublicKeyBytes$1(pk);
+          return secp256r1.keyFromPublic(pubBytes).verify(hash, sigObj);
+        } catch (err) {
+          return false;
+        }
+      });
+      if (!signer) throw new Error('invalid_signature: Signature invalid for JWT');
+      return signer;
+    }
+    function verifyES256K(data, signature, authenticators) {
+      const hash = sha256$1(data);
+      const sigObj = toSignatureObject(signature);
+      const fullPublicKeys = authenticators.filter(({
+        ethereumAddress,
+        blockchainAccountId
+      }) => {
+        return typeof ethereumAddress === 'undefined' && typeof blockchainAccountId === 'undefined';
+      });
+      const blockchainAddressKeys = authenticators.filter(({
+        ethereumAddress,
+        blockchainAccountId
+      }) => {
+        return typeof ethereumAddress !== 'undefined' || typeof blockchainAccountId !== 'undefined';
+      });
+      let signer = fullPublicKeys.find(pk => {
+        try {
+          const pubBytes = extractPublicKeyBytes$1(pk);
+          return secp256k1$2.keyFromPublic(pubBytes).verify(hash, sigObj);
+        } catch (err) {
+          return false;
+        }
+      });
 
-    	    /**
-    	     * Clear subscriptions by the topic
-    	     * @function
-    	     * @public
-    	     * @alias clearAllSubscriptions
-    	     * @return { int }
-    	     */
-    	    PubSub.clearSubscriptions = function clearSubscriptions(topic){
-    	        var m;
-    	        for (m in messages){
-    	            if (Object.prototype.hasOwnProperty.call(messages, m) && m.indexOf(topic) === 0){
-    	                delete messages[m];
-    	            }
-    	        }
-    	    };
+      if (!signer && blockchainAddressKeys.length > 0) {
+        signer = verifyRecoverableES256K(data, signature, blockchainAddressKeys);
+      }
 
-    	    /**
-    	       Count subscriptions by the topic
-    	     * @function
-    	     * @public
-    	     * @alias countSubscriptions
-    	     * @return { Array }
-    	    */
-    	    PubSub.countSubscriptions = function countSubscriptions(topic){
-    	        var m;
-    	        // eslint-disable-next-line no-unused-vars
-    	        var token;
-    	        var count = 0;
-    	        for (m in messages) {
-    	            if (Object.prototype.hasOwnProperty.call(messages, m) && m.indexOf(topic) === 0) {
-    	                for (token in messages[m]) {
-    	                    count++;
-    	                }
-    	                break;
-    	            }
-    	        }
-    	        return count;
-    	    };
+      if (!signer) throw new Error('invalid_signature: Signature invalid for JWT');
+      return signer;
+    }
+    function verifyRecoverableES256K(data, signature, authenticators) {
+      let signatures;
 
+      if (signature.length > 86) {
+        signatures = [toSignatureObject(signature, true)];
+      } else {
+        const so = toSignatureObject(signature, false);
+        signatures = [{ ...so,
+          recoveryParam: 0
+        }, { ...so,
+          recoveryParam: 1
+        }];
+      }
 
-    	    /**
-    	       Gets subscriptions by the topic
-    	     * @function
-    	     * @public
-    	     * @alias getSubscriptions
-    	    */
-    	    PubSub.getSubscriptions = function getSubscriptions(topic){
-    	        var m;
-    	        var list = [];
-    	        for (m in messages){
-    	            if (Object.prototype.hasOwnProperty.call(messages, m) && m.indexOf(topic) === 0){
-    	                list.push(m);
-    	            }
-    	        }
-    	        return list;
-    	    };
+      const checkSignatureAgainstSigner = sigObj => {
+        const hash = sha256$1(data); // eslint-disable-next-line @typescript-eslint/no-explicit-any
 
-    	    /**
-    	     * Removes subscriptions
-    	     *
-    	     * - When passed a token, removes a specific subscription.
-    	     *
-    		 * - When passed a function, removes all subscriptions for that function
-    	     *
-    		 * - When passed a topic, removes all subscriptions for that topic (hierarchy)
-    	     * @function
-    	     * @public
-    	     * @alias subscribeOnce
-    	     * @param { String | Function } value A token, function or topic to unsubscribe from
-    	     * @example // Unsubscribing with a token
-    	     * var token = PubSub.subscribe('mytopic', myFunc);
-    	     * PubSub.unsubscribe(token);
-    	     * @example // Unsubscribing with a function
-    	     * PubSub.unsubscribe(myFunc);
-    	     * @example // Unsubscribing from a topic
-    	     * PubSub.unsubscribe('mytopic');
-    	     */
-    	    PubSub.unsubscribe = function(value){
-    	        var descendantTopicExists = function(topic) {
-    	                var m;
-    	                for ( m in messages ){
-    	                    if ( Object.prototype.hasOwnProperty.call(messages, m) && m.indexOf(topic) === 0 ){
-    	                        // a descendant of the topic exists:
-    	                        return true;
-    	                    }
-    	                }
+        const recoveredKey = secp256k1$2.recoverPubKey(hash, sigObj, sigObj.recoveryParam);
+        const recoveredPublicKeyHex = recoveredKey.encode('hex');
+        const recoveredCompressedPublicKeyHex = recoveredKey.encode('hex', true);
+        const recoveredAddress = toEthereumAddress(recoveredPublicKeyHex).toLowerCase();
+        const signer = authenticators.find(pk => {
+          var _pk$ethereumAddress, _pk$blockchainAccount, _pk$blockchainAccount2;
 
-    	                return false;
-    	            },
-    	            isTopic    = typeof value === 'string' && ( Object.prototype.hasOwnProperty.call(messages, value) || descendantTopicExists(value) ),
-    	            isToken    = !isTopic && typeof value === 'string',
-    	            isFunction = typeof value === 'function',
-    	            result = false,
-    	            m, message, t;
+          const keyHex = bytesToHex$1(extractPublicKeyBytes$1(pk));
+          return keyHex === recoveredPublicKeyHex || keyHex === recoveredCompressedPublicKeyHex || ((_pk$ethereumAddress = pk.ethereumAddress) == null ? void 0 : _pk$ethereumAddress.toLowerCase()) === recoveredAddress || ((_pk$blockchainAccount = pk.blockchainAccountId) == null ? void 0 : (_pk$blockchainAccount2 = _pk$blockchainAccount.split('@eip155')) == null ? void 0 : _pk$blockchainAccount2[0].toLowerCase()) === recoveredAddress || // CAIP-2
+          verifyBlockchainAccountId(recoveredPublicKeyHex, pk.blockchainAccountId) // CAIP-10
+          ;
+        });
+        return signer;
+      };
 
-    	        if (isTopic){
-    	            PubSub.clearSubscriptions(value);
-    	            return;
-    	        }
+      const signer = signatures.map(checkSignatureAgainstSigner).filter(key => typeof key !== 'undefined');
+      if (signer.length === 0) throw new Error('invalid_signature: Signature invalid for JWT');
+      return signer[0];
+    }
+    function verifyEd25519(data, signature, authenticators) {
+      const clear = stringToBytes$1(data);
+      const sig = base64ToBytes(signature);
+      const signer = authenticators.find(pk => {
+        return ed25519.verify(extractPublicKeyBytes$1(pk), clear, sig);
+      });
+      if (!signer) throw new Error('invalid_signature: Signature invalid for JWT');
+      return signer;
+    }
+    const algorithms = {
+      ES256: verifyES256,
+      ES256K: verifyES256K,
+      // This is a non-standard algorithm but retained for backwards compatibility
+      // see https://github.com/decentralized-identity/did-jwt/issues/146
+      'ES256K-R': verifyRecoverableES256K,
+      // This is actually incorrect but retained for backwards compatibility
+      // see https://github.com/decentralized-identity/did-jwt/issues/130
+      Ed25519: verifyEd25519,
+      EdDSA: verifyEd25519
+    };
 
-    	        for ( m in messages ){
-    	            if ( Object.prototype.hasOwnProperty.call( messages, m ) ){
-    	                message = messages[m];
+    function VerifierAlgorithm(alg) {
+      const impl = algorithms[alg];
+      if (!impl) throw new Error(`not_supported: Unsupported algorithm ${alg}`);
+      return impl;
+    }
 
-    	                if ( isToken && message[value] ){
-    	                    delete message[value];
-    	                    result = value;
-    	                    // tokens are unique, so we can just stop here
-    	                    break;
-    	                }
+    VerifierAlgorithm.toSignatureObject = toSignatureObject;
 
-    	                if (isFunction) {
-    	                    for ( t in message ){
-    	                        if (Object.prototype.hasOwnProperty.call(message, t) && message[t] === value){
-    	                            delete message[t];
-    	                            result = true;
-    	                        }
-    	                    }
-    	                }
-    	            }
-    	        }
+    function decodeJWS(jws) {
+      const parts = jws.match(/^([a-zA-Z0-9_-]+)\.([a-zA-Z0-9_-]+)\.([a-zA-Z0-9_-]+)$/);
 
-    	        return result;
-    	    };
-    	})); 
-    } (pubsub, pubsub.exports));
+      if (parts) {
+        return {
+          header: JSON.parse(decodeBase64url(parts[1])),
+          payload: parts[2],
+          signature: parts[3],
+          data: `${parts[1]}.${parts[2]}`
+        };
+      }
 
-    var pubsubExports = pubsub.exports;
-    var PubSub = /*@__PURE__*/getDefaultExportFromCjs$1(pubsubExports);
+      throw new Error('invalid_argument: Incorrect format JWS');
+    }
 
-    const SDK_EVENTS = {
-        TX_RECEIPT_ACCEPTED: 'TX_RECEIPT_ACCEPTED'
-    };
-    /**
-     * Represents a message bus that allows publishing and subscribing to topics.
+    function verifyJWSDecoded({
+      header,
+      data,
+      signature
+    }, pubKeys) {
+      if (!Array.isArray(pubKeys)) pubKeys = [pubKeys];
+      const signer = VerifierAlgorithm(header.alg)(data, signature, pubKeys);
+      return signer;
+    }
+    /**
+     *  Verifies given JWS. If the JWS is valid, returns the public key that was
+     *  used to sign the JWS, or throws an `Error` if none of the `pubKeys` match.
+     *
+     *  @example
+     *  const pubKey = verifyJWS('eyJ0eXAiOiJKV1QiLCJhbGciOiJFUzI1NksifQ.eyJyZXF1Z....', { publicKeyHex: '0x12341...' })
+     *
+     *  @param    {String}                          jws         A JWS string to verify
+     *  @param    {Array<VerificationMethod> | VerificationMethod}    pubKeys     The public keys used to verify the JWS
+     *  @return   {VerificationMethod}                       The public key used to sign the JWS
      */
-    class MessageBus {
-        /**
-         * Private constructor for the MessageBus class.
-         */
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        constructor() { }
-        /**
-         * Returns the singleton instance of the MessageBus class.
-         * If the instance doesn't exist, it creates a new one.
-         * @returns The singleton instance of the MessageBus class.
-         */
-        static getInstance() {
-            // If the instance doesn't exist, create it
-            if (!MessageBus.instance) {
-                MessageBus.instance = new MessageBus();
-            }
-            // Return the instance
-            return MessageBus.instance;
-        }
-        /**
-         * Publishes a message to the specified topic.
-         *
-         * @template T - The type of data being published.
-         * @param {SdkTopic} topic - The topic to publish the message to.
-         * @param {T} data - The data to be published.
-         * @returns {boolean} - Returns true if the message was successfully published, false otherwise.
-         */
-        publish(topic, data) {
-            return PubSub.publish(topic.toString(), data);
-        }
-        /**
-         * Subscribes to a specific topic and registers a callback function to be executed when a message is published.
-         *
-         * @param topic - The topic to subscribe to.
-         * @param callback - The callback function to be executed when a message is published.
-         */
-        subscribe(topic, callback) {
-            return PubSub.subscribe(topic.toString(), (_, data) => callback(data));
-        }
-        /**
-         * Subscribes to a specific topic and registers a callback function to be executed when a message is published.
-         * The callback function is executed only once.
-         *
-         * @param topic - The topic to subscribe to.
-         * @param callback - The callback function to be executed when a message is published.
-         */
-        subscribeOnce(topic, callback) {
-            PubSub.subscribeOnce(topic.toString(), (_, data) => callback(data));
-        }
-        /**
-         * Unsubscribes from a specific topic in the message bus.
-         *
-         * @param topic - The topic to unsubscribe from.
-         * @returns A string or boolean indicating the success of the unsubscribe operation.
-         */
-        unsubscribe(topic) {
-            return PubSub.unsubscribe(topic.toString());
-        }
+
+
+    function verifyJWS(jws, pubKeys) {
+      const jwsDecoded = decodeJWS(jws);
+      return verifyJWSDecoded(jwsDecoded, pubKeys);
     }
 
-    const bigIntCompare = (a, b) => {
-        if (a < b)
-            return -1;
-        if (a > b)
-            return 1;
-        return 0;
-    };
+    typeof Symbol !== "undefined" ? Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator")) : "@@iterator";
 
     /**
      * Provider for Sec256p1 keys256p1
@@ -14334,8 +15983,8 @@ var PolygonIdSdk = (function (exports) {
             if (!privateKeyHex) {
                 throw new Error('Private key not found for keyId: ' + keyId.id);
             }
-            const signatureBase64 = await ES256KSigner(hexToBytes$1(privateKeyHex), opts.alg === 'ES256K-R')(data);
-            const signatureHex = bytesToHex$1(base64UrlToBytes(signatureBase64.toString()));
+            const signatureBase64 = await ES256KSigner(hexToBytes$2(privateKeyHex), opts.alg === 'ES256K-R')(data);
+            const signatureHex = bytesToHex$2(base64UrlToBytes(signatureBase64.toString()));
             if (typeof signatureHex !== 'string') {
                 throw new Error('Signature is not a string');
             }
@@ -14388,6 +16037,7 @@ var PolygonIdSdk = (function (exports) {
     (function (KmsKeyType) {
         KmsKeyType["BabyJubJub"] = "BJJ";
         KmsKeyType["Secp256k1"] = "Secp256k1";
+        KmsKeyType["Ed25519"] = "Ed25519";
     })(exports.KmsKeyType || (exports.KmsKeyType = {}));
 
     /**
@@ -56014,6 +57664,10 @@ var PolygonIdSdk = (function (exports) {
         $sd: exports.Operators.SD,
         $nullify: exports.Operators.NULLIFY
     };
+    const getOperatorNameByValue = (operator) => {
+        const ops = Object.entries(QueryOperators).find(([, queryOp]) => queryOp === operator);
+        return ops ? ops[0] : 'unknown';
+    };
     const allOperations$1 = Object.values(QueryOperators);
     const availableTypesOperators = new Map([
         [
@@ -83719,6 +85373,7 @@ var PolygonIdSdk = (function (exports) {
                 circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
                 circuitInputs.profileNonce = BigInt(params.authProfileNonce);
                 circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
+                this.checkOperatorSupport(proofReq.circuitId, query.operator);
                 return circuitInputs.inputsMarshal();
             };
             this.credentialAtomicQueryMTPV2OnChainPrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
@@ -83766,6 +85421,7 @@ var PolygonIdSdk = (function (exports) {
                 circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
                 circuitInputs.profileNonce = BigInt(params.authProfileNonce);
                 circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
+                this.checkOperatorSupport(proofReq.circuitId, query.operator);
                 return circuitInputs.inputsMarshal();
             };
             this.credentialAtomicQuerySigV2PrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
@@ -83787,6 +85443,7 @@ var PolygonIdSdk = (function (exports) {
                 query.operator = this.transformV2QueryOperator(query.operator);
                 circuitInputs.query = query;
                 circuitInputs.currentTimeStamp = S$3(new Date());
+                this.checkOperatorSupport(proofReq.circuitId, query.operator);
                 return circuitInputs.inputsMarshal();
             };
             this.credentialAtomicQuerySigV2OnChainPrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
@@ -83834,6 +85491,7 @@ var PolygonIdSdk = (function (exports) {
                 const signature = await this._identityWallet.signChallenge(params.challenge, authInfo.credential);
                 circuitInputs.signature = signature;
                 circuitInputs.challenge = params.challenge;
+                this.checkOperatorSupport(proofReq.circuitId, query.operator);
                 return circuitInputs.inputsMarshal();
             };
             this.credentialAtomicQueryV3PrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
@@ -83883,6 +85541,7 @@ var PolygonIdSdk = (function (exports) {
                 circuitInputs.nullifierSessionID = proofReq.params?.nullifierSessionId
                     ? BigInt(proofReq.params?.nullifierSessionId?.toString())
                     : BigInt(0);
+                this.checkOperatorSupport(proofReq.circuitId, query.operator);
                 return circuitInputs.inputsMarshal();
             };
             this.credentialAtomicQueryV3OnChainPrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
@@ -83961,15 +85620,19 @@ var PolygonIdSdk = (function (exports) {
                     circuitInputs.treeState = authClaimData.treeState;
                     circuitInputs.signature = signature;
                 }
+                this.checkOperatorSupport(proofReq.circuitId, query.operator);
                 return circuitInputs.inputsMarshal();
             };
-            this.linkedMultiQuery10PrepareInputs = async ({ preparedCredential, params, circuitQueries }) => {
+            this.linkedMultiQuery10PrepareInputs = async ({ preparedCredential, params, proofReq, circuitQueries }) => {
                 const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
                 circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
                 const circuitInputs = new LinkedMultiQueryInputs();
                 circuitInputs.linkNonce = params.linkNonce ?? BigInt(0);
                 circuitInputs.claim = circuitClaimData.claim;
                 circuitInputs.query = circuitQueries;
+                circuitQueries.forEach((query) => {
+                    this.checkOperatorSupport(proofReq.circuitId, query.operator);
+                });
                 return circuitInputs.inputsMarshal();
             };
         }
@@ -84054,10 +85717,16 @@ var PolygonIdSdk = (function (exports) {
         transformV2QueryOperator(operator) {
             return operator === exports.Operators.SD || operator === exports.Operators.NOOP ? exports.Operators.EQ : operator;
         }
+        checkOperatorSupport(circuitId, operator) {
+            const supportedOperators = circuitValidator[circuitId].supportedOperations;
+            if (!supportedOperators.includes(operator)) {
+                throw new Error(`operator ${getOperatorNameByValue(operator)} is not supported by ${circuitId}`);
+            }
+        }
     }
 
     const defaultProofGenerationDelayOpts = 24 * 60 * 60 * 1000; // 24 hours
-    async function checkQueryRequest(query, outputs, circuitId, schemaLoader, verifiablePresentation, opts) {
+    async function checkQueryRequest(query, queriesMetadata, ldContext, outputs, circuitId, schemaLoader, opts) {
         // validate issuer
         const userDID = W$2.parseFromId(outputs.issuerId);
         const issuerAllowed = !query.allowedIssuers ||
@@ -84065,19 +85734,10 @@ var PolygonIdSdk = (function (exports) {
         if (!issuerAllowed) {
             throw new Error('issuer is not in allowed list');
         }
-        // validate schema
-        let schema;
-        try {
-            const loader = schemaLoader ?? af();
-            schema = (await loader(query.context ?? '')).document;
-        }
-        catch (e) {
-            throw new Error(`can't load schema for request query`);
-        }
         if (!query.type) {
-            throw new Error(`proof query type is undefined`);
+            throw new Error('query type is missing');
         }
-        const schemaId = await lf.getTypeIDFromContext(JSON.stringify(schema), query.type, {
+        const schemaId = await lf.getTypeIDFromContext(JSON.stringify(ldContext), query.type, {
             documentLoader: schemaLoader
         });
         const schemaHash = calculateCoreSchemaHash(byteEncoder.encode(schemaId));
@@ -84087,75 +85747,67 @@ var PolygonIdSdk = (function (exports) {
         if (!query.skipClaimRevocationCheck && outputs.isRevocationChecked === 0) {
             throw new Error(`check revocation is required`);
         }
-        const queriesMetadata = await parseQueriesMetadata(query.type, JSON.stringify(schema), query.credentialSubject, {
-            documentLoader: schemaLoader
-        });
+        checkCircuitQueriesLength(circuitId, queriesMetadata);
+        // verify timestamp
+        let acceptedProofGenerationDelay = defaultProofGenerationDelayOpts;
+        if (opts?.acceptedProofGenerationDelay) {
+            acceptedProofGenerationDelay = opts.acceptedProofGenerationDelay;
+        }
+        const timeDiff = Date.now() - b$4(Number(outputs.timestamp)).getTime();
+        if (timeDiff > acceptedProofGenerationDelay) {
+            throw new Error('generated proof is outdated');
+        }
+        return;
+    }
+    function checkCircuitQueriesLength(circuitId, queriesMetadata) {
         const circuitValidationData = circuitValidator[circuitId];
         if (queriesMetadata.length > circuitValidationData.maxQueriesCount) {
             throw new Error(`circuit ${circuitId} supports only ${circuitValidator[circuitId].maxQueriesCount} queries`);
         }
-        const notSupportedOpIndx = queriesMetadata.findIndex((i) => !circuitValidationData.supportedOperations.includes(i.operator));
-        if (notSupportedOpIndx > -1) {
-            throw new Error(`circuit ${circuitId} not support ${queriesMetadata[notSupportedOpIndx].operator} operator`);
+    }
+    function checkCircuitOperator(circuitId, operator) {
+        const circuitValidationData = circuitValidator[circuitId];
+        if (!circuitValidationData.supportedOperations.includes(operator)) {
+            throw new Error(`circuit ${circuitId} not support ${getOperatorNameByValue(operator)} operator`);
         }
-        for (let i = 0; i < queriesMetadata.length; i++) {
-            const metadata = queriesMetadata[i];
-            if (!query.type) {
-                throw new Error(`proof query type is undefined`);
-            }
-            // validate selective disclosure
-            if (metadata.operator === exports.Operators.SD) {
-                try {
-                    await validateDisclosure(metadata, outputs, verifiablePresentation, schemaLoader);
-                }
-                catch (e) {
-                    throw new Error(`failed to validate selective disclosure: ${e.message}`);
-                }
-            }
-            else if (!metadata.fieldName && metadata.operator == exports.Operators.NOOP) {
-                try {
-                    await validateEmptyCredentialSubject(metadata, outputs);
-                    return;
-                }
-                catch (e) {
-                    throw new Error(`failed to validate operators: ${e.message}`);
-                }
-            }
-            else {
-                try {
-                    await validateOperators(metadata, outputs);
-                }
-                catch (e) {
-                    throw new Error(`failed to validate operators: ${e.message}`);
-                }
+    }
+    function verifyFieldValueInclusionV2(outputs, metadata) {
+        if (outputs.operator == QueryOperators.$noop) {
+            return;
+        }
+        if (outputs.merklized === 1) {
+            if (outputs.claimPathNotExists === 1) {
+                throw new Error(`proof doesn't contains target query key`);
             }
-            // verify claim
-            if (outputs.merklized === 1) {
-                if (outputs.claimPathNotExists === 1) {
-                    throw new Error(`proof doesn't contains target query key`);
-                }
-                if (outputs.claimPathKey !== metadata.claimPathKey) {
-                    throw new Error(`proof was generated for another path`);
-                }
+            if (outputs.claimPathKey !== metadata.claimPathKey) {
+                throw new Error(`proof was generated for another path`);
             }
-            else {
-                if (outputs.slotIndex !== metadata.slotIndex) {
-                    throw new Error(`wrong claim slot was used in claim`);
-                }
+        }
+        else {
+            if (outputs.slotIndex !== metadata.slotIndex) {
+                throw new Error(`wrong claim slot was used in claim`);
             }
-            // verify timestamp
-            let acceptedProofGenerationDelay = defaultProofGenerationDelayOpts;
-            if (opts?.acceptedProofGenerationDelay) {
-                acceptedProofGenerationDelay = opts.acceptedProofGenerationDelay;
+        }
+    }
+    function verifyFieldValueInclusionNativeExistsSupport(outputs, metadata) {
+        if (outputs.operator == exports.Operators.NOOP) {
+            return;
+        }
+        if (outputs.operator === exports.Operators.EXISTS && !outputs.merklized) {
+            throw new Error('$exists operator is not supported for non-merklized credential');
+        }
+        if (outputs.merklized === 1) {
+            if (outputs.claimPathKey !== metadata.claimPathKey) {
+                throw new Error(`proof was generated for another path`);
             }
-            const timeDiff = Date.now() - b$4(Number(outputs.timestamp)).getTime();
-            if (timeDiff > acceptedProofGenerationDelay) {
-                throw new Error('generated proof is outdated');
+        }
+        else {
+            if (outputs.slotIndex !== metadata.slotIndex) {
+                throw new Error(`wrong claim slot was used in claim`);
             }
         }
-        return;
     }
-    async function validateEmptyCredentialSubject(cq, outputs) {
+    async function validateEmptyCredentialSubjectV2Circuit(cq, outputs) {
         if (outputs.operator !== exports.Operators.EQ) {
             throw new Error('empty credentialSubject request available only for equal operation');
         }
@@ -84188,7 +85840,11 @@ var PolygonIdSdk = (function (exports) {
             }
         }
     }
-    async function validateDisclosure(cq, outputs, verifiablePresentation, ldLoader) {
+    async function validateDisclosureV2Circuit(cq, outputs, verifiablePresentation, ldLoader) {
+        const bi = await fieldValueFromVerifiablePresentation(cq.fieldName, verifiablePresentation, ldLoader);
+        if (bi !== outputs.value[0]) {
+            throw new Error(`value that was used is not equal to requested in query`);
+        }
         if (outputs.operator !== exports.Operators.EQ) {
             throw new Error(`operator for selective disclosure must be $eq`);
         }
@@ -84197,9 +85853,29 @@ var PolygonIdSdk = (function (exports) {
                 throw new Error(`selective disclosure not available for array of values`);
             }
         }
+    }
+    async function validateDisclosureNativeSDSupport(cq, outputs, verifiablePresentation, ldLoader) {
         const bi = await fieldValueFromVerifiablePresentation(cq.fieldName, verifiablePresentation, ldLoader);
-        if (bi !== outputs.value[0]) {
-            throw new Error(`value that was used is not equal to requested in query`);
+        if (bi !== outputs.operatorOutput) {
+            throw new Error(`operator output should be equal to disclosed value`);
+        }
+        if (outputs.operator !== exports.Operators.SD) {
+            throw new Error(`operator for selective disclosure must be $sd`);
+        }
+        for (let index = 0; index < outputs.value.length; index++) {
+            if (outputs.value[index] !== 0n) {
+                throw new Error(`public signal values must be zero`);
+            }
+        }
+    }
+    async function validateEmptyCredentialSubjectNoopNativeSupport(outputs) {
+        if (outputs.operator !== exports.Operators.NOOP) {
+            throw new Error('empty credentialSubject request available only for $noop operation');
+        }
+        for (let index = 1; index < outputs.value.length; index++) {
+            if (outputs.value[index] !== 0n) {
+                throw new Error(`empty credentialSubject request not available for array of values`);
+            }
         }
     }
     const fieldValueFromVerifiablePresentation = async (fieldName, verifiablePresentation, ldLoader) => {
@@ -84320,7 +85996,7 @@ var PolygonIdSdk = (function (exports) {
                     valueArraySize: mtpv2PubSignals.getValueArrSize(),
                     isRevocationChecked: mtpv2PubSignals.isRevocationChecked
                 };
-                await checkQueryRequest(query, outs, exports.CircuitId.AtomicQueryMTPV2, this._documentLoader, verifiablePresentation, opts);
+                await this.checkQueryV2Circuits(exports.CircuitId.AtomicQueryMTPV2, query, outs, opts, verifiablePresentation);
                 // verify state
                 await this.checkStateExistenceForId(mtpv2PubSignals.issuerID, mtpv2PubSignals.issuerClaimIdenState);
                 if (mtpv2PubSignals.isRevocationChecked !== 0) {
@@ -84349,7 +86025,7 @@ var PolygonIdSdk = (function (exports) {
                     valueArraySize: sigV2PubSignals.getValueArrSize(),
                     isRevocationChecked: sigV2PubSignals.isRevocationChecked
                 };
-                await checkQueryRequest(query, outs, exports.CircuitId.AtomicQuerySigV2, this._documentLoader, verifiablePresentation, opts);
+                await this.checkQueryV2Circuits(exports.CircuitId.AtomicQuerySigV2, query, outs, opts, verifiablePresentation);
                 // verify state
                 await this.checkStateExistenceForId(sigV2PubSignals.issuerID, sigV2PubSignals.issuerAuthState);
                 if (sigV2PubSignals.isRevocationChecked !== 0) {
@@ -84375,9 +86051,55 @@ var PolygonIdSdk = (function (exports) {
                     merklized: v3PubSignals.merklized,
                     claimPathKey: v3PubSignals.claimPathKey,
                     valueArraySize: v3PubSignals.getValueArrSize(),
+                    operatorOutput: v3PubSignals.operatorOutput,
                     isRevocationChecked: v3PubSignals.isRevocationChecked
                 };
-                await checkQueryRequest(query, outs, exports.CircuitId.AtomicQueryV3, this._documentLoader, verifiablePresentation, opts);
+                if (!query.type) {
+                    throw new Error(`proof query type is undefined`);
+                }
+                const loader = this._documentLoader ?? af();
+                // validate schema
+                let context;
+                try {
+                    context = (await loader(query.context ?? '')).document;
+                }
+                catch (e) {
+                    throw new Error(`can't load schema for request query`);
+                }
+                const queriesMetadata = await parseQueriesMetadata(query.type, JSON.stringify(context), query.credentialSubject, {
+                    documentLoader: loader
+                });
+                const circuitId = exports.CircuitId.AtomicQueryV3;
+                await checkQueryRequest(query, queriesMetadata, context, outs, circuitId, this._documentLoader, opts);
+                const queryMetadata = queriesMetadata[0]; // only one query is supported
+                checkCircuitOperator(circuitId, outs.operator);
+                // validate selective disclosure
+                if (queryMetadata.operator === exports.Operators.SD) {
+                    try {
+                        await validateDisclosureNativeSDSupport(queryMetadata, outs, verifiablePresentation, loader);
+                    }
+                    catch (e) {
+                        throw new Error(`failed to validate selective disclosure: ${e.message}`);
+                    }
+                }
+                else if (!queryMetadata.fieldName && queryMetadata.operator == exports.Operators.NOOP) {
+                    try {
+                        await validateEmptyCredentialSubjectNoopNativeSupport(outs);
+                    }
+                    catch (e) {
+                        throw new Error(`failed to validate operators: ${e.message}`);
+                    }
+                }
+                else {
+                    try {
+                        await validateOperators(queryMetadata, outs);
+                    }
+                    catch (e) {
+                        throw new Error(`failed to validate operators: ${e.message}`);
+                    }
+                }
+                // verify field inclusion / non-inclusion
+                verifyFieldValueInclusionNativeExistsSupport(outs, queryMetadata);
                 const { proofType, verifierID, nullifier, nullifierSessionID, linkID } = v3PubSignals;
                 switch (query.proofType) {
                     case exports.ProofType.BJJSignature:
@@ -84552,6 +86274,53 @@ var PolygonIdSdk = (function (exports) {
             }
             return fn(ctx);
         }
+        async checkQueryV2Circuits(circuitId, query, outs, opts, verifiablePresentation) {
+            if (!query.type) {
+                throw new Error(`proof query type is undefined`);
+            }
+            const loader = this._documentLoader ?? af();
+            // validate schema
+            let context;
+            try {
+                context = (await loader(query.context ?? '')).document;
+            }
+            catch (e) {
+                throw new Error(`can't load schema for request query`);
+            }
+            const queriesMetadata = await parseQueriesMetadata(query.type, JSON.stringify(context), query.credentialSubject, {
+                documentLoader: loader
+            });
+            await checkQueryRequest(query, queriesMetadata, context, outs, circuitId, this._documentLoader, opts);
+            const queryMetadata = queriesMetadata[0]; // only one query is supported
+            checkCircuitOperator(circuitId, outs.operator);
+            // validate selective disclosure
+            if (queryMetadata.operator === exports.Operators.SD) {
+                try {
+                    await validateDisclosureV2Circuit(queryMetadata, outs, verifiablePresentation, loader);
+                }
+                catch (e) {
+                    throw new Error(`failed to validate selective disclosure: ${e.message}`);
+                }
+            }
+            else if (!queryMetadata.fieldName && queryMetadata.operator == exports.Operators.NOOP) {
+                try {
+                    await validateEmptyCredentialSubjectV2Circuit(queryMetadata, outs);
+                }
+                catch (e) {
+                    throw new Error(`failed to validate operators: ${e.message}`);
+                }
+            }
+            else {
+                try {
+                    await validateOperators(queryMetadata, outs);
+                }
+                catch (e) {
+                    throw new Error(`failed to validate operators: ${e.message}`);
+                }
+            }
+            // verify field inclusion
+            verifyFieldValueInclusionV2(outs, queryMetadata);
+        }
         async resolve(id, state) {
             const idBigInt = id.bigInt();
             const did = W$2.parseFromId(id);
@@ -85048,7 +86817,7 @@ var PolygonIdSdk = (function (exports) {
             }
             else {
                 const header = envelope.split('.')[0];
-                base64HeaderBytes = base64$1.parse(header, { loose: true });
+                base64HeaderBytes = base64$3.parse(header, { loose: true });
             }
             const header = bytesToHeaderStub(base64HeaderBytes);
             return header.typ;
@@ -85261,7 +87030,7 @@ var PolygonIdSdk = (function (exports) {
     const extractPublicKeyBytes = (vm) => {
         const isSupportedVmType = Object.keys(SUPPORTED_PUBLIC_KEY_TYPES).some((key) => SUPPORTED_PUBLIC_KEY_TYPES[key].includes(vm.type));
         if (vm.publicKeyBase58 && isSupportedVmType) {
-            return { publicKeyBytes: base58ToBytes(vm.publicKeyBase58), kmsKeyType: exports.KmsKeyType.Secp256k1 };
+            return { publicKeyBytes: base58ToBytes$1(vm.publicKeyBase58), kmsKeyType: exports.KmsKeyType.Secp256k1 };
         }
         if (vm.publicKeyBase64 && isSupportedVmType) {
             return {
@@ -85270,17 +87039,17 @@ var PolygonIdSdk = (function (exports) {
             };
         }
         if (vm.publicKeyHex && isSupportedVmType) {
-            return { publicKeyBytes: hexToBytes$1(vm.publicKeyHex), kmsKeyType: exports.KmsKeyType.Secp256k1 };
+            return { publicKeyBytes: hexToBytes$2(vm.publicKeyHex), kmsKeyType: exports.KmsKeyType.Secp256k1 };
         }
         if (vm.publicKeyJwk &&
             vm.publicKeyJwk.crv === 'secp256k1' &&
             vm.publicKeyJwk.x &&
             vm.publicKeyJwk.y) {
             return {
-                publicKeyBytes: hexToBytes$1(secp256k1
+                publicKeyBytes: hexToBytes$2(secp256k1
                     .keyFromPublic({
-                    x: bytesToHex$1(base64UrlToBytes(vm.publicKeyJwk.x)),
-                    y: bytesToHex$1(base64UrlToBytes(vm.publicKeyJwk.y))
+                    x: bytesToHex$2(base64UrlToBytes(vm.publicKeyJwk.x)),
+                    y: bytesToHex$2(base64UrlToBytes(vm.publicKeyJwk.y))
                 })
                     .getPublic('hex')),
                 kmsKeyType: exports.KmsKeyType.Secp256k1
@@ -85407,7 +87176,7 @@ var PolygonIdSdk = (function (exports) {
                 if (!kmsKeyType) {
                     throw new Error('No KMS key type found');
                 }
-                const signatureBytes = await this._kms.sign({ type: kmsKeyType, id: keyPath(kmsKeyType, bytesToHex$1(publicKeyBytes)) }, signingInputBytes);
+                const signatureBytes = await this._kms.sign({ type: kmsKeyType, id: keyPath(kmsKeyType, bytesToHex$2(publicKeyBytes)) }, signingInputBytes);
                 signatureBase64 = byteDecoder.decode(signatureBytes);
             }
             return byteEncoder.encode(`${signingInput}.${signatureBase64}`);
@@ -85421,8 +87190,8 @@ var PolygonIdSdk = (function (exports) {
         async unpack(envelope) {
             const jws = byteDecoder.decode(envelope);
             const [headerStr, msgStr] = jws.split('.');
-            const header = JSON.parse(decodeBase64url(headerStr));
-            const message = JSON.parse(decodeBase64url(msgStr));
+            const header = JSON.parse(decodeBase64url$1(headerStr));
+            const message = JSON.parse(decodeBase64url$1(msgStr));
             const explicitSender = parse(header.kid)?.did;
             if (explicitSender && explicitSender !== message.from) {
                 throw new Error(`Sender does not match DID in message with kid ${header?.kid}`);
@@ -86156,6 +87925,7 @@ var PolygonIdSdk = (function (exports) {
     exports.CredentialWallet = CredentialWallet;
     exports.DIDDocumentJSONSchema = DIDDocumentJSONSchema;
     exports.DataPrepareHandlerFunc = DataPrepareHandlerFunc;
+    exports.Ed25519Provider = Ed25519Provider;
     exports.ErrorEmptyAuthClaimNonRevProof = ErrorEmptyAuthClaimNonRevProof;
     exports.ErrorEmptyAuthClaimProof = ErrorEmptyAuthClaimProof;
     exports.ErrorEmptyChallengeSignature = ErrorEmptyChallengeSignature;
@@ -86221,8 +87991,8 @@ var PolygonIdSdk = (function (exports) {
     exports.W3CCredential = W3CCredential;
     exports.ZKPPacker = ZKPPacker;
     exports.availableTypesOperators = availableTypesOperators;
-    exports.base58ToBytes = base58ToBytes;
-    exports.base64ToBytes = base64ToBytes;
+    exports.base58ToBytes = base58ToBytes$1;
+    exports.base64ToBytes = base64ToBytes$1;
     exports.base64UrlToBytes = base64UrlToBytes;
     exports.bigIntArrayToStringArray = bigIntArrayToStringArray;
     exports.bigIntCompare = bigIntCompare;
@@ -86231,14 +88001,16 @@ var PolygonIdSdk = (function (exports) {
     exports.buildVerifierId = buildVerifierId;
     exports.byteDecoder = byteDecoder;
     exports.byteEncoder = byteEncoder;
-    exports.bytesToBase58 = bytesToBase58;
+    exports.bytesToBase58 = bytesToBase58$1;
     exports.bytesToBase64 = bytesToBase64;
-    exports.bytesToBase64url = bytesToBase64url;
-    exports.bytesToHex = bytesToHex$1;
+    exports.bytesToBase64url = bytesToBase64url$1;
+    exports.bytesToHex = bytesToHex$2;
     exports.cacheLoader = cacheLoader;
     exports.calculateCoreSchemaHash = calculateCoreSchemaHash;
     exports.calculateQueryHashV2 = calculateQueryHashV2;
     exports.calculateQueryHashV3 = calculateQueryHashV3;
+    exports.checkCircuitOperator = checkCircuitOperator;
+    exports.checkCircuitQueriesLength = checkCircuitQueriesLength;
     exports.checkDataInField = checkDataInField;
     exports.checkQueryRequest = checkQueryRequest;
     exports.circuitValidator = circuitValidator;
@@ -86250,7 +88022,7 @@ var PolygonIdSdk = (function (exports) {
     exports.createVerifiablePresentation = createVerifiablePresentation;
     exports.credentialSubjectKey = credentialSubjectKey;
     exports.dataFillsSlot = dataFillsSlot;
-    exports.decodeBase64url = decodeBase64url;
+    exports.decodeBase64url = decodeBase64url$1;
     exports.defaultEthConnectionConfig = defaultEthConnectionConfig;
     exports.defaultMTLevels = defaultMTLevels;
     exports.defaultMTLevelsClaim = defaultMTLevelsClaim;
@@ -86273,11 +88045,12 @@ var PolygonIdSdk = (function (exports) {
     exports.getKMSIdByAuthCredential = getKMSIdByAuthCredential;
     exports.getNodeAuxValue = getNodeAuxValue;
     exports.getNodesRepresentation = getNodesRepresentation;
+    exports.getOperatorNameByValue = getOperatorNameByValue;
     exports.getProperties = getProperties;
     exports.getSerializationAttrFromContext = getSerializationAttrFromContext;
     exports.getSerializationAttrFromParsedContext = getSerializationAttrFromParsedContext;
     exports.getUserDIDFromCredential = getUserDIDFromCredential;
-    exports.hexToBytes = hexToBytes$1;
+    exports.hexToBytes = hexToBytes$2;
     exports.isGenesisState = isGenesisState;
     exports.isGenesisStateId = isGenesisStateId;
     exports.isIssuerGenesis = isIssuerGenesis;
@@ -86307,7 +88080,14 @@ var PolygonIdSdk = (function (exports) {
     exports.transformQueryValueToBigInts = transformQueryValueToBigInts;
     exports.userStateError = userStateError;
     exports.validateDIDDocumentAuth = validateDIDDocumentAuth;
+    exports.validateDisclosureNativeSDSupport = validateDisclosureNativeSDSupport;
+    exports.validateDisclosureV2Circuit = validateDisclosureV2Circuit;
+    exports.validateEmptyCredentialSubjectNoopNativeSupport = validateEmptyCredentialSubjectNoopNativeSupport;
+    exports.validateEmptyCredentialSubjectV2Circuit = validateEmptyCredentialSubjectV2Circuit;
+    exports.validateOperators = validateOperators;
     exports.validateTreeState = validateTreeState;
+    exports.verifyFieldValueInclusionNativeExistsSupport = verifyFieldValueInclusionNativeExistsSupport;
+    exports.verifyFieldValueInclusionV2 = verifyFieldValueInclusionV2;
     exports.witnessBuilder = witnessBuilder;
 
     return exports;