@settlemint/sdk-cli 2.4.0-prfdc1cdc0 → 2.4.0

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/eciesjs/node_modules/@noble/curves/abstract/utils.js
+// ../../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/eciesjs/node_modules/@noble/curves/abstract/modular.js
+// ../../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/eciesjs/node_modules/@noble/curves/abstract/curve.js
+// ../../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/eciesjs/node_modules/@noble/curves/abstract/edwards.js
+// ../../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/eciesjs/node_modules/@noble/curves/abstract/hash-to-curve.js
+// ../../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/eciesjs/node_modules/@noble/curves/abstract/montgomery.js
+// ../../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/eciesjs/node_modules/@noble/curves/ed25519.js
+// ../../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/eciesjs/node_modules/@noble/curves/abstract/weierstrass.js
+// ../../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/eciesjs/node_modules/@noble/curves/_shortw_utils.js
+// ../../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/eciesjs/node_modules/@noble/curves/secp256k1.js
+// ../../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;
@@ -231623,7 +231623,7 @@ function size(value4) {
 var init_size = () => {};
 
 // ../../node_modules/viem/_esm/errors/version.js
-var version5 = "2.31.2";
+var version5 = "2.31.1";
 
 // ../../node_modules/viem/_esm/errors/base.js
 function walk(err, fn) {
@@ -232421,46 +232421,6 @@ 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");
@@ -232507,15 +232467,12 @@ function randomBytes(bytesLength = 32) {
   }
   throw new Error("crypto.getRandomValues must be defined");
 }
-var isLE, swap32IfBE, hasHexBuiltin, hexes2, asciis;
+var isLE, swap32IfBE;
 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
@@ -235181,7 +235138,14 @@ var init_hmac = __esm(() => {
   hmac.create = (hash2, key2) => new HMAC(hash2, key2);
 });
 
-// ../../node_modules/@noble/curves/esm/utils.js
+// ../../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");
+}
 function abool(title, value4) {
   if (typeof value4 !== "boolean")
     throw new Error(title + " boolean expected, got " + value4);
@@ -235195,11 +235159,51 @@ 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) {
-  abytes(bytes);
+  abytes2(bytes);
   return hexToNumber2(bytesToHex2(Uint8Array.from(bytes).reverse()));
 }
 function numberToBytesBE(n6, len) {
@@ -235216,7 +235220,7 @@ function ensureBytes(title, hex, expectedLength) {
     } catch (e10) {
       throw new Error(title + " must be hex string or Uint8Array, cause: " + e10);
     }
-  } else if (isBytes(hex)) {
+  } else if (isBytes2(hex)) {
     res = Uint8Array.from(hex);
   } else {
     throw new Error(title + " must be hex string or Uint8Array");
@@ -235226,6 +235230,26 @@ 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;
 }
@@ -235246,8 +235270,6 @@ 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;
@@ -235258,11 +235280,11 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   };
   const h8 = (...b4) => hmacFn(k5, v6, ...b4);
   const reseed = (seed = u8n(0)) => {
-    k5 = h8(u8of(0), seed);
+    k5 = h8(u8fr([0]), seed);
     v6 = h8();
     if (seed.length === 0)
       return;
-    k5 = h8(u8of(1), seed);
+    k5 = h8(u8fr([1]), seed);
     v6 = h8();
   };
   const gen2 = () => {
@@ -235276,7 +235298,7 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
       out.push(sl);
       len += v6.length;
     }
-    return concatBytes(...out);
+    return concatBytes3(...out);
   };
   const genUntil = (seed, pred) => {
     reset2();
@@ -235289,22 +235311,23 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   };
   return genUntil;
 }
-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) {
+function validateObject(object4, validators, optValidators = {}) {
+  const checkField = (fieldName, type4, isOptional) => {
+    const checkVal = validatorFns[type4];
+    if (typeof checkVal !== "function")
+      throw new Error("invalid validator function");
     const val = object4[fieldName];
-    if (isOpt && val === undefined)
+    if (isOptional && val === undefined)
       return;
-    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));
+    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;
 }
 function memoized(fn) {
   const map6 = new WeakMap;
@@ -235317,13 +235340,25 @@ function memoized(fn) {
     return computed;
   };
 }
