@solana/web3.js 1.91.7 → 1.91.9

package/lib/index.iife.js

@@ -2171,15 +2171,13 @@ var solanaWeb3 = (function (exports) {
 		  if (value > max || value < min) {
 		    const n = typeof min === 'bigint' ? 'n' : '';
 		    let range;
-		    if (byteLength > 3) {
+		    {
 		      if (min === 0 || min === BigInt(0)) {
 		        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`;
 		      } else {
 		        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +
 		                `${(byteLength + 1) * 8 - 1}${n}`;
 		      }
-		    } else {
-		      range = `>= ${min}${n} and <= ${max}${n}`;
 		    }
 		    throw new errors.ERR_OUT_OF_RANGE('value', range, value)
 		  }
@@ -2195,15 +2193,15 @@ var solanaWeb3 = (function (exports) {
 		function boundsError (value, length, type) {
 		  if (Math.floor(value) !== value) {
 		    validateNumber(value, type);
-		    throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)
+		    throw new errors.ERR_OUT_OF_RANGE('offset', 'an integer', value)
 		  }
 
 		  if (length < 0) {
 		    throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()
 		  }
 
-		  throw new errors.ERR_OUT_OF_RANGE(type || 'offset',
-		                                    `>= ${type ? 1 : 0} and <= ${length}`,
+		  throw new errors.ERR_OUT_OF_RANGE('offset',
+		                                    `>= ${0} and <= ${length}`,
 		                                    value)
 		}
 
@@ -2381,17 +2379,17 @@ var solanaWeb3 = (function (exports) {
 		} 
 	} (buffer));
 
-	function number$2(n) {
+	function number$1(n) {
 	    if (!Number.isSafeInteger(n) || n < 0)
 	        throw new Error(`positive integer expected, not ${n}`);
 	}
 	// copied from utils
-	function isBytes$3(a) {
+	function isBytes$1(a) {
 	    return (a instanceof Uint8Array ||
 	        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
 	}
-	function bytes$1(b, ...lengths) {
-	    if (!isBytes$3(b))
+	function bytes(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}`);
@@ -2399,17 +2397,17 @@ var solanaWeb3 = (function (exports) {
 	function hash(h) {
 	    if (typeof h !== 'function' || typeof h.create !== 'function')
 	        throw new Error('Hash should be wrapped by utils.wrapConstructor');
-	    number$2(h.outputLen);
-	    number$2(h.blockLen);
+	    number$1(h.outputLen);
+	    number$1(h.blockLen);
 	}
-	function exists$1(instance, checkFinished = true) {
+	function exists(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);
+	function output(out, instance) {
+	    bytes(out);
 	    const min = instance.outputLen;
 	    if (out.length < min) {
 	        throw new Error(`digestInto() expects output buffer of length at least ${min}`);
@@ -2425,15 +2423,27 @@ var solanaWeb3 = (function (exports) {
 	// 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.
+	const u32$1 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
 	// Cast array to view
-	const createView$1 = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+	const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 	// The rotate right (circular right shift) operation for uint32
-	const rotr$1 = (word, shift) => (word << (32 - shift)) | (word >>> shift);
-	new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
+	const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
+	const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
+	// The byte swap operation for uint32
+	const byteSwap = (word) => ((word << 24) & 0xff000000) |
+	    ((word << 8) & 0xff0000) |
+	    ((word >>> 8) & 0xff00) |
+	    ((word >>> 24) & 0xff);
+	// In place byte swap for Uint32Array
+	function byteSwap32(arr) {
+	    for (let i = 0; i < arr.length; i++) {
+	        arr[i] = byteSwap(arr[i]);
+	    }
+	}
 	/**
 	 * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
 	 */
-	function utf8ToBytes$2(str) {
+	function utf8ToBytes$1(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
@@ -2443,10 +2453,10 @@ var solanaWeb3 = (function (exports) {
 	 * Warning: when Uint8Array is passed, it would NOT get copied.
 	 * Keep in mind for future mutable operations.
 	 */
-	function toBytes$1(data) {
+	function toBytes(data) {
 	    if (typeof data === 'string')
-	        data = utf8ToBytes$2(data);
-	    bytes$1(data);
+	        data = utf8ToBytes$1(data);
+	    bytes(data);
 	    return data;
 	}
 	/**
@@ -2456,7 +2466,7 @@ var solanaWeb3 = (function (exports) {
 	    let sum = 0;
 	    for (let i = 0; i < arrays.length; i++) {
 	        const a = arrays[i];
-	        bytes$1(a);
+	        bytes(a);
 	        sum += a.length;
 	    }
 	    const res = new Uint8Array(sum);
@@ -2468,14 +2478,14 @@ var solanaWeb3 = (function (exports) {
 	    return res;
 	}
 	// For runtime check if class implements interface
-	let Hash$1 = class Hash {
+	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();
+	}
+	function wrapConstructor(hashCons) {
+	    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
 	    const tmp = hashCons();
 	    hashC.outputLen = tmp.outputLen;
 	    hashC.blockLen = tmp.blockLen;
@@ -2493,7 +2503,7 @@ var solanaWeb3 = (function (exports) {
 	}
 
 	// Polyfill for Safari 14
-	function setBigUint64$1(view, byteOffset, value, isLE) {
+	function setBigUint64(view, byteOffset, value, isLE) {
 	    if (typeof view.setBigUint64 === 'function')
 	        return view.setBigUint64(byteOffset, value, isLE);
 	    const _32n = BigInt(32);
@@ -2506,14 +2516,14 @@ var solanaWeb3 = (function (exports) {
 	    view.setUint32(byteOffset + l, wl, isLE);
 	}
 	// Choice: a ? b : c
-	const Chi$1 = (a, b, c) => (a & b) ^ (~a & c);
+	const Chi = (a, b, c) => (a & b) ^ (~a & c);
 	// Majority function, true if any two inpust is true
-	const Maj$1 = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
+	const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
 	/**
 	 * Merkle-Damgard hash construction base class.
 	 * Could be used to create MD5, RIPEMD, SHA1, SHA2.
 	 */
-	class HashMD extends Hash$1 {
+	class HashMD extends Hash {
 	    constructor(blockLen, outputLen, padOffset, isLE) {
 	        super();
 	        this.blockLen = blockLen;
@@ -2525,18 +2535,18 @@ var solanaWeb3 = (function (exports) {
 	        this.pos = 0;
 	        this.destroyed = false;
 	        this.buffer = new Uint8Array(blockLen);
-	        this.view = createView$1(this.buffer);
+	        this.view = createView(this.buffer);
 	    }
 	    update(data) {
-	        exists$1(this);
+	        exists(this);
 	        const { view, buffer, blockLen } = this;
-	        data = toBytes$1(data);
+	        data = toBytes(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);
+	                const dataView = createView(data);
 	                for (; blockLen <= len - pos; pos += blockLen)
 	                    this.process(dataView, pos);
 	                continue;
@@ -2554,8 +2564,8 @@ var solanaWeb3 = (function (exports) {
 	        return this;
 	    }
 	    digestInto(out) {
-	        exists$1(this);
-	        output$1(out, this);
+	        exists(this);
+	        output(out, this);
 	        this.finished = true;
 	        // Padding
 	        // We can avoid allocation of buffer for padding completely if it
@@ -2577,9 +2587,9 @@ var solanaWeb3 = (function (exports) {
 	        // 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);
+	        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
 	        this.process(view, 0);
-	        const oview = createView$1(out);
+	        const oview = createView(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)
@@ -2612,24 +2622,24 @@ var solanaWeb3 = (function (exports) {
 	    }
 	}
 
-	const U32_MASK64$1 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
-	const _32n$1 = /* @__PURE__ */ BigInt(32);
+	const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+	const _32n = /* @__PURE__ */ BigInt(32);
 	// We are not using BigUint64Array, because they are extremely slow as per 2022
-	function fromBig$1(n, le = false) {
+	function fromBig(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 };
+	        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
+	    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
 	}
-	function split$1(lst, le = false) {
+	function split(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);
+	        const { h, l } = fromBig(lst[i], le);
 	        [Ah[i], Al[i]] = [h, l];
 	    }
 	    return [Ah, Al];
 	}
-	const toBig = (h, l) => (BigInt(h >>> 0) << _32n$1) | BigInt(l >>> 0);
+	const toBig = (h, l) => (BigInt(h >>> 0) << _32n) | 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);
@@ -2643,11 +2653,11 @@ var solanaWeb3 = (function (exports) {
 	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));
+	const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
+	const rotlSL = (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));
+	const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+	const rotlBL = (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) {
@@ -2663,11 +2673,11 @@ var solanaWeb3 = (function (exports) {
 	const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
 	// prettier-ignore
 	const u64$1 = {
-	    fromBig: fromBig$1, split: split$1, toBig,
+	    fromBig, split, toBig,
 	    shrSH, shrSL,
 	    rotrSH, rotrSL, rotrBH, rotrBL,
 	    rotr32H, rotr32L,
-	    rotlSH: rotlSH$1, rotlSL: rotlSL$1, rotlBH: rotlBH$1, rotlBL: rotlBL$1,
+	    rotlSH, rotlSL, rotlBH, rotlBL,
 	    add, add3L, add3H, add4L, add4H, add5H, add5L,
 	};
 
@@ -2825,7 +2835,7 @@ var solanaWeb3 = (function (exports) {
 	        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 	    }
 	}
-	const sha512 = /* @__PURE__ */ wrapConstructor$1(() => new SHA512());
+	const sha512 = /* @__PURE__ */ wrapConstructor(() => new SHA512());
 
 	/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 	// 100 lines of code in the file are duplicated from noble-hashes (utils).
@@ -2835,12 +2845,12 @@ var solanaWeb3 = (function (exports) {
 	const _0n$5 = BigInt(0);
 	const _1n$7 = BigInt(1);
 	const _2n$5 = BigInt(2);
-	function isBytes$2(a) {
+	function isBytes(a) {
 	    return (a instanceof Uint8Array ||
 	        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
 	}
 	function abytes(item) {
-	    if (!isBytes$2(item))
+	    if (!isBytes(item))
 	        throw new Error('Uint8Array expected');
 	}
 	// Array where index 0xf0 (240) is mapped to string 'f0'
@@ -2937,7 +2947,7 @@ var solanaWeb3 = (function (exports) {
 	            throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
 	        }
 	    }
-	    else if (isBytes$2(hex)) {
+	    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);
@@ -2980,7 +2990,7 @@ var solanaWeb3 = (function (exports) {
 	/**
 	 * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
 	 */
-	function utf8ToBytes$1(str) {
+	function utf8ToBytes(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
@@ -3082,7 +3092,7 @@ var solanaWeb3 = (function (exports) {
 	    function: (val) => typeof val === 'function',
 	    boolean: (val) => typeof val === 'boolean',
 	    string: (val) => typeof val === 'string',
-	    stringOrUint8Array: (val) => typeof val === 'string' || isBytes$2(val),
+	    stringOrUint8Array: (val) => typeof val === 'string' || isBytes(val),
 	    isSafeInteger: (val) => Number.isSafeInteger(val),
 	    array: (val) => Array.isArray(val),
 	    field: (val, object) => object.Fp.isValid(val),
@@ -3132,12 +3142,12 @@ var solanaWeb3 = (function (exports) {
 		equalBytes: equalBytes,
 		hexToBytes: hexToBytes,
 		hexToNumber: hexToNumber,
-		isBytes: isBytes$2,
+		isBytes: isBytes,
 		numberToBytesBE: numberToBytesBE,
 		numberToBytesLE: numberToBytesLE,
 		numberToHexUnpadded: numberToHexUnpadded,
 		numberToVarBytesBE: numberToVarBytesBE,
-		utf8ToBytes: utf8ToBytes$1,
+		utf8ToBytes: utf8ToBytes,
 		validateObject: validateObject
 	});
 
@@ -4166,7 +4176,7 @@ var solanaWeb3 = (function (exports) {
 	function ed25519_domain(data, ctx, phflag) {
 	    if (ctx.length > 255)
 	        throw new Error('Context is too big');
-	    return concatBytes$1(utf8ToBytes$2('SigEd25519 no Ed25519 collisions'), new Uint8Array([phflag ? 1 : 0, ctx.length]), ctx, data);
+	    return concatBytes$1(utf8ToBytes$1('SigEd25519 no Ed25519 collisions'), new Uint8Array([phflag ? 1 : 0, ctx.length]), ctx, data);
 	}
 	/* @__PURE__ */ twistedEdwards({
 	    ...ed25519Defaults,
@@ -7806,216 +7816,12 @@ var solanaWeb3 = (function (exports) {
 
 	var bs58$1 = /*@__PURE__*/getDefaultExportFromCjs(bs58);
 
-	function number$1(n) {
-	    if (!Number.isSafeInteger(n) || n < 0)
-	        throw new Error(`Wrong positive integer: ${n}`);
-	}
-	// copied from utils
-	function isBytes$1(a) {
-	    return (a instanceof Uint8Array ||
-	        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
-	}
-	function bytes(b, ...lengths) {
-	    if (!isBytes$1(b))
-	        throw new Error('Expected Uint8Array');
-	    if (lengths.length > 0 && !lengths.includes(b.length))
-	        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
-	}
-	function exists(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(out, instance) {
-	    bytes(out);
-	    const min = instance.outputLen;
-	    if (out.length < min) {
-	        throw new Error(`digestInto() expects output buffer of length at least ${min}`);
-	    }
-	}
-
-	/*! 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.
-	const u32$1 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-	function isBytes(a) {
-	    return (a instanceof Uint8Array ||
-	        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
-	}
-	// Cast array to view
-	const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-	// The rotate right (circular right shift) operation for uint32
-	const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
-	// big-endian hardware is rare. Just in case someone still decides to run hashes:
-	// early-throw an error because we don't support BE yet.
-	// Other libraries would silently corrupt the data instead of throwing an error,
-	// when they don't support it.
-	const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
-	if (!isLE)
-	    throw new Error('Non little-endian hardware is not supported');
-	/**
-	 * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
-	 */
-	function utf8ToBytes(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(data) {
-	    if (typeof data === 'string')
-	        data = utf8ToBytes(data);
-	    if (!isBytes(data))
-	        throw new Error(`expected Uint8Array, got ${typeof data}`);
-	    return data;
-	}
-	// For runtime check if class implements interface
-	class Hash {
-	    // Safe version that clones internal state
-	    clone() {
-	        return this._cloneInto();
-	    }
-	}
-	function wrapConstructor(hashCons) {
-	    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
-	    const tmp = hashCons();
-	    hashC.outputLen = tmp.outputLen;
-	    hashC.blockLen = tmp.blockLen;
-	    hashC.create = () => hashCons();
-	    return hashC;
-	}
-
-	// Polyfill for Safari 14
-	function setBigUint64(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);
-	}
-	// Base SHA2 class (RFC 6234)
-	class SHA2 extends Hash {
-	    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(this.buffer);
-	    }
-	    update(data) {
-	        exists(this);
-	        const { view, buffer, blockLen } = this;
-	        data = toBytes(data);
-	        const len = data.length;
-	        for (let pos = 0; pos < len;) {
-	            const take = Math.min(blockLen - this.pos, len - pos);
-	            // Fast path: we have at least one block in input, cast it to view and process
-	            if (take === blockLen) {
-	                const dataView = createView(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(this);
-	        output(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(view, blockLen - 8, BigInt(this.length * 8), isLE);
-	        this.process(view, 0);
-	        const oview = createView(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;
-	    }
-	}
-
 	// SHA2-256 need to try 2^128 hashes to execute birthday attack.
 	// BTC network is doing 2^67 hashes/sec as per early 2023.
-	// Choice: a ? b : c
-	const Chi = (a, b, c) => (a & b) ^ (~a & c);
-	// Majority function, true if any two inpust is true
-	const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
 	// Round constants:
 	// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)
 	// prettier-ignore
-	const SHA256_K$1 = /* @__PURE__ */ new Uint32Array([
+	const SHA256_K = /* @__PURE__ */ new Uint32Array([
 	    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
 	    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
 	    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
@@ -8025,27 +7831,28 @@ var solanaWeb3 = (function (exports) {
 	    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
 	    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 	]);
-	// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
+	// Initial state:
+	// first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19
 	// prettier-ignore
-	const IV = /* @__PURE__ */ new Uint32Array([
+	const SHA256_IV = /* @__PURE__ */ new Uint32Array([
 	    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
 	]);
 	// Temporary buffer, not used to store anything between runs
 	// Named this way because it matches specification.
-	const SHA256_W$1 = /* @__PURE__ */ new Uint32Array(64);
-	let SHA256$1 = class SHA256 extends SHA2 {
+	const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+	class SHA256 extends HashMD {
 	    constructor() {
 	        super(64, 32, 8, false);
 	        // We cannot use array here since array allows indexing by variable
 	        // which means optimizer/compiler cannot use registers.
-	        this.A = IV[0] | 0;
-	        this.B = IV[1] | 0;
-	        this.C = IV[2] | 0;
-	        this.D = IV[3] | 0;
-	        this.E = IV[4] | 0;
-	        this.F = IV[5] | 0;
-	        this.G = IV[6] | 0;
-	        this.H = IV[7] | 0;
+	        this.A = SHA256_IV[0] | 0;
+	        this.B = SHA256_IV[1] | 0;
+	        this.C = SHA256_IV[2] | 0;
+	        this.D = SHA256_IV[3] | 0;
+	        this.E = SHA256_IV[4] | 0;
+	        this.F = SHA256_IV[5] | 0;
+	        this.G = SHA256_IV[6] | 0;
+	        this.H = SHA256_IV[7] | 0;
 	    }
 	    get() {
 	        const { A, B, C, D, E, F, G, H } = this;
@@ -8065,19 +7872,19 @@ var solanaWeb3 = (function (exports) {
 	    process(view, offset) {
 	        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
 	        for (let i = 0; i < 16; i++, offset += 4)
-	            SHA256_W$1[i] = view.getUint32(offset, false);
+	            SHA256_W[i] = view.getUint32(offset, false);
 	        for (let i = 16; i < 64; i++) {
-	            const W15 = SHA256_W$1[i - 15];
-	            const W2 = SHA256_W$1[i - 2];
+	            const W15 = SHA256_W[i - 15];
+	            const W2 = SHA256_W[i - 2];
 	            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);
 	            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);
-	            SHA256_W$1[i] = (s1 + SHA256_W$1[i - 7] + s0 + SHA256_W$1[i - 16]) | 0;
+	            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
 	        }
 	        // Compression function main loop, 64 rounds
 	        let { A, B, C, D, E, F, G, H } = this;
 	        for (let i = 0; i < 64; i++) {
 	            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-	            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K$1[i] + SHA256_W$1[i]) | 0;
+	            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
 	            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
 	            const T2 = (sigma0 + Maj(A, B, C)) | 0;
 	            H = G;
@@ -8101,18 +7908,18 @@ var solanaWeb3 = (function (exports) {
 	        this.set(A, B, C, D, E, F, G, H);
 	    }
 	    roundClean() {
-	        SHA256_W$1.fill(0);
+	        SHA256_W.fill(0);
 	    }
 	    destroy() {
 	        this.set(0, 0, 0, 0, 0, 0, 0, 0);
 	        this.buffer.fill(0);
 	    }
-	};
+	}
 	/**
 	 * SHA2-256 hash function
 	 * @param message - data that would be hashed
 	 */
-	const sha256$1 = /* @__PURE__ */ wrapConstructor(() => new SHA256$1());
+	const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 
 	var lib = {};
 
@@ -9231,8 +9038,7 @@ var solanaWeb3 = (function (exports) {
 	}
 	const SOLANA_SCHEMA = new Map();
 
-	var _class;
-	let _Symbol$toStringTag;
+	var _PublicKey;
 
 	/**
 	 * Maximum length of derived pubkey seed
@@ -9262,7 +9068,6 @@ var solanaWeb3 = (function (exports) {
 	/**
 	 * A public key
 	 */
-	_Symbol$toStringTag = Symbol.toStringTag;
 	class PublicKey extends Struct$1 {
 	  /**
 	   * Create a new PublicKey object
@@ -9342,7 +9147,7 @@ var solanaWeb3 = (function (exports) {
 	    b.copy(zeroPad, 32 - b.length);
 	    return zeroPad;
 	  }
-	  get [_Symbol$toStringTag]() {
+	  get [Symbol.toStringTag]() {
 	    return `PublicKey(${this.toString()})`;
 	  }
 
@@ -9361,7 +9166,7 @@ var solanaWeb3 = (function (exports) {
 	  /* eslint-disable require-await */
 	  static async createWithSeed(fromPublicKey, seed, programId) {
 	    const buffer$1 = buffer.Buffer.concat([fromPublicKey.toBuffer(), buffer.Buffer.from(seed), programId.toBuffer()]);
-	    const publicKeyBytes = sha256$1(buffer$1);
+	    const publicKeyBytes = sha256(buffer$1);
 	    return new PublicKey(publicKeyBytes);
 	  }
 
@@ -9378,7 +9183,7 @@ var solanaWeb3 = (function (exports) {
 	      buffer$1 = buffer.Buffer.concat([buffer$1, toBuffer(seed)]);
 	    });
 	    buffer$1 = buffer.Buffer.concat([buffer$1, programId.toBuffer(), buffer.Buffer.from('ProgramDerivedAddress')]);
-	    const publicKeyBytes = sha256$1(buffer$1);
+	    const publicKeyBytes = sha256(buffer$1);
 	    if (isOnCurve(publicKeyBytes)) {
 	      throw new Error(`Invalid seeds, address must fall off the curve`);
 	    }
@@ -9440,8 +9245,8 @@ var solanaWeb3 = (function (exports) {
 	    return isOnCurve(pubkey.toBytes());
 	  }
 	}
-	_class = PublicKey;
-	PublicKey.default = new _class('11111111111111111111111111111111');
+	_PublicKey = PublicKey;
+	PublicKey.default = new _PublicKey('11111111111111111111111111111111');
 	SOLANA_SCHEMA.set(PublicKey, {
 	  kind: 'struct',
 	  fields: [['_bn', 'u256']]
@@ -14829,7 +14634,6 @@ var solanaWeb3 = (function (exports) {
 	/**
 	 * A `StructFailure` represents a single specific failure in validation.
 	 */
-
 	/**
 	 * `StructError` objects are thrown (or returned) when validation fails.
 	 *
@@ -14839,190 +14643,160 @@ var solanaWeb3 = (function (exports) {
 	 * continue validation and receive all the failures in the data.
 	 */
 	class StructError extends TypeError {
-	  constructor(failure, failures) {
-	    let cached;
-	    const {
-	      message,
-	      ...rest
-	    } = failure;
-	    const {
-	      path
-	    } = failure;
-	    const msg = path.length === 0 ? message : "At path: " + path.join('.') + " -- " + message;
-	    super(msg);
-	    Object.assign(this, rest);
-	    this.name = this.constructor.name;
-
-	    this.failures = () => {
-	      var _cached;
-
-	      return (_cached = cached) != null ? _cached : cached = [failure, ...failures()];
-	    };
-	  }
-
+	    constructor(failure, failures) {
+	        let cached;
+	        const { message, explanation, ...rest } = failure;
+	        const { path } = failure;
+	        const msg = path.length === 0 ? message : `At path: ${path.join('.')} -- ${message}`;
+	        super(explanation ?? msg);
+	        if (explanation != null)
+	            this.cause = msg;
+	        Object.assign(this, rest);
+	        this.name = this.constructor.name;
+	        this.failures = () => {
+	            return (cached ?? (cached = [failure, ...failures()]));
+	        };
+	    }
 	}
 
 	/**
 	 * Check if a value is an iterator.
 	 */
 	function isIterable(x) {
-	  return isObject(x) && typeof x[Symbol.iterator] === 'function';
+	    return isObject(x) && typeof x[Symbol.iterator] === 'function';
 	}
 	/**
 	 * Check if a value is a plain object.
 	 */
-
-
 	function isObject(x) {
-	  return typeof x === 'object' && x != null;
+	    return typeof x === 'object' && x != null;
 	}
 	/**
 	 * Return a value as a printable string.
 	 */
-
 	function print(value) {
-	  return typeof value === 'string' ? JSON.stringify(value) : "" + value;
+	    if (typeof value === 'symbol') {
+	        return value.toString();
+	    }
+	    return typeof value === 'string' ? JSON.stringify(value) : `${value}`;
 	}
 	/**
 	 * Shifts (removes and returns) the first value from the `input` iterator.
 	 * Like `Array.prototype.shift()` but for an `Iterator`.
 	 */
-
 	function shiftIterator(input) {
-	  const {
-	    done,
-	    value
-	  } = input.next();
-	  return done ? undefined : value;
+	    const { done, value } = input.next();
+	    return done ? undefined : value;
 	}
 	/**
 	 * Convert a single validation result to a failure.
 	 */
-
 	function toFailure(result, context, struct, value) {
-	  if (result === true) {
-	    return;
-	  } else if (result === false) {
-	    result = {};
-	  } else if (typeof result === 'string') {
-	    result = {
-	      message: result
+	    if (result === true) {
+	        return;
+	    }
+	    else if (result === false) {
+	        result = {};
+	    }
+	    else if (typeof result === 'string') {
+	        result = { message: result };
+	    }
+	    const { path, branch } = context;
+	    const { type } = struct;
+	    const { refinement, message = `Expected a value of type \`${type}\`${refinement ? ` with refinement \`${refinement}\`` : ''}, but received: \`${print(value)}\``, } = result;
+	    return {
+	        value,
+	        type,
+	        refinement,
+	        key: path[path.length - 1],
+	        path,
+	        branch,
+	        ...result,
+	        message,
 	    };
-	  }
-
-	  const {
-	    path,
-	    branch
-	  } = context;
-	  const {
-	    type
-	  } = struct;
-	  const {
-	    refinement,
-	    message = "Expected a value of type `" + type + "`" + (refinement ? " with refinement `" + refinement + "`" : '') + ", but received: `" + print(value) + "`"
-	  } = result;
-	  return {
-	    value,
-	    type,
-	    refinement,
-	    key: path[path.length - 1],
-	    path,
-	    branch,
-	    ...result,
-	    message
-	  };
 	}
 	/**
 	 * Convert a validation result to an iterable of failures.
 	 */
-
 	function* toFailures(result, context, struct, value) {
-	  if (!isIterable(result)) {
-	    result = [result];
-	  }
-
-	  for (const r of result) {
-	    const failure = toFailure(r, context, struct, value);
-
-	    if (failure) {
-	      yield failure;
+	    if (!isIterable(result)) {
+	        result = [result];
+	    }
+	    for (const r of result) {
+	        const failure = toFailure(r, context, struct, value);
+	        if (failure) {
+	            yield failure;
+	        }
 	    }
-	  }
 	}
 	/**
 	 * Check a value against a struct, traversing deeply into nested values, and
 	 * returning an iterator of failures or success.
 	 */
-
 	function* run(value, struct, options = {}) {
-	  const {
-	    path = [],
-	    branch = [value],
-	    coerce = false,
-	    mask = false
-	  } = options;
-	  const ctx = {
-	    path,
-	    branch
-	  };
-
-	  if (coerce) {
-	    value = struct.coercer(value, ctx);
-
-	    if (mask && struct.type !== 'type' && isObject(struct.schema) && isObject(value) && !Array.isArray(value)) {
-	      for (const key in value) {
-	        if (struct.schema[key] === undefined) {
-	          delete value[key];
+	    const { path = [], branch = [value], coerce = false, mask = false } = options;
+	    const ctx = { path, branch };
+	    if (coerce) {
+	        value = struct.coercer(value, ctx);
+	        if (mask &&
+	            struct.type !== 'type' &&
+	            isObject(struct.schema) &&
+	            isObject(value) &&
+	            !Array.isArray(value)) {
+	            for (const key in value) {
+	                if (struct.schema[key] === undefined) {
+	                    delete value[key];
+	                }
+	            }
 	        }
-	      }
 	    }
-	  }
-
-	  let valid = true;
-
-	  for (const failure of struct.validator(value, ctx)) {
-	    valid = false;
-	    yield [failure, undefined];
-	  }
-
-	  for (let [k, v, s] of struct.entries(value, ctx)) {
-	    const ts = run(v, s, {
-	      path: k === undefined ? path : [...path, k],
-	      branch: k === undefined ? branch : [...branch, v],
-	      coerce,
-	      mask
-	    });
-
-	    for (const t of ts) {
-	      if (t[0]) {
-	        valid = false;
-	        yield [t[0], undefined];
-	      } else if (coerce) {
-	        v = t[1];
-
-	        if (k === undefined) {
-	          value = v;
-	        } else if (value instanceof Map) {
-	          value.set(k, v);
-	        } else if (value instanceof Set) {
-	          value.add(v);
-	        } else if (isObject(value)) {
-	          value[k] = v;
+	    let status = 'valid';
+	    for (const failure of struct.validator(value, ctx)) {
+	        failure.explanation = options.message;
+	        status = 'not_valid';
+	        yield [failure, undefined];
+	    }
+	    for (let [k, v, s] of struct.entries(value, ctx)) {
+	        const ts = run(v, s, {
+	            path: k === undefined ? path : [...path, k],
+	            branch: k === undefined ? branch : [...branch, v],
+	            coerce,
+	            mask,
+	            message: options.message,
+	        });
+	        for (const t of ts) {
+	            if (t[0]) {
+	                status = t[0].refinement != null ? 'not_refined' : 'not_valid';
+	                yield [t[0], undefined];
+	            }
+	            else if (coerce) {
+	                v = t[1];
+	                if (k === undefined) {
+	                    value = v;
+	                }
+	                else if (value instanceof Map) {
+	                    value.set(k, v);
+	                }
+	                else if (value instanceof Set) {
+	                    value.add(v);
+	                }
+	                else if (isObject(value)) {
+	                    if (v !== undefined || k in value)
+	                        value[k] = v;
+	                }
+	            }
 	        }
-	      }
 	    }
-	  }
-
-	  if (valid) {
-	    for (const failure of struct.refiner(value, ctx)) {
-	      valid = false;
-	      yield [failure, undefined];
+	    if (status !== 'not_valid') {
+	        for (const failure of struct.refiner(value, ctx)) {
+	            failure.explanation = options.message;
+	            status = 'not_refined';
+	            yield [failure, undefined];
+	        }
+	    }
+	    if (status === 'valid') {
+	        yield [undefined, value];
 	    }
-	  }
-
-	  if (valid) {
-	    yield [undefined, value];
-	  }
 	}
 
 	/**
@@ -15030,269 +14804,227 @@ var solanaWeb3 = (function (exports) {
 	 * values. Once constructed, you use the `assert`, `is` or `validate` helpers to
 	 * validate unknown input data against the struct.
 	 */
-
 	class Struct {
-	  constructor(props) {
-	    const {
-	      type,
-	      schema,
-	      validator,
-	      refiner,
-	      coercer = value => value,
-	      entries = function* () {}
-	    } = props;
-	    this.type = type;
-	    this.schema = schema;
-	    this.entries = entries;
-	    this.coercer = coercer;
-
-	    if (validator) {
-	      this.validator = (value, context) => {
-	        const result = validator(value, context);
-	        return toFailures(result, context, this, value);
-	      };
-	    } else {
-	      this.validator = () => [];
+	    constructor(props) {
+	        const { type, schema, validator, refiner, coercer = (value) => value, entries = function* () { }, } = props;
+	        this.type = type;
+	        this.schema = schema;
+	        this.entries = entries;
+	        this.coercer = coercer;
+	        if (validator) {
+	            this.validator = (value, context) => {
+	                const result = validator(value, context);
+	                return toFailures(result, context, this, value);
+	            };
+	        }
+	        else {
+	            this.validator = () => [];
+	        }
+	        if (refiner) {
+	            this.refiner = (value, context) => {
+	                const result = refiner(value, context);
+	                return toFailures(result, context, this, value);
+	            };
+	        }
+	        else {
+	            this.refiner = () => [];
+	        }
 	    }
-
-	    if (refiner) {
-	      this.refiner = (value, context) => {
-	        const result = refiner(value, context);
-	        return toFailures(result, context, this, value);
-	      };
-	    } else {
-	      this.refiner = () => [];
+	    /**
+	     * Assert that a value passes the struct's validation, throwing if it doesn't.
+	     */
+	    assert(value, message) {
+	        return assert(value, this, message);
+	    }
+	    /**
+	     * Create a value with the struct's coercion logic, then validate it.
+	     */
+	    create(value, message) {
+	        return create(value, this, message);
+	    }
+	    /**
+	     * Check if a value passes the struct's validation.
+	     */
+	    is(value) {
+	        return is(value, this);
+	    }
+	    /**
+	     * Mask a value, coercing and validating it, but returning only the subset of
+	     * properties defined by the struct's schema.
+	     */
+	    mask(value, message) {
+	        return mask(value, this, message);
+	    }
+	    /**
+	     * Validate a value with the struct's validation logic, returning a tuple
+	     * representing the result.
+	     *
+	     * You may optionally pass `true` for the `withCoercion` argument to coerce
+	     * the value before attempting to validate it. If you do, the result will
+	     * contain the coerced result when successful.
+	     */
+	    validate(value, options = {}) {
+	        return validate$1(value, this, options);
 	    }
-	  }
-	  /**
-	   * Assert that a value passes the struct's validation, throwing if it doesn't.
-	   */
-
-
-	  assert(value) {
-	    return assert(value, this);
-	  }
-	  /**
-	   * Create a value with the struct's coercion logic, then validate it.
-	   */
-
-
-	  create(value) {
-	    return create(value, this);
-	  }
-	  /**
-	   * Check if a value passes the struct's validation.
-	   */
-
-
-	  is(value) {
-	    return is(value, this);
-	  }
-	  /**
-	   * Mask a value, coercing and validating it, but returning only the subset of
-	   * properties defined by the struct's schema.
-	   */
-
-
-	  mask(value) {
-	    return mask(value, this);
-	  }
-	  /**
-	   * Validate a value with the struct's validation logic, returning a tuple
-	   * representing the result.
-	   *
-	   * You may optionally pass `true` for the `withCoercion` argument to coerce
-	   * the value before attempting to validate it. If you do, the result will
-	   * contain the coerced result when successful.
-	   */
-
-
-	  validate(value, options = {}) {
-	    return validate$1(value, this, options);
-	  }
-
 	}
 	/**
 	 * Assert that a value passes a struct, throwing if it doesn't.
 	 */
-
-	function assert(value, struct) {
-	  const result = validate$1(value, struct);
-
-	  if (result[0]) {
-	    throw result[0];
-	  }
+	function assert(value, struct, message) {
+	    const result = validate$1(value, struct, { message });
+	    if (result[0]) {
+	        throw result[0];
+	    }
 	}
 	/**
 	 * Create a value with the coercion logic of struct and validate it.
 	 */
-
-	function create(value, struct) {
-	  const result = validate$1(value, struct, {
-	    coerce: true
-	  });
-
-	  if (result[0]) {
-	    throw result[0];
-	  } else {
-	    return result[1];
-	  }
+	function create(value, struct, message) {
+	    const result = validate$1(value, struct, { coerce: true, message });
+	    if (result[0]) {
+	        throw result[0];
+	    }
+	    else {
+	        return result[1];
+	    }
 	}
 	/**
 	 * Mask a value, returning only the subset of properties defined by a struct.
 	 */
-
-	function mask(value, struct) {
-	  const result = validate$1(value, struct, {
-	    coerce: true,
-	    mask: true
-	  });
-
-	  if (result[0]) {
-	    throw result[0];
-	  } else {
-	    return result[1];
-	  }
+	function mask(value, struct, message) {
+	    const result = validate$1(value, struct, { coerce: true, mask: true, message });
+	    if (result[0]) {
+	        throw result[0];
+	    }
+	    else {
+	        return result[1];
+	    }
 	}
 	/**
 	 * Check if a value passes a struct.
 	 */
-
 	function is(value, struct) {
-	  const result = validate$1(value, struct);
-	  return !result[0];
+	    const result = validate$1(value, struct);
+	    return !result[0];
 	}
 	/**
 	 * Validate a value against a struct, returning an error if invalid, or the
 	 * value (with potential coercion) if valid.
 	 */
-
 	function validate$1(value, struct, options = {}) {
-	  const tuples = run(value, struct, options);
-	  const tuple = shiftIterator(tuples);
-
-	  if (tuple[0]) {
-	    const error = new StructError(tuple[0], function* () {
-	      for (const t of tuples) {
-	        if (t[0]) {
-	          yield t[0];
-	        }
-	      }
-	    });
-	    return [error, undefined];
-	  } else {
-	    const v = tuple[1];
-	    return [undefined, v];
-	  }
+	    const tuples = run(value, struct, options);
+	    const tuple = shiftIterator(tuples);
+	    if (tuple[0]) {
+	        const error = new StructError(tuple[0], function* () {
+	            for (const t of tuples) {
+	                if (t[0]) {
+	                    yield t[0];
+	                }
+	            }
+	        });
+	        return [error, undefined];
+	    }
+	    else {
+	        const v = tuple[1];
+	        return [undefined, v];
+	    }
 	}
 	/**
 	 * Define a new struct type with a custom validation function.
 	 */
-
 	function define(name, validator) {
-	  return new Struct({
-	    type: name,
-	    schema: null,
-	    validator
-	  });
+	    return new Struct({ type: name, schema: null, validator });
 	}
 
 	/**
 	 * Ensure that any value passes validation.
 	 */
-
 	function any() {
-	  return define('any', () => true);
+	    return define('any', () => true);
 	}
 	function array(Element) {
-	  return new Struct({
-	    type: 'array',
-	    schema: Element,
-
-	    *entries(value) {
-	      if (Element && Array.isArray(value)) {
-	        for (const [i, v] of value.entries()) {
-	          yield [i, v, Element];
-	        }
-	      }
-	    },
-
-	    coercer(value) {
-	      return Array.isArray(value) ? value.slice() : value;
-	    },
-
-	    validator(value) {
-	      return Array.isArray(value) || "Expected an array value, but received: " + print(value);
-	    }
-
-	  });
+	    return new Struct({
+	        type: 'array',
+	        schema: Element,
+	        *entries(value) {
+	            if (Element && Array.isArray(value)) {
+	                for (const [i, v] of value.entries()) {
+	                    yield [i, v, Element];
+	                }
+	            }
+	        },
+	        coercer(value) {
+	            return Array.isArray(value) ? value.slice() : value;
+	        },
+	        validator(value) {
+	            return (Array.isArray(value) ||
+	                `Expected an array value, but received: ${print(value)}`);
+	        },
+	    });
 	}
 	/**
 	 * Ensure that a value is a boolean.
 	 */
-
 	function boolean() {
-	  return define('boolean', value => {
-	    return typeof value === 'boolean';
-	  });
+	    return define('boolean', (value) => {
+	        return typeof value === 'boolean';
+	    });
 	}
 	/**
 	 * Ensure that a value is an instance of a specific class.
 	 */
-
 	function instance(Class) {
-	  return define('instance', value => {
-	    return value instanceof Class || "Expected a `" + Class.name + "` instance, but received: " + print(value);
-	  });
+	    return define('instance', (value) => {
+	        return (value instanceof Class ||
+	            `Expected a \`${Class.name}\` instance, but received: ${print(value)}`);
+	    });
 	}
 	function literal(constant) {
-	  const description = print(constant);
-	  const t = typeof constant;
-	  return new Struct({
-	    type: 'literal',
-	    schema: t === 'string' || t === 'number' || t === 'boolean' ? constant : null,
-
-	    validator(value) {
-	      return value === constant || "Expected the literal `" + description + "`, but received: " + print(value);
-	    }
-
-	  });
+	    const description = print(constant);
+	    const t = typeof constant;
+	    return new Struct({
+	        type: 'literal',
+	        schema: t === 'string' || t === 'number' || t === 'boolean' ? constant : null,
+	        validator(value) {
+	            return (value === constant ||
+	                `Expected the literal \`${description}\`, but received: ${print(value)}`);
+	        },
+	    });
 	}
 	/**
 	 * Ensure that no value ever passes validation.
 	 */
-
 	function never() {
-	  return define('never', () => false);
+	    return define('never', () => false);
 	}
 	/**
 	 * Augment an existing struct to allow `null` values.
 	 */
-
 	function nullable(struct) {
-	  return new Struct({ ...struct,
-	    validator: (value, ctx) => value === null || struct.validator(value, ctx),
-	    refiner: (value, ctx) => value === null || struct.refiner(value, ctx)
-	  });
+	    return new Struct({
+	        ...struct,
+	        validator: (value, ctx) => value === null || struct.validator(value, ctx),
+	        refiner: (value, ctx) => value === null || struct.refiner(value, ctx),
+	    });
 	}
 	/**
 	 * Ensure that a value is a number.
 	 */
-
 	function number() {
-	  return define('number', value => {
-	    return typeof value === 'number' && !isNaN(value) || "Expected a number, but received: " + print(value);
-	  });
+	    return define('number', (value) => {
+	        return ((typeof value === 'number' && !isNaN(value)) ||
+	            `Expected a number, but received: ${print(value)}`);
+	    });
 	}
 	/**
 	 * Augment a struct to allow `undefined` values.
 	 */
-
 	function optional(struct) {
-	  return new Struct({ ...struct,
-	    validator: (value, ctx) => value === undefined || struct.validator(value, ctx),
-	    refiner: (value, ctx) => value === undefined || struct.refiner(value, ctx)
-	  });
+	    return new Struct({
+	        ...struct,
+	        validator: (value, ctx) => value === undefined || struct.validator(value, ctx),
+	        refiner: (value, ctx) => value === undefined || struct.refiner(value, ctx),
+	    });
 	}
 	/**
 	 * Ensure that a value is an object with keys and values of specific types, but
@@ -15300,58 +15032,55 @@ var solanaWeb3 = (function (exports) {
 	 *
 	 * Like TypeScript's `Record` utility.
 	 */
-
 	function record(Key, Value) {
-	  return new Struct({
-	    type: 'record',
-	    schema: null,
-
-	    *entries(value) {
-	      if (isObject(value)) {
-	        for (const k in value) {
-	          const v = value[k];
-	          yield [k, k, Key];
-	          yield [k, v, Value];
-	        }
-	      }
-	    },
-
-	    validator(value) {
-	      return isObject(value) || "Expected an object, but received: " + print(value);
-	    }
-
-	  });
+	    return new Struct({
+	        type: 'record',
+	        schema: null,
+	        *entries(value) {
+	            if (isObject(value)) {
+	                for (const k in value) {
+	                    const v = value[k];
+	                    yield [k, k, Key];
+	                    yield [k, v, Value];
+	                }
+	            }
+	        },
+	        validator(value) {
+	            return (isObject(value) || `Expected an object, but received: ${print(value)}`);
+	        },
+	    });
 	}
 	/**
 	 * Ensure that a value is a string.
 	 */
-
 	function string() {
-	  return define('string', value => {
-	    return typeof value === 'string' || "Expected a string, but received: " + print(value);
-	  });
+	    return define('string', (value) => {
+	        return (typeof value === 'string' ||
+	            `Expected a string, but received: ${print(value)}`);
+	    });
 	}
-	function tuple(Elements) {
-	  const Never = never();
-	  return new Struct({
-	    type: 'tuple',
-	    schema: null,
-
-	    *entries(value) {
-	      if (Array.isArray(value)) {
-	        const length = Math.max(Elements.length, value.length);
-
-	        for (let i = 0; i < length; i++) {
-	          yield [i, value[i], Elements[i] || Never];
-	        }
-	      }
-	    },
-
-	    validator(value) {
-	      return Array.isArray(value) || "Expected an array, but received: " + print(value);
-	    }
-
-	  });
+	/**
+	 * Ensure that a value is a tuple of a specific length, and that each of its
+	 * elements is of a specific type.
+	 */
+	function tuple(Structs) {
+	    const Never = never();
+	    return new Struct({
+	        type: 'tuple',
+	        schema: null,
+	        *entries(value) {
+	            if (Array.isArray(value)) {
+	                const length = Math.max(Structs.length, value.length);
+	                for (let i = 0; i < length; i++) {
+	                    yield [i, value[i], Structs[i] || Never];
+	                }
+	            }
+	        },
+	        validator(value) {
+	            return (Array.isArray(value) ||
+	                `Expected an array, but received: ${print(value)}`);
+	        },
+	    });
 	}
 	/**
 	 * Ensure that a value has a set of known properties of specific types.
@@ -15359,62 +15088,71 @@ var solanaWeb3 = (function (exports) {
 	 * Note: Unrecognized properties are allowed and untouched. This is similar to
 	 * how TypeScript's structural typing works.
 	 */
-
 	function type(schema) {
-	  const keys = Object.keys(schema);
-	  return new Struct({
-	    type: 'type',
-	    schema,
-
-	    *entries(value) {
-	      if (isObject(value)) {
-	        for (const k of keys) {
-	          yield [k, value[k], schema[k]];
-	        }
-	      }
-	    },
-
-	    validator(value) {
-	      return isObject(value) || "Expected an object, but received: " + print(value);
-	    }
-
-	  });
+	    const keys = Object.keys(schema);
+	    return new Struct({
+	        type: 'type',
+	        schema,
+	        *entries(value) {
+	            if (isObject(value)) {
+	                for (const k of keys) {
+	                    yield [k, value[k], schema[k]];
+	                }
+	            }
+	        },
+	        validator(value) {
+	            return (isObject(value) || `Expected an object, but received: ${print(value)}`);
+	        },
+	        coercer(value) {
+	            return isObject(value) ? { ...value } : value;
+	        },
+	    });
 	}
+	/**
+	 * Ensure that a value matches one of a set of types.
+	 */
 	function union(Structs) {
-	  const description = Structs.map(s => s.type).join(' | ');
-	  return new Struct({
-	    type: 'union',
-	    schema: null,
-
-	    validator(value, ctx) {
-	      const failures = [];
-
-	      for (const S of Structs) {
-	        const [...tuples] = run(value, S, ctx);
-	        const [first] = tuples;
-
-	        if (!first[0]) {
-	          return [];
-	        } else {
-	          for (const [failure] of tuples) {
-	            if (failure) {
-	              failures.push(failure);
+	    const description = Structs.map((s) => s.type).join(' | ');
+	    return new Struct({
+	        type: 'union',
+	        schema: null,
+	        coercer(value) {
+	            for (const S of Structs) {
+	                const [error, coerced] = S.validate(value, { coerce: true });
+	                if (!error) {
+	                    return coerced;
+	                }
 	            }
-	          }
-	        }
-	      }
-
-	      return ["Expected the value to satisfy a union of `" + description + "`, but received: " + print(value), ...failures];
-	    }
-
-	  });
+	            return value;
+	        },
+	        validator(value, ctx) {
+	            const failures = [];
+	            for (const S of Structs) {
+	                const [...tuples] = run(value, S, ctx);
+	                const [first] = tuples;
+	                if (!first[0]) {
+	                    return [];
+	                }
+	                else {
+	                    for (const [failure] of tuples) {
+	                        if (failure) {
+	                            failures.push(failure);
+	                        }
+	                    }
+	                }
+	            }
+	            return [
+	                `Expected the value to satisfy a union of \`${description}\`, but received: ${print(value)}`,
+	                ...failures,
+	            ];
+	        },
+	    });
 	}
 	/**
 	 * Ensure that any value passes validation, without widening its type to `any`.
 	 */
-
 	function unknown() {
-	  return define('unknown', () => true);
+	    return define('unknown', () => true);
 	}
 
 	/**
@@ -15427,13 +15165,15 @@ var solanaWeb3 = (function (exports) {
 	 * Note: You must use `create(value, Struct)` on the value to have the coercion
 	 * take effect! Using simply `assert()` or `is()` will not use coercion.
 	 */
-
 	function coerce(struct, condition, coercer) {
-	  return new Struct({ ...struct,
-	    coercer: (value, ctx) => {
-	      return is(value, condition) ? struct.coercer(coercer(value, ctx), ctx) : struct.coercer(value, ctx);
-	    }
-	  });
+	    return new Struct({
+	        ...struct,
+	        coercer: (value, ctx) => {
+	            return is(value, condition)
+	                ? struct.coercer(coercer(value, ctx), ctx)
+	                : struct.coercer(value, ctx);
+	        },
+	    });
 	}
 
 	// Unique ID creation requires a high quality random # generator. In the browser we therefore
@@ -16393,1593 +16133,771 @@ var solanaWeb3 = (function (exports) {
 
 	var client = {};
 
-	var interopRequireDefault = {exports: {}};
+	var eventemitter3 = {exports: {}};
 
 	(function (module) {
-		function _interopRequireDefault(obj) {
-		  return obj && obj.__esModule ? obj : {
-		    "default": obj
-		  };
-		}
-		module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-	} (interopRequireDefault));
-
-	var interopRequireDefaultExports = interopRequireDefault.exports;
-
-	var regeneratorRuntime$1 = {exports: {}};
-
-	var _typeof = {exports: {}};
 
-	var hasRequired_typeof;
+		var has = Object.prototype.hasOwnProperty
+		  , prefix = '~';
 
-	function require_typeof () {
-		if (hasRequired_typeof) return _typeof.exports;
-		hasRequired_typeof = 1;
-		(function (module) {
-			function _typeof(o) {
-			  "@babel/helpers - typeof";
-
-			  return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-			    return typeof o;
-			  } : function (o) {
-			    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-			  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(o);
-			}
-			module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-		} (_typeof));
-		return _typeof.exports;
-	}
-
-	var hasRequiredRegeneratorRuntime;
-
-	function requireRegeneratorRuntime () {
-		if (hasRequiredRegeneratorRuntime) return regeneratorRuntime$1.exports;
-		hasRequiredRegeneratorRuntime = 1;
-		(function (module) {
-			var _typeof = require_typeof()["default"];
-			function _regeneratorRuntime() {
-			  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
-			    return e;
-			  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-			  var t,
-			    e = {},
-			    r = Object.prototype,
-			    n = r.hasOwnProperty,
-			    o = Object.defineProperty || function (t, e, r) {
-			      t[e] = r.value;
-			    },
-			    i = "function" == typeof Symbol ? Symbol : {},
-			    a = i.iterator || "@@iterator",
-			    c = i.asyncIterator || "@@asyncIterator",
-			    u = i.toStringTag || "@@toStringTag";
-			  function define(t, e, r) {
-			    return Object.defineProperty(t, e, {
-			      value: r,
-			      enumerable: !0,
-			      configurable: !0,
-			      writable: !0
-			    }), t[e];
-			  }
-			  try {
-			    define({}, "");
-			  } catch (t) {
-			    define = function define(t, e, r) {
-			      return t[e] = r;
-			    };
-			  }
-			  function wrap(t, e, r, n) {
-			    var i = e && e.prototype instanceof Generator ? e : Generator,
-			      a = Object.create(i.prototype),
-			      c = new Context(n || []);
-			    return o(a, "_invoke", {
-			      value: makeInvokeMethod(t, r, c)
-			    }), a;
-			  }
-			  function tryCatch(t, e, r) {
-			    try {
-			      return {
-			        type: "normal",
-			        arg: t.call(e, r)
-			      };
-			    } catch (t) {
-			      return {
-			        type: "throw",
-			        arg: t
-			      };
-			    }
-			  }
-			  e.wrap = wrap;
-			  var h = "suspendedStart",
-			    l = "suspendedYield",
-			    f = "executing",
-			    s = "completed",
-			    y = {};
-			  function Generator() {}
-			  function GeneratorFunction() {}
-			  function GeneratorFunctionPrototype() {}
-			  var p = {};
-			  define(p, a, function () {
-			    return this;
-			  });
-			  var d = Object.getPrototypeOf,
-			    v = d && d(d(values([])));
-			  v && v !== r && n.call(v, a) && (p = v);
-			  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
-			  function defineIteratorMethods(t) {
-			    ["next", "throw", "return"].forEach(function (e) {
-			      define(t, e, function (t) {
-			        return this._invoke(e, t);
-			      });
-			    });
-			  }
-			  function AsyncIterator(t, e) {
-			    function invoke(r, o, i, a) {
-			      var c = tryCatch(t[r], t, o);
-			      if ("throw" !== c.type) {
-			        var u = c.arg,
-			          h = u.value;
-			        return h && "object" == _typeof(h) && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
-			          invoke("next", t, i, a);
-			        }, function (t) {
-			          invoke("throw", t, i, a);
-			        }) : e.resolve(h).then(function (t) {
-			          u.value = t, i(u);
-			        }, function (t) {
-			          return invoke("throw", t, i, a);
-			        });
-			      }
-			      a(c.arg);
-			    }
-			    var r;
-			    o(this, "_invoke", {
-			      value: function value(t, n) {
-			        function callInvokeWithMethodAndArg() {
-			          return new e(function (e, r) {
-			            invoke(t, n, e, r);
-			          });
-			        }
-			        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-			      }
-			    });
-			  }
-			  function makeInvokeMethod(e, r, n) {
-			    var o = h;
-			    return function (i, a) {
-			      if (o === f) throw new Error("Generator is already running");
-			      if (o === s) {
-			        if ("throw" === i) throw a;
-			        return {
-			          value: t,
-			          done: !0
-			        };
-			      }
-			      for (n.method = i, n.arg = a;;) {
-			        var c = n.delegate;
-			        if (c) {
-			          var u = maybeInvokeDelegate(c, n);
-			          if (u) {
-			            if (u === y) continue;
-			            return u;
-			          }
-			        }
-			        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
-			          if (o === h) throw o = s, n.arg;
-			          n.dispatchException(n.arg);
-			        } else "return" === n.method && n.abrupt("return", n.arg);
-			        o = f;
-			        var p = tryCatch(e, r, n);
-			        if ("normal" === p.type) {
-			          if (o = n.done ? s : l, p.arg === y) continue;
-			          return {
-			            value: p.arg,
-			            done: n.done
-			          };
-			        }
-			        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
-			      }
-			    };
-			  }
-			  function maybeInvokeDelegate(e, r) {
-			    var n = r.method,
-			      o = e.iterator[n];
-			    if (o === t) return r.delegate = null, "throw" === n && e.iterator["return"] && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
-			    var i = tryCatch(o, e.iterator, r.arg);
-			    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
-			    var a = i.arg;
-			    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
-			  }
-			  function pushTryEntry(t) {
-			    var e = {
-			      tryLoc: t[0]
-			    };
-			    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
-			  }
-			  function resetTryEntry(t) {
-			    var e = t.completion || {};
-			    e.type = "normal", delete e.arg, t.completion = e;
-			  }
-			  function Context(t) {
-			    this.tryEntries = [{
-			      tryLoc: "root"
-			    }], t.forEach(pushTryEntry, this), this.reset(!0);
-			  }
-			  function values(e) {
-			    if (e || "" === e) {
-			      var r = e[a];
-			      if (r) return r.call(e);
-			      if ("function" == typeof e.next) return e;
-			      if (!isNaN(e.length)) {
-			        var o = -1,
-			          i = function next() {
-			            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
-			            return next.value = t, next.done = !0, next;
-			          };
-			        return i.next = i;
-			      }
-			    }
-			    throw new TypeError(_typeof(e) + " is not iterable");
-			  }
-			  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
-			    value: GeneratorFunctionPrototype,
-			    configurable: !0
-			  }), o(GeneratorFunctionPrototype, "constructor", {
-			    value: GeneratorFunction,
-			    configurable: !0
-			  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
-			    var e = "function" == typeof t && t.constructor;
-			    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
-			  }, e.mark = function (t) {
-			    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
-			  }, e.awrap = function (t) {
-			    return {
-			      __await: t
-			    };
-			  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
-			    return this;
-			  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
-			    void 0 === i && (i = Promise);
-			    var a = new AsyncIterator(wrap(t, r, n, o), i);
-			    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
-			      return t.done ? t.value : a.next();
-			    });
-			  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
-			    return this;
-			  }), define(g, "toString", function () {
-			    return "[object Generator]";
-			  }), e.keys = function (t) {
-			    var e = Object(t),
-			      r = [];
-			    for (var n in e) r.push(n);
-			    return r.reverse(), function next() {
-			      for (; r.length;) {
-			        var t = r.pop();
-			        if (t in e) return next.value = t, next.done = !1, next;
-			      }
-			      return next.done = !0, next;
-			    };
-			  }, e.values = values, Context.prototype = {
-			    constructor: Context,
-			    reset: function reset(e) {
-			      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
-			    },
-			    stop: function stop() {
-			      this.done = !0;
-			      var t = this.tryEntries[0].completion;
-			      if ("throw" === t.type) throw t.arg;
-			      return this.rval;
-			    },
-			    dispatchException: function dispatchException(e) {
-			      if (this.done) throw e;
-			      var r = this;
-			      function handle(n, o) {
-			        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
-			      }
-			      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
-			        var i = this.tryEntries[o],
-			          a = i.completion;
-			        if ("root" === i.tryLoc) return handle("end");
-			        if (i.tryLoc <= this.prev) {
-			          var c = n.call(i, "catchLoc"),
-			            u = n.call(i, "finallyLoc");
-			          if (c && u) {
-			            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
-			            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-			          } else if (c) {
-			            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
-			          } else {
-			            if (!u) throw new Error("try statement without catch or finally");
-			            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-			          }
-			        }
-			      }
-			    },
-			    abrupt: function abrupt(t, e) {
-			      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
-			        var o = this.tryEntries[r];
-			        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
-			          var i = o;
-			          break;
-			        }
-			      }
-			      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
-			      var a = i ? i.completion : {};
-			      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
-			    },
-			    complete: function complete(t, e) {
-			      if ("throw" === t.type) throw t.arg;
-			      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
-			    },
-			    finish: function finish(t) {
-			      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-			        var r = this.tryEntries[e];
-			        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
-			      }
-			    },
-			    "catch": function _catch(t) {
-			      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-			        var r = this.tryEntries[e];
-			        if (r.tryLoc === t) {
-			          var n = r.completion;
-			          if ("throw" === n.type) {
-			            var o = n.arg;
-			            resetTryEntry(r);
-			          }
-			          return o;
-			        }
-			      }
-			      throw new Error("illegal catch attempt");
-			    },
-			    delegateYield: function delegateYield(e, r, n) {
-			      return this.delegate = {
-			        iterator: values(e),
-			        resultName: r,
-			        nextLoc: n
-			      }, "next" === this.method && (this.arg = t), y;
-			    }
-			  }, e;
-			}
-			module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-		} (regeneratorRuntime$1));
-		return regeneratorRuntime$1.exports;
-	}
-
-	var regenerator;
-	var hasRequiredRegenerator;
-
-	function requireRegenerator () {
-		if (hasRequiredRegenerator) return regenerator;
-		hasRequiredRegenerator = 1;
-		// TODO(Babel 8): Remove this file.
+		/**
+		 * Constructor to create a storage for our `EE` objects.
+		 * An `Events` instance is a plain object whose properties are event names.
+		 *
+		 * @constructor
+		 * @private
+		 */
+		function Events() {}
 
-		var runtime = requireRegeneratorRuntime()();
-		regenerator = runtime;
+		//
+		// We try to not inherit from `Object.prototype`. In some engines creating an
+		// instance in this way is faster than calling `Object.create(null)` directly.
+		// If `Object.create(null)` is not supported we prefix the event names with a
+		// character to make sure that the built-in object properties are not
+		// overridden or used as an attack vector.
+		//
+		if (Object.create) {
+		  Events.prototype = Object.create(null);
 
-		// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=
-		try {
-		  regeneratorRuntime = runtime;
-		} catch (accidentalStrictMode) {
-		  if (typeof globalThis === "object") {
-		    globalThis.regeneratorRuntime = runtime;
-		  } else {
-		    Function("r", "regeneratorRuntime = r")(runtime);
-		  }
+		  //
+		  // This hack is needed because the `__proto__` property is still inherited in
+		  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+		  //
+		  if (!new Events().__proto__) prefix = false;
 		}
-		return regenerator;
-	}
-
-	var asyncToGenerator = {exports: {}};
-
-	var hasRequiredAsyncToGenerator;
-
-	function requireAsyncToGenerator () {
-		if (hasRequiredAsyncToGenerator) return asyncToGenerator.exports;
-		hasRequiredAsyncToGenerator = 1;
-		(function (module) {
-			function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-			  try {
-			    var info = gen[key](arg);
-			    var value = info.value;
-			  } catch (error) {
-			    reject(error);
-			    return;
-			  }
-			  if (info.done) {
-			    resolve(value);
-			  } else {
-			    Promise.resolve(value).then(_next, _throw);
-			  }
-			}
-			function _asyncToGenerator(fn) {
-			  return function () {
-			    var self = this,
-			      args = arguments;
-			    return new Promise(function (resolve, reject) {
-			      var gen = fn.apply(self, args);
-			      function _next(value) {
-			        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-			      }
-			      function _throw(err) {
-			        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-			      }
-			      _next(undefined);
-			    });
-			  };
-			}
-			module.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-		} (asyncToGenerator));
-		return asyncToGenerator.exports;
-	}
-
-	var classCallCheck = {exports: {}};
-
-	var hasRequiredClassCallCheck;
-
-	function requireClassCallCheck () {
-		if (hasRequiredClassCallCheck) return classCallCheck.exports;
-		hasRequiredClassCallCheck = 1;
-		(function (module) {
-			function _classCallCheck(instance, Constructor) {
-			  if (!(instance instanceof Constructor)) {
-			    throw new TypeError("Cannot call a class as a function");
-			  }
-			}
-			module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-		} (classCallCheck));
-		return classCallCheck.exports;
-	}
-
-	var createClass = {exports: {}};
-
-	var toPropertyKey = {exports: {}};
-
-	var toPrimitive = {exports: {}};
-
-	var hasRequiredToPrimitive;
-
-	function requireToPrimitive () {
-		if (hasRequiredToPrimitive) return toPrimitive.exports;
-		hasRequiredToPrimitive = 1;
-		(function (module) {
-			var _typeof = require_typeof()["default"];
-			function _toPrimitive(input, hint) {
-			  if (_typeof(input) !== "object" || input === null) return input;
-			  var prim = input[Symbol.toPrimitive];
-			  if (prim !== undefined) {
-			    var res = prim.call(input, hint || "default");
-			    if (_typeof(res) !== "object") return res;
-			    throw new TypeError("@@toPrimitive must return a primitive value.");
-			  }
-			  return (hint === "string" ? String : Number)(input);
-			}
-			module.exports = _toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-		} (toPrimitive));
-		return toPrimitive.exports;
-	}
-
-	var hasRequiredToPropertyKey;
-
-	function requireToPropertyKey () {
-		if (hasRequiredToPropertyKey) return toPropertyKey.exports;
-		hasRequiredToPropertyKey = 1;
-		(function (module) {
-			var _typeof = require_typeof()["default"];
-			var toPrimitive = requireToPrimitive();
-			function _toPropertyKey(arg) {
-			  var key = toPrimitive(arg, "string");
-			  return _typeof(key) === "symbol" ? key : String(key);
-			}
-			module.exports = _toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-		} (toPropertyKey));
-		return toPropertyKey.exports;
-	}
-
-	var hasRequiredCreateClass;
-
-	function requireCreateClass () {
-		if (hasRequiredCreateClass) return createClass.exports;
-		hasRequiredCreateClass = 1;
-		(function (module) {
-			var toPropertyKey = requireToPropertyKey();
-			function _defineProperties(target, props) {
-			  for (var i = 0; i < props.length; i++) {
-			    var descriptor = props[i];
-			    descriptor.enumerable = descriptor.enumerable || false;
-			    descriptor.configurable = true;
-			    if ("value" in descriptor) descriptor.writable = true;
-			    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);
-			  }
-			}
-			function _createClass(Constructor, protoProps, staticProps) {
-			  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-			  if (staticProps) _defineProperties(Constructor, staticProps);
-			  Object.defineProperty(Constructor, "prototype", {
-			    writable: false
-			  });
-			  return Constructor;
-			}
-			module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-		} (createClass));
-		return createClass.exports;
-	}
-
-	var inherits = {exports: {}};
-
-	var setPrototypeOf = {exports: {}};
-
-	var hasRequiredSetPrototypeOf;
-
-	function requireSetPrototypeOf () {
-		if (hasRequiredSetPrototypeOf) return setPrototypeOf.exports;
-		hasRequiredSetPrototypeOf = 1;
-		(function (module) {
-			function _setPrototypeOf(o, p) {
-			  module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-			    o.__proto__ = p;
-			    return o;
-			  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-			  return _setPrototypeOf(o, p);
-			}
-			module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-		} (setPrototypeOf));
-		return setPrototypeOf.exports;
-	}
-
-	var hasRequiredInherits;
-
-	function requireInherits () {
-		if (hasRequiredInherits) return inherits.exports;
-		hasRequiredInherits = 1;
-		(function (module) {
-			var setPrototypeOf = requireSetPrototypeOf();
-			function _inherits(subClass, superClass) {
-			  if (typeof superClass !== "function" && superClass !== null) {
-			    throw new TypeError("Super expression must either be null or a function");
-			  }
-			  subClass.prototype = Object.create(superClass && superClass.prototype, {
-			    constructor: {
-			      value: subClass,
-			      writable: true,
-			      configurable: true
-			    }
-			  });
-			  Object.defineProperty(subClass, "prototype", {
-			    writable: false
-			  });
-			  if (superClass) setPrototypeOf(subClass, superClass);
-			}
-			module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-		} (inherits));
-		return inherits.exports;
-	}
-
-	var possibleConstructorReturn = {exports: {}};
-
-	var assertThisInitialized = {exports: {}};
-
-	var hasRequiredAssertThisInitialized;
-
-	function requireAssertThisInitialized () {
-		if (hasRequiredAssertThisInitialized) return assertThisInitialized.exports;
-		hasRequiredAssertThisInitialized = 1;
-		(function (module) {
-			function _assertThisInitialized(self) {
-			  if (self === void 0) {
-			    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-			  }
-			  return self;
-			}
-			module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-		} (assertThisInitialized));
-		return assertThisInitialized.exports;
-	}
-
-	var hasRequiredPossibleConstructorReturn;
-
-	function requirePossibleConstructorReturn () {
-		if (hasRequiredPossibleConstructorReturn) return possibleConstructorReturn.exports;
-		hasRequiredPossibleConstructorReturn = 1;
-		(function (module) {
-			var _typeof = require_typeof()["default"];
-			var assertThisInitialized = requireAssertThisInitialized();
-			function _possibleConstructorReturn(self, call) {
-			  if (call && (_typeof(call) === "object" || typeof call === "function")) {
-			    return call;
-			  } else if (call !== void 0) {
-			    throw new TypeError("Derived constructors may only return object or undefined");
-			  }
-			  return assertThisInitialized(self);
-			}
-			module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-		} (possibleConstructorReturn));
-		return possibleConstructorReturn.exports;
-	}
-
-	var getPrototypeOf = {exports: {}};
-
-	var hasRequiredGetPrototypeOf;
-
-	function requireGetPrototypeOf () {
-		if (hasRequiredGetPrototypeOf) return getPrototypeOf.exports;
-		hasRequiredGetPrototypeOf = 1;
-		(function (module) {
-			function _getPrototypeOf(o) {
-			  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
-			    return o.__proto__ || Object.getPrototypeOf(o);
-			  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-			  return _getPrototypeOf(o);
-			}
-			module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports; 
-		} (getPrototypeOf));
-		return getPrototypeOf.exports;
-	}
-
-	var eventemitter3 = {exports: {}};
-
-	var hasRequiredEventemitter3;
-
-	function requireEventemitter3 () {
-		if (hasRequiredEventemitter3) return eventemitter3.exports;
-		hasRequiredEventemitter3 = 1;
-		(function (module) {
-
-			var has = Object.prototype.hasOwnProperty
-			  , prefix = '~';
-
-			/**
-			 * Constructor to create a storage for our `EE` objects.
-			 * An `Events` instance is a plain object whose properties are event names.
-			 *
-			 * @constructor
-			 * @private
-			 */
-			function Events() {}
-
-			//
-			// We try to not inherit from `Object.prototype`. In some engines creating an
-			// instance in this way is faster than calling `Object.create(null)` directly.
-			// If `Object.create(null)` is not supported we prefix the event names with a
-			// character to make sure that the built-in object properties are not
-			// overridden or used as an attack vector.
-			//
-			if (Object.create) {
-			  Events.prototype = Object.create(null);
-
-			  //
-			  // This hack is needed because the `__proto__` property is still inherited in
-			  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
-			  //
-			  if (!new Events().__proto__) prefix = false;
-			}
-
-			/**
-			 * Representation of a single event listener.
-			 *
-			 * @param {Function} fn The listener function.
-			 * @param {*} context The context to invoke the listener with.
-			 * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
-			 * @constructor
-			 * @private
-			 */
-			function EE(fn, context, once) {
-			  this.fn = fn;
-			  this.context = context;
-			  this.once = once || false;
-			}
-
-			/**
-			 * Add a listener for a given event.
-			 *
-			 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
-			 * @param {(String|Symbol)} event The event name.
-			 * @param {Function} fn The listener function.
-			 * @param {*} context The context to invoke the listener with.
-			 * @param {Boolean} once Specify if the listener is a one-time listener.
-			 * @returns {EventEmitter}
-			 * @private
-			 */
-			function addListener(emitter, event, fn, context, once) {
-			  if (typeof fn !== 'function') {
-			    throw new TypeError('The listener must be a function');
-			  }
-
-			  var listener = new EE(fn, context || emitter, once)
-			    , evt = prefix ? prefix + event : event;
-
-			  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
-			  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
-			  else emitter._events[evt] = [emitter._events[evt], listener];
-
-			  return emitter;
-			}
-
-			/**
-			 * Clear event by name.
-			 *
-			 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
-			 * @param {(String|Symbol)} evt The Event name.
-			 * @private
-			 */
-			function clearEvent(emitter, evt) {
-			  if (--emitter._eventsCount === 0) emitter._events = new Events();
-			  else delete emitter._events[evt];
-			}
-
-			/**
-			 * Minimal `EventEmitter` interface that is molded against the Node.js
-			 * `EventEmitter` interface.
-			 *
-			 * @constructor
-			 * @public
-			 */
-			function EventEmitter() {
-			  this._events = new Events();
-			  this._eventsCount = 0;
-			}
-
-			/**
-			 * Return an array listing the events for which the emitter has registered
-			 * listeners.
-			 *
-			 * @returns {Array}
-			 * @public
-			 */
-			EventEmitter.prototype.eventNames = function eventNames() {
-			  var names = []
-			    , events
-			    , name;
-
-			  if (this._eventsCount === 0) return names;
-
-			  for (name in (events = this._events)) {
-			    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
-			  }
-
-			  if (Object.getOwnPropertySymbols) {
-			    return names.concat(Object.getOwnPropertySymbols(events));
-			  }
-
-			  return names;
-			};
-
-			/**
-			 * Return the listeners registered for a given event.
-			 *
-			 * @param {(String|Symbol)} event The event name.
-			 * @returns {Array} The registered listeners.
-			 * @public
-			 */
-			EventEmitter.prototype.listeners = function listeners(event) {
-			  var evt = prefix ? prefix + event : event
-			    , handlers = this._events[evt];
-
-			  if (!handlers) return [];
-			  if (handlers.fn) return [handlers.fn];
-
-			  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
-			    ee[i] = handlers[i].fn;
-			  }
-
-			  return ee;
-			};
-
-			/**
-			 * Return the number of listeners listening to a given event.
-			 *
-			 * @param {(String|Symbol)} event The event name.
-			 * @returns {Number} The number of listeners.
-			 * @public
-			 */
-			EventEmitter.prototype.listenerCount = function listenerCount(event) {
-			  var evt = prefix ? prefix + event : event
-			    , listeners = this._events[evt];
-
-			  if (!listeners) return 0;
-			  if (listeners.fn) return 1;
-			  return listeners.length;
-			};
-
-			/**
-			 * Calls each of the listeners registered for a given event.
-			 *
-			 * @param {(String|Symbol)} event The event name.
-			 * @returns {Boolean} `true` if the event had listeners, else `false`.
-			 * @public
-			 */
-			EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
-			  var evt = prefix ? prefix + event : event;
-
-			  if (!this._events[evt]) return false;
-
-			  var listeners = this._events[evt]
-			    , len = arguments.length
-			    , args
-			    , i;
-
-			  if (listeners.fn) {
-			    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
-
-			    switch (len) {
-			      case 1: return listeners.fn.call(listeners.context), true;
-			      case 2: return listeners.fn.call(listeners.context, a1), true;
-			      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
-			      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
-			      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
-			      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
-			    }
-
-			    for (i = 1, args = new Array(len -1); i < len; i++) {
-			      args[i - 1] = arguments[i];
-			    }
-
-			    listeners.fn.apply(listeners.context, args);
-			  } else {
-			    var length = listeners.length
-			      , j;
-
-			    for (i = 0; i < length; i++) {
-			      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
-
-			      switch (len) {
-			        case 1: listeners[i].fn.call(listeners[i].context); break;
-			        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
-			        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
-			        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
-			        default:
-			          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
-			            args[j - 1] = arguments[j];
-			          }
-
-			          listeners[i].fn.apply(listeners[i].context, args);
-			      }
-			    }
-			  }
-
-			  return true;
-			};
-
-			/**
-			 * Add a listener for a given event.
-			 *
-			 * @param {(String|Symbol)} event The event name.
-			 * @param {Function} fn The listener function.
-			 * @param {*} [context=this] The context to invoke the listener with.
-			 * @returns {EventEmitter} `this`.
-			 * @public
-			 */
-			EventEmitter.prototype.on = function on(event, fn, context) {
-			  return addListener(this, event, fn, context, false);
-			};
-
-			/**
-			 * Add a one-time listener for a given event.
-			 *
-			 * @param {(String|Symbol)} event The event name.
-			 * @param {Function} fn The listener function.
-			 * @param {*} [context=this] The context to invoke the listener with.
-			 * @returns {EventEmitter} `this`.
-			 * @public
-			 */
-			EventEmitter.prototype.once = function once(event, fn, context) {
-			  return addListener(this, event, fn, context, true);
-			};
-
-			/**
-			 * Remove the listeners of a given event.
-			 *
-			 * @param {(String|Symbol)} event The event name.
-			 * @param {Function} fn Only remove the listeners that match this function.
-			 * @param {*} context Only remove the listeners that have this context.
-			 * @param {Boolean} once Only remove one-time listeners.
-			 * @returns {EventEmitter} `this`.
-			 * @public
-			 */
-			EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
-			  var evt = prefix ? prefix + event : event;
-
-			  if (!this._events[evt]) return this;
-			  if (!fn) {
-			    clearEvent(this, evt);
-			    return this;
-			  }
-
-			  var listeners = this._events[evt];
-
-			  if (listeners.fn) {
-			    if (
-			      listeners.fn === fn &&
-			      (!once || listeners.once) &&
-			      (!context || listeners.context === context)
-			    ) {
-			      clearEvent(this, evt);
-			    }
-			  } else {
-			    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
-			      if (
-			        listeners[i].fn !== fn ||
-			        (once && !listeners[i].once) ||
-			        (context && listeners[i].context !== context)
-			      ) {
-			        events.push(listeners[i]);
-			      }
-			    }
-
-			    //
-			    // Reset the array, or remove it completely if we have no more listeners.
-			    //
-			    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
-			    else clearEvent(this, evt);
-			  }
-
-			  return this;
-			};
-
-			/**
-			 * Remove all listeners, or those of the specified event.
-			 *
-			 * @param {(String|Symbol)} [event] The event name.
-			 * @returns {EventEmitter} `this`.
-			 * @public
-			 */
-			EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
-			  var evt;
-
-			  if (event) {
-			    evt = prefix ? prefix + event : event;
-			    if (this._events[evt]) clearEvent(this, evt);
-			  } else {
-			    this._events = new Events();
-			    this._eventsCount = 0;
-			  }
-
-			  return this;
-			};
-
-			//
-			// Alias methods names because people roll like that.
-			//
-			EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-			EventEmitter.prototype.addListener = EventEmitter.prototype.on;
-
-			//
-			// Expose the prefix.
-			//
-			EventEmitter.prefixed = prefix;
-
-			//
-			// Allow `EventEmitter` to be imported as module namespace.
-			//
-			EventEmitter.EventEmitter = EventEmitter;
-
-			//
-			// Expose the module.
-			//
-			{
-			  module.exports = EventEmitter;
-			} 
-		} (eventemitter3));
-		return eventemitter3.exports;
-	}
 
-	/**
-	 * "Client" wraps "ws" or a browser-implemented "WebSocket" library
-	 * according to the environment providing JSON RPC 2.0 support on top.
-	 * @module Client
-	 */
-
-	(function (exports) {
-
-		var _interopRequireDefault = interopRequireDefaultExports;
-
-		Object.defineProperty(exports, "__esModule", {
-		  value: true
-		});
-		exports["default"] = void 0;
-
-		var _regenerator = _interopRequireDefault(requireRegenerator());
-
-		var _asyncToGenerator2 = _interopRequireDefault(requireAsyncToGenerator());
-
-		var _typeof2 = _interopRequireDefault(require_typeof());
-
-		var _classCallCheck2 = _interopRequireDefault(requireClassCallCheck());
-
-		var _createClass2 = _interopRequireDefault(requireCreateClass());
+		/**
+		 * Representation of a single event listener.
+		 *
+		 * @param {Function} fn The listener function.
+		 * @param {*} context The context to invoke the listener with.
+		 * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+		 * @constructor
+		 * @private
+		 */
+		function EE(fn, context, once) {
+		  this.fn = fn;
+		  this.context = context;
+		  this.once = once || false;
+		}
 
-		var _inherits2 = _interopRequireDefault(requireInherits());
+		/**
+		 * Add a listener for a given event.
+		 *
+		 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+		 * @param {(String|Symbol)} event The event name.
+		 * @param {Function} fn The listener function.
+		 * @param {*} context The context to invoke the listener with.
+		 * @param {Boolean} once Specify if the listener is a one-time listener.
+		 * @returns {EventEmitter}
+		 * @private
+		 */
+		function addListener(emitter, event, fn, context, once) {
+		  if (typeof fn !== 'function') {
+		    throw new TypeError('The listener must be a function');
+		  }
 
-		var _possibleConstructorReturn2 = _interopRequireDefault(requirePossibleConstructorReturn());
+		  var listener = new EE(fn, context || emitter, once)
+		    , evt = prefix ? prefix + event : event;
 
-		var _getPrototypeOf2 = _interopRequireDefault(requireGetPrototypeOf());
+		  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+		  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+		  else emitter._events[evt] = [emitter._events[evt], listener];
 
-		var _eventemitter = requireEventemitter3();
+		  return emitter;
+		}
 
-		function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+		/**
+		 * Clear event by name.
+		 *
+		 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+		 * @param {(String|Symbol)} evt The Event name.
+		 * @private
+		 */
+		function clearEvent(emitter, evt) {
+		  if (--emitter._eventsCount === 0) emitter._events = new Events();
+		  else delete emitter._events[evt];
+		}
 
-		function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+		/**
+		 * Minimal `EventEmitter` interface that is molded against the Node.js
+		 * `EventEmitter` interface.
+		 *
+		 * @constructor
+		 * @public
+		 */
+		function EventEmitter() {
+		  this._events = new Events();
+		  this._eventsCount = 0;
+		}
 
-		var __rest = function (s, e) {
-		  var t = {};
+		/**
+		 * Return an array listing the events for which the emitter has registered
+		 * listeners.
+		 *
+		 * @returns {Array}
+		 * @public
+		 */
+		EventEmitter.prototype.eventNames = function eventNames() {
+		  var names = []
+		    , events
+		    , name;
 
-		  for (var p in s) {
-		    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-		  }
+		  if (this._eventsCount === 0) return names;
 
-		  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-		    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+		  for (name in (events = this._events)) {
+		    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
 		  }
-		  return t;
-		}; // @ts-ignore
-
-
-		var CommonClient = /*#__PURE__*/function (_EventEmitter) {
-		  (0, _inherits2["default"])(CommonClient, _EventEmitter);
-
-		  var _super = _createSuper(CommonClient);
-
-		  /**
-		   * Instantiate a Client class.
-		   * @constructor
-		   * @param {webSocketFactory} webSocketFactory - factory method for WebSocket
-		   * @param {String} address - url to a websocket server
-		   * @param {Object} options - ws options object with reconnect parameters
-		   * @param {Function} generate_request_id - custom generation request Id
-		   * @return {CommonClient}
-		   */
-		  function CommonClient(webSocketFactory) {
-		    var _this;
-
-		    var address = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "ws://localhost:8080";
-
-		    var _a = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
-		    var generate_request_id = arguments.length > 3 ? arguments[3] : undefined;
-		    (0, _classCallCheck2["default"])(this, CommonClient);
-
-		    var _a$autoconnect = _a.autoconnect,
-		        autoconnect = _a$autoconnect === void 0 ? true : _a$autoconnect,
-		        _a$reconnect = _a.reconnect,
-		        reconnect = _a$reconnect === void 0 ? true : _a$reconnect,
-		        _a$reconnect_interval = _a.reconnect_interval,
-		        reconnect_interval = _a$reconnect_interval === void 0 ? 1000 : _a$reconnect_interval,
-		        _a$max_reconnects = _a.max_reconnects,
-		        max_reconnects = _a$max_reconnects === void 0 ? 5 : _a$max_reconnects,
-		        rest_options = __rest(_a, ["autoconnect", "reconnect", "reconnect_interval", "max_reconnects"]);
-
-		    _this = _super.call(this);
-		    _this.webSocketFactory = webSocketFactory;
-		    _this.queue = {};
-		    _this.rpc_id = 0;
-		    _this.address = address;
-		    _this.autoconnect = autoconnect;
-		    _this.ready = false;
-		    _this.reconnect = reconnect;
-		    _this.reconnect_timer_id = undefined;
-		    _this.reconnect_interval = reconnect_interval;
-		    _this.max_reconnects = max_reconnects;
-		    _this.rest_options = rest_options;
-		    _this.current_reconnects = 0;
-
-		    _this.generate_request_id = generate_request_id || function () {
-		      return ++_this.rpc_id;
-		    };
 
-		    if (_this.autoconnect) _this._connect(_this.address, Object.assign({
-		      autoconnect: _this.autoconnect,
-		      reconnect: _this.reconnect,
-		      reconnect_interval: _this.reconnect_interval,
-		      max_reconnects: _this.max_reconnects
-		    }, _this.rest_options));
-		    return _this;
+		  if (Object.getOwnPropertySymbols) {
+		    return names.concat(Object.getOwnPropertySymbols(events));
 		  }
-		  /**
-		   * Connects to a defined server if not connected already.
-		   * @method
-		   * @return {Undefined}
-		   */
-
-
-		  (0, _createClass2["default"])(CommonClient, [{
-		    key: "connect",
-		    value: function connect() {
-		      if (this.socket) return;
-
-		      this._connect(this.address, Object.assign({
-		        autoconnect: this.autoconnect,
-		        reconnect: this.reconnect,
-		        reconnect_interval: this.reconnect_interval,
-		        max_reconnects: this.max_reconnects
-		      }, this.rest_options));
-		    }
-		    /**
-		     * Calls a registered RPC method on server.
-		     * @method
-		     * @param {String} method - RPC method name
-		     * @param {Object|Array} params - optional method parameters
-		     * @param {Number} timeout - RPC reply timeout value
-		     * @param {Object} ws_opts - options passed to ws
-		     * @return {Promise}
-		     */
-
-		  }, {
-		    key: "call",
-		    value: function call(method, params, timeout, ws_opts) {
-		      var _this2 = this;
-
-		      if (!ws_opts && "object" === (0, _typeof2["default"])(timeout)) {
-		        ws_opts = timeout;
-		        timeout = null;
-		      }
 
-		      return new Promise(function (resolve, reject) {
-		        if (!_this2.ready) return reject(new Error("socket not ready"));
+		  return names;
+		};
 
-		        var rpc_id = _this2.generate_request_id(method, params);
+		/**
+		 * Return the listeners registered for a given event.
+		 *
+		 * @param {(String|Symbol)} event The event name.
+		 * @returns {Array} The registered listeners.
+		 * @public
+		 */
+		EventEmitter.prototype.listeners = function listeners(event) {
+		  var evt = prefix ? prefix + event : event
+		    , handlers = this._events[evt];
 
-		        var message = {
-		          jsonrpc: "2.0",
-		          method: method,
-		          params: params || null,
-		          id: rpc_id
-		        };
+		  if (!handlers) return [];
+		  if (handlers.fn) return [handlers.fn];
 
-		        _this2.socket.send(JSON.stringify(message), ws_opts, function (error) {
-		          if (error) return reject(error);
-		          _this2.queue[rpc_id] = {
-		            promise: [resolve, reject]
-		          };
-
-		          if (timeout) {
-		            _this2.queue[rpc_id].timeout = setTimeout(function () {
-		              delete _this2.queue[rpc_id];
-		              reject(new Error("reply timeout"));
-		            }, timeout);
-		          }
-		        });
-		      });
-		    }
-		    /**
-		     * Logins with the other side of the connection.
-		     * @method
-		     * @param {Object} params - Login credentials object
-		     * @return {Promise}
-		     */
-
-		  }, {
-		    key: "login",
-		    value: function () {
-		      var _login = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(params) {
-		        var resp;
-		        return _regenerator["default"].wrap(function _callee$(_context) {
-		          while (1) {
-		            switch (_context.prev = _context.next) {
-		              case 0:
-		                _context.next = 2;
-		                return this.call("rpc.login", params);
-
-		              case 2:
-		                resp = _context.sent;
-
-		                if (resp) {
-		                  _context.next = 5;
-		                  break;
-		                }
-
-		                throw new Error("authentication failed");
-
-		              case 5:
-		                return _context.abrupt("return", resp);
-
-		              case 6:
-		              case "end":
-		                return _context.stop();
-		            }
-		          }
-		        }, _callee, this);
-		      }));
-
-		      function login(_x) {
-		        return _login.apply(this, arguments);
-		      }
+		  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+		    ee[i] = handlers[i].fn;
+		  }
 
-		      return login;
-		    }()
-		    /**
-		     * Fetches a list of client's methods registered on server.
-		     * @method
-		     * @return {Array}
-		     */
-
-		  }, {
-		    key: "listMethods",
-		    value: function () {
-		      var _listMethods = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
-		        return _regenerator["default"].wrap(function _callee2$(_context2) {
-		          while (1) {
-		            switch (_context2.prev = _context2.next) {
-		              case 0:
-		                _context2.next = 2;
-		                return this.call("__listMethods");
-
-		              case 2:
-		                return _context2.abrupt("return", _context2.sent);
-
-		              case 3:
-		              case "end":
-		                return _context2.stop();
-		            }
-		          }
-		        }, _callee2, this);
-		      }));
+		  return ee;
+		};
 
-		      function listMethods() {
-		        return _listMethods.apply(this, arguments);
-		      }
+		/**
+		 * Return the number of listeners listening to a given event.
+		 *
+		 * @param {(String|Symbol)} event The event name.
+		 * @returns {Number} The number of listeners.
+		 * @public
+		 */
+		EventEmitter.prototype.listenerCount = function listenerCount(event) {
+		  var evt = prefix ? prefix + event : event
+		    , listeners = this._events[evt];
 
-		      return listMethods;
-		    }()
-		    /**
-		     * Sends a JSON-RPC 2.0 notification to server.
-		     * @method
-		     * @param {String} method - RPC method name
-		     * @param {Object} params - optional method parameters
-		     * @return {Promise}
-		     */
-
-		  }, {
-		    key: "notify",
-		    value: function notify(method, params) {
-		      var _this3 = this;
-
-		      return new Promise(function (resolve, reject) {
-		        if (!_this3.ready) return reject(new Error("socket not ready"));
-		        var message = {
-		          jsonrpc: "2.0",
-		          method: method,
-		          params: params || null
-		        };
+		  if (!listeners) return 0;
+		  if (listeners.fn) return 1;
+		  return listeners.length;
+		};
 
-		        _this3.socket.send(JSON.stringify(message), function (error) {
-		          if (error) return reject(error);
-		          resolve();
-		        });
-		      });
+		/**
+		 * Calls each of the listeners registered for a given event.
+		 *
+		 * @param {(String|Symbol)} event The event name.
+		 * @returns {Boolean} `true` if the event had listeners, else `false`.
+		 * @public
+		 */
+		EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+		  var evt = prefix ? prefix + event : event;
+
+		  if (!this._events[evt]) return false;
+
+		  var listeners = this._events[evt]
+		    , len = arguments.length
+		    , args
+		    , i;
+
+		  if (listeners.fn) {
+		    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+		    switch (len) {
+		      case 1: return listeners.fn.call(listeners.context), true;
+		      case 2: return listeners.fn.call(listeners.context, a1), true;
+		      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+		      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+		      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+		      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
 		    }
-		    /**
-		     * Subscribes for a defined event.
-		     * @method
-		     * @param {String|Array} event - event name
-		     * @return {Undefined}
-		     * @throws {Error}
-		     */
-
-		  }, {
-		    key: "subscribe",
-		    value: function () {
-		      var _subscribe = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(event) {
-		        var result;
-		        return _regenerator["default"].wrap(function _callee3$(_context3) {
-		          while (1) {
-		            switch (_context3.prev = _context3.next) {
-		              case 0:
-		                if (typeof event === "string") event = [event];
-		                _context3.next = 3;
-		                return this.call("rpc.on", event);
-
-		              case 3:
-		                result = _context3.sent;
-
-		                if (!(typeof event === "string" && result[event] !== "ok")) {
-		                  _context3.next = 6;
-		                  break;
-		                }
-
-		                throw new Error("Failed subscribing to an event '" + event + "' with: " + result[event]);
-
-		              case 6:
-		                return _context3.abrupt("return", result);
-
-		              case 7:
-		              case "end":
-		                return _context3.stop();
-		            }
-		          }
-		        }, _callee3, this);
-		      }));
-
-		      function subscribe(_x2) {
-		        return _subscribe.apply(this, arguments);
-		      }
-
-		      return subscribe;
-		    }()
-		    /**
-		     * Unsubscribes from a defined event.
-		     * @method
-		     * @param {String|Array} event - event name
-		     * @return {Undefined}
-		     * @throws {Error}
-		     */
-
-		  }, {
-		    key: "unsubscribe",
-		    value: function () {
-		      var _unsubscribe = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(event) {
-		        var result;
-		        return _regenerator["default"].wrap(function _callee4$(_context4) {
-		          while (1) {
-		            switch (_context4.prev = _context4.next) {
-		              case 0:
-		                if (typeof event === "string") event = [event];
-		                _context4.next = 3;
-		                return this.call("rpc.off", event);
-
-		              case 3:
-		                result = _context4.sent;
-
-		                if (!(typeof event === "string" && result[event] !== "ok")) {
-		                  _context4.next = 6;
-		                  break;
-		                }
-
-		                throw new Error("Failed unsubscribing from an event with: " + result);
-
-		              case 6:
-		                return _context4.abrupt("return", result);
-
-		              case 7:
-		              case "end":
-		                return _context4.stop();
-		            }
-		          }
-		        }, _callee4, this);
-		      }));
-
-		      function unsubscribe(_x3) {
-		        return _unsubscribe.apply(this, arguments);
-		      }
 
-		      return unsubscribe;
-		    }()
-		    /**
-		     * Closes a WebSocket connection gracefully.
-		     * @method
-		     * @param {Number} code - socket close code
-		     * @param {String} data - optional data to be sent before closing
-		     * @return {Undefined}
-		     */
-
-		  }, {
-		    key: "close",
-		    value: function close(code, data) {
-		      this.socket.close(code || 1000, data);
+		    for (i = 1, args = new Array(len -1); i < len; i++) {
+		      args[i - 1] = arguments[i];
 		    }
-		    /**
-		     * Connection/Message handler.
-		     * @method
-		     * @private
-		     * @param {String} address - WebSocket API address
-		     * @param {Object} options - ws options object
-		     * @return {Undefined}
-		     */
-
-		  }, {
-		    key: "_connect",
-		    value: function _connect(address, options) {
-		      var _this4 = this;
-
-		      clearTimeout(this.reconnect_timer_id);
-		      this.socket = this.webSocketFactory(address, options);
-		      this.socket.addEventListener("open", function () {
-		        _this4.ready = true;
-
-		        _this4.emit("open");
-
-		        _this4.current_reconnects = 0;
-		      });
-		      this.socket.addEventListener("message", function (_ref) {
-		        var message = _ref.data;
-		        if (message instanceof ArrayBuffer) message = Buffer.from(message).toString();
-
-		        try {
-		          message = JSON.parse(message);
-		        } catch (error) {
-		          return;
-		        } // check if any listeners are attached and forward event
-
-
-		        if (message.notification && _this4.listeners(message.notification).length) {
-		          if (!Object.keys(message.params).length) return _this4.emit(message.notification);
-		          var args = [message.notification];
-		          if (message.params.constructor === Object) args.push(message.params);else // using for-loop instead of unshift/spread because performance is better
-		            for (var i = 0; i < message.params.length; i++) {
-		              args.push(message.params[i]);
-		            } // run as microtask so that pending queue messages are resolved first
-		          // eslint-disable-next-line prefer-spread
-
-		          return Promise.resolve().then(function () {
-		            _this4.emit.apply(_this4, args);
-		          });
-		        }
 
-		        if (!_this4.queue[message.id]) {
-		          // general JSON RPC 2.0 events
-		          if (message.method && message.params) {
-		            // run as microtask so that pending queue messages are resolved first
-		            return Promise.resolve().then(function () {
-		              _this4.emit(message.method, message.params);
-		            });
+		    listeners.fn.apply(listeners.context, args);
+		  } else {
+		    var length = listeners.length
+		      , j;
+
+		    for (i = 0; i < length; i++) {
+		      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+		      switch (len) {
+		        case 1: listeners[i].fn.call(listeners[i].context); break;
+		        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
+		        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
+		        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
+		        default:
+		          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
+		            args[j - 1] = arguments[j];
 		          }
 
-		          return;
-		        } // reject early since server's response is invalid
-
-
-		        if ("error" in message === "result" in message) _this4.queue[message.id].promise[1](new Error("Server response malformed. Response must include either \"result\"" + " or \"error\", but not both."));
-		        if (_this4.queue[message.id].timeout) clearTimeout(_this4.queue[message.id].timeout);
-		        if (message.error) _this4.queue[message.id].promise[1](message.error);else _this4.queue[message.id].promise[0](message.result);
-		        delete _this4.queue[message.id];
-		      });
-		      this.socket.addEventListener("error", function (error) {
-		        return _this4.emit("error", error);
-		      });
-		      this.socket.addEventListener("close", function (_ref2) {
-		        var code = _ref2.code,
-		            reason = _ref2.reason;
-		        if (_this4.ready) // Delay close event until internal state is updated
-		          setTimeout(function () {
-		            return _this4.emit("close", code, reason);
-		          }, 0);
-		        _this4.ready = false;
-		        _this4.socket = undefined;
-		        if (code === 1000) return;
-		        _this4.current_reconnects++;
-		        if (_this4.reconnect && (_this4.max_reconnects > _this4.current_reconnects || _this4.max_reconnects === 0)) _this4.reconnect_timer_id = setTimeout(function () {
-		          return _this4._connect(address, options);
-		        }, _this4.reconnect_interval);
-		      });
+		          listeners[i].fn.apply(listeners[i].context, args);
+		      }
 		    }
-		  }]);
-		  return CommonClient;
-		}(_eventemitter.EventEmitter);
-
-		exports["default"] = CommonClient; 
-	} (client));
-
-	var RpcWebSocketCommonClient = /*@__PURE__*/getDefaultExportFromCjs(client);
-
-	var websocket_browser = {};
-
-	/**
-	 * WebSocket implements a browser-side WebSocket specification.
-	 * @module Client
-	 */
-
-	(function (exports) {
-
-		var _interopRequireDefault = interopRequireDefaultExports;
-
-		Object.defineProperty(exports, "__esModule", {
-		  value: true
-		});
-		exports["default"] = _default;
-
-		var _classCallCheck2 = _interopRequireDefault(requireClassCallCheck());
+		  }
 
-		var _createClass2 = _interopRequireDefault(requireCreateClass());
+		  return true;
+		};
 
-		var _inherits2 = _interopRequireDefault(requireInherits());
+		/**
+		 * Add a listener for a given event.
+		 *
+		 * @param {(String|Symbol)} event The event name.
+		 * @param {Function} fn The listener function.
+		 * @param {*} [context=this] The context to invoke the listener with.
+		 * @returns {EventEmitter} `this`.
+		 * @public
+		 */
+		EventEmitter.prototype.on = function on(event, fn, context) {
+		  return addListener(this, event, fn, context, false);
+		};
 
-		var _possibleConstructorReturn2 = _interopRequireDefault(requirePossibleConstructorReturn());
+		/**
+		 * Add a one-time listener for a given event.
+		 *
+		 * @param {(String|Symbol)} event The event name.
+		 * @param {Function} fn The listener function.
+		 * @param {*} [context=this] The context to invoke the listener with.
+		 * @returns {EventEmitter} `this`.
+		 * @public
+		 */
+		EventEmitter.prototype.once = function once(event, fn, context) {
+		  return addListener(this, event, fn, context, true);
+		};
 
-		var _getPrototypeOf2 = _interopRequireDefault(requireGetPrototypeOf());
+		/**
+		 * Remove the listeners of a given event.
+		 *
+		 * @param {(String|Symbol)} event The event name.
+		 * @param {Function} fn Only remove the listeners that match this function.
+		 * @param {*} context Only remove the listeners that have this context.
+		 * @param {Boolean} once Only remove one-time listeners.
+		 * @returns {EventEmitter} `this`.
+		 * @public
+		 */
+		EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+		  var evt = prefix ? prefix + event : event;
 
-		var _eventemitter = requireEventemitter3();
+		  if (!this._events[evt]) return this;
+		  if (!fn) {
+		    clearEvent(this, evt);
+		    return this;
+		  }
 
-		function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+		  var listeners = this._events[evt];
 
-		function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+		  if (listeners.fn) {
+		    if (
+		      listeners.fn === fn &&
+		      (!once || listeners.once) &&
+		      (!context || listeners.context === context)
+		    ) {
+		      clearEvent(this, evt);
+		    }
+		  } else {
+		    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+		      if (
+		        listeners[i].fn !== fn ||
+		        (once && !listeners[i].once) ||
+		        (context && listeners[i].context !== context)
+		      ) {
+		        events.push(listeners[i]);
+		      }
+		    }
 
-		var WebSocketBrowserImpl = /*#__PURE__*/function (_EventEmitter) {
-		  (0, _inherits2["default"])(WebSocketBrowserImpl, _EventEmitter);
+		    //
+		    // Reset the array, or remove it completely if we have no more listeners.
+		    //
+		    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+		    else clearEvent(this, evt);
+		  }
 
-		  var _super = _createSuper(WebSocketBrowserImpl);
+		  return this;
+		};
 
-		  /** Instantiate a WebSocket class
-		   * @constructor
-		   * @param {String} address - url to a websocket server
-		   * @param {(Object)} options - websocket options
-		   * @param {(String|Array)} protocols - a list of protocols
-		   * @return {WebSocketBrowserImpl} - returns a WebSocket instance
-		   */
-		  function WebSocketBrowserImpl(address, options, protocols) {
-		    var _this;
+		/**
+		 * Remove all listeners, or those of the specified event.
+		 *
+		 * @param {(String|Symbol)} [event] The event name.
+		 * @returns {EventEmitter} `this`.
+		 * @public
+		 */
+		EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+		  var evt;
 
-		    (0, _classCallCheck2["default"])(this, WebSocketBrowserImpl);
-		    _this = _super.call(this);
-		    _this.socket = new window.WebSocket(address, protocols);
+		  if (event) {
+		    evt = prefix ? prefix + event : event;
+		    if (this._events[evt]) clearEvent(this, evt);
+		  } else {
+		    this._events = new Events();
+		    this._eventsCount = 0;
+		  }
 
-		    _this.socket.onopen = function () {
-		      return _this.emit("open");
-		    };
+		  return this;
+		};
 
-		    _this.socket.onmessage = function (event) {
-		      return _this.emit("message", event.data);
-		    };
+		//
+		// Alias methods names because people roll like that.
+		//
+		EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+		EventEmitter.prototype.addListener = EventEmitter.prototype.on;
 
-		    _this.socket.onerror = function (error) {
-		      return _this.emit("error", error);
-		    };
+		//
+		// Expose the prefix.
+		//
+		EventEmitter.prefixed = prefix;
 
-		    _this.socket.onclose = function (event) {
-		      _this.emit("close", event.code, event.reason);
-		    };
+		//
+		// Allow `EventEmitter` to be imported as module namespace.
+		//
+		EventEmitter.EventEmitter = EventEmitter;
 
-		    return _this;
-		  }
-		  /**
-		   * Sends data through a websocket connection
-		   * @method
-		   * @param {(String|Object)} data - data to be sent via websocket
-		   * @param {Object} optionsOrCallback - ws options
-		   * @param {Function} callback - a callback called once the data is sent
-		   * @return {Undefined}
-		   */
-
-
-		  (0, _createClass2["default"])(WebSocketBrowserImpl, [{
-		    key: "send",
-		    value: function send(data, optionsOrCallback, callback) {
-		      var cb = callback || optionsOrCallback;
-
-		      try {
-		        this.socket.send(data);
-		        cb();
-		      } catch (error) {
-		        cb(error);
-		      }
-		    }
-		    /**
-		     * Closes an underlying socket
-		     * @method
-		     * @param {Number} code - status code explaining why the connection is being closed
-		     * @param {String} reason - a description why the connection is closing
-		     * @return {Undefined}
-		     * @throws {Error}
-		     */
-
-		  }, {
-		    key: "close",
-		    value: function close(code, reason) {
-		      this.socket.close(code, reason);
-		    }
-		  }, {
-		    key: "addEventListener",
-		    value: function addEventListener(type, listener, options) {
-		      this.socket.addEventListener(type, listener, options);
-		    }
-		  }]);
-		  return WebSocketBrowserImpl;
-		}(_eventemitter.EventEmitter);
-		/**
-		 * factory method for common WebSocket instance
-		 * @method
-		 * @param {String} address - url to a websocket server
-		 * @param {(Object)} options - websocket options
-		 * @return {Undefined}
-		 */
+		//
+		// Expose the module.
+		//
+		{
+		  module.exports = EventEmitter;
+		} 
+	} (eventemitter3));
+
+	var eventemitter3Exports = eventemitter3.exports;
+
+	var utils = {};
+
+	Object.defineProperty(utils, "__esModule", { value: true });
+	utils.createError = utils.DefaultDataPack = void 0;
+	const errors = new Map([
+	    [-32000, "Event not provided"],
+	    [-32600, "Invalid Request"],
+	    [-32601, "Method not found"],
+	    [-32602, "Invalid params"],
+	    [-32603, "Internal error"],
+	    [-32604, "Params not found"],
+	    [-32605, "Method forbidden"],
+	    [-32606, "Event forbidden"],
+	    [-32700, "Parse error"]
+	]);
+	class DefaultDataPack {
+	    encode(value) {
+	        return JSON.stringify(value);
+	    }
+	    decode(value) {
+	        return JSON.parse(value);
+	    }
+	}
+	utils.DefaultDataPack = DefaultDataPack;
+	/**
+	 * Creates a JSON-RPC 2.0-compliant error.
+	 * @param {Number} code - error code
+	 * @param {String} details - error details
+	 * @return {Object}
+	 */
+	function createError(code, details) {
+	    const error = {
+	        code: code,
+	        message: errors.get(code) || "Internal Server Error"
+	    };
+	    if (details)
+	        error["data"] = details;
+	    return error;
+	}
+	utils.createError = createError;
 
+	/**
+	 * "Client" wraps "ws" or a browser-implemented "WebSocket" library
+	 * according to the environment providing JSON RPC 2.0 support on top.
+	 * @module Client
+	 */
+	Object.defineProperty(client, "__esModule", { value: true });
+	// @ts-ignore
+	const eventemitter3_1$1 = eventemitter3Exports;
+	const utils_cjs_1 = utils;
+	class CommonClient extends eventemitter3_1$1.EventEmitter {
+	    address;
+	    rpc_id;
+	    queue;
+	    options;
+	    autoconnect;
+	    ready;
+	    reconnect;
+	    reconnect_timer_id;
+	    reconnect_interval;
+	    max_reconnects;
+	    rest_options;
+	    current_reconnects;
+	    generate_request_id;
+	    socket;
+	    webSocketFactory;
+	    dataPack;
+	    /**
+	     * Instantiate a Client class.
+	     * @constructor
+	     * @param {webSocketFactory} webSocketFactory - factory method for WebSocket
+	     * @param {String} address - url to a websocket server
+	     * @param {Object} options - ws options object with reconnect parameters
+	     * @param {Function} generate_request_id - custom generation request Id
+	     * @param {DataPack} dataPack - data pack contains encoder and decoder
+	     * @return {CommonClient}
+	     */
+	    constructor(webSocketFactory, address = "ws://localhost:8080", { autoconnect = true, reconnect = true, reconnect_interval = 1000, max_reconnects = 5, ...rest_options } = {}, generate_request_id, dataPack) {
+	        super();
+	        this.webSocketFactory = webSocketFactory;
+	        this.queue = {};
+	        this.rpc_id = 0;
+	        this.address = address;
+	        this.autoconnect = autoconnect;
+	        this.ready = false;
+	        this.reconnect = reconnect;
+	        this.reconnect_timer_id = undefined;
+	        this.reconnect_interval = reconnect_interval;
+	        this.max_reconnects = max_reconnects;
+	        this.rest_options = rest_options;
+	        this.current_reconnects = 0;
+	        this.generate_request_id = generate_request_id || (() => ++this.rpc_id);
+	        if (!dataPack)
+	            this.dataPack = new utils_cjs_1.DefaultDataPack();
+	        else
+	            this.dataPack = dataPack;
+	        if (this.autoconnect)
+	            this._connect(this.address, {
+	                autoconnect: this.autoconnect,
+	                reconnect: this.reconnect,
+	                reconnect_interval: this.reconnect_interval,
+	                max_reconnects: this.max_reconnects,
+	                ...this.rest_options
+	            });
+	    }
+	    /**
+	     * Connects to a defined server if not connected already.
+	     * @method
+	     * @return {Undefined}
+	     */
+	    connect() {
+	        if (this.socket)
+	            return;
+	        this._connect(this.address, {
+	            autoconnect: this.autoconnect,
+	            reconnect: this.reconnect,
+	            reconnect_interval: this.reconnect_interval,
+	            max_reconnects: this.max_reconnects,
+	            ...this.rest_options
+	        });
+	    }
+	    /**
+	     * Calls a registered RPC method on server.
+	     * @method
+	     * @param {String} method - RPC method name
+	     * @param {Object|Array} params - optional method parameters
+	     * @param {Number} timeout - RPC reply timeout value
+	     * @param {Object} ws_opts - options passed to ws
+	     * @return {Promise}
+	     */
+	    call(method, params, timeout, ws_opts) {
+	        if (!ws_opts && "object" === typeof timeout) {
+	            ws_opts = timeout;
+	            timeout = null;
+	        }
+	        return new Promise((resolve, reject) => {
+	            if (!this.ready)
+	                return reject(new Error("socket not ready"));
+	            const rpc_id = this.generate_request_id(method, params);
+	            const message = {
+	                jsonrpc: "2.0",
+	                method: method,
+	                params: params || undefined,
+	                id: rpc_id
+	            };
+	            this.socket.send(this.dataPack.encode(message), ws_opts, (error) => {
+	                if (error)
+	                    return reject(error);
+	                this.queue[rpc_id] = { promise: [resolve, reject] };
+	                if (timeout) {
+	                    this.queue[rpc_id].timeout = setTimeout(() => {
+	                        delete this.queue[rpc_id];
+	                        reject(new Error("reply timeout"));
+	                    }, timeout);
+	                }
+	            });
+	        });
+	    }
+	    /**
+	     * Logins with the other side of the connection.
+	     * @method
+	     * @param {Object} params - Login credentials object
+	     * @return {Promise}
+	     */
+	    async login(params) {
+	        const resp = await this.call("rpc.login", params);
+	        if (!resp)
+	            throw new Error("authentication failed");
+	        return resp;
+	    }
+	    /**
+	     * Fetches a list of client's methods registered on server.
+	     * @method
+	     * @return {Array}
+	     */
+	    async listMethods() {
+	        return await this.call("__listMethods");
+	    }
+	    /**
+	     * Sends a JSON-RPC 2.0 notification to server.
+	     * @method
+	     * @param {String} method - RPC method name
+	     * @param {Object} params - optional method parameters
+	     * @return {Promise}
+	     */
+	    notify(method, params) {
+	        return new Promise((resolve, reject) => {
+	            if (!this.ready)
+	                return reject(new Error("socket not ready"));
+	            const message = {
+	                jsonrpc: "2.0",
+	                method: method,
+	                params
+	            };
+	            this.socket.send(this.dataPack.encode(message), (error) => {
+	                if (error)
+	                    return reject(error);
+	                resolve();
+	            });
+	        });
+	    }
+	    /**
+	     * Subscribes for a defined event.
+	     * @method
+	     * @param {String|Array} event - event name
+	     * @return {Undefined}
+	     * @throws {Error}
+	     */
+	    async subscribe(event) {
+	        if (typeof event === "string")
+	            event = [event];
+	        const result = await this.call("rpc.on", event);
+	        if (typeof event === "string" && result[event] !== "ok")
+	            throw new Error("Failed subscribing to an event '" + event + "' with: " + result[event]);
+	        return result;
+	    }
+	    /**
+	     * Unsubscribes from a defined event.
+	     * @method
+	     * @param {String|Array} event - event name
+	     * @return {Undefined}
+	     * @throws {Error}
+	     */
+	    async unsubscribe(event) {
+	        if (typeof event === "string")
+	            event = [event];
+	        const result = await this.call("rpc.off", event);
+	        if (typeof event === "string" && result[event] !== "ok")
+	            throw new Error("Failed unsubscribing from an event with: " + result);
+	        return result;
+	    }
+	    /**
+	     * Closes a WebSocket connection gracefully.
+	     * @method
+	     * @param {Number} code - socket close code
+	     * @param {String} data - optional data to be sent before closing
+	     * @return {Undefined}
+	     */
+	    close(code, data) {
+	        this.socket.close(code || 1000, data);
+	    }
+	    /**
+	     * Enable / disable automatic reconnection.
+	     * @method
+	     * @param {Boolean} reconnect - enable / disable reconnection
+	     * @return {Undefined}
+	     */
+	    setAutoReconnect(reconnect) {
+	        this.reconnect = reconnect;
+	    }
+	    /**
+	     * Set the interval between reconnection attempts.
+	     * @method
+	     * @param {Number} interval - reconnection interval in milliseconds
+	     * @return {Undefined}
+	     */
+	    setReconnectInterval(interval) {
+	        this.reconnect_interval = interval;
+	    }
+	    /**
+	     * Set the maximum number of reconnection attempts.
+	     * @method
+	     * @param {Number} max_reconnects - maximum reconnection attempts
+	     * @return {Undefined}
+	     */
+	    setMaxReconnects(max_reconnects) {
+	        this.max_reconnects = max_reconnects;
+	    }
+	    /**
+	     * Connection/Message handler.
+	     * @method
+	     * @private
+	     * @param {String} address - WebSocket API address
+	     * @param {Object} options - ws options object
+	     * @return {Undefined}
+	     */
+	    _connect(address, options) {
+	        clearTimeout(this.reconnect_timer_id);
+	        this.socket = this.webSocketFactory(address, options);
+	        this.socket.addEventListener("open", () => {
+	            this.ready = true;
+	            this.emit("open");
+	            this.current_reconnects = 0;
+	        });
+	        this.socket.addEventListener("message", ({ data: message }) => {
+	            if (message instanceof ArrayBuffer)
+	                message = Buffer.from(message).toString();
+	            try {
+	                message = this.dataPack.decode(message);
+	            }
+	            catch (error) {
+	                return;
+	            }
+	            // check if any listeners are attached and forward event
+	            if (message.notification && this.listeners(message.notification).length) {
+	                if (!Object.keys(message.params).length)
+	                    return this.emit(message.notification);
+	                const args = [message.notification];
+	                if (message.params.constructor === Object)
+	                    args.push(message.params);
+	                else
+	                    // using for-loop instead of unshift/spread because performance is better
+	                    for (let i = 0; i < message.params.length; i++)
+	                        args.push(message.params[i]);
+	                // run as microtask so that pending queue messages are resolved first
+	                // eslint-disable-next-line prefer-spread
+	                return Promise.resolve().then(() => { this.emit.apply(this, args); });
+	            }
+	            if (!this.queue[message.id]) {
+	                // general JSON RPC 2.0 events
+	                if (message.method) {
+	                    // run as microtask so that pending queue messages are resolved first
+	                    return Promise.resolve().then(() => {
+	                        this.emit(message.method, message?.params);
+	                    });
+	                }
+	                return;
+	            }
+	            // reject early since server's response is invalid
+	            if ("error" in message === "result" in message)
+	                this.queue[message.id].promise[1](new Error("Server response malformed. Response must include either \"result\"" +
+	                    " or \"error\", but not both."));
+	            if (this.queue[message.id].timeout)
+	                clearTimeout(this.queue[message.id].timeout);
+	            if (message.error)
+	                this.queue[message.id].promise[1](message.error);
+	            else
+	                this.queue[message.id].promise[0](message.result);
+	            delete this.queue[message.id];
+	        });
+	        this.socket.addEventListener("error", (error) => this.emit("error", error));
+	        this.socket.addEventListener("close", ({ code, reason }) => {
+	            if (this.ready) // Delay close event until internal state is updated
+	                setTimeout(() => this.emit("close", code, reason), 0);
+	            this.ready = false;
+	            this.socket = undefined;
+	            if (code === 1000)
+	                return;
+	            this.current_reconnects++;
+	            if (this.reconnect && ((this.max_reconnects > this.current_reconnects) ||
+	                this.max_reconnects === 0))
+	                this.reconnect_timer_id = setTimeout(() => this._connect(address, options), this.reconnect_interval);
+	        });
+	    }
+	}
+	var _default$1 = client.default = CommonClient;
 
-		function _default(address, options) {
-		  return new WebSocketBrowserImpl(address, options);
-		} 
-	} (websocket_browser));
+	var websocket_browser = {};
 
-	var createRpc = /*@__PURE__*/getDefaultExportFromCjs(websocket_browser);
+	/**
+	 * WebSocket implements a browser-side WebSocket specification.
+	 * @module Client
+	 */
+	Object.defineProperty(websocket_browser, "__esModule", { value: true });
+	const eventemitter3_1 = eventemitter3Exports;
+	class WebSocketBrowserImpl extends eventemitter3_1.EventEmitter {
+	    socket;
+	    /** Instantiate a WebSocket class
+	     * @constructor
+	     * @param {String} address - url to a websocket server
+	     * @param {(Object)} options - websocket options
+	     * @param {(String|Array)} protocols - a list of protocols
+	     * @return {WebSocketBrowserImpl} - returns a WebSocket instance
+	     */
+	    constructor(address, options, protocols) {
+	        super();
+	        this.socket = new window.WebSocket(address, protocols);
+	        this.socket.onopen = () => this.emit("open");
+	        this.socket.onmessage = (event) => this.emit("message", event.data);
+	        this.socket.onerror = (error) => this.emit("error", error);
+	        this.socket.onclose = (event) => {
+	            this.emit("close", event.code, event.reason);
+	        };
+	    }
+	    /**
+	     * Sends data through a websocket connection
+	     * @method
+	     * @param {(String|Object)} data - data to be sent via websocket
+	     * @param {Object} optionsOrCallback - ws options
+	     * @param {Function} callback - a callback called once the data is sent
+	     * @return {Undefined}
+	     */
+	    send(data, optionsOrCallback, callback) {
+	        const cb = callback || optionsOrCallback;
+	        try {
+	            this.socket.send(data);
+	            cb();
+	        }
+	        catch (error) {
+	            cb(error);
+	        }
+	    }
+	    /**
+	     * Closes an underlying socket
+	     * @method
+	     * @param {Number} code - status code explaining why the connection is being closed
+	     * @param {String} reason - a description why the connection is closing
+	     * @return {Undefined}
+	     * @throws {Error}
+	     */
+	    close(code, reason) {
+	        this.socket.close(code, reason);
+	    }
+	    addEventListener(type, listener, options) {
+	        this.socket.addEventListener(type, listener, options);
+	    }
+	}
+	/**
+	 * factory method for common WebSocket instance
+	 * @method
+	 * @param {String} address - url to a websocket server
+	 * @param {(Object)} options - websocket options
+	 * @return {Undefined}
+	 */
+	function default_1(address, options) {
+	    return new WebSocketBrowserImpl(address, options);
+	}
+	var _default = websocket_browser.default = default_1;
 
-	class RpcWebSocketClient extends RpcWebSocketCommonClient {
+	class RpcWebSocketClient extends _default$1 {
 	  constructor(address, options, generate_request_id) {
 	    const webSocketFactory = url => {
-	      const rpc = createRpc(url, {
+	      const rpc = _default(url, {
 	        autoconnect: true,
 	        max_reconnects: 5,
 	        reconnect: true,
@@ -18085,7 +17003,7 @@ var solanaWeb3 = (function (exports) {
 	  const websocketPort =
 	  // Only shift the port by +1 as a convention for ws(s) only if given endpoint
 	  // is explicitly specifying the endpoint port (HTTP-based RPC), assuming
-	  // we're directly trying to connect to solana-validator's ws listening port.
+	  // we're directly trying to connect to agave-validator's ws listening port.
 	  // When the endpoint omits the port, we're connecting to the protocol
 	  // default ports: http(80) or https(443) and it's assumed we're behind a reverse
 	  // proxy which manages WebSocket upgrade and backend port redirection.
@@ -23172,34 +22090,12 @@ var solanaWeb3 = (function (exports) {
 	}
 	Ed25519Program.programId = new PublicKey('Ed25519SigVerify111111111111111111111111111');
 
-	const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
-	const _32n = /* @__PURE__ */ BigInt(32);
-	// We are not using BigUint64Array, because they are extremely slow as per 2022
-	function fromBig(n, le = false) {
-	    if (le)
-	        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
-	    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
-	}
-	function split(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(lst[i], le);
-	        [Ah[i], Al[i]] = [h, l];
-	    }
-	    return [Ah, Al];
-	}
-	// Left rotate for Shift in [1, 32)
-	const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
-	const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
-	// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
-	const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
-	const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
-
 	// SHA3 (keccak) is based on a new design: basically, the internal state is bigger than output size.
 	// It's called a sponge function.
 	// Various per round constants calculations
-	const [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
+	const SHA3_PI = [];
+	const SHA3_ROTL = [];
+	const _SHA3_IOTA = [];
 	const _0n$1 = /* @__PURE__ */ BigInt(0);
 	const _1n$2 = /* @__PURE__ */ BigInt(1);
 	const _2n$1 = /* @__PURE__ */ BigInt(2);
@@ -23293,7 +22189,11 @@ var solanaWeb3 = (function (exports) {
 	        this.state32 = u32$1(this.state);
 	    }
 	    keccak() {
+	        if (!isLE)
+	            byteSwap32(this.state32);
 	        keccakP(this.state32, this.rounds);
+	        if (!isLE)
+	            byteSwap32(this.state32);
 	        this.posOut = 0;
 	        this.pos = 0;
 	    }
@@ -23387,111 +22287,6 @@ var solanaWeb3 = (function (exports) {
 	 */
 	const keccak_256 = /* @__PURE__ */ gen(0x01, 136, 256 / 8);
 
-	// SHA2-256 need to try 2^128 hashes to execute birthday attack.
-	// BTC network is doing 2^67 hashes/sec as per early 2023.
-	// Round constants:
-	// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)
-	// prettier-ignore
-	const SHA256_K = /* @__PURE__ */ new Uint32Array([
-	    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-	    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-	    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-	    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-	    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-	    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-	    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-	    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
-	]);
-	// Initial state:
-	// first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19
-	// prettier-ignore
-	const SHA256_IV = /* @__PURE__ */ new Uint32Array([
-	    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
-	]);
-	// Temporary buffer, not used to store anything between runs
-	// Named this way because it matches specification.
-	const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-	class SHA256 extends HashMD {
-	    constructor() {
-	        super(64, 32, 8, false);
-	        // We cannot use array here since array allows indexing by variable
-	        // which means optimizer/compiler cannot use registers.
-	        this.A = SHA256_IV[0] | 0;
-	        this.B = SHA256_IV[1] | 0;
-	        this.C = SHA256_IV[2] | 0;
-	        this.D = SHA256_IV[3] | 0;
-	        this.E = SHA256_IV[4] | 0;
-	        this.F = SHA256_IV[5] | 0;
-	        this.G = SHA256_IV[6] | 0;
-	        this.H = SHA256_IV[7] | 0;
-	    }
-	    get() {
-	        const { A, B, C, D, E, F, G, H } = this;
-	        return [A, B, C, D, E, F, G, H];
-	    }
-	    // prettier-ignore
-	    set(A, B, C, D, E, F, G, H) {
-	        this.A = A | 0;
-	        this.B = B | 0;
-	        this.C = C | 0;
-	        this.D = D | 0;
-	        this.E = E | 0;
-	        this.F = F | 0;
-	        this.G = G | 0;
-	        this.H = H | 0;
-	    }
-	    process(view, offset) {
-	        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
-	        for (let i = 0; i < 16; i++, offset += 4)
-	            SHA256_W[i] = view.getUint32(offset, false);
-	        for (let i = 16; i < 64; i++) {
-	            const W15 = SHA256_W[i - 15];
-	            const W2 = SHA256_W[i - 2];
-	            const s0 = rotr$1(W15, 7) ^ rotr$1(W15, 18) ^ (W15 >>> 3);
-	            const s1 = rotr$1(W2, 17) ^ rotr$1(W2, 19) ^ (W2 >>> 10);
-	            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
-	        }
-	        // Compression function main loop, 64 rounds
-	        let { A, B, C, D, E, F, G, H } = this;
-	        for (let i = 0; i < 64; i++) {
-	            const sigma1 = rotr$1(E, 6) ^ rotr$1(E, 11) ^ rotr$1(E, 25);
-	            const T1 = (H + sigma1 + Chi$1(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
-	            const sigma0 = rotr$1(A, 2) ^ rotr$1(A, 13) ^ rotr$1(A, 22);
-	            const T2 = (sigma0 + Maj$1(A, B, C)) | 0;
-	            H = G;
-	            G = F;
-	            F = E;
-	            E = (D + T1) | 0;
-	            D = C;
-	            C = B;
-	            B = A;
-	            A = (T1 + T2) | 0;
-	        }
-	        // Add the compressed chunk to the current hash value
-	        A = (A + this.A) | 0;
-	        B = (B + this.B) | 0;
-	        C = (C + this.C) | 0;
-	        D = (D + this.D) | 0;
-	        E = (E + this.E) | 0;
-	        F = (F + this.F) | 0;
-	        G = (G + this.G) | 0;
-	        H = (H + this.H) | 0;
-	        this.set(A, B, C, D, E, F, G, H);
-	    }
-	    roundClean() {
-	        SHA256_W.fill(0);
-	    }
-	    destroy() {
-	        this.set(0, 0, 0, 0, 0, 0, 0, 0);
-	        this.buffer.fill(0);
-	    }
-	}
-	/**
-	 * SHA2-256 hash function
-	 * @param message - data that would be hashed
-	 */
-	const sha256 = /* @__PURE__ */ wrapConstructor$1(() => new SHA256());
-
 	/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 	// Short Weierstrass curve. The formula is: y² = x³ + ax + b
 	function validatePointOpts(curve) {
@@ -23629,7 +22424,7 @@ var solanaWeb3 = (function (exports) {
 	    function normPrivateKeyToScalar(key) {
 	        const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;
 	        if (lengths && typeof key !== 'bigint') {
-	            if (isBytes$2(key))
+	            if (isBytes(key))
 	                key = bytesToHex(key);
 	            // Normalize to hex string, pad. E.g. P521 would norm 130-132 char hex to 132-char bytes
 	            if (typeof key !== 'string' || !lengths.includes(key.length))
@@ -24214,7 +23009,7 @@ var solanaWeb3 = (function (exports) {
 	     * Quick and dirty check for item being public key. Does not validate hex, or being on-curve.
 	     */
 	    function isProbPub(item) {
-	        const arr = isBytes$2(item);
+	        const arr = isBytes(item);
 	        const str = typeof item === 'string';
 	        const len = (arr || str) && item.length;
 	        if (arr)
@@ -24375,7 +23170,7 @@ var solanaWeb3 = (function (exports) {
 	        let _sig = undefined;
 	        let P;
 	        try {
-	            if (typeof sg === 'string' || isBytes$2(sg)) {
+	            if (typeof sg === 'string' || isBytes(sg)) {
 	                // Signature can be represented in 2 ways: compact (2*nByteLength) & DER (variable-length).
 	                // Since DER can also be 2*nByteLength bytes, we check for it first.
 	                try {
@@ -24429,13 +23224,13 @@ var solanaWeb3 = (function (exports) {
 	}
 
 	// HMAC (RFC 2104)
-	class HMAC extends Hash$1 {
+	class HMAC extends Hash {
 	    constructor(hash$1, _key) {
 	        super();
 	        this.finished = false;
 	        this.destroyed = false;
 	        hash(hash$1);
-	        const key = toBytes$1(_key);
+	        const key = toBytes(_key);
 	        this.iHash = hash$1.create();
 	        if (typeof this.iHash.update !== 'function')
 	            throw new Error('Expected instance of class which extends utils.Hash');
@@ -24457,13 +23252,13 @@ var solanaWeb3 = (function (exports) {
 	        pad.fill(0);
 	    }
 	    update(buf) {
-	        exists$1(this);
+	        exists(this);
 	        this.iHash.update(buf);
 	        return this;
 	    }
 	    digestInto(out) {
-	        exists$1(this);
-	        bytes$1(out, this.outputLen);
+	        exists(this);
+	        bytes(out, this.outputLen);
 	        this.finished = true;
 	        this.iHash.digestInto(out);
 	        this.oHash.update(out);
@@ -24748,7 +23543,7 @@ var solanaWeb3 = (function (exports) {
 	}
 	Secp256k1Program.programId = new PublicKey('KeccakSecp256k11111111111111111111111111111');
 
-	var _class2;
+	var _Lockup;
 
 	/**
 	 * Address of the stake config account which configures the rate
@@ -24797,8 +23592,8 @@ var solanaWeb3 = (function (exports) {
 	   * Default, inactive Lockup value
 	   */
 	}
-	_class2 = Lockup;
-	Lockup.default = new _class2(0, 0, PublicKey.default);
+	_Lockup = Lockup;
+	Lockup.default = new _Lockup(0, 0, PublicKey.default);
 	/**
 	 * Create stake account transaction params
 	 */