@0xpolygonid/js-sdk 1.9.2 → 1.9.4

package/dist/browser/esm/index.js

@@ -5,7 +5,7 @@ import { Path, Merklizer, getDocumentLoader } from '@iden3/js-jsonld-merklizatio
 import * as jsJsonldMerklization from '@iden3/js-jsonld-merklization';
 export { jsJsonldMerklization as jsonLDMerklizer };
 import { PrivateKey, Hex, base58ToBytes as base58ToBytes$2, base58FromBytes, Signature as Signature$5, PublicKey, poseidon, sha256 as sha256$3, getRandomBytes, Poseidon } from '@iden3/js-crypto';
-import { Hash as Hash$1, Proof, verifyProof, rootFromProof, ZERO_HASH, swapEndianness as swapEndianness$1, newHashFromString, Merkletree, InMemoryDB, str2Bytes, LocalStorageDB, IndexedDBStorage, testBit, NodeLeaf, NODE_TYPE_LEAF, hashElems } from '@iden3/js-merkletree';
+import { Hash as Hash$2, Proof, verifyProof, rootFromProof, ZERO_HASH, swapEndianness as swapEndianness$1, newHashFromString, Merkletree, InMemoryDB, str2Bytes, LocalStorageDB, IndexedDBStorage, testBit, NodeLeaf, NODE_TYPE_LEAF, hashElems } from '@iden3/js-merkletree';
 import { groth16 } from 'snarkjs';
 import { getCurveFromName } from 'ffjavascript';
 import { Token, Header, ProvingMethodAlg, proving } from '@iden3/js-jwz';
@@ -157,6 +157,1839 @@ class BjjProvider {
     }
 }
 