-var _0n2, _1n2, isPosBig = (n6) => typeof n6 === "bigint" && _0n2 <= n6, bitMask = (n6) => (_1n2 << BigInt(n6)) - _1n2;
+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 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
@@ -235437,15 +235472,14 @@ function validateField(field2) {
   const initial = {
     ORDER: "bigint",
     MASK: "bigint",
-    BYTES: "number",
-    BITS: "number"
+    BYTES: "isSafeInteger",
+    BITS: "isSafeInteger"
   };
   const opts = FIELD_FIELDS.reduce((map6, val) => {
     map6[val] = "function";
     return map6;
   }, initial);
-  _validateObject(field2, opts);
-  return field2;
+  return validateObject(field2, opts);
 }
 function FpPow(Fp, num, power) {
   if (power < _0n3)
@@ -235498,28 +235532,10 @@ function nLength(n6, nBitLength) {
   const nByteLength = Math.ceil(_nBitLength / 8);
   return { nBitLength: _nBitLength, nByteLength };
 }
-function Field(ORDER, bitLenOrOpts, isLE2 = false, opts = {}) {
+function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
   if (ORDER <= _0n3)
     throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
-  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);
+  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
   if (BYTES > 2048)
     throw new Error("invalid field: expected ORDER of <= 2048 bytes");
   let sqrtP;
@@ -235538,7 +235554,6 @@ function Field(ORDER, bitLenOrOpts, isLE2 = false, opts = {}) {
       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,
@@ -235553,7 +235568,7 @@ function Field(ORDER, bitLenOrOpts, isLE2 = false, opts = {}) {
     subN: (lhs, rhs) => lhs - rhs,
     mulN: (lhs, rhs) => lhs * rhs,
     inv: (num) => invert(num, ORDER),
-    sqrt: _sqrt || ((n6) => {
+    sqrt: redef.sqrt || ((n6) => {
       if (!sqrtP)
         sqrtP = FpSqrt(ORDER);
       return sqrtP(f5, n6);
@@ -235591,6 +235606,7 @@ 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);
@@ -235622,16 +235638,10 @@ var init_modular = __esm(() => {
 });
 
 // ../../node_modules/@noble/curves/esm/abstract/curve.js
-function negateCt(condition, item) {
+function constTimeNegate(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);
@@ -235680,13 +235690,9 @@ 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: negateCt,
+    constTimeNegate,
     hasPrecomputes(elm) {
       return getW(elm) !== 1;
     },
@@ -235724,12 +235730,11 @@ function wNAF(c3, bits) {
         const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n6, window2, wo);
         n6 = nextN;
         if (isZero) {
-          f5 = f5.add(negateCt(isNegF, precomputes[offsetF]));
+          f5 = f5.add(constTimeNegate(isNegF, precomputes[offsetF]));
         } else {
-          p5 = p5.add(negateCt(isNeg, precomputes[offset]));
+          p5 = p5.add(constTimeNegate(isNeg, precomputes[offset]));
         }
       }
-      assert0(n6);
       return { p: p5, f: f5 };
     },
     wNAFUnsafe(W5, precomputes, n6, acc = c3.ZERO) {
@@ -235746,18 +235751,14 @@ 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) {
-          if (typeof transform5 === "function")
-            comp = transform5(comp);
-          pointPrecomputes.set(P5, comp);
-        }
+        if (W5 !== 1)
+          pointPrecomputes.set(P5, transform5(comp));
       }
       return comp;
     },
@@ -235778,21 +235779,6 @@ 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);
@@ -235832,38 +235818,27 @@ function pippenger(c3, fieldN, points, scalars) {
   }
   return sum;
 }
-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 };
+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 }
+  });
 }
 var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
 var init_curve = __esm(() => {
-  init_utils3();
   init_modular();
+  init_utils3();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   _0n4 = BigInt(0);
   _1n4 = BigInt(1);
@@ -235878,116 +235853,54 @@ function validateSigVerOpts(opts) {
   if (opts.prehash !== undefined)
     abool("prehash", opts.prehash);
 }
-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, {}, {
+function validatePointOpts(curve) {
+  const opts = validateBasic(curve);
+  validateObject(opts, {
+    a: "field",
+    b: "field"
+  }, {
     allowInfinityPoint: "boolean",
+    allowedPrivateKeyLengths: "array",
     clearCofactor: "function",
-    isTorsionFree: "function",
     fromBytes: "function",
+    isTorsionFree: "function",
     toBytes: "function",
-    endo: "object",
     wrapPrivateKey: "boolean"
   });
-  const { endo } = curveOpts;
+  const { endo, Fp, a: a7 } = opts;
   if (endo) {
-    if (!Fp.is0(CURVE.a) || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
-      throw new Error('invalid endo: expected "beta": bigint and "splitScalar": function');
+    if (!Fp.eql(a7, Fp.ZERO)) {
+      throw new Error("invalid endo: CURVE.a must be 0");
     }
-  }
-  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));
+    if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
+      throw new Error('invalid endo: expected "beta": bigint and "splitScalar": function');
     }
   }
-  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];
+  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) => {
     const tail = bytes.subarray(1);
-    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 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);
   }
