@solana/web3.js 1.91.5 → 1.91.7

package/lib/index.iife.js

@@ -2383,19 +2383,24 @@ var solanaWeb3 = (function (exports) {
 
 	function number$2(n) {
 	    if (!Number.isSafeInteger(n) || n < 0)
-	        throw new Error(`Wrong positive integer: ${n}`);
+	        throw new Error(`positive integer expected, not ${n}`);
+	}
+	// copied from utils
+	function isBytes$3(a) {
+	    return (a instanceof Uint8Array ||
+	        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
 	}
 	function bytes$1(b, ...lengths) {
-	    if (!(b instanceof Uint8Array))
-	        throw new Error('Expected Uint8Array');
+	    if (!isBytes$3(b))
+	        throw new Error('Uint8Array expected');
 	    if (lengths.length > 0 && !lengths.includes(b.length))
-	        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+	        throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
 	}
-	function hash(hash) {
-	    if (typeof hash !== 'function' || typeof hash.create !== 'function')
+	function hash(h) {
+	    if (typeof h !== 'function' || typeof h.create !== 'function')
 	        throw new Error('Hash should be wrapped by utils.wrapConstructor');
-	    number$2(hash.outputLen);
-	    number$2(hash.blockLen);
+	    number$2(h.outputLen);
+	    number$2(h.blockLen);
 	}
 	function exists$1(instance, checkFinished = true) {
 	    if (instance.destroyed)
@@ -2419,17 +2424,12 @@ var solanaWeb3 = (function (exports) {
 	// 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, we can just drop the import.
-	const u8a$1 = (a) => a instanceof Uint8Array;
+	// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
 	// Cast array to view
 	const createView$1 = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 	// The rotate right (circular right shift) operation for uint32
 	const rotr$1 = (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.
-	const isLE$1 = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
-	if (!isLE$1)
-	    throw new Error('Non little-endian hardware is not supported');
+	new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
 	/**
 	 * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
 	 */
@@ -2446,23 +2446,26 @@ var solanaWeb3 = (function (exports) {
 	function toBytes$1(data) {
 	    if (typeof data === 'string')
 	        data = utf8ToBytes$2(data);
-	    if (!u8a$1(data))
-	        throw new Error(`expected Uint8Array, got ${typeof data}`);
+	    bytes$1(data);
 	    return data;
 	}
 	/**
 	 * Copies several Uint8Arrays into one.
 	 */
 	function concatBytes$1(...arrays) {
-	    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
-	    let pad = 0; // walk through each item, ensure they have proper type
-	    arrays.forEach((a) => {
-	        if (!u8a$1(a))
-	            throw new Error('Uint8Array expected');
-	        r.set(a, pad);
+	    let sum = 0;
+	    for (let i = 0; i < arrays.length; i++) {
+	        const a = arrays[i];
+	        bytes$1(a);
+	        sum += a.length;
+	    }
+	    const res = new Uint8Array(sum);
+	    for (let i = 0, pad = 0; i < arrays.length; i++) {
+	        const a = arrays[i];
+	        res.set(a, pad);
 	        pad += a.length;
-	    });
-	    return r;
+	    }
+	    return res;
 	}
 	// For runtime check if class implements interface
 	let Hash$1 = class Hash {
@@ -2502,8 +2505,15 @@ var solanaWeb3 = (function (exports) {
 	    view.setUint32(byteOffset + h, wh, isLE);
 	    view.setUint32(byteOffset + l, wl, isLE);
 	}
-	// Base SHA2 class (RFC 6234)
-	let SHA2$1 = class SHA2 extends Hash$1 {
+	// Choice: a ? b : c
+	const Chi$1 = (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);
+	/**
+	 * Merkle-Damgard hash construction base class.
+	 * Could be used to create MD5, RIPEMD, SHA1, SHA2.
+	 */
+	class HashMD extends Hash$1 {
 	    constructor(blockLen, outputLen, padOffset, isLE) {
 	        super();
 	        this.blockLen = blockLen;
@@ -2555,7 +2565,8 @@ var solanaWeb3 = (function (exports) {
 	        // 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
+	        // 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;
@@ -2599,7 +2610,7 @@ var solanaWeb3 = (function (exports) {
 	            to.buffer.set(buffer);
 	        return to;
 	    }
-	};
+	}
 
 	const U32_MASK64$1 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
 	const _32n$1 = /* @__PURE__ */ BigInt(32);
@@ -2687,7 +2698,7 @@ var solanaWeb3 = (function (exports) {
 	// Temporary buffer, not used to store anything between runs
 	const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
 	const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
-	class SHA512 extends SHA2$1 {
+	class SHA512 extends HashMD {
 	    constructor() {
 	        super(128, 64, 16, false);
 	        // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.
@@ -2824,14 +2835,21 @@ var solanaWeb3 = (function (exports) {
 	const _0n$5 = BigInt(0);
 	const _1n$7 = BigInt(1);
 	const _2n$5 = BigInt(2);
-	const u8a = (a) => a instanceof Uint8Array;
+	function isBytes$2(a) {
+	    return (a instanceof Uint8Array ||
+	        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+	}
+	function abytes(item) {
+	    if (!isBytes$2(item))
+	        throw new Error('Uint8Array expected');
+	}
+	// Array where index 0xf0 (240) is mapped to string 'f0'
 	const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
 	/**
 	 * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
 	 */
 	function bytesToHex(bytes) {
-	    if (!u8a(bytes))
-	        throw new Error('Uint8Array expected');
+	    abytes(bytes);
 	    // pre-caching improves the speed 6x
 	    let hex = '';
 	    for (let i = 0; i < bytes.length; i++) {
@@ -2849,23 +2867,36 @@ var solanaWeb3 = (function (exports) {
 	    // Big Endian
 	    return BigInt(hex === '' ? '0' : `0x${hex}`);
 	}
+	// We use optimized technique to convert hex string to byte array
+	const asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
+	function asciiToBase16(char) {
+	    if (char >= asciis._0 && char <= asciis._9)
+	        return char - asciis._0;
+	    if (char >= asciis._A && char <= asciis._F)
+	        return char - (asciis._A - 10);
+	    if (char >= asciis._a && char <= asciis._f)
+	        return char - (asciis._a - 10);
+	    return;
+	}
 	/**
 	 * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
 	 */
 	function hexToBytes(hex) {
 	    if (typeof hex !== 'string')
 	        throw new Error('hex string expected, got ' + typeof hex);
-	    const len = hex.length;
-	    if (len % 2)
-	        throw new Error('padded hex string expected, got unpadded hex of length ' + len);
-	    const array = new Uint8Array(len / 2);
-	    for (let i = 0; i < array.length; i++) {
-	        const j = i * 2;
-	        const hexByte = hex.slice(j, j + 2);
-	        const byte = Number.parseInt(hexByte, 16);
-	        if (Number.isNaN(byte) || byte < 0)
-	            throw new Error('Invalid byte sequence');
-	        array[i] = byte;
+	    const hl = hex.length;
+	    const al = hl / 2;
+	    if (hl % 2)
+	        throw new Error('padded hex string expected, got unpadded hex of length ' + hl);
+	    const array = new Uint8Array(al);
+	    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+	        const n1 = asciiToBase16(hex.charCodeAt(hi));
+	        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+	        if (n1 === undefined || n2 === undefined) {
+	            const char = hex[hi] + hex[hi + 1];
+	            throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+	        }
+	        array[ai] = n1 * 16 + n2;
 	    }
 	    return array;
 	}
@@ -2874,8 +2905,7 @@ var solanaWeb3 = (function (exports) {
 	    return hexToNumber(bytesToHex(bytes));
 	}
 	function bytesToNumberLE(bytes) {
-	    if (!u8a(bytes))
-	        throw new Error('Uint8Array expected');
+	    abytes(bytes);
 	    return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
 	}
 	function numberToBytesBE(n, len) {
@@ -2907,7 +2937,7 @@ var solanaWeb3 = (function (exports) {
 	            throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
 	        }
 	    }
-	    else if (u8a(hex)) {
+	    else if (isBytes$2(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);
@@ -2924,24 +2954,28 @@ var solanaWeb3 = (function (exports) {
 	 * Copies several Uint8Arrays into one.
 	 */
 	function concatBytes(...arrays) {
-	    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
-	    let pad = 0; // walk through each item, ensure they have proper type
-	    arrays.forEach((a) => {
-	        if (!u8a(a))
-	            throw new Error('Uint8Array expected');
-	        r.set(a, pad);
+	    let sum = 0;
+	    for (let i = 0; i < arrays.length; i++) {
+	        const a = arrays[i];
+	        abytes(a);
+	        sum += a.length;
+	    }
+	    const res = new Uint8Array(sum);
+	    for (let i = 0, pad = 0; i < arrays.length; i++) {
+	        const a = arrays[i];
+	        res.set(a, pad);
 	        pad += a.length;
-	    });
-	    return r;
+	    }
+	    return res;
 	}
-	function equalBytes(b1, b2) {
-	    // We don't care about timing attacks here
-	    if (b1.length !== b2.length)
+	// Compares 2 u8a-s in kinda constant time
+	function equalBytes(a, b) {
+	    if (a.length !== b.length)
 	        return false;
-	    for (let i = 0; i < b1.length; i++)
-	        if (b1[i] !== b2[i])
-	            return false;
-	    return true;
+	    let diff = 0;
+	    for (let i = 0; i < a.length; i++)
+	        diff |= a[i] ^ b[i];
+	    return diff === 0;
 	}
 	/**
 	 * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
@@ -2973,9 +3007,9 @@ var solanaWeb3 = (function (exports) {
 	/**
 	 * Sets single bit at position.
 	 */
-	const bitSet = (n, pos, value) => {
+	function bitSet(n, pos, value) {
 	    return n | ((value ? _1n$7 : _0n$5) << BigInt(pos));
-	};
+	}
 	/**
 	 * Calculate mask for N bits. Not using ** operator with bigints because of old engines.
 	 * Same as BigInt(`0b${Array(i).fill('1').join('')}`)
@@ -3048,7 +3082,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' || val instanceof Uint8Array,
+	    stringOrUint8Array: (val) => typeof val === 'string' || isBytes$2(val),
 	    isSafeInteger: (val) => Number.isSafeInteger(val),
 	    array: (val) => Array.isArray(val),
 	    field: (val, object) => object.Fp.isValid(val),
@@ -3084,6 +3118,7 @@ var solanaWeb3 = (function (exports) {
 
 	var ut = /*#__PURE__*/Object.freeze({
 		__proto__: null,
+		abytes: abytes,
 		bitGet: bitGet,
 		bitLen: bitLen,
 		bitMask: bitMask,
@@ -3097,6 +3132,7 @@ var solanaWeb3 = (function (exports) {
 		equalBytes: equalBytes,
 		hexToBytes: hexToBytes,
 		hexToNumber: hexToNumber,
+		isBytes: isBytes$2,
 		numberToBytesBE: numberToBytesBE,
 		numberToBytesLE: numberToBytesLE,
 		numberToHexUnpadded: numberToHexUnpadded,
@@ -4104,7 +4140,7 @@ var solanaWeb3 = (function (exports) {
 	const Fp$1 = Field(ED25519_P, undefined, true);
 	const ed25519Defaults = {
 	    // Param: a
-	    a: BigInt(-1),
+	    a: BigInt(-1), // Fp.create(-1) is proper; our way still works and is faster
 	    // d is equal to -121665/121666 over finite field.
 	    // Negative number is P - number, and division is invert(number, P)
 	    d: BigInt('37095705934669439343138083508754565189542113879843219016388785533085940283555'),
@@ -7973,9 +8009,9 @@ var solanaWeb3 = (function (exports) {
 	// 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$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);
 	// Round constants:
 	// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)
 	// prettier-ignore
@@ -7991,7 +8027,7 @@ var solanaWeb3 = (function (exports) {
 	]);
 	// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
 	// prettier-ignore
-	const IV$1 = /* @__PURE__ */ new Uint32Array([
+	const IV = /* @__PURE__ */ new Uint32Array([
 	    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
 	]);
 	// Temporary buffer, not used to store anything between runs
@@ -8002,14 +8038,14 @@ var solanaWeb3 = (function (exports) {
 	        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$1[0] | 0;
-	        this.B = IV$1[1] | 0;
-	        this.C = IV$1[2] | 0;
-	        this.D = IV$1[3] | 0;
-	        this.E = IV$1[4] | 0;
-	        this.F = IV$1[5] | 0;
-	        this.G = IV$1[6] | 0;
-	        this.H = IV$1[7] | 0;
+	        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;
 	    }
 	    get() {
 	        const { A, B, C, D, E, F, G, H } = this;
@@ -8041,9 +8077,9 @@ var solanaWeb3 = (function (exports) {
 	        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$1(E, F, G) + SHA256_K$1[i] + SHA256_W$1[i]) | 0;
+	            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K$1[i] + SHA256_W$1[i]) | 0;
 	            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
-	            const T2 = (sigma0 + Maj$1(A, B, C)) | 0;
+	            const T2 = (sigma0 + Maj(A, B, C)) | 0;
 	            H = G;
 	            G = F;
 	            F = E;
@@ -14714,80 +14750,82 @@ var solanaWeb3 = (function (exports) {
 	  }
 	}
 
-	// src/index.ts
 	var objToString = Object.prototype.toString;
-	var objKeys = Object.keys || function (obj) {
-	  const keys = [];
-	  for (const name in obj) {
-	    keys.push(name);
-	  }
-	  return keys;
-	};
+	var objKeys = Object.keys || function(obj) {
+			var keys = [];
+			for (var name in obj) {
+				keys.push(name);
+			}
+			return keys;
+		};
+
 	function stringify$1(val, isArrayProp) {
-	  let i, max, str, keys, key, propVal, toStr;
-	  if (val === true) {
-	    return "true";
-	  }
-	  if (val === false) {
-	    return "false";
-	  }
-	  switch (typeof val) {
-	    case "object":
-	      if (val === null) {
-	        return null;
-	      } else if ("toJSON" in val && typeof val.toJSON === "function") {
-	        return stringify$1(val.toJSON(), isArrayProp);
-	      } else {
-	        toStr = objToString.call(val);
-	        if (toStr === "[object Array]") {
-	          str = "[";
-	          max = val.length - 1;
-	          for (i = 0; i < max; i++) {
-	            str += stringify$1(val[i], true) + ",";
-	          }
-	          if (max > -1) {
-	            str += stringify$1(val[i], true);
-	          }
-	          return str + "]";
-	        } else if (toStr === "[object Object]") {
-	          keys = objKeys(val).sort();
-	          max = keys.length;
-	          str = "";
-	          i = 0;
-	          while (i < max) {
-	            key = keys[i];
-	            propVal = stringify$1(val[key], false);
-	            if (propVal !== void 0) {
-	              if (str) {
-	                str += ",";
-	              }
-	              str += JSON.stringify(key) + ":" + propVal;
-	            }
-	            i++;
-	          }
-	          return "{" + str + "}";
-	        } else {
-	          return JSON.stringify(val);
-	        }
-	      }
-	    case "function":
-	    case "undefined":
-	      return isArrayProp ? null : void 0;
-	    case "bigint":
-	      return JSON.stringify(val.toString() + "n");
-	    case "string":
-	      return JSON.stringify(val);
-	    default:
-	      return isFinite(val) ? val : null;
-	  }
-	}
-	function src_default(val) {
-	  const returnVal = stringify$1(val, false);
-	  if (returnVal !== void 0) {
-	    return "" + returnVal;
-	  }
+		var i, max, str, keys, key, propVal, toStr;
+		if (val === true) {
+			return "true";
+		}
+		if (val === false) {
+			return "false";
+		}
+		switch (typeof val) {
+			case "object":
+				if (val === null) {
+					return null;
+				} else if (val.toJSON && typeof val.toJSON === "function") {
+					return stringify$1(val.toJSON(), isArrayProp);
+				} else {
+					toStr = objToString.call(val);
+					if (toStr === "[object Array]") {
+						str = '[';
+						max = val.length - 1;
+						for(i = 0; i < max; i++) {
+							str += stringify$1(val[i], true) + ',';
+						}
+						if (max > -1) {
+							str += stringify$1(val[i], true);
+						}
+						return str + ']';
+					} else if (toStr === "[object Object]") {
+						// only object is left
+						keys = objKeys(val).sort();
+						max = keys.length;
+						str = "";
+						i = 0;
+						while (i < max) {
+							key = keys[i];
+							propVal = stringify$1(val[key], false);
+							if (propVal !== undefined) {
+								if (str) {
+									str += ',';
+								}
+								str += JSON.stringify(key) + ':' + propVal;
+							}
+							i++;
+						}
+						return '{' + str + '}';
+					} else {
+						return JSON.stringify(val);
+					}
+				}
+			case "function":
+			case "undefined":
+				return isArrayProp ? null : undefined;
+			case "string":
+				return JSON.stringify(val);
+			default:
+				return isFinite(val) ? val : null;
+		}
 	}
 
+	var fastStableStringify = function(val) {
+		var returnVal = stringify$1(val, false);
+		if (returnVal !== undefined) {
+			return ''+ returnVal;
+		}
+	};
+
+	var fastStableStringify$1 = /*@__PURE__*/getDefaultExportFromCjs(fastStableStringify);
+
 	/**
 	 * A `StructFailure` represents a single specific failure in validation.
 	 */
@@ -19678,7 +19716,7 @@ var solanaWeb3 = (function (exports) {
 	          config
 	        } = extractCommitmentFromConfig(commitmentOrConfig);
 	        const args = this._buildArgs([], commitment, undefined /* encoding */, config);
-	        const requestHash = src_default(args);
+	        const requestHash = fastStableStringify$1(args);
 	        requestPromises[requestHash] = requestPromises[requestHash] ?? (async () => {
 	          try {
 	            const unsafeRes = await this._rpcRequest('getBlockHeight', args);
@@ -22114,7 +22152,7 @@ var solanaWeb3 = (function (exports) {
 	   */
 	  args) {
 	    const clientSubscriptionId = this._nextClientSubscriptionId++;
-	    const hash = src_default([subscriptionConfig.method, args]);
+	    const hash = fastStableStringify$1([subscriptionConfig.method, args]);
 	    const existingSubscription = this._subscriptionsByHash[hash];
 	    if (existingSubscription === undefined) {
 	      this._subscriptionsByHash[hash] = {
@@ -23351,10 +23389,6 @@ var solanaWeb3 = (function (exports) {
 
 	// 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
@@ -23368,27 +23402,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 = /* @__PURE__ */ new Uint32Array(64);
-	class SHA256 extends SHA2$1 {
+	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;
@@ -23420,9 +23455,9 @@ var solanaWeb3 = (function (exports) {
 	        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(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+	            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(A, B, C)) | 0;
+	            const T2 = (sigma0 + Maj$1(A, B, C)) | 0;
 	            H = G;
 	            G = F;
 	            F = E;
@@ -23517,8 +23552,7 @@ var solanaWeb3 = (function (exports) {
 	        // parse DER signature
 	        const { Err: E } = DER;
 	        const data = typeof hex === 'string' ? h2b(hex) : hex;
-	        if (!(data instanceof Uint8Array))
-	            throw new Error('ui8a expected');
+	        abytes(data);
 	        let l = data.length;
 	        if (l < 2 || data[0] != 0x30)
 	            throw new E('Invalid signature tag');
@@ -23595,7 +23629,7 @@ var solanaWeb3 = (function (exports) {
 	    function normPrivateKeyToScalar(key) {
 	        const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;
 	        if (lengths && typeof key !== 'bigint') {
-	            if (key instanceof Uint8Array)
+	            if (isBytes$2(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))
@@ -24026,7 +24060,14 @@ var solanaWeb3 = (function (exports) {
 	                if (!isValidFieldElement(x))
 	                    throw new Error('Point is not on curve');
 	                const y2 = weierstrassEquation(x); // y² = x³ + ax + b
-	                let y = Fp.sqrt(y2); // y = y² ^ (p+1)/4
+	                let y;
+	                try {
+	                    y = Fp.sqrt(y2); // y = y² ^ (p+1)/4
+	                }
+	                catch (sqrtError) {
+	                    const suffix = sqrtError instanceof Error ? ': ' + sqrtError.message : '';
+	                    throw new Error('Point is not on curve' + suffix);
+	                }
 	                const isYOdd = (y & _1n$1) === _1n$1;
 	                // ECDSA
 	                const isHeadOdd = (head & 1) === 1;
@@ -24173,7 +24214,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 = item instanceof Uint8Array;
+	        const arr = isBytes$2(item);
 	        const str = typeof item === 'string';
 	        const len = (arr || str) && item.length;
 	        if (arr)
@@ -24253,7 +24294,7 @@ var solanaWeb3 = (function (exports) {
 	        const d = normPrivateKeyToScalar(privateKey); // validate private key, convert to bigint
 	        const seedArgs = [int2octets(d), int2octets(h1int)];
 	        // extraEntropy. RFC6979 3.6: additional k' (optional).
-	        if (ent != null) {
+	        if (ent != null && ent !== false) {
 	            // K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) || k')
 	            const e = ent === true ? randomBytes(Fp.BYTES) : ent; // generate random bytes OR pass as-is
 	            seedArgs.push(ensureBytes('extraEntropy', e)); // check for being bytes
@@ -24334,7 +24375,7 @@ var solanaWeb3 = (function (exports) {
 	        let _sig = undefined;
 	        let P;
 	        try {
-	            if (typeof sg === 'string' || sg instanceof Uint8Array) {
+	            if (typeof sg === 'string' || isBytes$2(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 {
@@ -24512,15 +24553,15 @@ var solanaWeb3 = (function (exports) {
 	}
 	const Fp = Field(secp256k1P, undefined, undefined, { sqrt: sqrtMod });
 	const secp256k1 = createCurve({
-	    a: BigInt(0),
-	    b: BigInt(7),
-	    Fp,
-	    n: secp256k1N,
+	    a: BigInt(0), // equation params: a, b
+	    b: BigInt(7), // Seem to be rigid: bitcointalk.org/index.php?topic=289795.msg3183975#msg3183975
+	    Fp, // Field's prime: 2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n
+	    n: secp256k1N, // Curve order, total count of valid points in the field
 	    // Base point (x, y) aka generator point
 	    Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),
 	    Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),
-	    h: BigInt(1),
-	    lowS: true,
+	    h: BigInt(1), // Cofactor
+	    lowS: true, // Allow only low-S signatures by default in sign() and verify()
 	    /**
 	     * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
 	     * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.