@zoralabs/protocol-deployments 0.2.0 → 0.2.2

package/dist/{secp256k1-R7PEGLZR.js → secp256k1-5CEPNAX3.js}

@@ -10,12 +10,12 @@ import {
   rotr,
   toBytes,
   wrapConstructor
-} from "./chunk-2FDPSBOH.js";
+} from "./chunk-5JV63AHR.js";
 import {
   __export
 } from "./chunk-3EJPJMEH.js";
 
-// ../../node_modules/@noble/hashes/esm/_sha2.js
+// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_md.js
 function setBigUint64(view, byteOffset, value, isLE) {
   if (typeof view.setBigUint64 === "function")
     return view.setBigUint64(byteOffset, value, isLE);
@@ -28,7 +28,9 @@ function setBigUint64(view, byteOffset, value, isLE) {
   view.setUint32(byteOffset + h, wh, isLE);
   view.setUint32(byteOffset + l, wl, isLE);
 }
-var SHA2 = class extends Hash {
+var Chi = (a, b, c) => a & b ^ ~a & c;
+var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
+var HashMD = class extends Hash {
   constructor(blockLen, outputLen, padOffset, isLE) {
     super();
     this.blockLen = blockLen;
@@ -115,9 +117,7 @@ var SHA2 = class extends Hash {
   }
 };
 
-// ../../node_modules/@noble/hashes/esm/sha256.js
-var Chi = (a, b, c) => a & b ^ ~a & c;
-var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
+// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/sha256.js
 var SHA256_K = /* @__PURE__ */ new Uint32Array([
   1116352408,
   1899447441,
@@ -184,7 +184,7 @@ var SHA256_K = /* @__PURE__ */ new Uint32Array([
   3204031479,
   3329325298
 ]);
-var IV = /* @__PURE__ */ new Uint32Array([
+var SHA256_IV = /* @__PURE__ */ new Uint32Array([
   1779033703,
   3144134277,
   1013904242,
@@ -195,17 +195,17 @@ var IV = /* @__PURE__ */ new Uint32Array([
   1541459225
 ]);
 var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-var SHA256 = class extends SHA2 {
+var SHA256 = class extends HashMD {
   constructor() {
     super(64, 32, 8, false);
-    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;
@@ -267,9 +267,10 @@ var SHA256 = class extends SHA2 {
 };
 var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 
-// ../../node_modules/@noble/curves/esm/abstract/utils.js
+// ../../node_modules/.pnpm/@noble+curves@1.4.0/node_modules/@noble/curves/esm/abstract/utils.js
 var utils_exports = {};
 __export(utils_exports, {
+  abytes: () => abytes,
   bitGet: () => bitGet,
   bitLen: () => bitLen,
   bitMask: () => bitMask,
@@ -283,6 +284,7 @@ __export(utils_exports, {
   equalBytes: () => equalBytes,
   hexToBytes: () => hexToBytes,
   hexToNumber: () => hexToNumber,
+  isBytes: () => isBytes,
   numberToBytesBE: () => numberToBytesBE,
   numberToBytesLE: () => numberToBytesLE,
   numberToHexUnpadded: () => numberToHexUnpadded,
@@ -293,11 +295,16 @@ __export(utils_exports, {
 var _0n = BigInt(0);
 var _1n = BigInt(1);
 var _2n = BigInt(2);
-var u8a = (a) => a instanceof Uint8Array;
+function isBytes(a) {
+  return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+}
+function abytes(item) {
+  if (!isBytes(item))
+    throw new Error("Uint8Array expected");
+}
 var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
 function bytesToHex(bytes2) {
-  if (!u8a(bytes2))
-    throw new Error("Uint8Array expected");
+  abytes(bytes2);
   let hex = "";
   for (let i = 0; i < bytes2.length; i++) {
     hex += hexes[bytes2[i]];
@@ -313,20 +320,32 @@ function hexToNumber(hex) {
     throw new Error("hex string expected, got " + typeof hex);
   return BigInt(hex === "" ? "0" : `0x${hex}`);
 }
+var 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;
+}
 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 === void 0 || n2 === void 0) {
+      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;
 }
@@ -334,8 +353,7 @@ function bytesToNumberBE(bytes2) {
   return hexToNumber(bytesToHex(bytes2));
 }
 function bytesToNumberLE(bytes2) {
-  if (!u8a(bytes2))
-    throw new Error("Uint8Array expected");
+  abytes(bytes2);
   return hexToNumber(bytesToHex(Uint8Array.from(bytes2).reverse()));
 }
 function numberToBytesBE(n, len) {
@@ -355,7 +373,7 @@ function ensureBytes(title, hex, expectedLength) {
     } catch (e) {
       throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
     }
-  } else if (u8a(hex)) {
+  } else if (isBytes(hex)) {
     res = Uint8Array.from(hex);
   } else {
     throw new Error(`${title} must be hex string or Uint8Array`);
@@ -366,23 +384,27 @@ function ensureBytes(title, hex, expectedLength) {
   return res;
 }
 function concatBytes2(...arrays) {
-  const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
-  let pad = 0;
-  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) {
-  if (b1.length !== b2.length)
+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;
 }
 function utf8ToBytes(str) {
   if (typeof str !== "string")
@@ -398,9 +420,9 @@ function bitLen(n) {
 function bitGet(n, pos) {
   return n >> BigInt(pos) & _1n;
 }
-var bitSet = (n, pos, value) => {
+function bitSet(n, pos, value) {
   return n | (value ? _1n : _0n) << BigInt(pos);
-};
+}
 var bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;
 var u8n = (data) => new Uint8Array(data);
 var u8fr = (arr) => Uint8Array.from(arr);
@@ -457,7 +479,7 @@ var validatorFns = {
   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(val),
   isSafeInteger: (val) => Number.isSafeInteger(val),
   array: (val) => Array.isArray(val),
   field: (val, object) => object.Fp.isValid(val),
@@ -482,7 +504,7 @@ function validateObject(object, validators, optValidators = {}) {
   return object;
 }
 
-// ../../node_modules/@noble/curves/esm/abstract/modular.js
+// ../../node_modules/.pnpm/@noble+curves@1.4.0/node_modules/@noble/curves/esm/abstract/modular.js
 var _0n2 = BigInt(0);
 var _1n2 = BigInt(1);
 var _2n2 = BigInt(2);
@@ -748,7 +770,7 @@ function mapHashToField(key, fieldOrder, isLE = false) {
   return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
 }
 
-// ../../node_modules/@noble/curves/esm/abstract/curve.js
+// ../../node_modules/.pnpm/@noble+curves@1.4.0/node_modules/@noble/curves/esm/abstract/curve.js
 var _0n3 = BigInt(0);
 var _1n3 = BigInt(1);
 function wNAF(c, bits) {
@@ -866,7 +888,7 @@ function validateBasic(curve) {
   });
 }
 
-// ../../node_modules/@noble/curves/esm/abstract/weierstrass.js
+// ../../node_modules/.pnpm/@noble+curves@1.4.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
 function validatePointOpts(curve) {
   const opts = validateBasic(curve);
   validateObject(opts, {
@@ -917,8 +939,7 @@ var DER = {
   toSig(hex) {
     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] != 48)
       throw new E("Invalid signature tag");
@@ -981,7 +1002,7 @@ function weierstrassPoints(opts) {
   function normPrivateKeyToScalar(key) {
     const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;
     if (lengths && typeof key !== "bigint") {
-      if (key instanceof Uint8Array)
+      if (isBytes(key))
         key = bytesToHex(key);
       if (typeof key !== "string" || !lengths.includes(key.length))
         throw new Error("Invalid key");
@@ -1387,7 +1408,13 @@ function weierstrass(curveDef) {
         if (!isValidFieldElement(x))
           throw new Error("Point is not on curve");
         const y2 = weierstrassEquation(x);
-        let y = Fp2.sqrt(y2);
+        let y;
+        try {
+          y = Fp2.sqrt(y2);
+        } catch (sqrtError) {
+          const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
+          throw new Error("Point is not on curve" + suffix);
+        }
         const isYOdd = (y & _1n4) === _1n4;
         const isHeadOdd = (head & 1) === 1;
         if (isHeadOdd !== isYOdd)
@@ -1516,7 +1543,7 @@ function weierstrass(curveDef) {
     return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
   }
   function isProbPub(item) {
-    const arr = item instanceof Uint8Array;
+    const arr = isBytes(item);
     const str = typeof item === "string";
     const len = (arr || str) && item.length;
     if (arr)
@@ -1564,7 +1591,7 @@ function weierstrass(curveDef) {
     const h1int = bits2int_modN(msgHash);
     const d = normPrivateKeyToScalar(privateKey);
     const seedArgs = [int2octets(d), int2octets(h1int)];
-    if (ent != null) {
+    if (ent != null && ent !== false) {
       const e = ent === true ? randomBytes2(Fp2.BYTES) : ent;
       seedArgs.push(ensureBytes("extraEntropy", e));
     }
@@ -1611,7 +1638,7 @@ function weierstrass(curveDef) {
     let _sig = void 0;
     let P;
     try {
-      if (typeof sg === "string" || sg instanceof Uint8Array) {
+      if (typeof sg === "string" || isBytes(sg)) {
         try {
           _sig = Signature.fromDER(sg);
         } catch (derError) {
@@ -1757,14 +1784,7 @@ function mapToCurveSimpleSWU(Fp2, opts) {
   };
 }
 
-// ../../node_modules/@noble/curves/esm/abstract/hash-to-curve.js
-function validateDST(dst) {
-  if (dst instanceof Uint8Array)
-    return dst;
-  if (typeof dst === "string")
-    return utf8ToBytes(dst);
-  throw new Error("DST must be Uint8Array or string");
-}
+// ../../node_modules/.pnpm/@noble+curves@1.4.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js
 var os2ip = bytesToNumberBE;
 function i2osp(value, length) {
   if (value < 0 || value >= 1 << 8 * length) {
@@ -1784,18 +1804,14 @@ function strxor(a, b) {
   }
   return arr;
 }
-function isBytes(item) {
-  if (!(item instanceof Uint8Array))
-    throw new Error("Uint8Array expected");
-}
-function isNum(item) {
+function anum(item) {
   if (!Number.isSafeInteger(item))
     throw new Error("number expected");
 }
 function expand_message_xmd(msg, DST, lenInBytes, H) {
-  isBytes(msg);
-  isBytes(DST);
-  isNum(lenInBytes);
+  abytes(msg);
+  abytes(DST);
+  anum(lenInBytes);
   if (DST.length > 255)
     DST = H(concatBytes2(utf8ToBytes("H2C-OVERSIZE-DST-"), DST));
   const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
@@ -1816,9 +1832,9 @@ function expand_message_xmd(msg, DST, lenInBytes, H) {
   return pseudo_random_bytes.slice(0, lenInBytes);
 }
 function expand_message_xof(msg, DST, lenInBytes, k, H) {
-  isBytes(msg);
-  isBytes(DST);
-  isNum(lenInBytes);
+  abytes(msg);
+  abytes(DST);
+  anum(lenInBytes);
   if (DST.length > 255) {
     const dkLen = Math.ceil(2 * k / 8);
     DST = H.create({ dkLen }).update(utf8ToBytes("H2C-OVERSIZE-DST-")).update(DST).digest();
@@ -1836,9 +1852,9 @@ function hash_to_field(msg, count, options) {
     hash: "hash"
   });
   const { p, k, m, hash: hash2, expand, DST: _DST } = options;
-  isBytes(msg);
-  isNum(count);
-  const DST = validateDST(_DST);
+  abytes(msg);
+  anum(count);
+  const DST = typeof _DST === "string" ? utf8ToBytes(_DST) : _DST;
   const log2p = p.toString(2).length;
   const L = Math.ceil((log2p + k) / 8);
   const len_in_bytes = count * m * L;
@@ -1898,7 +1914,7 @@ function createHasher(Point2, mapToCurve, def) {
   };
 }
 
-// ../../node_modules/@noble/hashes/esm/hmac.js
+// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/hmac.js
 var HMAC = class extends Hash {
   constructor(hash2, _key) {
     super();
@@ -1963,7 +1979,7 @@ var HMAC = class extends Hash {
 var hmac = (hash2, key, message) => new HMAC(hash2, key).update(message).digest();
 hmac.create = (hash2, key) => new HMAC(hash2, key);
 
-// ../../node_modules/@noble/curves/esm/_shortw_utils.js
+// ../../node_modules/.pnpm/@noble+curves@1.4.0/node_modules/@noble/curves/esm/_shortw_utils.js
 function getHash(hash2) {
   return {
     hash: hash2,
@@ -1976,7 +1992,7 @@ function createCurve(curveDef, defHash) {
   return Object.freeze({ ...create(defHash), create });
 }
 
-// ../../node_modules/@noble/curves/esm/secp256k1.js
+// ../../node_modules/.pnpm/@noble+curves@1.4.0/node_modules/@noble/curves/esm/secp256k1.js
 var secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
 var secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
 var _1n5 = BigInt(1);
@@ -2007,14 +2023,20 @@ function sqrtMod(y) {
 var Fp = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
 var secp256k1 = createCurve({
   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),
+  // 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%.
@@ -2219,4 +2241,4 @@ export {
 @noble/curves/esm/secp256k1.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=secp256k1-R7PEGLZR.js.map
+//# sourceMappingURL=secp256k1-5CEPNAX3.js.map