-  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);
@@ -235999,10 +235912,28 @@ function weierstrassN(CURVE, curveOpts = {}) {
   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 acoord(title, n6, banZero = false) {
-    if (!Fp.isValid(n6) || banZero && Fp.is0(n6))
-      throw new Error(`bad point coordinate ${title}`);
-    return n6;
+  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 aprjpoint(other) {
     if (!(other instanceof Point))
@@ -236026,31 +235957,31 @@ function weierstrassN(CURVE, curveOpts = {}) {
   });
   const assertValidMemo = memoized((p5) => {
     if (p5.is0()) {
-      if (curveOpts.allowInfinityPoint && !Fp.is0(p5.py))
+      if (CURVE.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 field elements");
+      throw new Error("bad point: x or y not FE");
     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) {
-      this.px = acoord("x", px);
-      this.py = acoord("y", py, true);
-      this.pz = acoord("z", 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;
       Object.freeze(this);
     }
     static fromAffine(p5) {
@@ -236059,7 +235990,8 @@ function weierstrassN(CURVE, curveOpts = {}) {
         throw new Error("invalid affine point");
       if (p5 instanceof Point)
         throw new Error("projective point not allowed");
-      if (Fp.is0(x6) && Fp.is0(y4))
+      const is0 = (i6) => Fp.eql(i6, Fp.ZERO);
+      if (is0(x6) && is0(y4))
         return Point.ZERO;
       return new Point(x6, y4, Fp.ONE);
     }
@@ -236070,11 +236002,8 @@ function weierstrassN(CURVE, curveOpts = {}) {
       return this.toAffine().y;
     }
     static normalizeZ(points) {
-      return normalizeZ(Point, "pz", points);
-    }
-    static fromBytes(bytes) {
-      abytes(bytes);
-      return Point.fromHex(bytes);
+      const toInv = FpInvertBatch(Fp, points.map((p5) => p5.pz));
+      return points.map((p5, i6) => p5.toAffine(toInv[i6])).map(Point.fromAffine);
     }
     static fromHex(hex) {
       const P5 = Point.fromAffine(fromBytes(ensureBytes("pointHex", hex)));
@@ -236082,29 +236011,22 @@ function weierstrassN(CURVE, curveOpts = {}) {
       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);
     }
-    precompute(windowSize = 8, isLazy = true) {
-      wnaf.setWindowSize(this, windowSize);
-      if (!isLazy)
-        this.multiply(_3n2);
-      return this;
-    }
     _setWindowSize(windowSize) {
-      this.precompute(windowSize);
+      wnaf.setWindowSize(this, windowSize);
     }
     assertValidity() {
       assertValidMemo(this);
     }
     hasEvenY() {
       const { y: y4 } = this.toAffine();
-      if (!Fp.isOdd)
-        throw new Error("Field doesn't support isOdd");
-      return !Fp.isOdd(y4);
+      if (Fp.isOdd)
+        return !Fp.isOdd(y4);
+      throw new Error("Field doesn't support isOdd");
     }
     equals(other) {
       aprjpoint(other);
@@ -236210,121 +236132,188 @@ function weierstrassN(CURVE, curveOpts = {}) {
     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 } = curveOpts;
-      if (!Fn.isValidNot0(scalar))
-        throw new Error("invalid scalar: out of range");
+      const { endo: endo2, n: N6 } = CURVE;
+      aInRange("scalar", scalar, _1n5, N6);
       let point, fake;
-      const mul = (n6) => wnaf.wNAFCached(this, n6, Point.normalizeZ);
       if (endo2) {
         const { k1neg, k1, k2neg, k2: k22 } = endo2.splitScalar(scalar);
-        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);
+        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);
       } else {
-        const { p: p5, f: f5 } = mul(scalar);
+        const { p: p5, f: f5 } = this.wNAF(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 sum = this.multiplyUnsafe(a7).add(Q4.multiplyUnsafe(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));
       return sum.is0() ? undefined : sum;
     }
-    toAffine(invertedZ) {
-      return toAffineMemo(this, invertedZ);
+    toAffine(iz) {
+      return toAffineMemo(this, iz);
     }
     isTorsionFree() {
-      const { isTorsionFree } = curveOpts;
+      const { h: cofactor, isTorsionFree } = CURVE;
       if (cofactor === _1n5)
         return true;
       if (isTorsionFree)
         return isTorsionFree(Point, this);
-      return wnaf.wNAFCachedUnsafe(this, CURVE_ORDER).is0();
+      throw new Error("isTorsionFree() has not been declared for the elliptic curve");
     }
     clearCofactor() {
-      const { clearCofactor } = curveOpts;
+      const { h: cofactor, clearCofactor } = CURVE;
       if (cofactor === _1n5)
         return this;
       if (clearCofactor)
         return clearCofactor(Point, this);
-      return this.multiplyUnsafe(cofactor);
+      return this.multiplyUnsafe(CURVE.h);
     }
-    toBytes(isCompressed = true) {
+    toRawBytes(isCompressed = true) {
       abool("isCompressed", isCompressed);
       this.assertValidity();
       return toBytes3(Point, this, isCompressed);
     }
-    toRawBytes(isCompressed = true) {
-      return this.toBytes(isCompressed);
-    }
     toHex(isCompressed = true) {
-      return bytesToHex2(this.toBytes(isCompressed));
-    }
-    toString() {
-      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+      abool("isCompressed", isCompressed);
+      return bytesToHex2(this.toRawBytes(isCompressed));
     }
   }
   Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
   Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
-  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);
+  const { endo, nBitLength } = CURVE;
+  const wnaf = wNAF(Point, endo ? Math.ceil(nBitLength / 2) : nBitLength);
+  return {
+    CURVE,
+    ProjectivePoint: Point,
+    normPrivateKeyToScalar,
+    weierstrassEquation,
+    isWithinCurveOrder
+  };
 }
-function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
-  _validateObject(ecdsaOpts, { hash: "function" }, {
+function validateOpts(curve) {
+  const opts = validateBasic(curve);
+  validateObject(opts, {
+    hash: "hash",
     hmac: "function",
-    lowS: "boolean",
-    randomBytes: "function",
+    randomBytes: "function"
+  }, {
     bits2int: "function",
-    bits2int_modN: "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);
+      }
+    }
   });
-  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) ? Fn.neg(s7) : s7;
-  }
-  function aValidRS(title, num) {
-    if (!Fn.isValidNot0(num))
-      throw new Error(`invalid signature ${title}: out of range 1..CURVE.n`);
+    return isBiggerThanHalfOrder(s7) ? modN(-s7) : s7;
   }
+  const slcNum = (b4, from, to) => bytesToNumberBE(b4.slice(from, to));
 
   class Signature {
     constructor(r6, s7, recovery) {
-      aValidRS("r", r6);
-      aValidRS("s", s7);
+      aInRange("r", r6, _1n5, CURVE_ORDER);
+      aInRange("s", s7, _1n5, CURVE_ORDER);
       this.r = r6;
       this.s = s7;
       if (recovery != null)
@@ -236332,9 +236321,9 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
       Object.freeze(this);
     }
     static fromCompact(hex) {
-      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)));
+      const l3 = nByteLength;
+      hex = ensureBytes("compactSignature", hex, l3 * 2);
+      return new Signature(slcNum(hex, 0, l3), slcNum(hex, l3, 2 * l3));
     }
     static fromDER(hex) {
       const { r: r6, s: s7 } = DER.toSig(ensureBytes("DER", hex));
@@ -236345,24 +236334,20 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
       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 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))
+      const radj = rec === 2 || rec === 3 ? r6 + CURVE.n : r6;
+      if (radj >= Fp.ORDER)
         throw new Error("recovery id 2 or 3 invalid");
-      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())
+      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)
         throw new Error("point at infinify");
       Q4.assertValidity();
       return Q4;