+// 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(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, 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$1(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$1(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$1(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$1(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$1(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$1(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$1(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$1(-num, ORDER),
+        eql: (lhs, rhs) => lhs === rhs,
+        sqr: (num) => mod$1(num * num, ORDER),
+        add: (lhs, rhs) => mod$1(lhs + rhs, ORDER),
+        sub: (lhs, rhs) => mod$1(lhs - rhs, ORDER),
+        mul: (lhs, rhs) => mod$1(lhs * rhs, ORDER),
+        pow: (num, power) => FpPow$1(f, num, power),
+        div: (lhs, rhs) => mod$1(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$1(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$1(v * v * v, P); // v³
+    const v7 = mod$1(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$1(u * v3 * pow, P); // (uv³)(uv⁷)^(p-5)/8
+    const vx2 = mod$1(v * x * x, P); // vx²
+    const root1 = x; // First root candidate
+    const root2 = mod$1(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$1(-u, P); // If vx² = -u, set x <-- x * 2^((p-1)/4)
+    const noRoot = vx2 === mod$1(-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$1(-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$2 = {
+  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$2.parse(s, opts);
+}
+function bytesToBase64(b, opts = { pad: false }) {
+    return base64$2.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 base58ToBytes$2(s);
+}
+function bytesToBase58$1(b) {
+    return base58FromBytes(b);
+}
+function hexToBytes$2(s) {
+    const input = s.startsWith('0x') ? s.substring(2) : s;
+    return Hex.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 Hex.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;
+}
+
+/**
+ * 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 = Hash$2.fromHex(state).bigInt();
+    }
+    const id = DID.idFromDID(did);
+    const { method, blockchain, networkId } = DID.decodePartsFromId(id);
+    const type = buildDIDType(method, blockchain, networkId);
+    const idFromState = Id.idGenesisFromIdenState(type, state);
+    return id.bigInt().toString() === idFromState.bigInt().toString();
+}
+const buildVerifierId = (address, info) => {
+    address = address.replace('0x', '');
+    const ethAddrBytes = Hex.decodeString(address);
+    const ethAddr = ethAddrBytes.slice(0, 20);
+    const genesis = genesisFromEthAddress(ethAddr);
+    const tp = buildDIDType(info.method, info.blockchain, info.networkId);
+    return new Id(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 = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getDefaultExportFromCjs (x) {
@@ -188,6 +2021,506 @@ function getAugmentedNamespace(n) {
 	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, 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(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";
@@ -9578,7 +11911,7 @@ var base58 = /*#__PURE__*/Object.freeze({
     base58flickr: base58flickr
 });
 
-const base64$1 = rfc4648({
+const base64 = rfc4648({
   prefix: 'm',
   name: 'base64',
   alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
@@ -9590,7 +11923,7 @@ const base64pad = rfc4648({
   alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
   bitsPerChar: 6
 });
-const base64url$1 = rfc4648({
+const base64url = rfc4648({
   prefix: 'u',
   name: 'base64url',
   alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
@@ -9603,11 +11936,11 @@ const base64urlpad = rfc4648({
   bitsPerChar: 6
 });
 
-var base64$2 = /*#__PURE__*/Object.freeze({
+var base64$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    base64: base64$1,
+    base64: base64,
     base64pad: base64pad,
-    base64url: base64url$1,
+    base64url: base64url,
     base64urlpad: base64urlpad
 });
 
@@ -9658,7 +11991,7 @@ const bases = {
   ...base32$1,
   ...base36$1,
   ...base58,
-  ...base64$2,
+  ...base64$1,
   ...base256emoji$1
 };
 
@@ -12976,27 +15309,27 @@ function getLibraryFromEncoding(encoding) {
 var bech32 = dist$1.bech32 = getLibraryFromEncoding('bech32');
 dist$1.bech32m = getLibraryFromEncoding('bech32m');
 
-function bytesToBase64url$1(b) {
+function bytesToBase64url(b) {
   return toString(b, 'base64url');
 }
-function base64ToBytes$1(s) {
+function base64ToBytes(s) {
   const inputBase64Url = s.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
   return fromString(inputBase64Url, 'base64url');
 }
-function base58ToBytes$1(s) {
+function base58ToBytes(s) {
   return fromString(s, 'base58btc');
 }
-function bytesToBase58$1(b) {
+function bytesToBase58(b) {
   return toString(b, 'base58btc');
 }
-function hexToBytes$2(s) {
+function hexToBytes$1(s) {
   const input = s.startsWith('0x') ? s.substring(2) : s;
   return fromString(input.toLowerCase(), 'base16');
 }
-function decodeBase64url$1(s) {
-  return toString(base64ToBytes$1(s));
+function decodeBase64url(s) {
+  return toString(base64ToBytes(s));
 }
-function bytesToHex$2(b) {
+function bytesToHex$1(b) {
   return toString(b, 'base16');
 }
 function stringToBytes$1(s) {
@@ -13019,7 +15352,7 @@ function toJose({
     jose[64] = recoveryParam;
   }
 
-  return bytesToBase64url$1(jose);
+  return bytesToBase64url(jose);
 }
 function leftpad(data, size = 64) {
   if (data.length === size) return data;
@@ -13095,1135 +15428,451 @@ class Ripemd160 {
         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[i]], hl[0], sl[i]);
-          tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i]);
-        } else if (i < 32) {
-          tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i]);
-          tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i]);
-        } else if (i < 48) {
-          tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i]);
-          tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i]);
-        } else if (i < 64) {
-          tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i]);
-          tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i]);
-        } else {
-          // if (i<80) {
-          tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i]);
-          tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[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(payload) : payload;
-  return sha256$2.hash(data);
-}
-function keccak(data) {
-  return new Uint8Array(sha3$1.keccak_256.arrayBuffer(data));
-}
-function toEthereumAddress(hexPublicKey) {
-  const hashInput = fromString(hexPublicKey.slice(2), 'base16');
-  return `0x${toString(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(base58ToBytes$1(otherAddress).slice(0, 1), 'hex');
-  const publicKeyBuffer = fromString(publicKey, 'hex');
-  const publicKeyHash = ripemd160(sha256$1(publicKeyBuffer));
-  const step1 = version + toString(publicKeyHash, 'hex');
-  const step2 = sha256$1(fromString(step1, 'hex'));
-  const step3 = sha256$1(step2);
-  const checksum = toString(step3, 'hex').substring(0, 8);
-  const step4 = step1 + checksum;
-  return bytesToBase58$1(fromString(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(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 = {
-  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.parse(s, opts);
-}
-function bytesToBase64(b, opts = { pad: false }) {
-    return base64.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 base58ToBytes$2(s);
-}
-function bytesToBase58(b) {
-    return base58FromBytes(b);
-}
-function hexToBytes$1(s) {
-    const input = s.startsWith('0x') ? s.substring(2) : s;
-    return Hex.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 Hex.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
 
-/**
- * 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 = Hash$1.fromHex(state).bigInt();
-    }
-    const id = DID.idFromDID(did);
-    const { method, blockchain, networkId } = DID.decodePartsFromId(id);
-    const type = buildDIDType(method, blockchain, networkId);
-    const idFromState = Id.idGenesisFromIdenState(type, state);
-    return id.bigInt().toString() === idFromState.bigInt().toString();
-}
-const buildVerifierId = (address, info) => {
-    address = address.replace('0x', '');
-    const ethAddrBytes = Hex.decodeString(address);
-    const ethAddr = ethAddrBytes.slice(0, 20);
-    const genesis = genesisFromEthAddress(ethAddr);
-    const tp = buildDIDType(info.method, info.blockchain, info.networkId);
-    return new Id(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');
-};
+      for (let i = 0; i < 80; i += 1) {
+        let tl;
+        let tr;
 
-var pubsub = {exports: {}};
+        if (i < 16) {
+          tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i]);
+          tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i]);
+        } else if (i < 32) {
+          tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i]);
+          tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i]);
+        } else if (i < 48) {
+          tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i]);
+          tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i]);
+        } else if (i < 64) {
+          tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i]);
+          tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i]);
+        } else {
+          // if (i<80) {
+          tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i]);
+          tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i]);
+        }
 
-/**
- * Copyright (c) 2010,2011,2012,2013,2014 Morgan Roderick http://roderick.dk
- * License: MIT - http://mrgnrdrck.mit-license.org
- *
- * https://github.com/mroderick/PubSubJS
- */
+        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
 
-(function (module, exports) {
-	(function (root, factory){
 
-	    var PubSub = {};
+      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;
+    };
 
-	    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
-	    }
+    this._digest = () => {
+      // create padding and handle blocks
+      this._block[this._blockOffset++] = 0x80;
 
-	}(( typeof window === 'object' && window ) || commonjsGlobal, function (PubSub){
+      if (this._blockOffset > 56) {
+        this._block.fill(0, this._blockOffset, 64);
 
-	    var messages = {},
-	        lastUid = -1,
-	        ALL_SUBSCRIBING_MSG = '*';
+        this._update();
 
-	    function hasKeys(obj){
-	        var key;
+        this._blockOffset = 0;
+      }
 
-	        for (key in obj){
-	            if ( Object.prototype.hasOwnProperty.call(obj, key) ){
-	                return true;
-	            }
-	        }
-	        return false;
-	    }
+      this._block.fill(0, this._blockOffset, 56);
 
-	    /**
-	     * 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;
-	        };
-	    }
+      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);
 
-	    function callSubscriberWithDelayedExceptions( subscriber, message, data ){
-	        try {
-	            subscriber( message, data );
-	        } catch( ex ){
-	            setTimeout( throwException( ex ), 0);
-	        }
-	    }
+      this._update(); // produce result
 
-	    function callSubscriberWithImmediateExceptions( subscriber, message, data ){
-	        subscriber( message, data );
-	    }
 
-	    function deliverMessage( originalMessage, matchedMessage, data, immediateExceptions ){
-	        var subscribers = messages[matchedMessage],
-	            callSubscriber = immediateExceptions ? callSubscriberWithImmediateExceptions : callSubscriberWithDelayedExceptions,
-	            s;
+      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);
+    };
 
-	        if ( !Object.prototype.hasOwnProperty.call( messages, matchedMessage ) ) {
-	            return;
-	        }
+    this._block = new Uint8Array(blockSize);
+    this._blockSize = blockSize;
+    this._blockOffset = 0;
+    this._length = [0, 0, 0, 0];
+    this._finalized = false;
+  }
 
-	        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( '.' );
+function sha256$1(payload) {
+  const data = typeof payload === 'string' ? fromString(payload) : payload;
+  return sha256$2.hash(data);
+}
+function keccak(data) {
+  return new Uint8Array(sha3$1.keccak_256.arrayBuffer(data));
+}
+function toEthereumAddress(hexPublicKey) {
+  const hashInput = fromString(hexPublicKey.slice(2), 'base16');
+  return `0x${toString(keccak(hashInput).slice(-20), 'base16')}`;
+}
+function ripemd160(data) {
+  return new Ripemd160().update(data).digest();
+}
 
-	            // deliver the message as it is now
-	            deliverMessage(message, message, data, immediateExceptions);
+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>`
+ */
 
-	            // 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 );
-	            }
+function ES256KSigner(privateKey, recoverable = false) {
+  const privateKeyBytes = privateKey;
 
-	            deliverMessage(message, ALL_SUBSCRIBING_MSG, data, immediateExceptions);
-	        };
-	    }
+  if (privateKeyBytes.length !== 32) {
+    throw new Error(`bad_key: Invalid private key format. Expecting 32 bytes, but got ${privateKeyBytes.length}`);
+  }
 
-	    function hasDirectSubscribersFor( message ) {
-	        var topic = String( message ),
-	            found = Boolean(Object.prototype.hasOwnProperty.call( messages, topic ) && hasKeys(messages[topic]));
+  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);
+    }
+  };
+}
 
-	        return found;
-	    }
+new elliptic.ec('p256');
 
-	    function messageHasSubscribers( message ){
-	        var topic = String( message ),
-	            found = hasDirectSubscribersFor(topic) || hasDirectSubscribersFor(ALL_SUBSCRIBING_MSG),
-	            position = topic.lastIndexOf( '.' );
+const publicKeyToAddress$1 = (publicKey, otherAddress) => {
+  // Use the same version/prefix byte as the given address.
+  const version = toString(base58ToBytes(otherAddress).slice(0, 1), 'hex');
+  const publicKeyBuffer = fromString(publicKey, 'hex');
+  const publicKeyHash = ripemd160(sha256$1(publicKeyBuffer));
+  const step1 = version + toString(publicKeyHash, 'hex');
+  const step2 = sha256$1(fromString(step1, 'hex'));
+  const step3 = sha256$1(step2);
+  const checksum = toString(step3, 'hex').substring(0, 8);
+  const step4 = step1 + checksum;
+  return bytesToBase58(fromString(step4, 'hex'));
+};
 
-	        while ( !found && position !== -1 ){
-	            topic = topic.substr( 0, position );
-	            position = topic.lastIndexOf( '.' );
-	            found = hasDirectSubscribersFor(topic);
-	        }
+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(compressedPublicKey, 'hex');
+  const hash = ripemd160(sha256$1(publicKeyBuffer));
+  const words = bech32.toWords(hash);
+  return bech32.encode(prefix, words).replace(prefix, '');
+};
 
-	        return found;
-	    }
+const verifyBlockchainAccountId = (publicKey, blockchainAccountId) => {
+  if (blockchainAccountId) {
+    const chain = blockchainAccountId.split(':');
 
-	    function publish( message, data, sync, immediateExceptions ){
-	        message = (typeof message === 'symbol') ? message.toString() : message;
+    switch (chain[0]) {
+      case 'bip122':
+        chain[chain.length - 1] = publicKeyToAddress$1(publicKey, chain[chain.length - 1]);
+        break;
 
-	        var deliver = createDeliveryFunction( message, data, immediateExceptions ),
-	            hasSubscribers = messageHasSubscribers( message );
+      case 'cosmos':
+        chain[chain.length - 1] = publicKeyToAddress(publicKey, chain[1]);
+        break;
 
-	        if ( !hasSubscribers ){
-	            return false;
-	        }
+      case 'eip155':
+        chain[chain.length - 1] = toEthereumAddress(publicKey);
+        break;
 
-	        if ( sync === true ){
-	            deliver();
-	        } else {
-	            setTimeout( deliver, 0 );
-	        }
-	        return true;
-	    }
+      default:
+        return false;
+    }
 
-	    /**
-	     * 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 chain.join(':').toLowerCase() === blockchainAccountId.toLowerCase();
+  }
 
-	    /**
-	     * 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 );
-	    };
+  return false;
+};
 
-	    /**
-	     * 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;
-	        }
+const secp256k1$2 = new elliptic.ec('secp256k1');
+const secp256r1 = new elliptic.ec('p256'); // converts a JOSE signature to it's components
 
-	        message = (typeof message === 'symbol') ? message.toString() : message;
+function toSignatureObject(signature, recoverable = false) {
+  const rawSig = base64ToBytes(signature);
 
-	        // message is not registered yet
-	        if ( !Object.prototype.hasOwnProperty.call( messages, message ) ){
-	            messages[message] = {};
-	        }
+  if (rawSig.length !== (recoverable ? 65 : 64)) {
+    throw new Error('wrong signature length');
+  }
 
-	        // 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;
+  const r = bytesToHex$1(rawSig.slice(0, 32));
+  const s = bytesToHex$1(rawSig.slice(32, 64));
+  const sigObj = {
+    r,
+    s
+  };
+
+  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(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
@@ -14281,8 +15930,8 @@ class Sec256k1Provider {
         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');
         }
@@ -14335,6 +15984,7 @@ var KmsKeyType;
 (function (KmsKeyType) {
     KmsKeyType["BabyJubJub"] = "BJJ";
     KmsKeyType["Secp256k1"] = "Secp256k1";
+    KmsKeyType["Ed25519"] = "Ed25519";
 })(KmsKeyType || (KmsKeyType = {}));
 
 /**
@@ -14664,13 +16314,13 @@ class Iden3SparseMerkleTreeProof {
             // legacy
             const ne = obj?.mtp?.notEmpties;
             const notEmpties = ne instanceof Uint8Array ? ne : new Uint8Array(Object.values(ne));
-            const siblingsHashes = obj?.mtp?.siblings.map((h) => Hash$1.fromString(JSON.stringify(h)));
+            const siblingsHashes = obj?.mtp?.siblings.map((h) => Hash$2.fromString(JSON.stringify(h)));
             const allSiblings = Proof.buildAllSiblings(obj?.mtp?.depth, notEmpties, siblingsHashes);
             let nodeAux = undefined;
             if (obj.mtp.nodeAux) {
                 nodeAux = {
-                    key: Hash$1.fromString(JSON.stringify(obj.mtp.nodeAux.key)),
-                    value: Hash$1.fromString(JSON.stringify(obj.mtp.nodeAux.value))
+                    key: Hash$2.fromString(JSON.stringify(obj.mtp.nodeAux.key)),
+                    value: Hash$2.fromString(JSON.stringify(obj.mtp.nodeAux.value))
                 };
             }
             mtp = new Proof({ existence: obj?.mtp.existence, nodeAux: nodeAux, siblings: allSiblings });
@@ -14685,10 +16335,10 @@ class Iden3SparseMerkleTreeProof {
                 id: DID.parse(obj.issuerData.id),
                 state: {
                     ...obj.issuerData.state,
-                    rootOfRoots: Hash$1.fromHex(obj.issuerData.state.rootOfRoots),
-                    claimsTreeRoot: Hash$1.fromHex(obj.issuerData.state.claimsTreeRoot),
-                    revocationTreeRoot: Hash$1.fromHex(obj.issuerData.state.revocationTreeRoot),
-                    value: Hash$1.fromHex(obj.issuerData.state.value)
+                    rootOfRoots: Hash$2.fromHex(obj.issuerData.state.rootOfRoots),
+                    claimsTreeRoot: Hash$2.fromHex(obj.issuerData.state.claimsTreeRoot),
+                    revocationTreeRoot: Hash$2.fromHex(obj.issuerData.state.revocationTreeRoot),
+                    value: Hash$2.fromHex(obj.issuerData.state.value)
                 }
             }
         });
@@ -14744,10 +16394,10 @@ class BJJSignatureProof2021 {
                 mtp: Proof.fromJSON(obj.issuerData.mtp),
                 state: {
                     ...obj.issuerData.state,
-                    rootOfRoots: Hash$1.fromHex(obj.issuerData.state.rootOfRoots),
-                    claimsTreeRoot: Hash$1.fromHex(obj.issuerData.state.claimsTreeRoot),
-                    revocationTreeRoot: Hash$1.fromHex(obj.issuerData.state.revocationTreeRoot),
-                    value: Hash$1.fromHex(obj.issuerData.state.value)
+                    rootOfRoots: Hash$2.fromHex(obj.issuerData.state.rootOfRoots),
+                    claimsTreeRoot: Hash$2.fromHex(obj.issuerData.state.claimsTreeRoot),
+                    revocationTreeRoot: Hash$2.fromHex(obj.issuerData.state.revocationTreeRoot),
+                    value: Hash$2.fromHex(obj.issuerData.state.value)
                 },
                 credentialStatus: obj.issuerData.credentialStatus,
                 authCoreClaim: new Claim().fromHex(obj.issuerData.authCoreClaim)
@@ -27582,7 +29232,7 @@ class W3CCredential {
         if (revocationNonce !== proof.issuerData.authCoreClaim.getRevocationNonce()) {
             throw new Error(`revocation nonce mismatch: revocation nonce from core representation of auth credential is not the same as in its credential`);
         }
-        const proofValid = await verifyProof(Hash$1.fromHex(credStatus.issuer.revocationTreeRoot), credStatus.mtp, revocationNonce, BigInt(0));
+        const proofValid = await verifyProof(Hash$2.fromHex(credStatus.issuer.revocationTreeRoot), credStatus.mtp, revocationNonce, BigInt(0));
         if (!proofValid) {
             throw new Error(`proof validation failed. revNonce=${revocationNonce}`);
         }
@@ -27668,13 +29318,13 @@ function extractProof(proof) {
  * @returns {boolean}
  */
 function validateTreeState(treeState) {
-    const ctrHash = treeState.claimsTreeRoot ? Hash$1.fromHex(treeState.claimsTreeRoot) : new Hash$1();
+    const ctrHash = treeState.claimsTreeRoot ? Hash$2.fromHex(treeState.claimsTreeRoot) : new Hash$2();
     const rtrHash = treeState.revocationTreeRoot
-        ? Hash$1.fromHex(treeState.revocationTreeRoot)
-        : new Hash$1();
-    const rorHash = treeState.rootOfRoots ? Hash$1.fromHex(treeState.rootOfRoots) : new Hash$1();
+        ? Hash$2.fromHex(treeState.revocationTreeRoot)
+        : new Hash$2();
+    const rorHash = treeState.rootOfRoots ? Hash$2.fromHex(treeState.rootOfRoots) : new Hash$2();
     const wantState = poseidon.hash([ctrHash.bigInt(), rtrHash.bigInt(), rorHash.bigInt()]);
-    const stateHash = treeState.state ? Hash$1.fromHex(treeState.state) : new Hash$1();
+    const stateHash = treeState.state ? Hash$2.fromHex(treeState.state) : new Hash$2();
     return wantState === stateHash.bigInt();
 }
 
@@ -55706,7 +57356,7 @@ const strMTHex = (s) => {
     if (!s) {
         return ZERO_HASH;
     }
-    const h = new Hash$1();
+    const h = new Hash$2();
     h.value = swapEndianness$1(Hex.decodeString(s));
     return h;
 };
@@ -55720,10 +57370,10 @@ const strMTHex = (s) => {
  * @returns TreeState
  */
 const buildTreeState = (state, claimsTreeRoot, revocationTreeRoot, rootOfRoots) => ({
-    state: Hash$1.fromHex(state),
-    claimsRoot: Hash$1.fromHex(claimsTreeRoot),
-    revocationRoot: Hash$1.fromHex(revocationTreeRoot),
-    rootOfRoots: Hash$1.fromHex(rootOfRoots)
+    state: Hash$2.fromHex(state),
+    claimsRoot: Hash$2.fromHex(claimsTreeRoot),
+    revocationRoot: Hash$2.fromHex(revocationTreeRoot),
+    rootOfRoots: Hash$2.fromHex(rootOfRoots)
 });
 /**
  * siblings as string array
@@ -55875,6 +57525,10 @@ const QueryOperators = {
     $sd: Operators.SD,
     $nullify: 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([
     [
@@ -56339,13 +57993,13 @@ class AtomicQueryMTPV2PubSignals extends BaseConfig {
         this.issuerID = Id.fromBigInt(BigInt(sVals[fieldIdx]));
         fieldIdx++;
         // - issuerClaimIdenState
-        this.issuerClaimIdenState = Hash$1.fromString(sVals[fieldIdx]);
+        this.issuerClaimIdenState = Hash$2.fromString(sVals[fieldIdx]);
         fieldIdx++;
         // - isRevocationChecked
         this.isRevocationChecked = parseInt(sVals[fieldIdx]);
         fieldIdx++;
         // - issuerClaimNonRevState
-        this.issuerClaimNonRevState = Hash$1.fromString(sVals[fieldIdx]);
+        this.issuerClaimNonRevState = Hash$2.fromString(sVals[fieldIdx]);
         fieldIdx++;
         //  - timestamp
         this.timestamp = parseInt(sVals[fieldIdx]);
@@ -56529,19 +58183,19 @@ class AtomicQueryMTPV2OnChainPubSignals extends BaseConfig {
         this.challenge = BigInt(sVals[fieldIdx]);
         fieldIdx++;
         // - gistRoot
-        this.gistRoot = Hash$1.fromString(sVals[fieldIdx]);
+        this.gistRoot = Hash$2.fromString(sVals[fieldIdx]);
         fieldIdx++;
         // - issuerID
         this.issuerID = Id.fromBigInt(BigInt(sVals[fieldIdx]));
         fieldIdx++;
         // - issuerClaimIdenState
-        this.issuerClaimIdenState = Hash$1.fromString(sVals[fieldIdx]);
+        this.issuerClaimIdenState = Hash$2.fromString(sVals[fieldIdx]);
         fieldIdx++;
         // - isRevocationChecked
         this.isRevocationChecked = parseInt(sVals[fieldIdx]);
         fieldIdx++;
         // - issuerClaimNonRevState
-        this.issuerClaimNonRevState = Hash$1.fromString(sVals[fieldIdx]);
+        this.issuerClaimNonRevState = Hash$2.fromString(sVals[fieldIdx]);
         fieldIdx++;
         //  - timestamp
         this.timestamp = parseInt(sVals[fieldIdx]);
@@ -56718,7 +58372,7 @@ class AtomicQuerySigV2PubSignals extends BaseConfig {
         this.userID = Id.fromBigInt(BigInt(sVals[fieldIdx]));
         fieldIdx++;
         // - issuerAuthState
-        this.issuerAuthState = Hash$1.fromString(sVals[fieldIdx]);
+        this.issuerAuthState = Hash$2.fromString(sVals[fieldIdx]);
         fieldIdx++;
         // - requestID
         this.requestID = BigInt(sVals[fieldIdx]);
@@ -56730,7 +58384,7 @@ class AtomicQuerySigV2PubSignals extends BaseConfig {
         this.isRevocationChecked = parseInt(sVals[fieldIdx]);
         fieldIdx++;
         // - issuerClaimNonRevState
-        this.issuerClaimNonRevState = Hash$1.fromString(sVals[fieldIdx]);
+        this.issuerClaimNonRevState = Hash$2.fromString(sVals[fieldIdx]);
         fieldIdx++;
         //  - timestamp
         this.timestamp = parseInt(sVals[fieldIdx]);
@@ -56970,7 +58624,7 @@ class AtomicQueryV3PubSignals extends BaseConfig {
         this.userID = Id.fromBigInt(BigInt(sVals[fieldIdx]));
         fieldIdx++;
         // - issuerState
-        this.issuerState = Hash$1.fromString(sVals[fieldIdx]);
+        this.issuerState = Hash$2.fromString(sVals[fieldIdx]);
         fieldIdx++;
         // - linkID
         this.linkID = BigInt(sVals[fieldIdx]);
@@ -56994,7 +58648,7 @@ class AtomicQueryV3PubSignals extends BaseConfig {
         this.isRevocationChecked = parseInt(sVals[fieldIdx]);
         fieldIdx++;
         // - issuerClaimNonRevState
-        this.issuerClaimNonRevState = Hash$1.fromString(sVals[fieldIdx]);
+        this.issuerClaimNonRevState = Hash$2.fromString(sVals[fieldIdx]);
         fieldIdx++;
         //  - timestamp
         this.timestamp = parseInt(sVals[fieldIdx]);
@@ -57293,7 +58947,7 @@ class AtomicQueryV3OnChainPubSignals extends BaseConfig {
         this.circuitQueryHash = BigInt(sVals[fieldIdx]);
         fieldIdx++;
         // - issuerState
-        this.issuerState = Hash$1.fromString(sVals[fieldIdx]);
+        this.issuerState = Hash$2.fromString(sVals[fieldIdx]);
         fieldIdx++;
         // - linkID
         this.linkID = BigInt(sVals[fieldIdx]);
@@ -57314,13 +58968,13 @@ class AtomicQueryV3OnChainPubSignals extends BaseConfig {
         this.challenge = BigInt(sVals[fieldIdx]);
         fieldIdx++;
         // - gistRoot
-        this.gistRoot = Hash$1.fromString(sVals[fieldIdx]);
+        this.gistRoot = Hash$2.fromString(sVals[fieldIdx]);
         fieldIdx++;
         // - issuerID
         this.issuerID = Id.fromBigInt(BigInt(sVals[fieldIdx]));
         fieldIdx++;
         // - issuerClaimNonRevState
-        this.issuerClaimNonRevState = Hash$1.fromString(sVals[fieldIdx]);
+        this.issuerClaimNonRevState = Hash$2.fromString(sVals[fieldIdx]);
         fieldIdx++;
         //  - timestamp
         this.timestamp = parseInt(sVals[fieldIdx]);
@@ -57638,7 +59292,7 @@ class AuthV2PubSignals {
         }
         this.userID = Id.fromBigInt(BigInt(sVals[0]));
         this.challenge = BigInt(sVals[1]);
-        this.GISTRoot = Hash$1.fromString(sVals[2]);
+        this.GISTRoot = Hash$2.fromString(sVals[2]);
         return this;
     }
 }
@@ -59763,7 +61417,7 @@ class OnChainRevocationStorage {
         });
     }
     static convertIssuerInfo(issuer) {
-        const [state, claimsTreeRoot, revocationTreeRoot, rootOfRoots] = issuer.map((i) => Hash$1.fromBigInt(i).hex());
+        const [state, claimsTreeRoot, revocationTreeRoot, rootOfRoots] = issuer.map((i) => Hash$2.fromBigInt(i).hex());
         return {
             state,
             claimsTreeRoot,
@@ -60781,7 +62435,7 @@ class OnChainResolver {
             if (!stateHex) {
                 throw new Error('latest state not found and state parameter is not present in credentialStatus.id');
             }
-            const stateBigInt = Hash$1.fromHex(stateHex).bigInt();
+            const stateBigInt = Hash$2.fromHex(stateHex).bigInt();
             if (!isGenesisState(issuer, stateBigInt)) {
                 throw new Error(`latest state not found and state parameter ${stateHex} is not genesis state`);
             }
@@ -60914,7 +62568,7 @@ class ProofNode {
         if (this.children.length === 2) {
             return NodeType.Middle;
         }
-        if (this.children.length === 3 && this.children[2].hex() === Hash$1.fromBigInt(BigInt(1)).hex()) {
+        if (this.children.length === 3 && this.children[2].hex() === Hash$2.fromBigInt(BigInt(1)).hex()) {
             return NodeType.Leaf;
         }
         if (this.children.length === 3) {
@@ -60941,7 +62595,7 @@ class ProofNode {
      * @returns ProofNode
      */
     static fromHex(hexNode) {
-        return new ProofNode(Hash$1.fromHex(hexNode.hash), hexNode.children.map((ch) => Hash$1.fromHex(ch)));
+        return new ProofNode(Hash$2.fromHex(hexNode.hash), hexNode.children.map((ch) => Hash$2.fromHex(ch)));
     }
 }
 var NodeType;
@@ -61014,15 +62668,15 @@ class RHSResolver {
             if (!stateHex) {
                 return this.getRevocationStatusFromIssuerData(issuerDID, issuerData, genesisState);
             }
-            const currentStateBigInt = Hash$1.fromHex(stateHex).bigInt();
+            const currentStateBigInt = Hash$2.fromHex(stateHex).bigInt();
             if (!isGenesisState(issuerDID, currentStateBigInt)) {
                 throw new Error(`latest state not found and state parameter ${stateHex} is not genesis state`);
             }
             latestState = currentStateBigInt;
         }
         const rhsHost = credentialStatus.id.split('/node')[0];
-        const hashedRevNonce = Hash$1.fromBigInt(BigInt(credentialStatus.revocationNonce ?? 0));
-        const hashedIssuerRoot = Hash$1.fromBigInt(latestState);
+        const hashedRevNonce = Hash$2.fromBigInt(BigInt(credentialStatus.revocationNonce ?? 0));
+        const hashedIssuerRoot = Hash$2.fromBigInt(latestState);
         return await this.getRevocationStatusFromRHS(hashedRevNonce, hashedIssuerRoot, rhsHost);
     }
     /**
@@ -61074,7 +62728,7 @@ class RHSResolver {
         }
         const s = issuerRoot.hex();
         const [cTR, rTR, roTR] = treeRoots.children;
-        const rtrHashed = Hash$1.fromHex(rTR);
+        const rtrHashed = Hash$2.fromHex(rTR);
         const nonRevProof = await this.rhsGenerateProof(rtrHashed, data, `${rhsUrl}/node`);
         return {
             mtp: nonRevProof,
@@ -61722,8 +63376,8 @@ class NodesBuilder {
     }
     async addKey(tree, nodeKey) {
         const { value: nodeValue, siblings } = await tree.get(nodeKey);
-        const nodeKeyHash = Hash$1.fromBigInt(nodeKey);
-        const nodeValueHash = Hash$1.fromBigInt(nodeValue);
+        const nodeKeyHash = Hash$2.fromBigInt(nodeKey);
+        const nodeValueHash = Hash$2.fromBigInt(nodeValue);
         const node = new NodeLeaf(nodeKeyHash, nodeValueHash);
         const newNodes = await buildNodesUp(siblings, node);
         for (const n of newNodes) {
@@ -61753,7 +63407,7 @@ async function buildNodesUp(siblings, node) {
         nodes[index] = new ProofNode();
     }
     nodes[sl].hash = prevHash;
-    const hashOfOne = Hash$1.fromBigInt(BigInt(1));
+    const hashOfOne = Hash$2.fromBigInt(BigInt(1));
     nodes[sl].children = [node.entry[0], node.entry[1], hashOfOne];
     const pathKey = node.entry[0];
     for (let i = sl - 1; i >= 0; i--) {
@@ -62290,7 +63944,7 @@ const toClaimNonRevStatus = (s) => {
         return {
             proof: new Proof(),
             treeState: {
-                state: Hash$1.fromBigInt(hash),
+                state: Hash$2.fromBigInt(hash),
                 claimsRoot: ZERO_HASH,
                 revocationRoot: ZERO_HASH,
                 rootOfRoots: ZERO_HASH
@@ -62317,14 +63971,14 @@ const toGISTProof = (smtProof) => {
     else {
         if (smtProof.auxExistence) {
             nodeAux = {
-                key: Hash$1.fromBigInt(smtProof.auxIndex),
-                value: Hash$1.fromBigInt(smtProof.auxValue)
+                key: Hash$2.fromBigInt(smtProof.auxIndex),
+                value: Hash$2.fromBigInt(smtProof.auxValue)
             };
         }
     }
-    const allSiblings = smtProof.siblings.map((s) => Hash$1.fromBigInt(s));
+    const allSiblings = smtProof.siblings.map((s) => Hash$2.fromBigInt(s));
     const proof = new Proof({ siblings: allSiblings, nodeAux: nodeAux, existence: existence });
-    const root = Hash$1.fromBigInt(smtProof.root);
+    const root = Hash$2.fromBigInt(smtProof.root);
     return {
         root,
         proof
@@ -62817,6 +64471,7 @@ class InputGenerator {
             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 }) => {
@@ -62864,6 +64519,7 @@ class InputGenerator {
             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 }) => {
@@ -62885,6 +64541,7 @@ class InputGenerator {
             query.operator = this.transformV2QueryOperator(query.operator);
             circuitInputs.query = query;
             circuitInputs.currentTimeStamp = getUnixTimestamp(new Date());
+            this.checkOperatorSupport(proofReq.circuitId, query.operator);
             return circuitInputs.inputsMarshal();
         };
         this.credentialAtomicQuerySigV2OnChainPrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
@@ -62932,6 +64589,7 @@ class InputGenerator {
             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 }) => {
@@ -62981,6 +64639,7 @@ class InputGenerator {
             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 }) => {
@@ -63059,15 +64718,19 @@ class InputGenerator {
                 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();
         };
     }
@@ -63152,10 +64815,16 @@ class InputGenerator {
     transformV2QueryOperator(operator) {
         return operator === Operators.SD || operator === Operators.NOOP ? 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 = DID.parseFromId(outputs.issuerId);
     const issuerAllowed = !query.allowedIssuers ||
@@ -63163,19 +64832,10 @@ async function checkQueryRequest(query, outputs, circuitId, schemaLoader, verifi
     if (!issuerAllowed) {
         throw new Error('issuer is not in allowed list');
     }
-    // validate schema
-    let schema;
-    try {
-        const loader = schemaLoader ?? getDocumentLoader();
-        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 Path.getTypeIDFromContext(JSON.stringify(schema), query.type, {
+    const schemaId = await Path.getTypeIDFromContext(JSON.stringify(ldContext), query.type, {
         documentLoader: schemaLoader
     });
     const schemaHash = calculateCoreSchemaHash(byteEncoder.encode(schemaId));
@@ -63185,75 +64845,67 @@ async function checkQueryRequest(query, outputs, circuitId, schemaLoader, verifi
     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() - getDateFromUnixTimestamp(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 === 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 == 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 == Operators.NOOP) {
+        return;
+    }
+    if (outputs.operator === 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() - getDateFromUnixTimestamp(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 !== Operators.EQ) {
         throw new Error('empty credentialSubject request available only for equal operation');
     }
@@ -63286,7 +64938,11 @@ async function validateOperators(cq, outputs) {
         }
     }
 }
-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 !== Operators.EQ) {
         throw new Error(`operator for selective disclosure must be $eq`);
     }
@@ -63295,9 +64951,29 @@ async function validateDisclosure(cq, outputs, verifiablePresentation, ldLoader)
             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 !== 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 !== 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) => {
@@ -63418,7 +65094,7 @@ class PubSignalsVerifier {
                 valueArraySize: mtpv2PubSignals.getValueArrSize(),
                 isRevocationChecked: mtpv2PubSignals.isRevocationChecked
             };
-            await checkQueryRequest(query, outs, CircuitId.AtomicQueryMTPV2, this._documentLoader, verifiablePresentation, opts);
+            await this.checkQueryV2Circuits(CircuitId.AtomicQueryMTPV2, query, outs, opts, verifiablePresentation);
             // verify state
             await this.checkStateExistenceForId(mtpv2PubSignals.issuerID, mtpv2PubSignals.issuerClaimIdenState);
             if (mtpv2PubSignals.isRevocationChecked !== 0) {
@@ -63447,7 +65123,7 @@ class PubSignalsVerifier {
                 valueArraySize: sigV2PubSignals.getValueArrSize(),
                 isRevocationChecked: sigV2PubSignals.isRevocationChecked
             };
-            await checkQueryRequest(query, outs, CircuitId.AtomicQuerySigV2, this._documentLoader, verifiablePresentation, opts);
+            await this.checkQueryV2Circuits(CircuitId.AtomicQuerySigV2, query, outs, opts, verifiablePresentation);
             // verify state
             await this.checkStateExistenceForId(sigV2PubSignals.issuerID, sigV2PubSignals.issuerAuthState);
             if (sigV2PubSignals.isRevocationChecked !== 0) {
@@ -63473,9 +65149,55 @@ class PubSignalsVerifier {
                 merklized: v3PubSignals.merklized,
                 claimPathKey: v3PubSignals.claimPathKey,
                 valueArraySize: v3PubSignals.getValueArrSize(),
+                operatorOutput: v3PubSignals.operatorOutput,
                 isRevocationChecked: v3PubSignals.isRevocationChecked
             };
-            await checkQueryRequest(query, outs, CircuitId.AtomicQueryV3, this._documentLoader, verifiablePresentation, opts);
+            if (!query.type) {
+                throw new Error(`proof query type is undefined`);
+            }
+            const loader = this._documentLoader ?? getDocumentLoader();
+            // 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 = 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 === 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 == 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 ProofType.BJJSignature:
@@ -63650,6 +65372,53 @@ class PubSignalsVerifier {
         }
         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 ?? getDocumentLoader();
+        // 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 === 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 == 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 = DID.parseFromId(id);
@@ -63957,7 +65726,7 @@ class ProofService {
         if (circuitId !== CircuitId.AuthV2) {
             throw new Error(`CircuitId is not supported ${circuitId}`);
         }
-        const gistRoot = Hash$1.fromString(pubSignals[2]).bigInt();
+        const gistRoot = Hash$2.fromString(pubSignals[2]).bigInt();
         const globalStateInfo = await this._stateStorage.getGISTRootInfo(gistRoot);
         if (globalStateInfo.createdAtTimestamp === 0n) {
             throw new Error(`gist state doesn't exists in contract`);
@@ -64144,7 +65913,7 @@ class PackageManager {
         }
         else {
             const header = envelope.split('.')[0];
-            base64HeaderBytes = base64.parse(header, { loose: true });
+            base64HeaderBytes = base64$2.parse(header, { loose: true });
         }
         const header = bytesToHeaderStub(base64HeaderBytes);
         return header.typ;
@@ -64357,7 +66126,7 @@ const secp256k1 = new elliptic.ec('secp256k1');
 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: KmsKeyType.Secp256k1 };
+        return { publicKeyBytes: base58ToBytes$1(vm.publicKeyBase58), kmsKeyType: KmsKeyType.Secp256k1 };
     }
     if (vm.publicKeyBase64 && isSupportedVmType) {
         return {
@@ -64366,17 +66135,17 @@ const extractPublicKeyBytes = (vm) => {
         };
     }
     if (vm.publicKeyHex && isSupportedVmType) {
-        return { publicKeyBytes: hexToBytes$1(vm.publicKeyHex), kmsKeyType: KmsKeyType.Secp256k1 };
+        return { publicKeyBytes: hexToBytes$2(vm.publicKeyHex), kmsKeyType: 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: KmsKeyType.Secp256k1
@@ -64503,7 +66272,7 @@ class JWSPacker {
             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}`);
@@ -64517,8 +66286,8 @@ class JWSPacker {
     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}`);
@@ -65221,5 +66990,5 @@ class RevocationStatusHandler {
     }
 }
 
-export { AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DataPrepareHandlerFunc, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, InputGenerator, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, MessageBus, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes, base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58, bytesToBase64, bytesToBase64url, bytesToHex$1 as bytesToHex, cacheLoader, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fieldValueFromVerifiablePresentation, fillCoreClaimSlot, fillSlot, findCredentialType, findValue, generateProfileDID, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$1 as hexToBytes, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateTreeState, witnessBuilder };
+export { AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DataPrepareHandlerFunc, Ed25519Provider, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, InputGenerator, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, MessageBus, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$2 as bytesToHex, cacheLoader, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url$1 as decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fieldValueFromVerifiablePresentation, fillCoreClaimSlot, fillSlot, findCredentialType, findValue, generateProfileDID, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$2 as hexToBytes, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
 //# sourceMappingURL=index.js.map