@settlemint/sdk-cli 2.3.14-prfdf11875 → 2.4.0-main005a9b57

package/dist/cli.js

@@ -5149,7 +5149,7 @@ var require_sha2 = __commonJS((exports) => {
   exports.sha512_224 = (0, utils_ts_1.createHasher)(() => new SHA512_224);
 });
 
-// ../../node_modules/@noble/curves/abstract/utils.js
+// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/utils.js
 var require_utils5 = __commonJS((exports) => {
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -5423,7 +5423,7 @@ var require_utils5 = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/@noble/curves/abstract/modular.js
+// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/modular.js
 var require_modular = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.isNegativeLE = undefined;
@@ -5753,7 +5753,7 @@ var require_modular = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/@noble/curves/abstract/curve.js
+// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/curve.js
 var require_curve = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.wNAF = wNAF;
@@ -6002,7 +6002,7 @@ var require_curve = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/@noble/curves/abstract/edwards.js
+// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/edwards.js
 var require_edwards = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.twistedEdwards = twistedEdwards;
@@ -6361,7 +6361,7 @@ var require_edwards = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/@noble/curves/abstract/hash-to-curve.js
+// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/hash-to-curve.js
 var require_hash_to_curve = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.expand_message_xmd = expand_message_xmd;
@@ -6514,7 +6514,7 @@ var require_hash_to_curve = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/@noble/curves/abstract/montgomery.js
+// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/montgomery.js
 var require_montgomery = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.montgomery = montgomery;
@@ -6621,7 +6621,7 @@ var require_montgomery = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/@noble/curves/ed25519.js
+// ../../node_modules/eciesjs/node_modules/@noble/curves/ed25519.js
 var require_ed25519 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.hash_to_ristretto255 = exports.hashToRistretto255 = exports.RistrettoPoint = exports.encodeToCurve = exports.hashToCurve = exports.ed25519_hasher = exports.edwardsToMontgomery = exports.x25519 = exports.ed25519ph = exports.ed25519ctx = exports.ed25519 = exports.ED25519_TORSION_SUBGROUP = undefined;
@@ -7061,7 +7061,7 @@ var require_hmac = __commonJS((exports) => {
   exports.hmac.create = (hash, key) => new HMAC(hash, key);
 });
 
-// ../../node_modules/@noble/curves/abstract/weierstrass.js
+// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/weierstrass.js
 var require_weierstrass = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.DER = exports.DERErr = undefined;
@@ -7980,7 +7980,7 @@ var require_weierstrass = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/@noble/curves/_shortw_utils.js
+// ../../node_modules/eciesjs/node_modules/@noble/curves/_shortw_utils.js
 var require__shortw_utils = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.getHash = getHash;
@@ -8002,7 +8002,7 @@ var require__shortw_utils = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/@noble/curves/secp256k1.js
+// ../../node_modules/eciesjs/node_modules/@noble/curves/secp256k1.js
 var require_secp256k1 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.encodeToCurve = exports.hashToCurve = exports.secp256k1_hasher = exports.schnorr = exports.secp256k1 = undefined;
@@ -48857,7 +48857,7 @@ var require_typescript = __commonJS((exports, module) => {
       tryGetPropertyNameOfBindingOrAssignmentElement: () => tryGetPropertyNameOfBindingOrAssignmentElement,
       tryGetSourceMappingURL: () => tryGetSourceMappingURL,
       tryGetTextOfPropertyName: () => tryGetTextOfPropertyName,
-      tryParseJson: () => tryParseJson4,
+      tryParseJson: () => tryParseJson5,
       tryParsePattern: () => tryParsePattern,
       tryParsePatterns: () => tryParsePatterns,
       tryParseRawSourceMap: () => tryParseRawSourceMap,
@@ -66862,7 +66862,7 @@ ${lanes.join(`
     function readJson(path7, host) {
       return readJsonOrUndefined(path7, host) || {};
     }
-    function tryParseJson4(text) {
+    function tryParseJson5(text) {
       try {
         return JSON.parse(text);
       } catch {
@@ -92927,7 +92927,7 @@ ${lanes.join(`
       if (isMissingPackageJsonInfo(cachedPackageJson) || !host.fileExists(packageJsonPath)) {
         return;
       }
-      const packageJsonContent = (cachedPackageJson == null ? undefined : cachedPackageJson.contents.packageJsonContent) || tryParseJson4(host.readFile(packageJsonPath));
+      const packageJsonContent = (cachedPackageJson == null ? undefined : cachedPackageJson.contents.packageJsonContent) || tryParseJson5(host.readFile(packageJsonPath));
       const imports = packageJsonContent == null ? undefined : packageJsonContent.imports;
       if (!imports) {
         return;
@@ -93013,7 +93013,7 @@ ${lanes.join(`
         let maybeBlockedByTypesVersions = false;
         const cachedPackageJson = (_b = (_a = host.getPackageJsonInfoCache) == null ? undefined : _a.call(host)) == null ? undefined : _b.getPackageJsonInfo(packageJsonPath);
         if (isPackageJsonInfo(cachedPackageJson) || cachedPackageJson === undefined && host.fileExists(packageJsonPath)) {
-          const packageJsonContent = (cachedPackageJson == null ? undefined : cachedPackageJson.contents.packageJsonContent) || tryParseJson4(host.readFile(packageJsonPath));
+          const packageJsonContent = (cachedPackageJson == null ? undefined : cachedPackageJson.contents.packageJsonContent) || tryParseJson5(host.readFile(packageJsonPath));
           const importMode = overrideMode || getDefaultResolutionModeForFile(importingSourceFile, host, options);
           if (getResolvePackageJsonExports(options)) {
             const nodeModulesDirectoryName2 = packageRootPath.substring(parts.topLevelPackageNameIndex + 1);
@@ -166185,7 +166185,7 @@ ${lanes.join(`
       }
       const dependencyKeys = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
       const stringContent = host.readFile(fileName) || "";
-      const content = tryParseJson4(stringContent);
+      const content = tryParseJson5(stringContent);
       const info = {};
       if (content) {
         for (const key2 of dependencyKeys) {
@@ -204120,7 +204120,7 @@ ${options.prefix}` : `
       tryGetPropertyNameOfBindingOrAssignmentElement: () => tryGetPropertyNameOfBindingOrAssignmentElement,
       tryGetSourceMappingURL: () => tryGetSourceMappingURL,
       tryGetTextOfPropertyName: () => tryGetTextOfPropertyName,
-      tryParseJson: () => tryParseJson4,
+      tryParseJson: () => tryParseJson5,
       tryParsePattern: () => tryParsePattern,
       tryParsePatterns: () => tryParsePatterns,
       tryParseRawSourceMap: () => tryParseRawSourceMap,
@@ -231623,7 +231623,7 @@ function size(value4) {
 var init_size = () => {};
 
 // ../../node_modules/viem/_esm/errors/version.js
-var version5 = "2.31.0";
+var version5 = "2.31.2";
 
 // ../../node_modules/viem/_esm/errors/base.js
 function walk(err, fn) {
@@ -232421,6 +232421,46 @@ function byteSwap32(arr) {
   }
   return arr;
 }
+function bytesToHex2(bytes) {
+  abytes(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i6 = 0;i6 < bytes.length; i6++) {
+    hex += hexes2[bytes[i6]];
+  }
+  return hex;
+}
+function asciiToBase16(ch) {
+  if (ch >= asciis._0 && ch <= asciis._9)
+    return ch - asciis._0;
+  if (ch >= asciis.A && ch <= asciis.F)
+    return ch - (asciis.A - 10);
+  if (ch >= asciis.a && ch <= asciis.f)
+    return ch - (asciis.a - 10);
+  return;
+}
+function hexToBytes2(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  if (hasHexBuiltin)
+    return Uint8Array.fromHex(hex);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + hl);
+  const array4 = new Uint8Array(al);
+  for (let ai = 0, hi = 0;ai < al; ai++, hi += 2) {
+    const n1 = asciiToBase16(hex.charCodeAt(hi));
+    const n22 = asciiToBase16(hex.charCodeAt(hi + 1));
+    if (n1 === undefined || n22 === undefined) {
+      const char = hex[hi] + hex[hi + 1];
+      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+    }
+    array4[ai] = n1 * 16 + n22;
+  }
+  return array4;
+}
 function utf8ToBytes(str) {
   if (typeof str !== "string")
     throw new Error("string expected");
@@ -232467,12 +232507,15 @@ function randomBytes(bytesLength = 32) {
   }
   throw new Error("crypto.getRandomValues must be defined");
 }
-var isLE, swap32IfBE;
+var isLE, swap32IfBE, hasHexBuiltin, hexes2, asciis;
 var init_utils2 = __esm(() => {
   init_cryptoNode();
   /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
   swap32IfBE = isLE ? (u6) => u6 : byteSwap32;
+  hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+  hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_5, i6) => i6.toString(16).padStart(2, "0"));
+  asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
 });
 
 // ../../node_modules/@noble/hashes/esm/sha3.js
@@ -235138,14 +235181,7 @@ var init_hmac = __esm(() => {
   hmac.create = (hash2, key2) => new HMAC(hash2, key2);
 });
 
-// ../../node_modules/@noble/curves/esm/abstract/utils.js
-function isBytes2(a7) {
-  return a7 instanceof Uint8Array || ArrayBuffer.isView(a7) && a7.constructor.name === "Uint8Array";
-}
-function abytes2(item) {
-  if (!isBytes2(item))
-    throw new Error("Uint8Array expected");
-}
+// ../../node_modules/@noble/curves/esm/utils.js
 function abool(title, value4) {
   if (typeof value4 !== "boolean")
     throw new Error(title + " boolean expected, got " + value4);
@@ -235159,51 +235195,11 @@ function hexToNumber2(hex) {
     throw new Error("hex string expected, got " + typeof hex);
   return hex === "" ? _0n2 : BigInt("0x" + hex);
 }
-function bytesToHex2(bytes) {
-  abytes2(bytes);
-  if (hasHexBuiltin)
-    return bytes.toHex();
-  let hex = "";
-  for (let i6 = 0;i6 < bytes.length; i6++) {
-    hex += hexes2[bytes[i6]];
-  }
-  return hex;
-}
-function asciiToBase16(ch) {
-  if (ch >= asciis._0 && ch <= asciis._9)
-    return ch - asciis._0;
-  if (ch >= asciis.A && ch <= asciis.F)
-    return ch - (asciis.A - 10);
-  if (ch >= asciis.a && ch <= asciis.f)
-    return ch - (asciis.a - 10);
-  return;
-}
-function hexToBytes2(hex) {
-  if (typeof hex !== "string")
-    throw new Error("hex string expected, got " + typeof hex);
-  if (hasHexBuiltin)
-    return Uint8Array.fromHex(hex);
-  const hl = hex.length;
-  const al = hl / 2;
-  if (hl % 2)
-    throw new Error("hex string expected, got unpadded hex of length " + hl);
-  const array4 = new Uint8Array(al);
-  for (let ai = 0, hi = 0;ai < al; ai++, hi += 2) {
-    const n1 = asciiToBase16(hex.charCodeAt(hi));
-    const n22 = asciiToBase16(hex.charCodeAt(hi + 1));
-    if (n1 === undefined || n22 === undefined) {
-      const char = hex[hi] + hex[hi + 1];
-      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
-    }
-    array4[ai] = n1 * 16 + n22;
-  }
-  return array4;
-}
 function bytesToNumberBE(bytes) {
   return hexToNumber2(bytesToHex2(bytes));
 }
 function bytesToNumberLE(bytes) {
-  abytes2(bytes);
+  abytes(bytes);
   return hexToNumber2(bytesToHex2(Uint8Array.from(bytes).reverse()));
 }
 function numberToBytesBE(n6, len) {
@@ -235220,7 +235216,7 @@ function ensureBytes(title, hex, expectedLength) {
     } catch (e10) {
       throw new Error(title + " must be hex string or Uint8Array, cause: " + e10);
     }
-  } else if (isBytes2(hex)) {
+  } else if (isBytes(hex)) {
     res = Uint8Array.from(hex);
   } else {
     throw new Error(title + " must be hex string or Uint8Array");
@@ -235230,26 +235226,6 @@ function ensureBytes(title, hex, expectedLength) {
     throw new Error(title + " of length " + expectedLength + " expected, got " + len);
   return res;
 }
-function concatBytes3(...arrays) {
-  let sum = 0;
-  for (let i6 = 0;i6 < arrays.length; i6++) {
-    const a7 = arrays[i6];
-    abytes2(a7);
-    sum += a7.length;
-  }
-  const res = new Uint8Array(sum);
-  for (let i6 = 0, pad2 = 0;i6 < arrays.length; i6++) {
-    const a7 = arrays[i6];
-    res.set(a7, pad2);
-    pad2 += a7.length;
-  }
-  return res;
-}
-function utf8ToBytes2(str) {
-  if (typeof str !== "string")
-    throw new Error("string expected");
-  return new Uint8Array(new TextEncoder().encode(str));
-}
 function inRange(n6, min, max) {
   return isPosBig(n6) && isPosBig(min) && isPosBig(max) && min <= n6 && n6 < max;
 }
@@ -235270,6 +235246,8 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
     throw new Error("qByteLen must be a number");
   if (typeof hmacFn !== "function")
     throw new Error("hmacFn must be a function");
+  const u8n = (len) => new Uint8Array(len);
+  const u8of = (byte) => Uint8Array.of(byte);
   let v6 = u8n(hashLen);
   let k5 = u8n(hashLen);
   let i6 = 0;
@@ -235280,11 +235258,11 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   };
   const h8 = (...b4) => hmacFn(k5, v6, ...b4);
   const reseed = (seed = u8n(0)) => {
-    k5 = h8(u8fr([0]), seed);
+    k5 = h8(u8of(0), seed);
     v6 = h8();
     if (seed.length === 0)
       return;
-    k5 = h8(u8fr([1]), seed);
+    k5 = h8(u8of(1), seed);
     v6 = h8();
   };
   const gen2 = () => {
@@ -235298,7 +235276,7 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
       out.push(sl);
       len += v6.length;
     }
-    return concatBytes3(...out);
+    return concatBytes(...out);
   };
   const genUntil = (seed, pred) => {
     reset2();
@@ -235311,23 +235289,22 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   };
   return genUntil;
 }
-function validateObject(object4, validators, optValidators = {}) {
-  const checkField = (fieldName, type4, isOptional) => {
-    const checkVal = validatorFns[type4];
-    if (typeof checkVal !== "function")
-      throw new Error("invalid validator function");
+function isHash(val) {
+  return typeof val === "function" && Number.isSafeInteger(val.outputLen);
+}
+function _validateObject(object4, fields, optFields = {}) {
+  if (!object4 || typeof object4 !== "object")
+    throw new Error("expected valid options object");
+  function checkField(fieldName, expectedType, isOpt) {
     const val = object4[fieldName];
-    if (isOptional && val === undefined)
+    if (isOpt && val === undefined)
       return;
-    if (!checkVal(val, object4)) {
-      throw new Error("param " + String(fieldName) + " is invalid. Expected " + type4 + ", got " + val);
-    }
-  };
-  for (const [fieldName, type4] of Object.entries(validators))
-    checkField(fieldName, type4, false);
-  for (const [fieldName, type4] of Object.entries(optValidators))
-    checkField(fieldName, type4, true);
-  return object4;
+    const current = typeof val;
+    if (current !== expectedType || val === null)
+      throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
+  }
+  Object.entries(fields).forEach(([k5, v6]) => checkField(k5, v6, false));
+  Object.entries(optFields).forEach(([k5, v6]) => checkField(k5, v6, true));
 }
 function memoized(fn) {
   const map6 = new WeakMap;
@@ -235340,25 +235317,13 @@ function memoized(fn) {
     return computed;
   };
 }
-var _0n2, _1n2, hasHexBuiltin, hexes2, asciis, isPosBig = (n6) => typeof n6 === "bigint" && _0n2 <= n6, bitMask = (n6) => (_1n2 << BigInt(n6)) - _1n2, u8n = (len) => new Uint8Array(len), u8fr = (arr) => Uint8Array.from(arr), validatorFns;
+var _0n2, _1n2, isPosBig = (n6) => typeof n6 === "bigint" && _0n2 <= n6, bitMask = (n6) => (_1n2 << BigInt(n6)) - _1n2;
 var init_utils3 = __esm(() => {
+  init_utils2();
+  init_utils2();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   _0n2 = /* @__PURE__ */ BigInt(0);
   _1n2 = /* @__PURE__ */ BigInt(1);
-  hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
-  hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_5, i6) => i6.toString(16).padStart(2, "0"));
-  asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
-  validatorFns = {
-    bigint: (val) => typeof val === "bigint",
-    function: (val) => typeof val === "function",
-    boolean: (val) => typeof val === "boolean",
-    string: (val) => typeof val === "string",
-    stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
-    isSafeInteger: (val) => Number.isSafeInteger(val),
-    array: (val) => Array.isArray(val),
-    field: (val, object4) => object4.Fp.isValid(val),
-    hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
-  };
 });
 
 // ../../node_modules/@noble/curves/esm/abstract/modular.js
@@ -235472,14 +235437,15 @@ function validateField(field2) {
   const initial = {
     ORDER: "bigint",
     MASK: "bigint",
-    BYTES: "isSafeInteger",
-    BITS: "isSafeInteger"
+    BYTES: "number",
+    BITS: "number"
   };
   const opts = FIELD_FIELDS.reduce((map6, val) => {
     map6[val] = "function";
     return map6;
   }, initial);
-  return validateObject(field2, opts);
+  _validateObject(field2, opts);
+  return field2;
 }
 function FpPow(Fp, num, power) {
   if (power < _0n3)
@@ -235532,10 +235498,28 @@ function nLength(n6, nBitLength) {
   const nByteLength = Math.ceil(_nBitLength / 8);
   return { nBitLength: _nBitLength, nByteLength };
 }
-function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
+function Field(ORDER, bitLenOrOpts, isLE2 = false, opts = {}) {
   if (ORDER <= _0n3)
     throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
-  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
+  let _nbitLength = undefined;
+  let _sqrt = undefined;
+  if (typeof bitLenOrOpts === "object" && bitLenOrOpts != null) {
+    if (opts.sqrt || isLE2)
+      throw new Error("cannot specify opts in two arguments");
+    const _opts = bitLenOrOpts;
+    if (_opts.BITS)
+      _nbitLength = _opts.BITS;
+    if (_opts.sqrt)
+      _sqrt = _opts.sqrt;
+    if (typeof _opts.isLE === "boolean")
+      isLE2 = _opts.isLE;
+  } else {
+    if (typeof bitLenOrOpts === "number")
+      _nbitLength = bitLenOrOpts;
+    if (opts.sqrt)
+      _sqrt = opts.sqrt;
+  }
+  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, _nbitLength);
   if (BYTES > 2048)
     throw new Error("invalid field: expected ORDER of <= 2048 bytes");
   let sqrtP;
@@ -235554,6 +235538,7 @@ function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
       return _0n3 <= num && num < ORDER;
     },
     is0: (num) => num === _0n3,
+    isValidNot0: (num) => !f5.is0(num) && f5.isValid(num),
     isOdd: (num) => (num & _1n3) === _1n3,
     neg: (num) => mod(-num, ORDER),
     eql: (lhs, rhs) => lhs === rhs,
@@ -235568,7 +235553,7 @@ function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
     subN: (lhs, rhs) => lhs - rhs,
     mulN: (lhs, rhs) => lhs * rhs,
     inv: (num) => invert(num, ORDER),
-    sqrt: redef.sqrt || ((n6) => {
+    sqrt: _sqrt || ((n6) => {
       if (!sqrtP)
         sqrtP = FpSqrt(ORDER);
       return sqrtP(f5, n6);
@@ -235606,7 +235591,6 @@ function mapHashToField(key2, fieldOrder, isLE2 = false) {
 }
 var _0n3, _1n3, _2n2, _3n, _4n, _5n, _8n, FIELD_FIELDS;
 var init_modular = __esm(() => {
-  init_utils2();
   init_utils3();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   _0n3 = BigInt(0);
@@ -235638,10 +235622,16 @@ var init_modular = __esm(() => {
 });
 
 // ../../node_modules/@noble/curves/esm/abstract/curve.js
-function constTimeNegate(condition, item) {
+function negateCt(condition, item) {
   const neg = item.negate();
   return condition ? neg : item;
 }
+function normalizeZ(c3, property, points) {
+  const getz = property === "pz" ? (p5) => p5.pz : (p5) => p5.ez;
+  const toInv = FpInvertBatch(c3.Fp, points.map(getz));
+  const affined = points.map((p5, i6) => p5.toAffine(toInv[i6]));
+  return affined.map(c3.fromAffine);
+}
 function validateW(W5, bits) {
   if (!Number.isSafeInteger(W5) || W5 <= 0 || W5 > bits)
     throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W5);
@@ -235690,9 +235680,13 @@ function validateMSMScalars(scalars, field2) {
 function getW(P5) {
   return pointWindowSizes.get(P5) || 1;
 }
+function assert0(n6) {
+  if (n6 !== _0n4)
+    throw new Error("invalid wNAF");
+}
 function wNAF(c3, bits) {
   return {
-    constTimeNegate,
+    constTimeNegate: negateCt,
     hasPrecomputes(elm) {
       return getW(elm) !== 1;
     },
@@ -235730,11 +235724,12 @@ function wNAF(c3, bits) {
         const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n6, window2, wo);
         n6 = nextN;
         if (isZero) {
-          f5 = f5.add(constTimeNegate(isNegF, precomputes[offsetF]));
+          f5 = f5.add(negateCt(isNegF, precomputes[offsetF]));
         } else {
-          p5 = p5.add(constTimeNegate(isNeg, precomputes[offset]));
+          p5 = p5.add(negateCt(isNeg, precomputes[offset]));
         }
       }
+      assert0(n6);
       return { p: p5, f: f5 };
     },
     wNAFUnsafe(W5, precomputes, n6, acc = c3.ZERO) {
@@ -235751,14 +235746,18 @@ function wNAF(c3, bits) {
           acc = acc.add(isNeg ? item.negate() : item);
         }
       }
+      assert0(n6);
       return acc;
     },
     getPrecomputes(W5, P5, transform5) {
       let comp = pointPrecomputes.get(P5);
       if (!comp) {
         comp = this.precomputeWindow(P5, W5);
-        if (W5 !== 1)
-          pointPrecomputes.set(P5, transform5(comp));
+        if (W5 !== 1) {
+          if (typeof transform5 === "function")
+            comp = transform5(comp);
+          pointPrecomputes.set(P5, comp);
+        }
       }
       return comp;
     },
@@ -235779,6 +235778,21 @@ function wNAF(c3, bits) {
     }
   };
 }
+function mulEndoUnsafe(c3, point, k1, k22) {
+  let acc = point;
+  let p1 = c3.ZERO;
+  let p22 = c3.ZERO;
+  while (k1 > _0n4 || k22 > _0n4) {
+    if (k1 & _1n4)
+      p1 = p1.add(acc);
+    if (k22 & _1n4)
+      p22 = p22.add(acc);
+    acc = acc.double();
+    k1 >>= _1n4;
+    k22 >>= _1n4;
+  }
+  return { p1, p2: p22 };
+}
 function pippenger(c3, fieldN, points, scalars) {
   validateMSMPoints(points, c3);
   validateMSMScalars(scalars, fieldN);
@@ -235818,27 +235832,38 @@ function pippenger(c3, fieldN, points, scalars) {
   }
   return sum;
 }
-function validateBasic(curve) {
-  validateField(curve.Fp);
-  validateObject(curve, {
-    n: "bigint",
-    h: "bigint",
-    Gx: "field",
-    Gy: "field"
-  }, {
-    nBitLength: "isSafeInteger",
-    nByteLength: "isSafeInteger"
-  });
-  return Object.freeze({
-    ...nLength(curve.n, curve.nBitLength),
-    ...curve,
-    ...{ p: curve.Fp.ORDER }
-  });
+function createField(order, field2) {
+  if (field2) {
+    if (field2.ORDER !== order)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    validateField(field2);
+    return field2;
+  } else {
+    return Field(order);
+  }
+}
+function _createCurveFields(type4, CURVE, curveOpts = {}) {
+  if (!CURVE || typeof CURVE !== "object")
+    throw new Error(`expected valid ${type4} CURVE object`);
+  for (const p5 of ["p", "n", "h"]) {
+    const val = CURVE[p5];
+    if (!(typeof val === "bigint" && val > _0n4))
+      throw new Error(`CURVE.${p5} must be positive bigint`);
+  }
+  const Fp = createField(CURVE.p, curveOpts.Fp);
+  const Fn = createField(CURVE.n, curveOpts.Fn);
+  const _b = type4 === "weierstrass" ? "b" : "d";
+  const params = ["Gx", "Gy", "a", _b];
+  for (const p5 of params) {
+    if (!Fp.isValid(CURVE[p5]))
+      throw new Error(`CURVE.${p5} must be valid field element of CURVE.Fp`);
+  }
+  return { Fp, Fn };
 }
 var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
 var init_curve = __esm(() => {
-  init_modular();
   init_utils3();
+  init_modular();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   _0n4 = BigInt(0);
   _1n4 = BigInt(1);
@@ -235853,54 +235878,116 @@ function validateSigVerOpts(opts) {
   if (opts.prehash !== undefined)
     abool("prehash", opts.prehash);
 }
-function validatePointOpts(curve) {
-  const opts = validateBasic(curve);
-  validateObject(opts, {
-    a: "field",
-    b: "field"
-  }, {
+function _legacyHelperEquat(Fp, a7, b4) {
+  function weierstrassEquation(x6) {
+    const x22 = Fp.sqr(x6);
+    const x32 = Fp.mul(x22, x6);
+    return Fp.add(Fp.add(x32, Fp.mul(x6, a7)), b4);
+  }
+  return weierstrassEquation;
+}
+function _legacyHelperNormPriv(Fn, allowedPrivateKeyLengths, wrapPrivateKey) {
+  const { BYTES: expected } = Fn;
+  function normPrivateKeyToScalar(key2) {
+    let num;
+    if (typeof key2 === "bigint") {
+      num = key2;
+    } else {
+      let bytes = ensureBytes("private key", key2);
+      if (allowedPrivateKeyLengths) {
+        if (!allowedPrivateKeyLengths.includes(bytes.length * 2))
+          throw new Error("invalid private key");
+        const padded = new Uint8Array(expected);
+        padded.set(bytes, padded.length - bytes.length);
+        bytes = padded;
+      }
+      try {
+        num = Fn.fromBytes(bytes);
+      } catch (error44) {
+        throw new Error(`invalid private key: expected ui8a of size ${expected}, got ${typeof key2}`);
+      }
+    }
+    if (wrapPrivateKey)
+      num = Fn.create(num);
+    if (!Fn.isValidNot0(num))
+      throw new Error("invalid private key: out of range [1..N-1]");
+    return num;
+  }
+  return normPrivateKeyToScalar;
+}
+function weierstrassN(CURVE, curveOpts = {}) {
+  const { Fp, Fn } = _createCurveFields("weierstrass", CURVE, curveOpts);
+  const { h: cofactor, n: CURVE_ORDER } = CURVE;
+  _validateObject(curveOpts, {}, {
     allowInfinityPoint: "boolean",
-    allowedPrivateKeyLengths: "array",
     clearCofactor: "function",
-    fromBytes: "function",
     isTorsionFree: "function",
+    fromBytes: "function",
     toBytes: "function",
+    endo: "object",
     wrapPrivateKey: "boolean"
   });
-  const { endo, Fp, a: a7 } = opts;
+  const { endo } = curveOpts;
   if (endo) {
-    if (!Fp.eql(a7, Fp.ZERO)) {
-      throw new Error("invalid endo: CURVE.a must be 0");
-    }
-    if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
+    if (!Fp.is0(CURVE.a) || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
       throw new Error('invalid endo: expected "beta": bigint and "splitScalar": function');
     }
   }
-  return Object.freeze({ ...opts });
-}
-function numToSizedHex(num, size2) {
-  return bytesToHex2(numberToBytesBE(num, size2));
-}
-function weierstrassPoints(opts) {
-  const CURVE = validatePointOpts(opts);
-  const { Fp } = CURVE;
-  const Fn = Field(CURVE.n, CURVE.nBitLength);
-  const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
-    const a7 = point.toAffine();
-    return concatBytes3(Uint8Array.from([4]), Fp.toBytes(a7.x), Fp.toBytes(a7.y));
-  });
-  const fromBytes = CURVE.fromBytes || ((bytes) => {
+  function assertCompressionIsSupported() {
+    if (!Fp.isOdd)
+      throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function pointToBytes(_c, point, isCompressed) {
+    const { x: x6, y: y4 } = point.toAffine();
+    const bx = Fp.toBytes(x6);
+    abool("isCompressed", isCompressed);
+    if (isCompressed) {
+      assertCompressionIsSupported();
+      const hasEvenY = !Fp.isOdd(y4);
+      return concatBytes(pprefix(hasEvenY), bx);
+    } else {
+      return concatBytes(Uint8Array.of(4), bx, Fp.toBytes(y4));
+    }
+  }
+  function pointFromBytes(bytes) {
+    abytes(bytes);
+    const L5 = Fp.BYTES;
+    const LC = L5 + 1;
+    const LU = 2 * L5 + 1;
+    const length = bytes.length;
+    const head = bytes[0];
     const tail = bytes.subarray(1);
-    const x6 = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
-    const y4 = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
-    return { x: x6, y: y4 };
-  });
-  function weierstrassEquation(x6) {
-    const { a: a7, b: b4 } = CURVE;
-    const x22 = Fp.sqr(x6);
-    const x32 = Fp.mul(x22, x6);
-    return Fp.add(Fp.add(x32, Fp.mul(x6, a7)), b4);
+    if (length === LC && (head === 2 || head === 3)) {
+      const x6 = Fp.fromBytes(tail);
+      if (!Fp.isValid(x6))
+        throw new Error("bad point: is not on curve, wrong x");
+      const y22 = weierstrassEquation(x6);
+      let y4;
+      try {
+        y4 = Fp.sqrt(y22);
+      } catch (sqrtError) {
+        const err = sqrtError instanceof Error ? ": " + sqrtError.message : "";
+        throw new Error("bad point: is not on curve, sqrt error" + err);
+      }
+      assertCompressionIsSupported();
+      const isYOdd = Fp.isOdd(y4);
+      const isHeadOdd = (head & 1) === 1;
+      if (isHeadOdd !== isYOdd)
+        y4 = Fp.neg(y4);
+      return { x: x6, y: y4 };
+    } else if (length === LU && head === 4) {
+      const x6 = Fp.fromBytes(tail.subarray(L5 * 0, L5 * 1));
+      const y4 = Fp.fromBytes(tail.subarray(L5 * 1, L5 * 2));
+      if (!isValidXY(x6, y4))
+        throw new Error("bad point: is not on curve");
+      return { x: x6, y: y4 };
+    } else {
+      throw new Error(`bad point: got length ${length}, expected compressed=${LC} or uncompressed=${LU}`);
+    }
   }
+  const toBytes3 = curveOpts.toBytes || pointToBytes;
+  const fromBytes = curveOpts.fromBytes || pointFromBytes;
+  const weierstrassEquation = _legacyHelperEquat(Fp, CURVE.a, CURVE.b);
   function isValidXY(x6, y4) {
     const left = Fp.sqr(y4);
     const right = weierstrassEquation(x6);
@@ -235912,28 +235999,10 @@ function weierstrassPoints(opts) {
   const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));
   if (Fp.is0(Fp.add(_4a3, _27b2)))
     throw new Error("bad curve params: a or b");
-  function isWithinCurveOrder(num) {
-    return inRange(num, _1n5, CURVE.n);
-  }
-  function normPrivateKeyToScalar(key2) {
-    const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N6 } = CURVE;
-    if (lengths && typeof key2 !== "bigint") {
-      if (isBytes2(key2))
-        key2 = bytesToHex2(key2);
-      if (typeof key2 !== "string" || !lengths.includes(key2.length))
-        throw new Error("invalid private key");
-      key2 = key2.padStart(nByteLength * 2, "0");
-    }
-    let num;
-    try {
-      num = typeof key2 === "bigint" ? key2 : bytesToNumberBE(ensureBytes("private key", key2, nByteLength));
-    } catch (error44) {
-      throw new Error("invalid private key, expected hex or " + nByteLength + " bytes, got " + typeof key2);
-    }
-    if (wrapPrivateKey)
-      num = mod(num, N6);
-    aInRange("private key", num, _1n5, N6);
-    return num;
+  function acoord(title, n6, banZero = false) {
+    if (!Fp.isValid(n6) || banZero && Fp.is0(n6))
+      throw new Error(`bad point coordinate ${title}`);
+    return n6;
   }
   function aprjpoint(other) {
     if (!(other instanceof Point))
@@ -235957,31 +236026,31 @@ function weierstrassPoints(opts) {
   });
   const assertValidMemo = memoized((p5) => {
     if (p5.is0()) {
-      if (CURVE.allowInfinityPoint && !Fp.is0(p5.py))
+      if (curveOpts.allowInfinityPoint && !Fp.is0(p5.py))
         return;
       throw new Error("bad point: ZERO");
     }
     const { x: x6, y: y4 } = p5.toAffine();
     if (!Fp.isValid(x6) || !Fp.isValid(y4))
-      throw new Error("bad point: x or y not FE");
+      throw new Error("bad point: x or y not field elements");
     if (!isValidXY(x6, y4))
       throw new Error("bad point: equation left != right");
     if (!p5.isTorsionFree())
       throw new Error("bad point: not in prime-order subgroup");
     return true;
   });
+  function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {
+    k2p = new Point(Fp.mul(k2p.px, endoBeta), k2p.py, k2p.pz);
+    k1p = negateCt(k1neg, k1p);
+    k2p = negateCt(k2neg, k2p);
+    return k1p.add(k2p);
+  }
 
   class Point {
     constructor(px, py, pz) {
-      if (px == null || !Fp.isValid(px))
-        throw new Error("x required");
-      if (py == null || !Fp.isValid(py) || Fp.is0(py))
-        throw new Error("y required");
-      if (pz == null || !Fp.isValid(pz))
-        throw new Error("z required");
-      this.px = px;
-      this.py = py;
-      this.pz = pz;
+      this.px = acoord("x", px);
+      this.py = acoord("y", py, true);
+      this.pz = acoord("z", pz);
       Object.freeze(this);
     }
     static fromAffine(p5) {
@@ -235990,8 +236059,7 @@ function weierstrassPoints(opts) {
         throw new Error("invalid affine point");
       if (p5 instanceof Point)
         throw new Error("projective point not allowed");
-      const is0 = (i6) => Fp.eql(i6, Fp.ZERO);
-      if (is0(x6) && is0(y4))
+      if (Fp.is0(x6) && Fp.is0(y4))
         return Point.ZERO;
       return new Point(x6, y4, Fp.ONE);
     }
@@ -236002,8 +236070,11 @@ function weierstrassPoints(opts) {
       return this.toAffine().y;
     }
     static normalizeZ(points) {
-      const toInv = FpInvertBatch(Fp, points.map((p5) => p5.pz));
-      return points.map((p5, i6) => p5.toAffine(toInv[i6])).map(Point.fromAffine);
+      return normalizeZ(Point, "pz", points);
+    }
+    static fromBytes(bytes) {
+      abytes(bytes);
+      return Point.fromHex(bytes);
     }
     static fromHex(hex) {
       const P5 = Point.fromAffine(fromBytes(ensureBytes("pointHex", hex)));
@@ -236011,22 +236082,29 @@ function weierstrassPoints(opts) {
       return P5;
     }
     static fromPrivateKey(privateKey) {
+      const normPrivateKeyToScalar = _legacyHelperNormPriv(Fn, curveOpts.allowedPrivateKeyLengths, curveOpts.wrapPrivateKey);
       return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
     }
     static msm(points, scalars) {
       return pippenger(Point, Fn, points, scalars);
     }
-    _setWindowSize(windowSize) {
+    precompute(windowSize = 8, isLazy = true) {
       wnaf.setWindowSize(this, windowSize);
+      if (!isLazy)
+        this.multiply(_3n2);
+      return this;
+    }
+    _setWindowSize(windowSize) {
+      this.precompute(windowSize);
     }
     assertValidity() {
       assertValidMemo(this);
     }
     hasEvenY() {
       const { y: y4 } = this.toAffine();
-      if (Fp.isOdd)
-        return !Fp.isOdd(y4);
-      throw new Error("Field doesn't support isOdd");
+      if (!Fp.isOdd)
+        throw new Error("Field doesn't support isOdd");
+      return !Fp.isOdd(y4);
     }
     equals(other) {
       aprjpoint(other);
@@ -236132,188 +236210,121 @@ function weierstrassPoints(opts) {
     is0() {
       return this.equals(Point.ZERO);
     }
-    wNAF(n6) {
-      return wnaf.wNAFCached(this, n6, Point.normalizeZ);
-    }
-    multiplyUnsafe(sc) {
-      const { endo: endo2, n: N6 } = CURVE;
-      aInRange("scalar", sc, _0n5, N6);
-      const I6 = Point.ZERO;
-      if (sc === _0n5)
-        return I6;
-      if (this.is0() || sc === _1n5)
-        return this;
-      if (!endo2 || wnaf.hasPrecomputes(this))
-        return wnaf.wNAFCachedUnsafe(this, sc, Point.normalizeZ);
-      let { k1neg, k1, k2neg, k2: k22 } = endo2.splitScalar(sc);
-      let k1p = I6;
-      let k2p = I6;
-      let d6 = this;
-      while (k1 > _0n5 || k22 > _0n5) {
-        if (k1 & _1n5)
-          k1p = k1p.add(d6);
-        if (k22 & _1n5)
-          k2p = k2p.add(d6);
-        d6 = d6.double();
-        k1 >>= _1n5;
-        k22 >>= _1n5;
-      }
-      if (k1neg)
-        k1p = k1p.negate();
-      if (k2neg)
-        k2p = k2p.negate();
-      k2p = new Point(Fp.mul(k2p.px, endo2.beta), k2p.py, k2p.pz);
-      return k1p.add(k2p);
-    }
     multiply(scalar) {
-      const { endo: endo2, n: N6 } = CURVE;
-      aInRange("scalar", scalar, _1n5, N6);
+      const { endo: endo2 } = curveOpts;
+      if (!Fn.isValidNot0(scalar))
+        throw new Error("invalid scalar: out of range");
       let point, fake;
+      const mul = (n6) => wnaf.wNAFCached(this, n6, Point.normalizeZ);
       if (endo2) {
         const { k1neg, k1, k2neg, k2: k22 } = endo2.splitScalar(scalar);
-        let { p: k1p, f: f1p } = this.wNAF(k1);
-        let { p: k2p, f: f2p } = this.wNAF(k22);
-        k1p = wnaf.constTimeNegate(k1neg, k1p);
-        k2p = wnaf.constTimeNegate(k2neg, k2p);
-        k2p = new Point(Fp.mul(k2p.px, endo2.beta), k2p.py, k2p.pz);
-        point = k1p.add(k2p);
-        fake = f1p.add(f2p);
+        const { p: k1p, f: k1f } = mul(k1);
+        const { p: k2p, f: k2f } = mul(k22);
+        fake = k1f.add(k2f);
+        point = finishEndo(endo2.beta, k1p, k2p, k1neg, k2neg);
       } else {
-        const { p: p5, f: f5 } = this.wNAF(scalar);
+        const { p: p5, f: f5 } = mul(scalar);
         point = p5;
         fake = f5;
       }
       return Point.normalizeZ([point, fake])[0];
     }
+    multiplyUnsafe(sc) {
+      const { endo: endo2 } = curveOpts;
+      const p5 = this;
+      if (!Fn.isValid(sc))
+        throw new Error("invalid scalar: out of range");
+      if (sc === _0n5 || p5.is0())
+        return Point.ZERO;
+      if (sc === _1n5)
+        return p5;
+      if (wnaf.hasPrecomputes(this))
+        return this.multiply(sc);
+      if (endo2) {
+        const { k1neg, k1, k2neg, k2: k22 } = endo2.splitScalar(sc);
+        const { p1, p2: p22 } = mulEndoUnsafe(Point, p5, k1, k22);
+        return finishEndo(endo2.beta, p1, p22, k1neg, k2neg);
+      } else {
+        return wnaf.wNAFCachedUnsafe(p5, sc);
+      }
+    }
     multiplyAndAddUnsafe(Q4, a7, b4) {
-      const G4 = Point.BASE;
-      const mul = (P5, a8) => a8 === _0n5 || a8 === _1n5 || !P5.equals(G4) ? P5.multiplyUnsafe(a8) : P5.multiply(a8);
-      const sum = mul(this, a7).add(mul(Q4, b4));
+      const sum = this.multiplyUnsafe(a7).add(Q4.multiplyUnsafe(b4));
       return sum.is0() ? undefined : sum;
     }
-    toAffine(iz) {
-      return toAffineMemo(this, iz);
+    toAffine(invertedZ) {
+      return toAffineMemo(this, invertedZ);
     }
     isTorsionFree() {
-      const { h: cofactor, isTorsionFree } = CURVE;
+      const { isTorsionFree } = curveOpts;
       if (cofactor === _1n5)
         return true;
       if (isTorsionFree)
         return isTorsionFree(Point, this);
-      throw new Error("isTorsionFree() has not been declared for the elliptic curve");
+      return wnaf.wNAFCachedUnsafe(this, CURVE_ORDER).is0();
     }
     clearCofactor() {
-      const { h: cofactor, clearCofactor } = CURVE;
+      const { clearCofactor } = curveOpts;
       if (cofactor === _1n5)
         return this;
       if (clearCofactor)
         return clearCofactor(Point, this);
-      return this.multiplyUnsafe(CURVE.h);
+      return this.multiplyUnsafe(cofactor);
     }
-    toRawBytes(isCompressed = true) {
+    toBytes(isCompressed = true) {
       abool("isCompressed", isCompressed);
       this.assertValidity();
       return toBytes3(Point, this, isCompressed);
     }
+    toRawBytes(isCompressed = true) {
+      return this.toBytes(isCompressed);
+    }
     toHex(isCompressed = true) {
-      abool("isCompressed", isCompressed);
-      return bytesToHex2(this.toRawBytes(isCompressed));
+      return bytesToHex2(this.toBytes(isCompressed));
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
     }
   }
   Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
   Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
-  const { endo, nBitLength } = CURVE;
-  const wnaf = wNAF(Point, endo ? Math.ceil(nBitLength / 2) : nBitLength);
-  return {
-    CURVE,
-    ProjectivePoint: Point,
-    normPrivateKeyToScalar,
-    weierstrassEquation,
-    isWithinCurveOrder
-  };
+  Point.Fp = Fp;
+  Point.Fn = Fn;
+  const bits = Fn.BITS;
+  const wnaf = wNAF(Point, curveOpts.endo ? Math.ceil(bits / 2) : bits);
+  return Point;
+}
+function pprefix(hasEvenY) {
+  return Uint8Array.of(hasEvenY ? 2 : 3);
 }
-function validateOpts(curve) {
-  const opts = validateBasic(curve);
-  validateObject(opts, {
-    hash: "hash",
+function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
+  _validateObject(ecdsaOpts, { hash: "function" }, {
     hmac: "function",
-    randomBytes: "function"
-  }, {
+    lowS: "boolean",
+    randomBytes: "function",
     bits2int: "function",
-    bits2int_modN: "function",
-    lowS: "boolean"
-  });
-  return Object.freeze({ lowS: true, ...opts });
-}
-function weierstrass(curveDef) {
-  const CURVE = validateOpts(curveDef);
-  const { Fp, n: CURVE_ORDER, nByteLength, nBitLength } = CURVE;
-  const compressedLen = Fp.BYTES + 1;
-  const uncompressedLen = 2 * Fp.BYTES + 1;
-  function modN(a7) {
-    return mod(a7, CURVE_ORDER);
-  }
-  function invN(a7) {
-    return invert(a7, CURVE_ORDER);
-  }
-  const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
-    ...CURVE,
-    toBytes(_c, point, isCompressed) {
-      const a7 = point.toAffine();
-      const x6 = Fp.toBytes(a7.x);
-      const cat = concatBytes3;
-      abool("isCompressed", isCompressed);
-      if (isCompressed) {
-        return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x6);
-      } else {
-        return cat(Uint8Array.from([4]), x6, Fp.toBytes(a7.y));
-      }
-    },
-    fromBytes(bytes) {
-      const len = bytes.length;
-      const head = bytes[0];
-      const tail = bytes.subarray(1);
-      if (len === compressedLen && (head === 2 || head === 3)) {
-        const x6 = bytesToNumberBE(tail);
-        if (!inRange(x6, _1n5, Fp.ORDER))
-          throw new Error("Point is not on curve");
-        const y22 = weierstrassEquation(x6);
-        let y4;
-        try {
-          y4 = Fp.sqrt(y22);
-        } catch (sqrtError) {
-          const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
-          throw new Error("Point is not on curve" + suffix);
-        }
-        const isYOdd = (y4 & _1n5) === _1n5;
-        const isHeadOdd = (head & 1) === 1;
-        if (isHeadOdd !== isYOdd)
-          y4 = Fp.neg(y4);
-        return { x: x6, y: y4 };
-      } else if (len === uncompressedLen && head === 4) {
-        const x6 = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
-        const y4 = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
-        return { x: x6, y: y4 };
-      } else {
-        const cl = compressedLen;
-        const ul = uncompressedLen;
-        throw new Error("invalid Point, expected length of " + cl + ", or uncompressed " + ul + ", got " + len);
-      }
-    }
+    bits2int_modN: "function"
   });
+  const randomBytes_ = ecdsaOpts.randomBytes || randomBytes;
+  const hmac_ = ecdsaOpts.hmac || ((key2, ...msgs) => hmac(ecdsaOpts.hash, key2, concatBytes(...msgs)));
+  const { Fp, Fn } = Point;
+  const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
   function isBiggerThanHalfOrder(number6) {
     const HALF = CURVE_ORDER >> _1n5;
     return number6 > HALF;
   }
   function normalizeS(s7) {
-    return isBiggerThanHalfOrder(s7) ? modN(-s7) : s7;
+    return isBiggerThanHalfOrder(s7) ? Fn.neg(s7) : s7;
+  }
+  function aValidRS(title, num) {
+    if (!Fn.isValidNot0(num))
+      throw new Error(`invalid signature ${title}: out of range 1..CURVE.n`);
   }
-  const slcNum = (b4, from, to) => bytesToNumberBE(b4.slice(from, to));
 
   class Signature {
     constructor(r6, s7, recovery) {
-      aInRange("r", r6, _1n5, CURVE_ORDER);
-      aInRange("s", s7, _1n5, CURVE_ORDER);
+      aValidRS("r", r6);
+      aValidRS("s", s7);
       this.r = r6;
       this.s = s7;
       if (recovery != null)
@@ -236321,9 +236332,9 @@ function weierstrass(curveDef) {
       Object.freeze(this);
     }
     static fromCompact(hex) {
-      const l3 = nByteLength;
-      hex = ensureBytes("compactSignature", hex, l3 * 2);
-      return new Signature(slcNum(hex, 0, l3), slcNum(hex, l3, 2 * l3));
+      const L5 = Fn.BYTES;
+      const b4 = ensureBytes("compactSignature", hex, L5 * 2);
+      return new Signature(Fn.fromBytes(b4.subarray(0, L5)), Fn.fromBytes(b4.subarray(L5, L5 * 2)));
     }
     static fromDER(hex) {
       const { r: r6, s: s7 } = DER.toSig(ensureBytes("DER", hex));
@@ -236334,20 +236345,24 @@ function weierstrass(curveDef) {
       return new Signature(this.r, this.s, recovery);
     }
     recoverPublicKey(msgHash) {
+      const FIELD_ORDER = Fp.ORDER;
       const { r: r6, s: s7, recovery: rec } = this;
-      const h8 = bits2int_modN(ensureBytes("msgHash", msgHash));
       if (rec == null || ![0, 1, 2, 3].includes(rec))
         throw new Error("recovery id invalid");
-      const radj = rec === 2 || rec === 3 ? r6 + CURVE.n : r6;
-      if (radj >= Fp.ORDER)
+      const hasCofactor = CURVE_ORDER * _2n3 < FIELD_ORDER;
+      if (hasCofactor && rec > 1)
+        throw new Error("recovery id is ambiguous for h>1 curve");
+      const radj = rec === 2 || rec === 3 ? r6 + CURVE_ORDER : r6;
+      if (!Fp.isValid(radj))
         throw new Error("recovery id 2 or 3 invalid");
-      const prefix = (rec & 1) === 0 ? "02" : "03";
-      const R7 = Point.fromHex(prefix + numToSizedHex(radj, Fp.BYTES));
-      const ir2 = invN(radj);
-      const u1 = modN(-h8 * ir2);
-      const u22 = modN(s7 * ir2);
-      const Q4 = Point.BASE.multiplyAndAddUnsafe(R7, u1, u22);
-      if (!Q4)
+      const x6 = Fp.toBytes(radj);
+      const R7 = Point.fromHex(concatBytes(pprefix((rec & 1) === 0), x6));
+      const ir2 = Fn.inv(radj);
+      const h8 = bits2int_modN(ensureBytes("msgHash", msgHash));
+      const u1 = Fn.create(-h8 * ir2);
+      const u22 = Fn.create(s7 * ir2);
+      const Q4 = Point.BASE.multiplyUnsafe(u1).add(R7.multiplyUnsafe(u22));
+      if (Q4.is0())
         throw new Error("point at infinify");
       Q4.assertValidity();
       return Q4;
@@ -236356,22 +236371,29 @@ function weierstrass(curveDef) {
       return isBiggerThanHalfOrder(this.s);
     }
     normalizeS() {
-      return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;
+      return this.hasHighS() ? new Signature(this.r, Fn.neg(this.s), this.recovery) : this;
+    }
+    toBytes(format2) {
+      if (format2 === "compact")
+        return concatBytes(Fn.toBytes(this.r), Fn.toBytes(this.s));
+      if (format2 === "der")
+        return hexToBytes2(DER.hexFromSig(this));
+      throw new Error("invalid format");
     }
     toDERRawBytes() {
-      return hexToBytes2(this.toDERHex());
+      return this.toBytes("der");
     }
     toDERHex() {
-      return DER.hexFromSig(this);
+      return bytesToHex2(this.toBytes("der"));
     }
     toCompactRawBytes() {
-      return hexToBytes2(this.toCompactHex());
+      return this.toBytes("compact");
     }
     toCompactHex() {
-      const l3 = nByteLength;
-      return numToSizedHex(this.r, l3) + numToSizedHex(this.s, l3);
+      return bytesToHex2(this.toBytes("compact"));
     }
   }
+  const normPrivateKeyToScalar = _legacyHelperNormPriv(Fn, curveOpts.allowedPrivateKeyLengths, curveOpts.wrapPrivateKey);
   const utils = {
     isValidPrivateKey(privateKey) {
       try {
@@ -236383,17 +236405,15 @@ function weierstrass(curveDef) {
     },
     normPrivateKeyToScalar,
     randomPrivateKey: () => {
-      const length = getMinHashLength(CURVE.n);
-      return mapHashToField(CURVE.randomBytes(length), CURVE.n);
+      const n6 = CURVE_ORDER;
+      return mapHashToField(randomBytes_(getMinHashLength(n6)), n6);
     },
     precompute(windowSize = 8, point = Point.BASE) {
-      point._setWindowSize(windowSize);
-      point.multiply(BigInt(3));
-      return point;
+      return point.precompute(windowSize, false);
     }
   };
   function getPublicKey(privateKey, isCompressed = true) {
-    return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
+    return Point.fromPrivateKey(privateKey).toBytes(isCompressed);
   }
   function isProbPub(item) {
     if (typeof item === "bigint")
@@ -236401,14 +236421,14 @@ function weierstrass(curveDef) {
     if (item instanceof Point)
       return true;
     const arr = ensureBytes("key", item);
-    const len = arr.length;
-    const fpl = Fp.BYTES;
-    const compLen = fpl + 1;
-    const uncompLen = 2 * fpl + 1;
-    if (CURVE.allowedPrivateKeyLengths || nByteLength === compLen) {
+    const length = arr.length;
+    const L5 = Fp.BYTES;
+    const LC = L5 + 1;
+    const LU = 2 * L5 + 1;
+    if (curveOpts.allowedPrivateKeyLengths || Fn.BYTES === LC) {
       return;
     } else {
-      return len === compLen || len === uncompLen;
+      return length === LC || length === LU;
     }
   }
   function getSharedSecret(privateA, publicB, isCompressed = true) {
@@ -236417,27 +236437,27 @@ function weierstrass(curveDef) {
     if (isProbPub(publicB) === false)
       throw new Error("second arg must be public key");
     const b4 = Point.fromHex(publicB);
-    return b4.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
+    return b4.multiply(normPrivateKeyToScalar(privateA)).toBytes(isCompressed);
   }
-  const bits2int = CURVE.bits2int || function(bytes) {
+  const bits2int = ecdsaOpts.bits2int || function(bytes) {
     if (bytes.length > 8192)
       throw new Error("input is too large");
     const num = bytesToNumberBE(bytes);
-    const delta = bytes.length * 8 - nBitLength;
+    const delta = bytes.length * 8 - fnBits;
     return delta > 0 ? num >> BigInt(delta) : num;
   };
-  const bits2int_modN = CURVE.bits2int_modN || function(bytes) {
-    return modN(bits2int(bytes));
+  const bits2int_modN = ecdsaOpts.bits2int_modN || function(bytes) {
+    return Fn.create(bits2int(bytes));
   };
-  const ORDER_MASK = bitMask(nBitLength);
+  const ORDER_MASK = bitMask(fnBits);
   function int2octets(num) {
-    aInRange("num < 2^" + nBitLength, num, _0n5, ORDER_MASK);
-    return numberToBytesBE(num, nByteLength);
+    aInRange("num < 2^" + fnBits, num, _0n5, ORDER_MASK);
+    return Fn.toBytes(num);
   }
   function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
     if (["recovered", "canonical"].some((k5) => (k5 in opts)))
       throw new Error("sign() legacy options not supported");
-    const { hash: hash2, randomBytes: randomBytes2 } = CURVE;
+    const { hash: hash2 } = ecdsaOpts;
     let { lowS, prehash, extraEntropy: ent } = opts;
     if (lowS == null)
       lowS = true;
@@ -236449,21 +236469,21 @@ function weierstrass(curveDef) {
     const d6 = normPrivateKeyToScalar(privateKey);
     const seedArgs = [int2octets(d6), int2octets(h1int)];
     if (ent != null && ent !== false) {
-      const e10 = ent === true ? randomBytes2(Fp.BYTES) : ent;
+      const e10 = ent === true ? randomBytes_(Fp.BYTES) : ent;
       seedArgs.push(ensureBytes("extraEntropy", e10));
     }
-    const seed = concatBytes3(...seedArgs);
+    const seed = concatBytes(...seedArgs);
     const m7 = h1int;
     function k2sig(kBytes) {
       const k5 = bits2int(kBytes);
-      if (!isWithinCurveOrder(k5))
+      if (!Fn.isValidNot0(k5))
         return;
-      const ik = invN(k5);
+      const ik = Fn.inv(k5);
       const q6 = Point.BASE.multiply(k5).toAffine();
-      const r6 = modN(q6.x);
+      const r6 = Fn.create(q6.x);
       if (r6 === _0n5)
         return;
-      const s7 = modN(ik * modN(m7 + r6 * d6));
+      const s7 = Fn.create(ik * Fn.create(m7 + r6 * d6));
       if (s7 === _0n5)
         return;
       let recovery = (q6.x === r6 ? 0 : 2) | Number(q6.y & _1n5);
@@ -236476,34 +236496,38 @@ function weierstrass(curveDef) {
     }
     return { seed, k2sig };
   }
-  const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
-  const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
+  const defaultSigOpts = { lowS: ecdsaOpts.lowS, prehash: false };
+  const defaultVerOpts = { lowS: ecdsaOpts.lowS, prehash: false };
   function sign(msgHash, privKey, opts = defaultSigOpts) {
     const { seed, k2sig } = prepSig(msgHash, privKey, opts);
-    const C4 = CURVE;
-    const drbg = createHmacDrbg(C4.hash.outputLen, C4.nByteLength, C4.hmac);
+    const drbg = createHmacDrbg(ecdsaOpts.hash.outputLen, Fn.BYTES, hmac_);
     return drbg(seed, k2sig);
   }
-  Point.BASE._setWindowSize(8);
+  Point.BASE.precompute(8);
   function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
     const sg = signature;
     msgHash = ensureBytes("msgHash", msgHash);
     publicKey = ensureBytes("publicKey", publicKey);
-    const { lowS, prehash, format: format2 } = opts;
     validateSigVerOpts(opts);
+    const { lowS, prehash, format: format2 } = opts;
     if ("strict" in opts)
       throw new Error("options.strict was renamed to lowS");
-    if (format2 !== undefined && format2 !== "compact" && format2 !== "der")
-      throw new Error("format must be compact or der");
-    const isHex2 = typeof sg === "string" || isBytes2(sg);
+    if (format2 !== undefined && !["compact", "der", "js"].includes(format2))
+      throw new Error('format must be "compact", "der" or "js"');
+    const isHex2 = typeof sg === "string" || isBytes(sg);
     const isObj = !isHex2 && !format2 && typeof sg === "object" && sg !== null && typeof sg.r === "bigint" && typeof sg.s === "bigint";
     if (!isHex2 && !isObj)
       throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
     let _sig = undefined;
     let P5;
     try {
-      if (isObj)
-        _sig = new Signature(sg.r, sg.s);
+      if (isObj) {
+        if (format2 === undefined || format2 === "js") {
+          _sig = new Signature(sg.r, sg.s);
+        } else {
+          throw new Error("invalid format");
+        }
+      }
       if (isHex2) {
         try {
           if (format2 !== "compact")
@@ -236524,28 +236548,77 @@ function weierstrass(curveDef) {
     if (lowS && _sig.hasHighS())
       return false;
     if (prehash)
-      msgHash = CURVE.hash(msgHash);
+      msgHash = ecdsaOpts.hash(msgHash);
     const { r: r6, s: s7 } = _sig;
     const h8 = bits2int_modN(msgHash);
-    const is = invN(s7);
-    const u1 = modN(h8 * is);
-    const u22 = modN(r6 * is);
-    const R7 = Point.BASE.multiplyAndAddUnsafe(P5, u1, u22)?.toAffine();
-    if (!R7)
+    const is = Fn.inv(s7);
+    const u1 = Fn.create(h8 * is);
+    const u22 = Fn.create(r6 * is);
+    const R7 = Point.BASE.multiplyUnsafe(u1).add(P5.multiplyUnsafe(u22));
+    if (R7.is0())
       return false;
-    const v6 = modN(R7.x);
+    const v6 = Fn.create(R7.x);
     return v6 === r6;
   }
-  return {
-    CURVE,
+  return Object.freeze({
     getPublicKey,
     getSharedSecret,
     sign,
     verify,
-    ProjectivePoint: Point,
-    Signature,
-    utils
-  };
+    utils,
+    Point,
+    Signature
+  });
+}
+function _weierstrass_legacy_opts_to_new(c3) {
+  const CURVE = {
+    a: c3.a,
+    b: c3.b,
+    p: c3.Fp.ORDER,
+    n: c3.n,
+    h: c3.h,
+    Gx: c3.Gx,
+    Gy: c3.Gy
+  };
+  const Fp = c3.Fp;
+  const Fn = Field(CURVE.n, c3.nBitLength);
+  const curveOpts = {
+    Fp,
+    Fn,
+    allowedPrivateKeyLengths: c3.allowedPrivateKeyLengths,
+    allowInfinityPoint: c3.allowInfinityPoint,
+    endo: c3.endo,
+    wrapPrivateKey: c3.wrapPrivateKey,
+    isTorsionFree: c3.isTorsionFree,
+    clearCofactor: c3.clearCofactor,
+    fromBytes: c3.fromBytes,
+    toBytes: c3.toBytes
+  };
+  return { CURVE, curveOpts };
+}
+function _ecdsa_legacy_opts_to_new(c3) {
+  const { CURVE, curveOpts } = _weierstrass_legacy_opts_to_new(c3);
+  const ecdsaOpts = {
+    hash: c3.hash,
+    hmac: c3.hmac,
+    randomBytes: c3.randomBytes,
+    lowS: c3.lowS,
+    bits2int: c3.bits2int,
+    bits2int_modN: c3.bits2int_modN
+  };
+  return { CURVE, curveOpts, ecdsaOpts };
+}
+function _ecdsa_new_output_to_legacy(c3, ecdsa2) {
+  return Object.assign({}, ecdsa2, {
+    ProjectivePoint: ecdsa2.Point,
+    CURVE: c3
+  });
+}
+function weierstrass(c3) {
+  const { CURVE, curveOpts, ecdsaOpts } = _ecdsa_legacy_opts_to_new(c3);
+  const Point = weierstrassN(CURVE, curveOpts);
+  const signs = ecdsa(Point, ecdsaOpts, curveOpts);
+  return _ecdsa_new_output_to_legacy(c3, signs);
 }
 function SWUFpSqrtRatio(Fp, Z4) {
   const q6 = Fp.ORDER;
@@ -236611,28 +236684,29 @@ function SWUFpSqrtRatio(Fp, Z4) {
 }
 function mapToCurveSimpleSWU(Fp, opts) {
   validateField(Fp);
-  if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))
+  const { A: A5, B: B4, Z: Z4 } = opts;
+  if (!Fp.isValid(A5) || !Fp.isValid(B4) || !Fp.isValid(Z4))
     throw new Error("mapToCurveSimpleSWU: invalid opts");
-  const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);
+  const sqrtRatio = SWUFpSqrtRatio(Fp, Z4);
   if (!Fp.isOdd)
-    throw new Error("Fp.isOdd is not implemented!");
+    throw new Error("Field does not have .isOdd()");
   return (u6) => {
     let tv1, tv2, tv3, tv4, tv5, tv6, x6, y4;
     tv1 = Fp.sqr(u6);
-    tv1 = Fp.mul(tv1, opts.Z);
+    tv1 = Fp.mul(tv1, Z4);
     tv2 = Fp.sqr(tv1);
     tv2 = Fp.add(tv2, tv1);
     tv3 = Fp.add(tv2, Fp.ONE);
-    tv3 = Fp.mul(tv3, opts.B);
-    tv4 = Fp.cmov(opts.Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO));
-    tv4 = Fp.mul(tv4, opts.A);
+    tv3 = Fp.mul(tv3, B4);
+    tv4 = Fp.cmov(Z4, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO));
+    tv4 = Fp.mul(tv4, A5);
     tv2 = Fp.sqr(tv3);
     tv6 = Fp.sqr(tv4);
-    tv5 = Fp.mul(tv6, opts.A);
+    tv5 = Fp.mul(tv6, A5);
     tv2 = Fp.add(tv2, tv5);
     tv2 = Fp.mul(tv2, tv3);
     tv6 = Fp.mul(tv6, tv4);
-    tv5 = Fp.mul(tv6, opts.B);
+    tv5 = Fp.mul(tv6, B4);
     tv2 = Fp.add(tv2, tv5);
     x6 = Fp.mul(tv1, tv3);
     const { isValid, value: value4 } = sqrtRatio(tv2, tv6);
@@ -236649,9 +236723,10 @@ function mapToCurveSimpleSWU(Fp, opts) {
 }
 var DERErr, DER, _0n5, _1n5, _2n3, _3n2, _4n2;
 var init_weierstrass = __esm(() => {
+  init_hmac();
+  init_utils3();
   init_curve();
   init_modular();
-  init_utils3();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   DERErr = class DERErr extends Error {
     constructor(m7 = "") {
@@ -236759,20 +236834,11 @@ var init_weierstrass = __esm(() => {
 });
 
 // ../../node_modules/@noble/curves/esm/_shortw_utils.js
-function getHash(hash2) {
-  return {
-    hash: hash2,
-    hmac: (key2, ...msgs) => hmac(hash2, key2, concatBytes(...msgs)),
-    randomBytes
-  };
-}
 function createCurve(curveDef, defHash) {
-  const create2 = (hash2) => weierstrass({ ...curveDef, ...getHash(hash2) });
+  const create2 = (hash2) => weierstrass({ ...curveDef, hash: hash2 });
   return { ...create2(defHash), create: create2 };
 }
 var init__shortw_utils = __esm(() => {
-  init_hmac();
-  init_utils2();
   init_weierstrass();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 });
@@ -236802,52 +236868,55 @@ function anum(item) {
     throw new Error("number expected");
 }
 function expand_message_xmd(msg, DST, lenInBytes, H4) {
-  abytes2(msg);
-  abytes2(DST);
+  abytes(msg);
+  abytes(DST);
   anum(lenInBytes);
   if (DST.length > 255)
-    DST = H4(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
+    DST = H4(concatBytes(utf8ToBytes("H2C-OVERSIZE-DST-"), DST));
   const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H4;
   const ell = Math.ceil(lenInBytes / b_in_bytes);
   if (lenInBytes > 65535 || ell > 255)
     throw new Error("expand_message_xmd: invalid lenInBytes");
-  const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
+  const DST_prime = concatBytes(DST, i2osp(DST.length, 1));
   const Z_pad = i2osp(0, r_in_bytes);
   const l_i_b_str = i2osp(lenInBytes, 2);
   const b4 = new Array(ell);
-  const b_0 = H4(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
-  b4[0] = H4(concatBytes3(b_0, i2osp(1, 1), DST_prime));
+  const b_0 = H4(concatBytes(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
+  b4[0] = H4(concatBytes(b_0, i2osp(1, 1), DST_prime));
   for (let i6 = 1;i6 <= ell; i6++) {
     const args = [strxor(b_0, b4[i6 - 1]), i2osp(i6 + 1, 1), DST_prime];
-    b4[i6] = H4(concatBytes3(...args));
+    b4[i6] = H4(concatBytes(...args));
   }
-  const pseudo_random_bytes = concatBytes3(...b4);
+  const pseudo_random_bytes = concatBytes(...b4);
   return pseudo_random_bytes.slice(0, lenInBytes);
 }
 function expand_message_xof(msg, DST, lenInBytes, k5, H4) {
-  abytes2(msg);
-  abytes2(DST);
+  abytes(msg);
+  abytes(DST);
   anum(lenInBytes);
   if (DST.length > 255) {
     const dkLen = Math.ceil(2 * k5 / 8);
-    DST = H4.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
+    DST = H4.create({ dkLen }).update(utf8ToBytes("H2C-OVERSIZE-DST-")).update(DST).digest();
   }
   if (lenInBytes > 65535 || DST.length > 255)
     throw new Error("expand_message_xof: invalid lenInBytes");
   return H4.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
 }
 function hash_to_field(msg, count, options) {
-  validateObject(options, {
-    DST: "stringOrUint8Array",
+  _validateObject(options, {
     p: "bigint",
-    m: "isSafeInteger",
-    k: "isSafeInteger",
-    hash: "hash"
+    m: "number",
+    k: "number",
+    hash: "function"
   });
   const { p: p5, k: k5, m: m7, hash: hash2, expand, DST: _DST } = options;
-  abytes2(msg);
+  if (!isBytes(_DST) && typeof _DST !== "string")
+    throw new Error("DST must be string or uint8array");
+  if (!isHash(options.hash))
+    throw new Error("expected valid hash");
+  abytes(msg);
   anum(count);
-  const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
+  const DST = typeof _DST === "string" ? utf8ToBytes(_DST) : _DST;
   const log2p = p5.toString(2).length;
   const L5 = Math.ceil((log2p + k5) / 8);
   const len_in_bytes = count * m7 * L5;
@@ -236899,13 +236968,17 @@ function createHasher2(Point, mapToCurve, defaults4) {
   return {
     defaults: defaults4,
     hashToCurve(msg, options) {
-      const u6 = hash_to_field(msg, 2, { ...defaults4, DST: defaults4.DST, ...options });
+      const dst = defaults4.DST ? defaults4.DST : {};
+      const opts = Object.assign({}, defaults4, dst, options);
+      const u6 = hash_to_field(msg, 2, opts);
       const u0 = map6(u6[0]);
       const u1 = map6(u6[1]);
       return clear(u0.add(u1));
     },
     encodeToCurve(msg, options) {
-      const u6 = hash_to_field(msg, 1, { ...defaults4, DST: defaults4.encodeDST, ...options });
+      const dst = defaults4.encodeDST ? defaults4.encodeDST : {};
+      const opts = Object.assign({}, defaults4, dst, options);
+      const u6 = hash_to_field(msg, 1, opts);
       return clear(map6(u6[0]));
     },
     mapToCurve(scalars) {
@@ -236920,8 +236993,8 @@ function createHasher2(Point, mapToCurve, defaults4) {
 }
 var os2ip;
 var init_hash_to_curve = __esm(() => {
-  init_modular();
   init_utils3();
+  init_modular();
   os2ip = bytesToNumberBE;
 });
 
@@ -236935,7 +237008,7 @@ __export(exports_secp256k1, {
   encodeToCurve: () => encodeToCurve
 });
 function sqrtMod(y4) {
-  const P5 = secp256k1P;
+  const P5 = secp256k1_CURVE.p;
   const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
   const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
   const b22 = y4 * y4 * y4 % P5;
@@ -236960,25 +237033,25 @@ function taggedHash(tag, ...messages) {
   let tagP = TAGGED_HASH_PREFIXES[tag];
   if (tagP === undefined) {
     const tagH = sha256(Uint8Array.from(tag, (c3) => c3.charCodeAt(0)));
-    tagP = concatBytes3(tagH, tagH);
+    tagP = concatBytes(tagH, tagH);
     TAGGED_HASH_PREFIXES[tag] = tagP;
   }
-  return sha256(concatBytes3(tagP, ...messages));
+  return sha256(concatBytes(tagP, ...messages));
 }
 function schnorrGetExtPubKey(priv) {
   let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
   let p5 = Point.fromPrivateKey(d_);
-  const scalar = p5.hasEvenY() ? d_ : modN(-d_);
+  const scalar = hasEven(p5.y) ? d_ : modN(-d_);
   return { scalar, bytes: pointToBytes(p5) };
 }
 function lift_x(x6) {
-  aInRange("x", x6, _1n6, secp256k1P);
+  aInRange("x", x6, _1n6, secp256k1_CURVE.p);
   const xx = modP(x6 * x6);
   const c3 = modP(xx * x6 + BigInt(7));
   let y4 = sqrtMod(c3);
-  if (y4 % _2n4 !== _0n6)
+  if (!hasEven(y4))
     y4 = modP(-y4);
-  const p5 = new Point(x6, y4, _1n6);
+  const p5 = Point.fromAffine({ x: x6, y: y4 });
   p5.assertValidity();
   return p5;
 }
@@ -237013,49 +237086,52 @@ function schnorrVerify(signature, message, publicKey) {
   try {
     const P5 = lift_x(num(pub));
     const r6 = num(sig.subarray(0, 32));
-    if (!inRange(r6, _1n6, secp256k1P))
+    if (!inRange(r6, _1n6, secp256k1_CURVE.p))
       return false;
     const s7 = num(sig.subarray(32, 64));
-    if (!inRange(s7, _1n6, secp256k1N))
+    if (!inRange(s7, _1n6, secp256k1_CURVE.n))
       return false;
     const e10 = challenge(numTo32b(r6), pointToBytes(P5), m7);
-    const R7 = GmulAdd(P5, s7, modN(-e10));
-    if (!R7 || !R7.hasEvenY() || R7.toAffine().x !== r6)
+    const R7 = Point.BASE.multiplyUnsafe(s7).add(P5.multiplyUnsafe(modN(-e10)));
+    const { x: x6, y: y4 } = R7.toAffine();
+    if (R7.is0() || !hasEven(y4) || x6 !== r6)
       return false;
     return true;
   } catch (error44) {
     return false;
   }
 }
-var secp256k1P, secp256k1N, _0n6, _1n6, _2n4, divNearest = (a7, b4) => (a7 + b4 / _2n4) / b4, Fpk1, secp256k1, TAGGED_HASH_PREFIXES, pointToBytes = (point) => point.toRawBytes(true).slice(1), numTo32b = (n6) => numberToBytesBE(n6, 32), modP = (x6) => mod(x6, secp256k1P), modN = (x6) => mod(x6, secp256k1N), Point, GmulAdd = (Q4, a7, b4) => Point.BASE.multiplyAndAddUnsafe(Q4, a7, b4), num, schnorr, isoMap, mapSWU, secp256k1_hasher, hashToCurve, encodeToCurve;
+var secp256k1_CURVE, _0n6, _1n6, _2n4, divNearest = (a7, b4) => (a7 + b4 / _2n4) / b4, Fpk1, secp256k1, TAGGED_HASH_PREFIXES, pointToBytes = (point) => point.toBytes(true).slice(1), numTo32b = (n6) => numberToBytesBE(n6, 32), modP = (x6) => mod(x6, secp256k1_CURVE.p), modN = (x6) => mod(x6, secp256k1_CURVE.n), Point, hasEven = (y4) => y4 % _2n4 === _0n6, num, schnorr, isoMap, mapSWU, secp256k1_hasher, hashToCurve, encodeToCurve;
 var init_secp256k1 = __esm(() => {
   init_sha2();
   init_utils2();
   init__shortw_utils();
   init_hash_to_curve();
   init_modular();
-  init_utils3();
   init_weierstrass();
+  init_utils3();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
-  secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
+  secp256k1_CURVE = {
+    p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
+    n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
+    h: BigInt(1),
+    a: BigInt(0),
+    b: BigInt(7),
+    Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
+    Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
+  };
   _0n6 = BigInt(0);
   _1n6 = BigInt(1);
   _2n4 = BigInt(2);
-  Fpk1 = Field(secp256k1P, undefined, undefined, { sqrt: sqrtMod });
+  Fpk1 = Field(secp256k1_CURVE.p, undefined, undefined, { sqrt: sqrtMod });
   secp256k1 = createCurve({
-    a: _0n6,
-    b: BigInt(7),
+    ...secp256k1_CURVE,
     Fp: Fpk1,
-    n: secp256k1N,
-    Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
-    Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
-    h: BigInt(1),
     lowS: true,
     endo: {
       beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
       splitScalar: (k5) => {
-        const n6 = secp256k1N;
+        const n6 = secp256k1_CURVE.n;
         const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
         const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
         const a22 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
@@ -237079,7 +237155,7 @@ var init_secp256k1 = __esm(() => {
     }
   }, sha256);
   TAGGED_HASH_PREFIXES = {};
-  Point = /* @__PURE__ */ (() => secp256k1.ProjectivePoint)();
+  Point = /* @__PURE__ */ (() => secp256k1.Point)();
   num = bytesToNumberBE;
   schnorr = /* @__PURE__ */ (() => ({
     getPublicKey: schnorrGetPublicKey,
@@ -237125,7 +237201,7 @@ var init_secp256k1 = __esm(() => {
     B: BigInt("1771"),
     Z: Fpk1.create(BigInt("-11"))
   }))();
-  secp256k1_hasher = /* @__PURE__ */ (() => createHasher2(secp256k1.ProjectivePoint, (scalars) => {
+  secp256k1_hasher = /* @__PURE__ */ (() => createHasher2(secp256k1.Point, (scalars) => {
     const { x: x6, y: y4 } = mapSWU(Fpk1.create(scalars[0]));
     return isoMap(x6, y4);
   }, {
@@ -263764,7 +263840,7 @@ function pruneCurrentEnv(currentEnv, env2) {
 var package_default = {
   name: "@settlemint/sdk-cli",
   description: "Command-line interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "2.3.14-prfdf11875",
+  version: "2.4.0-main005a9b57",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -263813,9 +263889,10 @@ var package_default = {
     "@inquirer/input": "4.1.12",
     "@inquirer/password": "4.0.15",
     "@inquirer/select": "4.2.3",
-    "@settlemint/sdk-js": "2.3.14-prfdf11875",
-    "@settlemint/sdk-utils": "2.3.14-prfdf11875",
-    "@types/node": "24.0.0",
+    "@settlemint/sdk-js": "2.4.0-main005a9b57",
+    "@settlemint/sdk-utils": "2.4.0-main005a9b57",
+    "@settlemint/sdk-viem": "2.4.0-main005a9b57",
+    "@types/node": "24.0.1",
     "@types/semver": "7.7.0",
     "@types/which": "3.0.4",
     "get-tsconfig": "4.10.1",
@@ -263823,13 +263900,13 @@ var package_default = {
     "is-in-ci": "1.0.0",
     semver: "7.7.2",
     slugify: "1.6.6",
-    viem: "2.31.0",
+    viem: "2.31.2",
     which: "5.0.0",
     yaml: "2.8.0",
     yoctocolors: "2.1.1"
   },
   peerDependencies: {
-    hardhat: "2.24.2"
+    hardhat: "2.24.3"
   },
   peerDependenciesMeta: {
     hardhat: {
@@ -295792,6 +295869,17 @@ async function exists3(path$1) {
     return false;
   }
 }
+function tryParseJson3(value2, defaultValue = null) {
+  try {
+    const parsed = JSON.parse(value2);
+    if (parsed === undefined || parsed === null) {
+      return defaultValue;
+    }
+    return parsed;
+  } catch (err) {
+    return defaultValue;
+  }
+}
 var require_balanced_match4 = __commonJS4({ "../../node_modules/balanced-match/index.js"(exports, module) {
   module.exports = balanced$1;
   function balanced$1(a3, b, str) {
@@ -301270,9 +301358,45 @@ var glob3 = Object.assign(glob_3, {
   unescape: unescape4
 });
 glob3.glob = glob3;
+async function findMonoRepoRoot2(startDir) {
+  const lockFilePath = await findUp([
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "bun.lockb",
+    "bun.lock"
+  ], { cwd: startDir });
+  if (lockFilePath) {
+    const packageJsonPath = join3(dirname3(lockFilePath), "package.json");
+    const hasWorkSpaces = await packageJsonHasWorkspaces2(packageJsonPath);
+    return hasWorkSpaces ? dirname3(lockFilePath) : null;
+  }
+  let currentDir = startDir;
+  while (currentDir !== "/") {
+    const packageJsonPath = join3(currentDir, "package.json");
+    if (await packageJsonHasWorkspaces2(packageJsonPath)) {
+      return currentDir;
+    }
+    const parentDir = dirname3(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return null;
+}
+async function packageJsonHasWorkspaces2(packageJsonPath) {
+  if (await exists3(packageJsonPath)) {
+    const packageJson = tryParseJson3(await readFile3(packageJsonPath, "utf-8"));
+    if (packageJson?.workspaces && Array.isArray(packageJson?.workspaces) && packageJson?.workspaces.length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
 
 // ../utils/dist/json.js
-function tryParseJson3(value2, defaultValue = null) {
+function tryParseJson4(value2, defaultValue = null) {
   try {
     const parsed = JSON.parse(value2);
     if (parsed === undefined || parsed === null) {
@@ -301291,7 +301415,7 @@ function extractJsonObject(value2) {
   if (!result) {
     return null;
   }
-  return tryParseJson3(result[0]);
+  return tryParseJson4(result[0]);
 }
 
 // src/utils/config.ts
@@ -301306,7 +301430,7 @@ async function readConfig() {
   await ensureConfigDir();
   try {
     const content = await readFile4(CONFIG_FILE, "utf-8");
-    return tryParseJson3(content, { instances: {} });
+    return tryParseJson4(content, { instances: {} });
   } catch (error41) {
     return { instances: {} };
   }
@@ -304887,8 +305011,11 @@ function observe(observerId, callbacks, fn) {
     if (!listeners2.some((cb) => cb.id === callbackId))
       return;
     const cleanup2 = cleanupCache.get(observerId);
-    if (listeners2.length === 1 && cleanup2)
-      cleanup2();
+    if (listeners2.length === 1 && cleanup2) {
+      const p5 = cleanup2();
+      if (p5 instanceof Promise)
+        p5.catch(() => {});
+    }
     unsubscribe();
   };
   const listeners = getListeners();
@@ -307067,7 +307194,7 @@ async function simulateBlocks(client, parameters) {
             return;
           return getContractError(error45, {
             abi: abi2 ?? [],
-            address: to,
+            address: to ?? "0x",
             args,
             functionName: functionName ?? "<unknown>"
           });
@@ -308009,14 +308136,6 @@ async function simulateCalls(client, parameters) {
     });
     return accessList.map(({ address, storageKeys }) => storageKeys.length > 0 ? address : null);
   })).then((x6) => x6.flat().filter(Boolean)) : [];
-  const resultsStateOverrides = stateOverrides?.map((override) => {
-    if (override.address === account?.address)
-      return {
-        ...override,
-        nonce: 0
-      };
-    return override;
-  });
   const blocks = await simulateBlocks(client, {
     blockNumber,
     blockTag,
@@ -308046,12 +308165,11 @@ async function simulateCalls(client, parameters) {
         }
       ] : [],
       {
-        calls: [...calls, {}].map((call2, index2) => ({
+        calls: [...calls, {}].map((call2) => ({
           ...call2,
-          from: account?.address,
-          nonce: index2
+          from: account?.address
         })),
-        stateOverrides: resultsStateOverrides
+        stateOverrides
       },
       ...traceAssetChanges ? [
         {
@@ -308590,7 +308708,7 @@ function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBe
             if (!active)
               return;
             const block = await getAction(client, getBlock, "getBlock")({
-              blockNumber: data.blockNumber,
+              blockNumber: data.result?.number,
               includeTransactions
             }).catch(() => {});
             if (!active)
@@ -329313,9 +329431,9 @@ function hardhatTestCommand() {
   });
 }
 
-// src/utils/subgraph/setup.ts
-import { rm as rm4 } from "node:fs/promises";
-var import_semver = __toESM(require_semver2(), 1);
+// src/commands/smart-contract-set/subgraph/add.ts
+import { copyFile, mkdir as mkdir7, readFile as readFile10, unlink as unlink2, writeFile as writeFile9 } from "node:fs/promises";
+import { basename as basename5, dirname as dirname8, isAbsolute as isAbsolute2, join as join11, relative as relative4 } from "node:path";
 
 // src/utils/subgraph/subgraph-config.ts
 import { readFile as readFile9, writeFile as writeFile8 } from "node:fs/promises";
@@ -329347,7 +329465,7 @@ var updateSubgraphYamlConfig = async (config5, cwd2 = process.cwd()) => {
 var getSubgraphConfig = async (path7 = process.cwd()) => {
   try {
     const configContents = await readFile9(join10(path7, CONFIG_FILE_PATH));
-    const currentConfig = tryParseJson3(configContents.toString());
+    const currentConfig = tryParseJson4(configContents.toString());
     return currentConfig;
   } catch (err) {
     const error45 = err;
@@ -329356,7 +329474,102 @@ var getSubgraphConfig = async (path7 = process.cwd()) => {
   }
 };
 
+// src/commands/smart-contract-set/subgraph/add.ts
+var DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
+function subgraphAddCommand() {
+  return new Command("add").description("Add a contract to the subgraph").usage(createExamples([
+    {
+      description: "Add a contract to the subgraph",
+      command: "scs subgraph add --abi=./abis/bond.json --contract-name=bond"
+    }
+  ])).requiredOption("--abi <abi>", "Path to the contract ABI.").requiredOption("--contract-name <contract-name>", "Name of the contract.").option("--address <contract-address>", `Address of the contract (defaults to ${DEFAULT_ADDRESS}).`).option("--start-block <start-block>", "Start block of the contract (defaults to 0).").option("--network <network>", "Network name (defaults to settlemint).").action(async ({ abi: abi2, contractName, address, startBlock, network }) => {
+    intro(`Adding subgraph config for contract ${contractName}`);
+    const abiPath = isAbsolute2(abi2) ? abi2 : join11(process.cwd(), abi2);
+    if (!await exists3(abiPath)) {
+      throw new Error("ABI file not found");
+    }
+    await validateIfRequiredPackagesAreInstalled(["@graphprotocol/graph-cli"]);
+    if (await isGenerated()) {
+      throw new Error("This command does not support automatically generated subgraph configs");
+    }
+    const { command, args } = await getPackageManagerExecutable();
+    const subgraphYamlFile = await getSubgraphYamlFile();
+    const abiName = basename5(abiPath);
+    const subgraphYamlDir = dirname8(subgraphYamlFile);
+    await mkdir7(join11(subgraphYamlDir, "abis"), { recursive: true });
+    const localAbiPath = join11(subgraphYamlDir, "abis", abiName);
+    await copyFile(abiPath, localAbiPath);
+    try {
+      const root = await projectRoot3();
+      await fixPackageJson(root);
+      const monoRepoRoot = await findMonoRepoRoot2(root);
+      if (monoRepoRoot) {
+        await fixPackageJson(monoRepoRoot, false);
+      }
+      await executeCommand(command, [
+        ...args,
+        "graph",
+        "add",
+        "--abi",
+        abi2,
+        "--contract-name",
+        contractName,
+        "--start-block",
+        startBlock ?? "0",
+        address ?? DEFAULT_ADDRESS,
+        subgraphYamlFile
+      ]);
+      const subgraphYamlConfig = await getSubgraphYamlConfig();
+      if (subgraphYamlConfig) {
+        const updatedDataSources = subgraphYamlConfig?.dataSources.map((dataSource) => {
+          if (dataSource.name === contractName) {
+            dataSource.network = network ?? "settlemint";
+            dataSource.mapping.abis = [
+              {
+                name: contractName,
+                file: relative4(subgraphYamlDir, abiPath)
+              }
+            ];
+          }
+          return dataSource;
+        });
+        await updateSubgraphYamlConfig({
+          ...subgraphYamlConfig,
+          dataSources: updatedDataSources
+        });
+      }
+    } finally {
+      await unlink2(localAbiPath);
+    }
+    outro(`Subgraph config for contract ${contractName} added successfully`);
+  });
+}
+async function fixPackageJson(packageJsonDir, requiresCodegenScript = true) {
+  const packageJsonPath = join11(packageJsonDir, "package.json");
+  if (!await exists3(packageJsonPath)) {
+    return;
+  }
+  let hasPackageJsonChanged = false;
+  const subgraphPackageJson = await readFile10(packageJsonPath);
+  const subgraphPackageJsonData = JSON.parse(subgraphPackageJson.toString());
+  if (subgraphPackageJsonData.packageManager?.includes("bun")) {
+    note("Removing package manager from package.json (bun is not an official package manager)");
+    delete subgraphPackageJsonData.packageManager;
+    hasPackageJsonChanged = true;
+  }
+  if (requiresCodegenScript && !subgraphPackageJsonData.scripts?.codegen) {
+    note("Adding codegen script to package.json");
+    subgraphPackageJsonData.scripts.codegen = "settlemint scs subgraph codegen";
+    hasPackageJsonChanged = true;
+  }
+  if (hasPackageJsonChanged) {
+    await writeFile9(packageJsonPath, JSON.stringify(subgraphPackageJsonData, null, 2));
+  }
+}
+
 // src/utils/subgraph/setup.ts
+import { rm as rm4 } from "node:fs/promises";
+var import_semver = __toESM(require_semver2(), 1);
 var SETTLEMINT_NETWORK = "settlemint";
 async function subgraphSetup({ network }) {
   const generated = await isGenerated();
@@ -329746,6 +329959,7 @@ function smartContractSetCommand() {
   hardhat.addCommand(hardhatScriptCommand());
   hardhat.addCommand(hardhatTestCommand());
   const subgraph = new Command("subgraph").alias("sg").enablePositionalOptions().description("Commands for managing TheGraph subgraphs for smart contract indexing");
+  subgraph.addCommand(subgraphAddCommand());
   subgraph.addCommand(subgraphBuildCommand());
   subgraph.addCommand(subgraphCodegenCommand());
   subgraph.addCommand(subgraphDeployCommand());
@@ -329875,4 +330089,4 @@ async function sdkCliCommand(argv = process.argv) {
 // src/cli.ts
 sdkCliCommand();
 
-//# debugId=4DCFE5EBE8F6591364756E2164756E21
+//# debugId=54A153F5116DB2FB64756E2164756E21