@@ -236371,29 +236356,22 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
       return isBiggerThanHalfOrder(this.s);
     }
     normalizeS() {
-      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");
+      return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;
     }
     toDERRawBytes() {
-      return this.toBytes("der");
+      return hexToBytes2(this.toDERHex());
     }
     toDERHex() {
-      return bytesToHex2(this.toBytes("der"));
+      return DER.hexFromSig(this);
     }
     toCompactRawBytes() {
-      return this.toBytes("compact");
+      return hexToBytes2(this.toCompactHex());
     }
     toCompactHex() {
-      return bytesToHex2(this.toBytes("compact"));
+      const l3 = nByteLength;
+      return numToSizedHex(this.r, l3) + numToSizedHex(this.s, l3);
     }
   }
-  const normPrivateKeyToScalar = _legacyHelperNormPriv(Fn, curveOpts.allowedPrivateKeyLengths, curveOpts.wrapPrivateKey);
   const utils = {
     isValidPrivateKey(privateKey) {
       try {
@@ -236405,15 +236383,17 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
     },
     normPrivateKeyToScalar,
     randomPrivateKey: () => {
-      const n6 = CURVE_ORDER;
-      return mapHashToField(randomBytes_(getMinHashLength(n6)), n6);
+      const length = getMinHashLength(CURVE.n);
+      return mapHashToField(CURVE.randomBytes(length), CURVE.n);
     },
     precompute(windowSize = 8, point = Point.BASE) {
-      return point.precompute(windowSize, false);
+      point._setWindowSize(windowSize);
+      point.multiply(BigInt(3));
+      return point;
     }
   };
   function getPublicKey(privateKey, isCompressed = true) {
-    return Point.fromPrivateKey(privateKey).toBytes(isCompressed);
+    return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
   }
   function isProbPub(item) {
     if (typeof item === "bigint")
@@ -236421,14 +236401,14 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
     if (item instanceof Point)
       return true;
     const arr = ensureBytes("key", item);
-    const length = arr.length;
-    const L5 = Fp.BYTES;
-    const LC = L5 + 1;
-    const LU = 2 * L5 + 1;
-    if (curveOpts.allowedPrivateKeyLengths || Fn.BYTES === LC) {
+    const len = arr.length;
+    const fpl = Fp.BYTES;
+    const compLen = fpl + 1;
+    const uncompLen = 2 * fpl + 1;
+    if (CURVE.allowedPrivateKeyLengths || nByteLength === compLen) {
       return;
     } else {
-      return length === LC || length === LU;
+      return len === compLen || len === uncompLen;
     }
   }
   function getSharedSecret(privateA, publicB, isCompressed = true) {
@@ -236437,27 +236417,27 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
     if (isProbPub(publicB) === false)
       throw new Error("second arg must be public key");
     const b4 = Point.fromHex(publicB);
-    return b4.multiply(normPrivateKeyToScalar(privateA)).toBytes(isCompressed);
+    return b4.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
   }
-  const bits2int = ecdsaOpts.bits2int || function(bytes) {
+  const bits2int = CURVE.bits2int || function(bytes) {
     if (bytes.length > 8192)
       throw new Error("input is too large");
     const num = bytesToNumberBE(bytes);
-    const delta = bytes.length * 8 - fnBits;
+    const delta = bytes.length * 8 - nBitLength;
     return delta > 0 ? num >> BigInt(delta) : num;
   };
-  const bits2int_modN = ecdsaOpts.bits2int_modN || function(bytes) {
-    return Fn.create(bits2int(bytes));
+  const bits2int_modN = CURVE.bits2int_modN || function(bytes) {
+    return modN(bits2int(bytes));
   };
-  const ORDER_MASK = bitMask(fnBits);
+  const ORDER_MASK = bitMask(nBitLength);
   function int2octets(num) {
-    aInRange("num < 2^" + fnBits, num, _0n5, ORDER_MASK);
-    return Fn.toBytes(num);
+    aInRange("num < 2^" + nBitLength, num, _0n5, ORDER_MASK);
+    return numberToBytesBE(num, nByteLength);
   }
   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 } = ecdsaOpts;
+    const { hash: hash2, randomBytes: randomBytes2 } = CURVE;
     let { lowS, prehash, extraEntropy: ent } = opts;
     if (lowS == null)
       lowS = true;
@@ -236469,21 +236449,21 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
     const d6 = normPrivateKeyToScalar(privateKey);
     const seedArgs = [int2octets(d6), int2octets(h1int)];
     if (ent != null && ent !== false) {
-      const e10 = ent === true ? randomBytes_(Fp.BYTES) : ent;
+      const e10 = ent === true ? randomBytes2(Fp.BYTES) : ent;
       seedArgs.push(ensureBytes("extraEntropy", e10));
     }
-    const seed = concatBytes(...seedArgs);
+    const seed = concatBytes3(...seedArgs);
     const m7 = h1int;
     function k2sig(kBytes) {
       const k5 = bits2int(kBytes);
-      if (!Fn.isValidNot0(k5))
+      if (!isWithinCurveOrder(k5))
         return;
-      const ik = Fn.inv(k5);
+      const ik = invN(k5);
       const q6 = Point.BASE.multiply(k5).toAffine();
-      const r6 = Fn.create(q6.x);
+      const r6 = modN(q6.x);
       if (r6 === _0n5)
         return;
-      const s7 = Fn.create(ik * Fn.create(m7 + r6 * d6));
+      const s7 = modN(ik * modN(m7 + r6 * d6));
       if (s7 === _0n5)
         return;
       let recovery = (q6.x === r6 ? 0 : 2) | Number(q6.y & _1n5);
@@ -236496,38 +236476,34 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
     }
     return { seed, k2sig };
   }
-  const defaultSigOpts = { lowS: ecdsaOpts.lowS, prehash: false };
-  const defaultVerOpts = { lowS: ecdsaOpts.lowS, prehash: false };
+  const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
+  const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
   function sign(msgHash, privKey, opts = defaultSigOpts) {
     const { seed, k2sig } = prepSig(msgHash, privKey, opts);
-    const drbg = createHmacDrbg(ecdsaOpts.hash.outputLen, Fn.BYTES, hmac_);
+    const C4 = CURVE;
+    const drbg = createHmacDrbg(C4.hash.outputLen, C4.nByteLength, C4.hmac);
     return drbg(seed, k2sig);
   }
-  Point.BASE.precompute(8);
+  Point.BASE._setWindowSize(8);
   function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
     const sg = signature;
     msgHash = ensureBytes("msgHash", msgHash);
     publicKey = ensureBytes("publicKey", publicKey);
-    validateSigVerOpts(opts);
     const { lowS, prehash, format: format2 } = opts;
+    validateSigVerOpts(opts);
     if ("strict" in opts)
       throw new Error("options.strict was renamed to lowS");
-    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);
+    if (format2 !== undefined && format2 !== "compact" && format2 !== "der")
+      throw new Error("format must be compact or der");
+    const isHex2 = typeof sg === "string" || isBytes2(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) {
-        if (format2 === undefined || format2 === "js") {
-          _sig = new Signature(sg.r, sg.s);
-        } else {
-          throw new Error("invalid format");
-        }
-      }
+      if (isObj)
+        _sig = new Signature(sg.r, sg.s);
       if (isHex2) {
         try {
           if (format2 !== "compact")
@@ -236548,77 +236524,28 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
     if (lowS && _sig.hasHighS())
       return false;
     if (prehash)
-      msgHash = ecdsaOpts.hash(msgHash);
+      msgHash = CURVE.hash(msgHash);
     const { r: r6, s: s7 } = _sig;
     const h8 = bits2int_modN(msgHash);
-    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())
+    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)
       return false;
-    const v6 = Fn.create(R7.x);
+    const v6 = modN(R7.x);
     return v6 === r6;
   }
-  return Object.freeze({
+  return {
+    CURVE,
     getPublicKey,
     getSharedSecret,
     sign,
     verify,
-    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);
+    ProjectivePoint: Point,
+    Signature,
+    utils
+  };
 }
 function SWUFpSqrtRatio(Fp, Z4) {
   const q6 = Fp.ORDER;
@@ -236684,29 +236611,28 @@ function SWUFpSqrtRatio(Fp, Z4) {
 }
 function mapToCurveSimpleSWU(Fp, opts) {
   validateField(Fp);
-  const { A: A5, B: B4, Z: Z4 } = opts;
-  if (!Fp.isValid(A5) || !Fp.isValid(B4) || !Fp.isValid(Z4))
+  if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))
     throw new Error("mapToCurveSimpleSWU: invalid opts");
-  const sqrtRatio = SWUFpSqrtRatio(Fp, Z4);
+  const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);
   if (!Fp.isOdd)
-    throw new Error("Field does not have .isOdd()");
+    throw new Error("Fp.isOdd is not implemented!");
   return (u6) => {
     let tv1, tv2, tv3, tv4, tv5, tv6, x6, y4;
     tv1 = Fp.sqr(u6);
-    tv1 = Fp.mul(tv1, Z4);
+    tv1 = Fp.mul(tv1, opts.Z);
     tv2 = Fp.sqr(tv1);
     tv2 = Fp.add(tv2, tv1);
     tv3 = Fp.add(tv2, Fp.ONE);
-    tv3 = Fp.mul(tv3, B4);
-    tv4 = Fp.cmov(Z4, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO));
-    tv4 = Fp.mul(tv4, A5);
+    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);
     tv2 = Fp.sqr(tv3);
     tv6 = Fp.sqr(tv4);
-    tv5 = Fp.mul(tv6, A5);
+    tv5 = Fp.mul(tv6, opts.A);
     tv2 = Fp.add(tv2, tv5);
     tv2 = Fp.mul(tv2, tv3);
     tv6 = Fp.mul(tv6, tv4);
-    tv5 = Fp.mul(tv6, B4);
+    tv5 = Fp.mul(tv6, opts.B);
     tv2 = Fp.add(tv2, tv5);
     x6 = Fp.mul(tv1, tv3);
     const { isValid, value: value4 } = sqrtRatio(tv2, tv6);
@@ -236723,10 +236649,9 @@ 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 = "") {
@@ -236834,11 +236759,20 @@ 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, hash: hash2 });
+  const create2 = (hash2) => weierstrass({ ...curveDef, ...getHash(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) */
 });
@@ -236868,55 +236802,52 @@ function anum(item) {
     throw new Error("number expected");
 }
 function expand_message_xmd(msg, DST, lenInBytes, H4) {
-  abytes(msg);
-  abytes(DST);
+  abytes2(msg);
+  abytes2(DST);
   anum(lenInBytes);
   if (DST.length > 255)
-    DST = H4(concatBytes(utf8ToBytes("H2C-OVERSIZE-DST-"), DST));
+    DST = H4(concatBytes3(utf8ToBytes2("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 = concatBytes(DST, i2osp(DST.length, 1));
+  const DST_prime = concatBytes3(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(concatBytes(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
-  b4[0] = H4(concatBytes(b_0, i2osp(1, 1), DST_prime));
+  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));
   for (let i6 = 1;i6 <= ell; i6++) {
     const args = [strxor(b_0, b4[i6 - 1]), i2osp(i6 + 1, 1), DST_prime];
-    b4[i6] = H4(concatBytes(...args));
+    b4[i6] = H4(concatBytes3(...args));
   }
-  const pseudo_random_bytes = concatBytes(...b4);
+  const pseudo_random_bytes = concatBytes3(...b4);
   return pseudo_random_bytes.slice(0, lenInBytes);
 }
 function expand_message_xof(msg, DST, lenInBytes, k5, H4) {
-  abytes(msg);
-  abytes(DST);
+  abytes2(msg);
+  abytes2(DST);
   anum(lenInBytes);
   if (DST.length > 255) {
     const dkLen = Math.ceil(2 * k5 / 8);
-    DST = H4.create({ dkLen }).update(utf8ToBytes("H2C-OVERSIZE-DST-")).update(DST).digest();
+    DST = H4.create({ dkLen }).update(utf8ToBytes2("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, {
+  validateObject(options, {
+    DST: "stringOrUint8Array",
     p: "bigint",
-    m: "number",
-    k: "number",
-    hash: "function"
+    m: "isSafeInteger",
+    k: "isSafeInteger",
+    hash: "hash"
   });
   const { p: p5, k: k5, m: m7, hash: hash2, expand, DST: _DST } = options;
-  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);
+  abytes2(msg);
   anum(count);
-  const DST = typeof _DST === "string" ? utf8ToBytes(_DST) : _DST;
+  const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
   const log2p = p5.toString(2).length;
   const L5 = Math.ceil((log2p + k5) / 8);
   const len_in_bytes = count * m7 * L5;
@@ -236968,17 +236899,13 @@ function createHasher2(Point, mapToCurve, defaults4) {
   return {
     defaults: defaults4,
     hashToCurve(msg, options) {
-      const dst = defaults4.DST ? defaults4.DST : {};
-      const opts = Object.assign({}, defaults4, dst, options);
-      const u6 = hash_to_field(msg, 2, opts);
+      const u6 = hash_to_field(msg, 2, { ...defaults4, DST: defaults4.DST, ...options });
       const u0 = map6(u6[0]);
       const u1 = map6(u6[1]);
       return clear(u0.add(u1));
     },
     encodeToCurve(msg, options) {
-      const dst = defaults4.encodeDST ? defaults4.encodeDST : {};
-      const opts = Object.assign({}, defaults4, dst, options);
-      const u6 = hash_to_field(msg, 1, opts);
+      const u6 = hash_to_field(msg, 1, { ...defaults4, DST: defaults4.encodeDST, ...options });
       return clear(map6(u6[0]));
     },
     mapToCurve(scalars) {
@@ -236993,8 +236920,8 @@ function createHasher2(Point, mapToCurve, defaults4) {
 }
 var os2ip;
 var init_hash_to_curve = __esm(() => {
-  init_utils3();
   init_modular();
+  init_utils3();
   os2ip = bytesToNumberBE;
 });
 
@@ -237008,7 +236935,7 @@ __export(exports_secp256k1, {
   encodeToCurve: () => encodeToCurve
 });
 function sqrtMod(y4) {
-  const P5 = secp256k1_CURVE.p;
+  const P5 = secp256k1P;
   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;
@@ -237033,25 +236960,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 = concatBytes(tagH, tagH);
+    tagP = concatBytes3(tagH, tagH);
     TAGGED_HASH_PREFIXES[tag] = tagP;
   }
-  return sha256(concatBytes(tagP, ...messages));
+  return sha256(concatBytes3(tagP, ...messages));
 }
 function schnorrGetExtPubKey(priv) {
   let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
   let p5 = Point.fromPrivateKey(d_);
-  const scalar = hasEven(p5.y) ? d_ : modN(-d_);
+  const scalar = p5.hasEvenY() ? d_ : modN(-d_);
   return { scalar, bytes: pointToBytes(p5) };
 }
 function lift_x(x6) {
-  aInRange("x", x6, _1n6, secp256k1_CURVE.p);
+  aInRange("x", x6, _1n6, secp256k1P);
   const xx = modP(x6 * x6);
   const c3 = modP(xx * x6 + BigInt(7));
   let y4 = sqrtMod(c3);
-  if (!hasEven(y4))
+  if (y4 % _2n4 !== _0n6)
     y4 = modP(-y4);
-  const p5 = Point.fromAffine({ x: x6, y: y4 });
+  const p5 = new Point(x6, y4, _1n6);
   p5.assertValidity();
   return p5;
 }
@@ -237086,52 +237013,49 @@ function schnorrVerify(signature, message, publicKey) {
   try {
     const P5 = lift_x(num(pub));
     const r6 = num(sig.subarray(0, 32));
-    if (!inRange(r6, _1n6, secp256k1_CURVE.p))
+    if (!inRange(r6, _1n6, secp256k1P))
       return false;
     const s7 = num(sig.subarray(32, 64));
-    if (!inRange(s7, _1n6, secp256k1_CURVE.n))
+    if (!inRange(s7, _1n6, secp256k1N))
       return false;
     const e10 = challenge(numTo32b(r6), pointToBytes(P5), m7);
-    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)
+    const R7 = GmulAdd(P5, s7, modN(-e10));
+    if (!R7 || !R7.hasEvenY() || R7.toAffine().x !== r6)
       return false;
     return true;
   } catch (error44) {
     return false;
   }
 }
-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 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 init_secp256k1 = __esm(() => {
   init_sha2();
   init_utils2();
   init__shortw_utils();
   init_hash_to_curve();
   init_modular();
-  init_weierstrass();
   init_utils3();
+  init_weierstrass();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  secp256k1_CURVE = {
-    p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
-    n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
-    h: BigInt(1),
-    a: BigInt(0),
-    b: BigInt(7),
-    Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
-    Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
-  };
+  secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
+  secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
   _0n6 = BigInt(0);
   _1n6 = BigInt(1);
   _2n4 = BigInt(2);
-  Fpk1 = Field(secp256k1_CURVE.p, undefined, undefined, { sqrt: sqrtMod });
+  Fpk1 = Field(secp256k1P, undefined, undefined, { sqrt: sqrtMod });
   secp256k1 = createCurve({
-    ...secp256k1_CURVE,
+    a: _0n6,
+    b: BigInt(7),
     Fp: Fpk1,
+    n: secp256k1N,
+    Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
+    Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
+    h: BigInt(1),
     lowS: true,
     endo: {
       beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
       splitScalar: (k5) => {
-        const n6 = secp256k1_CURVE.n;
+        const n6 = secp256k1N;
         const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
         const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
         const a22 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
@@ -237155,7 +237079,7 @@ var init_secp256k1 = __esm(() => {
     }
   }, sha256);
   TAGGED_HASH_PREFIXES = {};
-  Point = /* @__PURE__ */ (() => secp256k1.Point)();
+  Point = /* @__PURE__ */ (() => secp256k1.ProjectivePoint)();
   num = bytesToNumberBE;
   schnorr = /* @__PURE__ */ (() => ({
     getPublicKey: schnorrGetPublicKey,
@@ -237201,7 +237125,7 @@ var init_secp256k1 = __esm(() => {
     B: BigInt("1771"),
     Z: Fpk1.create(BigInt("-11"))
   }))();
-  secp256k1_hasher = /* @__PURE__ */ (() => createHasher2(secp256k1.Point, (scalars) => {
+  secp256k1_hasher = /* @__PURE__ */ (() => createHasher2(secp256k1.ProjectivePoint, (scalars) => {
     const { x: x6, y: y4 } = mapSWU(Fpk1.create(scalars[0]));
     return isoMap(x6, y4);
   }, {
@@ -263840,7 +263764,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.4.0-prfdc1cdc0",
+  version: "2.4.0",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -263889,10 +263813,10 @@ var package_default = {
     "@inquirer/input": "4.1.12",
     "@inquirer/password": "4.0.15",
     "@inquirer/select": "4.2.3",
-    "@settlemint/sdk-js": "2.4.0-prfdc1cdc0",
-    "@settlemint/sdk-utils": "2.4.0-prfdc1cdc0",
-    "@settlemint/sdk-viem": "2.4.0-prfdc1cdc0",
-    "@types/node": "24.0.3",
+    "@settlemint/sdk-js": "2.4.0",
+    "@settlemint/sdk-utils": "2.4.0",
+    "@settlemint/sdk-viem": "2.4.0",
+    "@types/node": "24.0.1",
     "@types/semver": "7.7.0",
     "@types/which": "3.0.4",
     "get-tsconfig": "4.10.1",
@@ -263900,7 +263824,7 @@ var package_default = {
     "is-in-ci": "1.0.0",
     semver: "7.7.2",
     slugify: "1.6.6",
-    viem: "2.31.2",
+    viem: "2.31.1",
     which: "5.0.0",
     yaml: "2.8.0",
     yoctocolors: "2.1.1"
@@ -305011,11 +304935,8 @@ function observe(observerId, callbacks, fn) {
     if (!listeners2.some((cb) => cb.id === callbackId))
       return;
     const cleanup2 = cleanupCache.get(observerId);
-    if (listeners2.length === 1 && cleanup2) {
-      const p5 = cleanup2();
-      if (p5 instanceof Promise)
-        p5.catch(() => {});
-    }
+    if (listeners2.length === 1 && cleanup2)
+      cleanup2();
     unsubscribe();
   };
   const listeners = getListeners();
@@ -307194,7 +307115,7 @@ async function simulateBlocks(client, parameters) {
             return;
           return getContractError(error45, {
             abi: abi2 ?? [],
-            address: to ?? "0x",
+            address: to,
             args,
             functionName: functionName ?? "<unknown>"
           });
@@ -308136,6 +308057,14 @@ 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,
@@ -308165,11 +308094,12 @@ async function simulateCalls(client, parameters) {
         }
       ] : [],
       {
-        calls: [...calls, {}].map((call2) => ({
+        calls: [...calls, {}].map((call2, index2) => ({
           ...call2,
-          from: account?.address
+          from: account?.address,
+          nonce: index2
         })),
-        stateOverrides
+        stateOverrides: resultsStateOverrides
       },
       ...traceAssetChanges ? [
         {
@@ -308708,7 +308638,7 @@ function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBe
             if (!active)
               return;
             const block = await getAction(client, getBlock, "getBlock")({
-              blockNumber: data.result?.number,
+              blockNumber: data.blockNumber,
               includeTransactions
             }).catch(() => {});
             if (!active)
@@ -330089,4 +330019,4 @@ async function sdkCliCommand(argv = process.argv) {
 // src/cli.ts
 sdkCliCommand();
 
-//# debugId=027CA61C7CAC49A464756E2164756E21
+//# debugId=C10D93033A91B39964756E2164756E21