genlayer 0.22.0 → 0.23.0

package/dist/index.js

@@ -7715,7 +7715,7 @@ var version3;
 var init_version2 = __esm({
   "node_modules/viem/_esm/errors/version.js"() {
     "use strict";
-    version3 = "2.30.5";
+    version3 = "2.31.7";
   }
 });
 
@@ -8564,6 +8564,46 @@ function byteSwap32(arr) {
   }
   return arr;
 }
+function bytesToHex2(bytes) {
+  abytes(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    hex += hexes2[bytes[i2]];
+  }
+  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 array = new Uint8Array(al);
+  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+    const n1 = asciiToBase16(hex.charCodeAt(hi));
+    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+    if (n1 === void 0 || n2 === void 0) {
+      const char = hex[hi] + hex[hi + 1];
+      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+    }
+    array[ai] = n1 * 16 + n2;
+  }
+  return array;
+}
 function utf8ToBytes(str) {
   if (typeof str !== "string")
     throw new Error("string expected");
@@ -8607,13 +8647,19 @@ function randomBytes(bytesLength = 32) {
   }
   throw new Error("crypto.getRandomValues must be defined");
 }
-var isLE, swap32IfBE, Hash;
+var isLE, swap32IfBE, hasHexBuiltin, hexes2, asciis, Hash;
 var init_utils2 = __esm({
   "node_modules/viem/node_modules/@noble/hashes/esm/utils.js"() {
     "use strict";
     init_cryptoNode();
     isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
     swap32IfBE = isLE ? (u) => u : byteSwap32;
+    hasHexBuiltin = /* @__PURE__ */ (() => (
+      // @ts-ignore
+      typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+    ))();
+    hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i2) => i2.toString(16).padStart(2, "0"));
+    asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
     Hash = class {
     };
   }
@@ -11480,14 +11526,7 @@ var init_hmac = __esm({
   }
 });
 
-// node_modules/viem/node_modules/@noble/curves/esm/abstract/utils.js
-function isBytes2(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-function abytes2(item) {
-  if (!isBytes2(item))
-    throw new Error("Uint8Array expected");
-}
+// node_modules/viem/node_modules/@noble/curves/esm/utils.js
 function abool(title, value) {
   if (typeof value !== "boolean")
     throw new Error(title + " boolean expected, got " + value);
@@ -11501,51 +11540,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 i2 = 0; i2 < bytes.length; i2++) {
-    hex += hexes2[bytes[i2]];
-  }
-  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 array = new Uint8Array(al);
-  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
-    const n1 = asciiToBase16(hex.charCodeAt(hi));
-    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
-    if (n1 === void 0 || n2 === void 0) {
-      const char = hex[hi] + hex[hi + 1];
-      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
-    }
-    array[ai] = n1 * 16 + n2;
-  }
-  return array;
-}
 function bytesToNumberBE(bytes) {
   return hexToNumber2(bytesToHex2(bytes));
 }
 function bytesToNumberLE(bytes) {
-  abytes2(bytes);
+  abytes(bytes);
   return hexToNumber2(bytesToHex2(Uint8Array.from(bytes).reverse()));
 }
 function numberToBytesBE(n, len) {
@@ -11562,7 +11561,7 @@ function ensureBytes(title, hex, expectedLength) {
     } catch (e2) {
       throw new Error(title + " must be hex string or Uint8Array, cause: " + e2);
     }
-  } else if (isBytes2(hex)) {
+  } else if (isBytes(hex)) {
     res = Uint8Array.from(hex);
   } else {
     throw new Error(title + " must be hex string or Uint8Array");
@@ -11572,26 +11571,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 i2 = 0; i2 < arrays.length; i2++) {
-    const a = arrays[i2];
-    abytes2(a);
-    sum += a.length;
-  }
-  const res = new Uint8Array(sum);
-  for (let i2 = 0, pad4 = 0; i2 < arrays.length; i2++) {
-    const a = arrays[i2];
-    res.set(a, pad4);
-    pad4 += a.length;
-  }
-  return res;
-}
-function utf8ToBytes2(str) {
-  if (typeof str !== "string")
-    throw new Error("string expected");
-  return new Uint8Array(new TextEncoder().encode(str));
-}
 function inRange(n, min, max) {
   return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
 }
@@ -11612,6 +11591,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 v = u8n(hashLen);
   let k = u8n(hashLen);
   let i2 = 0;
@@ -11622,11 +11603,11 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   };
   const h2 = (...b) => hmacFn(k, v, ...b);
   const reseed = (seed = u8n(0)) => {
-    k = h2(u8fr([0]), seed);
+    k = h2(u8of(0), seed);
     v = h2();
     if (seed.length === 0)
       return;
-    k = h2(u8fr([1]), seed);
+    k = h2(u8of(1), seed);
     v = h2();
   };
   const gen3 = () => {
@@ -11640,7 +11621,7 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
       out.push(sl);
       len += v.length;
     }
-    return concatBytes3(...out);
+    return concatBytes(...out);
   };
   const genUntil = (seed, pred) => {
     reset();
@@ -11653,23 +11634,22 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   };
   return genUntil;
 }
-function validateObject(object, validators, optValidators = {}) {
-  const checkField = (fieldName, type, isOptional) => {
-    const checkVal = validatorFns[type];
-    if (typeof checkVal !== "function")
-      throw new Error("invalid validator function");
+function isHash(val) {
+  return typeof val === "function" && Number.isSafeInteger(val.outputLen);
+}
+function _validateObject(object, fields, optFields = {}) {
+  if (!object || typeof object !== "object")
+    throw new Error("expected valid options object");
+  function checkField(fieldName, expectedType, isOpt) {
     const val = object[fieldName];
-    if (isOptional && val === void 0)
+    if (isOpt && val === void 0)
       return;
-    if (!checkVal(val, object)) {
-      throw new Error("param " + String(fieldName) + " is invalid. Expected " + type + ", got " + val);
-    }
-  };
-  for (const [fieldName, type] of Object.entries(validators))
-    checkField(fieldName, type, false);
-  for (const [fieldName, type] of Object.entries(optValidators))
-    checkField(fieldName, type, true);
-  return object;
+    const current = typeof val;
+    if (current !== expectedType || val === null)
+      throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
+  }
+  Object.entries(fields).forEach(([k, v]) => checkField(k, v, false));
+  Object.entries(optFields).forEach(([k, v]) => checkField(k, v, true));
 }
 function memoized(fn) {
   const map = /* @__PURE__ */ new WeakMap();
@@ -11682,31 +11662,16 @@ function memoized(fn) {
     return computed;
   };
 }
-var _0n2, _1n2, hasHexBuiltin, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns;
+var _0n2, _1n2, isPosBig, bitMask;
 var init_utils4 = __esm({
-  "node_modules/viem/node_modules/@noble/curves/esm/abstract/utils.js"() {
+  "node_modules/viem/node_modules/@noble/curves/esm/utils.js"() {
     "use strict";
+    init_utils2();
+    init_utils2();
     _0n2 = /* @__PURE__ */ BigInt(0);
     _1n2 = /* @__PURE__ */ BigInt(1);
-    hasHexBuiltin = // @ts-ignore
-    typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
-    hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i2) => i2.toString(16).padStart(2, "0"));
-    asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
     isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
     bitMask = (n) => (_1n2 << BigInt(n)) - _1n2;
-    u8n = (len) => new Uint8Array(len);
-    u8fr = (arr) => Uint8Array.from(arr);
-    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, object) => object.Fp.isValid(val),
-      hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
-    };
   }
 });
 
@@ -11821,14 +11786,15 @@ function validateField(field) {
   const initial = {
     ORDER: "bigint",
     MASK: "bigint",
-    BYTES: "isSafeInteger",
-    BITS: "isSafeInteger"
+    BYTES: "number",
+    BITS: "number"
   };
   const opts = FIELD_FIELDS.reduce((map, val) => {
     map[val] = "function";
     return map;
   }, initial);
-  return validateObject(field, opts);
+  _validateObject(field, opts);
+  return field;
 }
 function FpPow(Fp, num2, power) {
   if (power < _0n3)
@@ -11881,10 +11847,28 @@ function nLength(n, nBitLength) {
   const nByteLength = Math.ceil(_nBitLength / 8);
   return { nBitLength: _nBitLength, nByteLength };
 }
-function Field(ORDER, bitLen2, isLE3 = false, redef = {}) {
+function Field(ORDER, bitLenOrOpts, isLE3 = 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 = void 0;
+  let _sqrt = void 0;
+  if (typeof bitLenOrOpts === "object" && bitLenOrOpts != null) {
+    if (opts.sqrt || isLE3)
+      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")
+      isLE3 = _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;
@@ -11903,6 +11887,8 @@ function Field(ORDER, bitLen2, isLE3 = false, redef = {}) {
       return _0n3 <= num2 && num2 < ORDER;
     },
     is0: (num2) => num2 === _0n3,
+    // is valid and invertible
+    isValidNot0: (num2) => !f3.is0(num2) && f3.isValid(num2),
     isOdd: (num2) => (num2 & _1n3) === _1n3,
     neg: (num2) => mod(-num2, ORDER),
     eql: (lhs, rhs) => lhs === rhs,
@@ -11918,7 +11904,7 @@ function Field(ORDER, bitLen2, isLE3 = false, redef = {}) {
     subN: (lhs, rhs) => lhs - rhs,
     mulN: (lhs, rhs) => lhs * rhs,
     inv: (num2) => invert(num2, ORDER),
-    sqrt: redef.sqrt || ((n) => {
+    sqrt: _sqrt || ((n) => {
       if (!sqrtP)
         sqrtP = FpSqrt(ORDER);
       return sqrtP(f3, n);
@@ -11961,7 +11947,6 @@ var _0n3, _1n3, _2n2, _3n, _4n, _5n, _8n, FIELD_FIELDS;
 var init_modular = __esm({
   "node_modules/viem/node_modules/@noble/curves/esm/abstract/modular.js"() {
     "use strict";
-    init_utils2();
     init_utils4();
     _0n3 = BigInt(0);
     _1n3 = BigInt(1);
@@ -11993,10 +11978,16 @@ var init_modular = __esm({
 });
 
 // node_modules/viem/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(c, property, points) {
+  const getz = property === "pz" ? (p) => p.pz : (p) => p.ez;
+  const toInv = FpInvertBatch(c.Fp, points.map(getz));
+  const affined = points.map((p, i2) => p.toAffine(toInv[i2]));
+  return affined.map(c.fromAffine);
+}
 function validateW(W, bits) {
   if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
     throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W);
@@ -12045,9 +12036,13 @@ function validateMSMScalars(scalars, field) {
 function getW(P) {
   return pointWindowSizes.get(P) || 1;
 }
+function assert0(n) {
+  if (n !== _0n4)
+    throw new Error("invalid wNAF");
+}
 function wNAF(c, bits) {
   return {
-    constTimeNegate,
+    constTimeNegate: negateCt,
     hasPrecomputes(elm) {
       return getW(elm) !== 1;
     },
@@ -12105,11 +12100,12 @@ function wNAF(c, bits) {
         const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window2, wo);
         n = nextN;
         if (isZero) {
-          f3 = f3.add(constTimeNegate(isNegF, precomputes[offsetF]));
+          f3 = f3.add(negateCt(isNegF, precomputes[offsetF]));
         } else {
-          p = p.add(constTimeNegate(isNeg, precomputes[offset]));
+          p = p.add(negateCt(isNeg, precomputes[offset]));
         }
       }
+      assert0(n);
       return { p, f: f3 };
     },
     /**
@@ -12134,14 +12130,18 @@ function wNAF(c, bits) {
           acc = acc.add(isNeg ? item.negate() : item);
         }
       }
+      assert0(n);
       return acc;
     },
     getPrecomputes(W, P, transform) {
       let comp = pointPrecomputes.get(P);
       if (!comp) {
         comp = this.precomputeWindow(P, W);
-        if (W !== 1)
-          pointPrecomputes.set(P, transform(comp));
+        if (W !== 1) {
+          if (typeof transform === "function")
+            comp = transform(comp);
+          pointPrecomputes.set(P, comp);
+        }
       }
       return comp;
     },
@@ -12165,6 +12165,21 @@ function wNAF(c, bits) {
     }
   };
 }
+function mulEndoUnsafe(c, point, k1, k2) {
+  let acc = point;
+  let p1 = c.ZERO;
+  let p2 = c.ZERO;
+  while (k1 > _0n4 || k2 > _0n4) {
+    if (k1 & _1n4)
+      p1 = p1.add(acc);
+    if (k2 & _1n4)
+      p2 = p2.add(acc);
+    acc = acc.double();
+    k1 >>= _1n4;
+    k2 >>= _1n4;
+  }
+  return { p1, p2 };
+}
 function pippenger(c, fieldN, points, scalars) {
   validateMSMPoints(points, c);
   validateMSMScalars(scalars, fieldN);
@@ -12204,29 +12219,40 @@ function pippenger(c, 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, field) {
+  if (field) {
+    if (field.ORDER !== order)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    validateField(field);
+    return field;
+  } else {
+    return Field(order);
+  }
+}
+function _createCurveFields(type, CURVE, curveOpts = {}) {
+  if (!CURVE || typeof CURVE !== "object")
+    throw new Error(`expected valid ${type} CURVE object`);
+  for (const p of ["p", "n", "h"]) {
+    const val = CURVE[p];
+    if (!(typeof val === "bigint" && val > _0n4))
+      throw new Error(`CURVE.${p} must be positive bigint`);
+  }
+  const Fp = createField(CURVE.p, curveOpts.Fp);
+  const Fn = createField(CURVE.n, curveOpts.Fn);
+  const _b = type === "weierstrass" ? "b" : "d";
+  const params = ["Gx", "Gy", "a", _b];
+  for (const p of params) {
+    if (!Fp.isValid(CURVE[p]))
+      throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);
+  }
+  return { Fp, Fn };
 }
 var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
 var init_curve = __esm({
   "node_modules/viem/node_modules/@noble/curves/esm/abstract/curve.js"() {
     "use strict";
-    init_modular();
     init_utils4();
+    init_modular();
     _0n4 = BigInt(0);
     _1n4 = BigInt(1);
     pointPrecomputes = /* @__PURE__ */ new WeakMap();
@@ -12241,54 +12267,116 @@ function validateSigVerOpts(opts) {
   if (opts.prehash !== void 0)
     abool("prehash", opts.prehash);
 }
-function validatePointOpts(curve) {
-  const opts = validateBasic(curve);
-  validateObject(opts, {
-    a: "field",
-    b: "field"
-  }, {
+function _legacyHelperEquat(Fp, a, b) {
+  function weierstrassEquation(x2) {
+    const x22 = Fp.sqr(x2);
+    const x3 = Fp.mul(x22, x2);
+    return Fp.add(Fp.add(x3, Fp.mul(x2, a)), b);
+  }
+  return weierstrassEquation;
+}
+function _legacyHelperNormPriv(Fn, allowedPrivateKeyLengths, wrapPrivateKey) {
+  const { BYTES: expected } = Fn;
+  function normPrivateKeyToScalar(key) {
+    let num2;
+    if (typeof key === "bigint") {
+      num2 = key;
+    } else {
+      let bytes = ensureBytes("private key", key);
+      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 {
+        num2 = Fn.fromBytes(bytes);
+      } catch (error) {
+        throw new Error(`invalid private key: expected ui8a of size ${expected}, got ${typeof key}`);
+      }
+    }
+    if (wrapPrivateKey)
+      num2 = Fn.create(num2);
+    if (!Fn.isValidNot0(num2))
+      throw new Error("invalid private key: out of range [1..N-1]");
+    return num2;
+  }
+  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 } = opts;
+  const { endo } = curveOpts;
   if (endo) {
-    if (!Fp.eql(a, 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(num2, size5) {
-  return bytesToHex2(numberToBytesBE(num2, size5));
-}
-function weierstrassPoints(opts) {
-  const CURVE = validatePointOpts(opts);
-  const { Fp } = CURVE;
-  const Fn = Field(CURVE.n, CURVE.nBitLength);
-  const toBytes4 = CURVE.toBytes || ((_c, point, _isCompressed) => {
-    const a = point.toAffine();
-    return concatBytes3(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
-  });
-  const fromBytes2 = CURVE.fromBytes || ((bytes) => {
+  function assertCompressionIsSupported() {
+    if (!Fp.isOdd)
+      throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function pointToBytes2(_c, point, isCompressed) {
+    const { x: x2, y } = point.toAffine();
+    const bx = Fp.toBytes(x2);
+    abool("isCompressed", isCompressed);
+    if (isCompressed) {
+      assertCompressionIsSupported();
+      const hasEvenY = !Fp.isOdd(y);
+      return concatBytes(pprefix(hasEvenY), bx);
+    } else {
+      return concatBytes(Uint8Array.of(4), bx, Fp.toBytes(y));
+    }
+  }
+  function pointFromBytes(bytes) {
+    abytes(bytes);
+    const L = Fp.BYTES;
+    const LC = L + 1;
+    const LU = 2 * L + 1;
+    const length = bytes.length;
+    const head = bytes[0];
     const tail = bytes.subarray(1);
-    const x2 = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
-    const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
-    return { x: x2, y };
-  });
-  function weierstrassEquation(x2) {
-    const { a, b } = CURVE;
-    const x22 = Fp.sqr(x2);
-    const x3 = Fp.mul(x22, x2);
-    return Fp.add(Fp.add(x3, Fp.mul(x2, a)), b);
+    if (length === LC && (head === 2 || head === 3)) {
+      const x2 = Fp.fromBytes(tail);
+      if (!Fp.isValid(x2))
+        throw new Error("bad point: is not on curve, wrong x");
+      const y2 = weierstrassEquation(x2);
+      let y;
+      try {
+        y = Fp.sqrt(y2);
+      } 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(y);
+      const isHeadOdd = (head & 1) === 1;
+      if (isHeadOdd !== isYOdd)
+        y = Fp.neg(y);
+      return { x: x2, y };
+    } else if (length === LU && head === 4) {
+      const x2 = Fp.fromBytes(tail.subarray(L * 0, L * 1));
+      const y = Fp.fromBytes(tail.subarray(L * 1, L * 2));
+      if (!isValidXY(x2, y))
+        throw new Error("bad point: is not on curve");
+      return { x: x2, y };
+    } else {
+      throw new Error(`bad point: got length ${length}, expected compressed=${LC} or uncompressed=${LU}`);
+    }
   }
+  const toBytes4 = curveOpts.toBytes || pointToBytes2;
+  const fromBytes2 = curveOpts.fromBytes || pointFromBytes;
+  const weierstrassEquation = _legacyHelperEquat(Fp, CURVE.a, CURVE.b);
   function isValidXY(x2, y) {
     const left = Fp.sqr(y);
     const right = weierstrassEquation(x2);
@@ -12300,28 +12388,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(num2) {
-    return inRange(num2, _1n5, CURVE.n);
-  }
-  function normPrivateKeyToScalar(key) {
-    const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
-    if (lengths && typeof key !== "bigint") {
-      if (isBytes2(key))
-        key = bytesToHex2(key);
-      if (typeof key !== "string" || !lengths.includes(key.length))
-        throw new Error("invalid private key");
-      key = key.padStart(nByteLength * 2, "0");
-    }
-    let num2;
-    try {
-      num2 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
-    } catch (error) {
-      throw new Error("invalid private key, expected hex or " + nByteLength + " bytes, got " + typeof key);
-    }
-    if (wrapPrivateKey)
-      num2 = mod(num2, N);
-    aInRange("private key", num2, _1n5, N);
-    return num2;
+  function acoord(title, n, banZero = false) {
+    if (!Fp.isValid(n) || banZero && Fp.is0(n))
+      throw new Error(`bad point coordinate ${title}`);
+    return n;
   }
   function aprjpoint(other) {
     if (!(other instanceof Point2))
@@ -12345,42 +12415,41 @@ function weierstrassPoints(opts) {
   });
   const assertValidMemo = memoized((p) => {
     if (p.is0()) {
-      if (CURVE.allowInfinityPoint && !Fp.is0(p.py))
+      if (curveOpts.allowInfinityPoint && !Fp.is0(p.py))
         return;
       throw new Error("bad point: ZERO");
     }
     const { x: x2, y } = p.toAffine();
     if (!Fp.isValid(x2) || !Fp.isValid(y))
-      throw new Error("bad point: x or y not FE");
+      throw new Error("bad point: x or y not field elements");
     if (!isValidXY(x2, y))
       throw new Error("bad point: equation left != right");
     if (!p.isTorsionFree())
       throw new Error("bad point: not in prime-order subgroup");
     return true;
   });
+  function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {
+    k2p = new Point2(Fp.mul(k2p.px, endoBeta), k2p.py, k2p.pz);
+    k1p = negateCt(k1neg, k1p);
+    k2p = negateCt(k2neg, k2p);
+    return k1p.add(k2p);
+  }
   class Point2 {
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
     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);
     }
-    // Does not validate if the point is on-curve.
-    // Use fromHex instead, or call assertValidity() later.
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
     static fromAffine(p) {
       const { x: x2, y } = p || {};
       if (!p || !Fp.isValid(x2) || !Fp.isValid(y))
         throw new Error("invalid affine point");
       if (p instanceof Point2)
         throw new Error("projective point not allowed");
-      const is0 = (i2) => Fp.eql(i2, Fp.ZERO);
-      if (is0(x2) && is0(y))
+      if (Fp.is0(x2) && Fp.is0(y))
         return Point2.ZERO;
       return new Point2(x2, y, Fp.ONE);
     }
@@ -12390,50 +12459,56 @@ function weierstrassPoints(opts) {
     get y() {
       return this.toAffine().y;
     }
-    /**
-     * Takes a bunch of Projective Points but executes only one
-     * inversion on all of them. Inversion is very slow operation,
-     * so this improves performance massively.
-     * Optimization: converts a list of projective points to a list of identical points with Z=1.
-     */
     static normalizeZ(points) {
-      const toInv = FpInvertBatch(Fp, points.map((p) => p.pz));
-      return points.map((p, i2) => p.toAffine(toInv[i2])).map(Point2.fromAffine);
+      return normalizeZ(Point2, "pz", points);
     }
-    /**
-     * Converts hash string or Uint8Array to Point.
-     * @param hex short/long ECDSA hex
-     */
+    static fromBytes(bytes) {
+      abytes(bytes);
+      return Point2.fromHex(bytes);
+    }
+    /** Converts hash string or Uint8Array to Point. */
     static fromHex(hex) {
       const P = Point2.fromAffine(fromBytes2(ensureBytes("pointHex", hex)));
       P.assertValidity();
       return P;
     }
-    // Multiplies generator point by privateKey.
+    /** Multiplies generator point by privateKey. */
     static fromPrivateKey(privateKey) {
+      const normPrivateKeyToScalar = _legacyHelperNormPriv(Fn, curveOpts.allowedPrivateKeyLengths, curveOpts.wrapPrivateKey);
       return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
     }
-    // Multiscalar Multiplication
+    /** Multiscalar Multiplication */
     static msm(points, scalars) {
       return pippenger(Point2, Fn, points, scalars);
     }
-    // "Private method", don't use it directly
-    _setWindowSize(windowSize) {
+    /**
+     *
+     * @param windowSize
+     * @param isLazy true will defer table computation until the first multiplication
+     * @returns
+     */
+    precompute(windowSize = 8, isLazy = true) {
       wnaf.setWindowSize(this, windowSize);
+      if (!isLazy)
+        this.multiply(_3n2);
+      return this;
+    }
+    /** "Private method", don't use it directly */
+    _setWindowSize(windowSize) {
+      this.precompute(windowSize);
     }
-    // A point on curve is valid if it conforms to equation.
+    // TODO: return `this`
+    /** A point on curve is valid if it conforms to equation. */
     assertValidity() {
       assertValidMemo(this);
     }
     hasEvenY() {
       const { y } = this.toAffine();
-      if (Fp.isOdd)
-        return !Fp.isOdd(y);
-      throw new Error("Field doesn't support isOdd");
+      if (!Fp.isOdd)
+        throw new Error("Field doesn't support isOdd");
+      return !Fp.isOdd(y);
     }
-    /**
-     * Compare one point to another.
-     */
+    /** Compare one point to another. */
     equals(other) {
       aprjpoint(other);
       const { px: X1, py: Y1, pz: Z1 } = this;
@@ -12442,9 +12517,7 @@ function weierstrassPoints(opts) {
       const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
       return U1 && U2;
     }
-    /**
-     * Flips point to one corresponding to (x, -y) in Affine coordinates.
-     */
+    /** Flips point to one corresponding to (x, -y) in Affine coordinates. */
     negate() {
       return new Point2(this.px, Fp.neg(this.py), this.pz);
     }
@@ -12549,44 +12622,6 @@ function weierstrassPoints(opts) {
     is0() {
       return this.equals(Point2.ZERO);
     }
-    wNAF(n) {
-      return wnaf.wNAFCached(this, n, Point2.normalizeZ);
-    }
-    /**
-     * Non-constant-time multiplication. Uses double-and-add algorithm.
-     * It's faster, but should only be used when you don't care about
-     * an exposed private key e.g. sig verification, which works over *public* keys.
-     */
-    multiplyUnsafe(sc) {
-      const { endo: endo2, n: N } = CURVE;
-      aInRange("scalar", sc, _0n5, N);
-      const I = Point2.ZERO;
-      if (sc === _0n5)
-        return I;
-      if (this.is0() || sc === _1n5)
-        return this;
-      if (!endo2 || wnaf.hasPrecomputes(this))
-        return wnaf.wNAFCachedUnsafe(this, sc, Point2.normalizeZ);
-      let { k1neg, k1, k2neg, k2 } = endo2.splitScalar(sc);
-      let k1p = I;
-      let k2p = I;
-      let d = this;
-      while (k1 > _0n5 || k2 > _0n5) {
-        if (k1 & _1n5)
-          k1p = k1p.add(d);
-        if (k2 & _1n5)
-          k2p = k2p.add(d);
-        d = d.double();
-        k1 >>= _1n5;
-        k2 >>= _1n5;
-      }
-      if (k1neg)
-        k1p = k1p.negate();
-      if (k2neg)
-        k2p = k2p.negate();
-      k2p = new Point2(Fp.mul(k2p.px, endo2.beta), k2p.py, k2p.pz);
-      return k1p.add(k2p);
-    }
     /**
      * Constant time multiplication.
      * Uses wNAF method. Windowed method may be 10% faster,
@@ -12597,162 +12632,133 @@ function weierstrassPoints(opts) {
      * @returns New point
      */
     multiply(scalar) {
-      const { endo: endo2, n: N } = CURVE;
-      aInRange("scalar", scalar, _1n5, N);
+      const { endo: endo2 } = curveOpts;
+      if (!Fn.isValidNot0(scalar))
+        throw new Error("invalid scalar: out of range");
       let point, fake;
+      const mul = (n) => wnaf.wNAFCached(this, n, Point2.normalizeZ);
       if (endo2) {
         const { k1neg, k1, k2neg, k2 } = endo2.splitScalar(scalar);
-        let { p: k1p, f: f1p } = this.wNAF(k1);
-        let { p: k2p, f: f2p } = this.wNAF(k2);
-        k1p = wnaf.constTimeNegate(k1neg, k1p);
-        k2p = wnaf.constTimeNegate(k2neg, k2p);
-        k2p = new Point2(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(k2);
+        fake = k1f.add(k2f);
+        point = finishEndo(endo2.beta, k1p, k2p, k1neg, k2neg);
       } else {
-        const { p, f: f3 } = this.wNAF(scalar);
+        const { p, f: f3 } = mul(scalar);
         point = p;
         fake = f3;
       }
       return Point2.normalizeZ([point, fake])[0];
     }
     /**
-     * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
-     * Not using Strauss-Shamir trick: precomputation tables are faster.
-     * The trick could be useful if both P and Q are not G (not in our case).
-     * @returns non-zero affine point
+     * Non-constant-time multiplication. Uses double-and-add algorithm.
+     * It's faster, but should only be used when you don't care about
+     * an exposed private key e.g. sig verification, which works over *public* keys.
      */
+    multiplyUnsafe(sc) {
+      const { endo: endo2 } = curveOpts;
+      const p = this;
+      if (!Fn.isValid(sc))
+        throw new Error("invalid scalar: out of range");
+      if (sc === _0n5 || p.is0())
+        return Point2.ZERO;
+      if (sc === _1n5)
+        return p;
+      if (wnaf.hasPrecomputes(this))
+        return this.multiply(sc);
+      if (endo2) {
+        const { k1neg, k1, k2neg, k2 } = endo2.splitScalar(sc);
+        const { p1, p2 } = mulEndoUnsafe(Point2, p, k1, k2);
+        return finishEndo(endo2.beta, p1, p2, k1neg, k2neg);
+      } else {
+        return wnaf.wNAFCachedUnsafe(p, sc);
+      }
+    }
     multiplyAndAddUnsafe(Q, a, b) {
-      const G = Point2.BASE;
-      const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
-      const sum = mul(this, a).add(mul(Q, b));
+      const sum = this.multiplyUnsafe(a).add(Q.multiplyUnsafe(b));
       return sum.is0() ? void 0 : sum;
     }
-    // Converts Projective point to affine (x, y) coordinates.
-    // Can accept precomputed Z^-1 - for example, from invertBatch.
-    // (x, y, z) ∋ (x=x/z, y=y/z)
-    toAffine(iz) {
-      return toAffineMemo(this, iz);
+    /**
+     * Converts Projective point to affine (x, y) coordinates.
+     * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
+     */
+    toAffine(invertedZ) {
+      return toAffineMemo(this, invertedZ);
     }
+    /**
+     * Checks whether Point is free of torsion elements (is in prime subgroup).
+     * Always torsion-free for cofactor=1 curves.
+     */
     isTorsionFree() {
-      const { h: cofactor, isTorsionFree } = CURVE;
+      const { isTorsionFree } = curveOpts;
       if (cofactor === _1n5)
         return true;
       if (isTorsionFree)
         return isTorsionFree(Point2, 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(Point2, this);
-      return this.multiplyUnsafe(CURVE.h);
+      return this.multiplyUnsafe(cofactor);
     }
-    toRawBytes(isCompressed = true) {
+    toBytes(isCompressed = true) {
       abool("isCompressed", isCompressed);
       this.assertValidity();
       return toBytes4(Point2, this, isCompressed);
     }
+    /** @deprecated use `toBytes` */
+    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()}>`;
     }
   }
   Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp.ONE);
   Point2.ZERO = new Point2(Fp.ZERO, Fp.ONE, Fp.ZERO);
-  const { endo, nBitLength } = CURVE;
-  const wnaf = wNAF(Point2, endo ? Math.ceil(nBitLength / 2) : nBitLength);
-  return {
-    CURVE,
-    ProjectivePoint: Point2,
-    normPrivateKeyToScalar,
-    weierstrassEquation,
-    isWithinCurveOrder
-  };
+  Point2.Fp = Fp;
+  Point2.Fn = Fn;
+  const bits = Fn.BITS;
+  const wnaf = wNAF(Point2, curveOpts.endo ? Math.ceil(bits / 2) : bits);
+  return Point2;
+}
+function pprefix(hasEvenY) {
+  return Uint8Array.of(hasEvenY ? 2 : 3);
 }
-function validateOpts(curve) {
-  const opts = validateBasic(curve);
-  validateObject(opts, {
-    hash: "hash",
+function ecdsa(Point2, 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 modN2(a) {
-    return mod(a, CURVE_ORDER);
-  }
-  function invN(a) {
-    return invert(a, CURVE_ORDER);
-  }
-  const { ProjectivePoint: Point2, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
-    ...CURVE,
-    toBytes(_c, point, isCompressed) {
-      const a = point.toAffine();
-      const x2 = Fp.toBytes(a.x);
-      const cat = concatBytes3;
-      abool("isCompressed", isCompressed);
-      if (isCompressed) {
-        return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x2);
-      } else {
-        return cat(Uint8Array.from([4]), x2, Fp.toBytes(a.y));
-      }
-    },
-    fromBytes(bytes) {
-      const len = bytes.length;
-      const head = bytes[0];
-      const tail = bytes.subarray(1);
-      if (len === compressedLen && (head === 2 || head === 3)) {
-        const x2 = bytesToNumberBE(tail);
-        if (!inRange(x2, _1n5, Fp.ORDER))
-          throw new Error("Point is not on curve");
-        const y2 = weierstrassEquation(x2);
-        let y;
-        try {
-          y = Fp.sqrt(y2);
-        } catch (sqrtError) {
-          const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
-          throw new Error("Point is not on curve" + suffix);
-        }
-        const isYOdd = (y & _1n5) === _1n5;
-        const isHeadOdd = (head & 1) === 1;
-        if (isHeadOdd !== isYOdd)
-          y = Fp.neg(y);
-        return { x: x2, y };
-      } else if (len === uncompressedLen && head === 4) {
-        const x2 = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
-        const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
-        return { x: x2, y };
-      } 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 || ((key, ...msgs) => hmac(ecdsaOpts.hash, key, concatBytes(...msgs)));
+  const { Fp, Fn } = Point2;
+  const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
   function isBiggerThanHalfOrder(number) {
     const HALF = CURVE_ORDER >> _1n5;
     return number > HALF;
   }
   function normalizeS(s2) {
-    return isBiggerThanHalfOrder(s2) ? modN2(-s2) : s2;
+    return isBiggerThanHalfOrder(s2) ? Fn.neg(s2) : s2;
+  }
+  function aValidRS(title, num2) {
+    if (!Fn.isValidNot0(num2))
+      throw new Error(`invalid signature ${title}: out of range 1..CURVE.n`);
   }
-  const slcNum = (b, from5, to) => bytesToNumberBE(b.slice(from5, to));
   class Signature {
     constructor(r2, s2, recovery) {
-      aInRange("r", r2, _1n5, CURVE_ORDER);
-      aInRange("s", s2, _1n5, CURVE_ORDER);
+      aValidRS("r", r2);
+      aValidRS("s", s2);
       this.r = r2;
       this.s = s2;
       if (recovery != null)
@@ -12761,9 +12767,9 @@ function weierstrass(curveDef) {
     }
     // pair (bytes of r, bytes of s)
     static fromCompact(hex) {
-      const l = nByteLength;
-      hex = ensureBytes("compactSignature", hex, l * 2);
-      return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
+      const L = Fn.BYTES;
+      const b = ensureBytes("compactSignature", hex, L * 2);
+      return new Signature(Fn.fromBytes(b.subarray(0, L)), Fn.fromBytes(b.subarray(L, L * 2)));
     }
     // DER encoded ECDSA signature
     // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
@@ -12780,21 +12786,26 @@ function weierstrass(curveDef) {
     addRecoveryBit(recovery) {
       return new Signature(this.r, this.s, recovery);
     }
+    // ProjPointType<bigint>
     recoverPublicKey(msgHash) {
+      const FIELD_ORDER = Fp.ORDER;
       const { r: r2, s: s2, recovery: rec } = this;
-      const h2 = 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 ? r2 + CURVE.n : r2;
-      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 ? r2 + CURVE_ORDER : r2;
+      if (!Fp.isValid(radj))
         throw new Error("recovery id 2 or 3 invalid");
-      const prefix = (rec & 1) === 0 ? "02" : "03";
-      const R = Point2.fromHex(prefix + numToSizedHex(radj, Fp.BYTES));
-      const ir = invN(radj);
-      const u1 = modN2(-h2 * ir);
-      const u2 = modN2(s2 * ir);
-      const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
-      if (!Q)
+      const x2 = Fp.toBytes(radj);
+      const R = Point2.fromHex(concatBytes(pprefix((rec & 1) === 0), x2));
+      const ir = Fn.inv(radj);
+      const h2 = bits2int_modN(ensureBytes("msgHash", msgHash));
+      const u1 = Fn.create(-h2 * ir);
+      const u2 = Fn.create(s2 * ir);
+      const Q = Point2.BASE.multiplyUnsafe(u1).add(R.multiplyUnsafe(u2));
+      if (Q.is0())
         throw new Error("point at infinify");
       Q.assertValidity();
       return Q;
@@ -12804,24 +12815,31 @@ function weierstrass(curveDef) {
       return isBiggerThanHalfOrder(this.s);
     }
     normalizeS() {
-      return this.hasHighS() ? new Signature(this.r, modN2(-this.s), this.recovery) : this;
+      return this.hasHighS() ? new Signature(this.r, Fn.neg(this.s), this.recovery) : this;
+    }
+    toBytes(format) {
+      if (format === "compact")
+        return concatBytes(Fn.toBytes(this.r), Fn.toBytes(this.s));
+      if (format === "der")
+        return hexToBytes2(DER.hexFromSig(this));
+      throw new Error("invalid format");
     }
     // DER-encoded
     toDERRawBytes() {
-      return hexToBytes2(this.toDERHex());
+      return this.toBytes("der");
     }
     toDERHex() {
-      return DER.hexFromSig(this);
+      return bytesToHex2(this.toBytes("der"));
     }
     // padded bytes of r, then padded bytes of s
     toCompactRawBytes() {
-      return hexToBytes2(this.toCompactHex());
+      return this.toBytes("compact");
     }
     toCompactHex() {
-      const l = nByteLength;
-      return numToSizedHex(this.r, l) + numToSizedHex(this.s, l);
+      return bytesToHex2(this.toBytes("compact"));
     }
   }
+  const normPrivateKeyToScalar = _legacyHelperNormPriv(Fn, curveOpts.allowedPrivateKeyLengths, curveOpts.wrapPrivateKey);
   const utils = {
     isValidPrivateKey(privateKey) {
       try {
@@ -12837,25 +12855,15 @@ function weierstrass(curveDef) {
      * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
      */
     randomPrivateKey: () => {
-      const length = getMinHashLength(CURVE.n);
-      return mapHashToField(CURVE.randomBytes(length), CURVE.n);
+      const n = CURVE_ORDER;
+      return mapHashToField(randomBytes_(getMinHashLength(n)), n);
     },
-    /**
-     * Creates precompute table for an arbitrary EC point. Makes point "cached".
-     * Allows to massively speed-up `point.multiply(scalar)`.
-     * @returns cached point
-     * @example
-     * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
-     * fast.multiply(privKey); // much faster ECDH now
-     */
     precompute(windowSize = 8, point = Point2.BASE) {
-      point._setWindowSize(windowSize);
-      point.multiply(BigInt(3));
-      return point;
+      return point.precompute(windowSize, false);
     }
   };
   function getPublicKey(privateKey, isCompressed = true) {
-    return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
+    return Point2.fromPrivateKey(privateKey).toBytes(isCompressed);
   }
   function isProbPub(item) {
     if (typeof item === "bigint")
@@ -12863,14 +12871,14 @@ function weierstrass(curveDef) {
     if (item instanceof Point2)
       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 L = Fp.BYTES;
+    const LC = L + 1;
+    const LU = 2 * L + 1;
+    if (curveOpts.allowedPrivateKeyLengths || Fn.BYTES === LC) {
       return void 0;
     } else {
-      return len === compLen || len === uncompLen;
+      return length === LC || length === LU;
     }
   }
   function getSharedSecret(privateA, publicB, isCompressed = true) {
@@ -12879,27 +12887,27 @@ function weierstrass(curveDef) {
     if (isProbPub(publicB) === false)
       throw new Error("second arg must be public key");
     const b = Point2.fromHex(publicB);
-    return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
+    return b.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 num2 = bytesToNumberBE(bytes);
-    const delta = bytes.length * 8 - nBitLength;
+    const delta = bytes.length * 8 - fnBits;
     return delta > 0 ? num2 >> BigInt(delta) : num2;
   };
-  const bits2int_modN = CURVE.bits2int_modN || function(bytes) {
-    return modN2(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(num2) {
-    aInRange("num < 2^" + nBitLength, num2, _0n5, ORDER_MASK);
-    return numberToBytesBE(num2, nByteLength);
+    aInRange("num < 2^" + fnBits, num2, _0n5, ORDER_MASK);
+    return Fn.toBytes(num2);
   }
   function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
     if (["recovered", "canonical"].some((k) => k 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;
@@ -12911,21 +12919,21 @@ function weierstrass(curveDef) {
     const d = normPrivateKeyToScalar(privateKey);
     const seedArgs = [int2octets(d), int2octets(h1int)];
     if (ent != null && ent !== false) {
-      const e2 = ent === true ? randomBytes2(Fp.BYTES) : ent;
+      const e2 = ent === true ? randomBytes_(Fp.BYTES) : ent;
       seedArgs.push(ensureBytes("extraEntropy", e2));
     }
-    const seed = concatBytes3(...seedArgs);
+    const seed = concatBytes(...seedArgs);
     const m2 = h1int;
     function k2sig(kBytes) {
       const k = bits2int(kBytes);
-      if (!isWithinCurveOrder(k))
+      if (!Fn.isValidNot0(k))
         return;
-      const ik = invN(k);
+      const ik = Fn.inv(k);
       const q = Point2.BASE.multiply(k).toAffine();
-      const r2 = modN2(q.x);
+      const r2 = Fn.create(q.x);
       if (r2 === _0n5)
         return;
-      const s2 = modN2(ik * modN2(m2 + r2 * d));
+      const s2 = Fn.create(ik * Fn.create(m2 + r2 * d));
       if (s2 === _0n5)
         return;
       let recovery = (q.x === r2 ? 0 : 2) | Number(q.y & _1n5);
@@ -12938,34 +12946,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 sign2(msgHash, privKey, opts = defaultSigOpts) {
     const { seed, k2sig } = prepSig(msgHash, privKey, opts);
-    const C = CURVE;
-    const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
+    const drbg = createHmacDrbg(ecdsaOpts.hash.outputLen, Fn.BYTES, hmac_);
     return drbg(seed, k2sig);
   }
-  Point2.BASE._setWindowSize(8);
+  Point2.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 } = opts;
     validateSigVerOpts(opts);
+    const { lowS, prehash, format } = opts;
     if ("strict" in opts)
       throw new Error("options.strict was renamed to lowS");
-    if (format !== void 0 && format !== "compact" && format !== "der")
-      throw new Error("format must be compact or der");
-    const isHex2 = typeof sg === "string" || isBytes2(sg);
+    if (format !== void 0 && !["compact", "der", "js"].includes(format))
+      throw new Error('format must be "compact", "der" or "js"');
+    const isHex2 = typeof sg === "string" || isBytes(sg);
     const isObj = !isHex2 && !format && 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 = void 0;
     let P;
     try {
-      if (isObj)
-        _sig = new Signature(sg.r, sg.s);
+      if (isObj) {
+        if (format === void 0 || format === "js") {
+          _sig = new Signature(sg.r, sg.s);
+        } else {
+          throw new Error("invalid format");
+        }
+      }
       if (isHex2) {
         try {
           if (format !== "compact")
@@ -12986,28 +12998,77 @@ function weierstrass(curveDef) {
     if (lowS && _sig.hasHighS())
       return false;
     if (prehash)
-      msgHash = CURVE.hash(msgHash);
+      msgHash = ecdsaOpts.hash(msgHash);
     const { r: r2, s: s2 } = _sig;
     const h2 = bits2int_modN(msgHash);
-    const is = invN(s2);
-    const u1 = modN2(h2 * is);
-    const u2 = modN2(r2 * is);
-    const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
-    if (!R)
+    const is = Fn.inv(s2);
+    const u1 = Fn.create(h2 * is);
+    const u2 = Fn.create(r2 * is);
+    const R = Point2.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2));
+    if (R.is0())
       return false;
-    const v = modN2(R.x);
+    const v = Fn.create(R.x);
     return v === r2;
   }
-  return {
-    CURVE,
+  return Object.freeze({
     getPublicKey,
     getSharedSecret,
     sign: sign2,
     verify,
-    ProjectivePoint: Point2,
-    Signature,
-    utils
+    utils,
+    Point: Point2,
+    Signature
+  });
+}
+function _weierstrass_legacy_opts_to_new(c) {
+  const CURVE = {
+    a: c.a,
+    b: c.b,
+    p: c.Fp.ORDER,
+    n: c.n,
+    h: c.h,
+    Gx: c.Gx,
+    Gy: c.Gy
+  };
+  const Fp = c.Fp;
+  const Fn = Field(CURVE.n, c.nBitLength);
+  const curveOpts = {
+    Fp,
+    Fn,
+    allowedPrivateKeyLengths: c.allowedPrivateKeyLengths,
+    allowInfinityPoint: c.allowInfinityPoint,
+    endo: c.endo,
+    wrapPrivateKey: c.wrapPrivateKey,
+    isTorsionFree: c.isTorsionFree,
+    clearCofactor: c.clearCofactor,
+    fromBytes: c.fromBytes,
+    toBytes: c.toBytes
   };
+  return { CURVE, curveOpts };
+}
+function _ecdsa_legacy_opts_to_new(c) {
+  const { CURVE, curveOpts } = _weierstrass_legacy_opts_to_new(c);
+  const ecdsaOpts = {
+    hash: c.hash,
+    hmac: c.hmac,
+    randomBytes: c.randomBytes,
+    lowS: c.lowS,
+    bits2int: c.bits2int,
+    bits2int_modN: c.bits2int_modN
+  };
+  return { CURVE, curveOpts, ecdsaOpts };
+}
+function _ecdsa_new_output_to_legacy(c, ecdsa2) {
+  return Object.assign({}, ecdsa2, {
+    ProjectivePoint: ecdsa2.Point,
+    CURVE: c
+  });
+}
+function weierstrass(c) {
+  const { CURVE, curveOpts, ecdsaOpts } = _ecdsa_legacy_opts_to_new(c);
+  const Point2 = weierstrassN(CURVE, curveOpts);
+  const signs = ecdsa(Point2, ecdsaOpts, curveOpts);
+  return _ecdsa_new_output_to_legacy(c, signs);
 }
 function SWUFpSqrtRatio(Fp, Z2) {
   const q = Fp.ORDER;
@@ -13073,28 +13134,29 @@ function SWUFpSqrtRatio(Fp, Z2) {
 }
 function mapToCurveSimpleSWU(Fp, opts) {
   validateField(Fp);
-  if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))
+  const { A: A2, B, Z: Z2 } = opts;
+  if (!Fp.isValid(A2) || !Fp.isValid(B) || !Fp.isValid(Z2))
     throw new Error("mapToCurveSimpleSWU: invalid opts");
-  const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);
+  const sqrtRatio = SWUFpSqrtRatio(Fp, Z2);
   if (!Fp.isOdd)
-    throw new Error("Fp.isOdd is not implemented!");
+    throw new Error("Field does not have .isOdd()");
   return (u) => {
     let tv1, tv2, tv3, tv4, tv5, tv6, x2, y;
     tv1 = Fp.sqr(u);
-    tv1 = Fp.mul(tv1, opts.Z);
+    tv1 = Fp.mul(tv1, Z2);
     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, B);
+    tv4 = Fp.cmov(Z2, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO));
+    tv4 = Fp.mul(tv4, A2);
     tv2 = Fp.sqr(tv3);
     tv6 = Fp.sqr(tv4);
-    tv5 = Fp.mul(tv6, opts.A);
+    tv5 = Fp.mul(tv6, A2);
     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, B);
     tv2 = Fp.add(tv2, tv5);
     x2 = Fp.mul(tv1, tv3);
     const { isValid, value } = sqrtRatio(tv2, tv6);
@@ -13113,9 +13175,10 @@ var DERErr, DER, _0n5, _1n5, _2n3, _3n2, _4n2;
 var init_weierstrass = __esm({
   "node_modules/viem/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
     "use strict";
+    init_hmac();
+    init_utils4();
     init_curve();
     init_modular();
-    init_utils4();
     DERErr = class extends Error {
       constructor(m2 = "") {
         super(m2);
@@ -13230,22 +13293,13 @@ var init_weierstrass = __esm({
 });
 
 // node_modules/viem/node_modules/@noble/curves/esm/_shortw_utils.js
-function getHash(hash2) {
-  return {
-    hash: hash2,
-    hmac: (key, ...msgs) => hmac(hash2, key, concatBytes(...msgs)),
-    randomBytes
-  };
-}
 function createCurve(curveDef, defHash) {
-  const create = (hash2) => weierstrass({ ...curveDef, ...getHash(hash2) });
+  const create = (hash2) => weierstrass({ ...curveDef, hash: hash2 });
   return { ...create(defHash), create };
 }
 var init_shortw_utils = __esm({
   "node_modules/viem/node_modules/@noble/curves/esm/_shortw_utils.js"() {
     "use strict";
-    init_hmac();
-    init_utils2();
     init_weierstrass();
   }
 });
@@ -13275,52 +13329,55 @@ function anum(item) {
     throw new Error("number expected");
 }
 function expand_message_xmd(msg, DST, lenInBytes, H) {
-  abytes2(msg);
-  abytes2(DST);
+  abytes(msg);
+  abytes(DST);
   anum(lenInBytes);
   if (DST.length > 255)
-    DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
+    DST = H(concatBytes(utf8ToBytes("H2C-OVERSIZE-DST-"), DST));
   const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
   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 b = new Array(ell);
-  const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
-  b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
+  const b_0 = H(concatBytes(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
+  b[0] = H(concatBytes(b_0, i2osp(1, 1), DST_prime));
   for (let i2 = 1; i2 <= ell; i2++) {
     const args = [strxor(b_0, b[i2 - 1]), i2osp(i2 + 1, 1), DST_prime];
-    b[i2] = H(concatBytes3(...args));
+    b[i2] = H(concatBytes(...args));
   }
-  const pseudo_random_bytes = concatBytes3(...b);
+  const pseudo_random_bytes = concatBytes(...b);
   return pseudo_random_bytes.slice(0, lenInBytes);
 }
 function expand_message_xof(msg, DST, lenInBytes, k, H) {
-  abytes2(msg);
-  abytes2(DST);
+  abytes(msg);
+  abytes(DST);
   anum(lenInBytes);
   if (DST.length > 255) {
     const dkLen = Math.ceil(2 * k / 8);
-    DST = H.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
+    DST = H.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 H.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, k, m: m2, 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 = p.toString(2).length;
   const L = Math.ceil((log2p + k) / 8);
   const len_in_bytes = count * m2 * L;
@@ -13371,21 +13428,21 @@ function createHasher2(Point2, mapToCurve, defaults) {
   }
   return {
     defaults,
-    // Encodes byte string to elliptic curve.
-    // hash_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
     hashToCurve(msg, options) {
-      const u = hash_to_field(msg, 2, { ...defaults, DST: defaults.DST, ...options });
+      const dst = defaults.DST ? defaults.DST : {};
+      const opts = Object.assign({}, defaults, dst, options);
+      const u = hash_to_field(msg, 2, opts);
       const u0 = map(u[0]);
       const u1 = map(u[1]);
       return clear(u0.add(u1));
     },
-    // Encodes byte string to elliptic curve.
-    // encode_to_curve from https://www.rfc-editor.org/rfc/rfc9380#section-3
     encodeToCurve(msg, options) {
-      const u = hash_to_field(msg, 1, { ...defaults, DST: defaults.encodeDST, ...options });
+      const dst = defaults.encodeDST ? defaults.encodeDST : {};
+      const opts = Object.assign({}, defaults, dst, options);
+      const u = hash_to_field(msg, 1, opts);
       return clear(map(u[0]));
     },
-    // Same as encodeToCurve, but without hash
+    /** See {@link H2CHasher} */
     mapToCurve(scalars) {
       if (!Array.isArray(scalars))
         throw new Error("expected array of bigints");
@@ -13400,8 +13457,8 @@ var os2ip;
 var init_hash_to_curve = __esm({
   "node_modules/viem/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
     "use strict";
-    init_modular();
     init_utils4();
+    init_modular();
     os2ip = bytesToNumberBE;
   }
 });
@@ -13416,7 +13473,7 @@ __export(secp256k1_exports, {
   secp256k1_hasher: () => secp256k1_hasher
 });
 function sqrtMod(y) {
-  const P = secp256k1P;
+  const P = 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 b2 = y * y * y % P;
@@ -13441,25 +13498,25 @@ function taggedHash(tag, ...messages) {
   let tagP = TAGGED_HASH_PREFIXES[tag];
   if (tagP === void 0) {
     const tagH = sha256(Uint8Array.from(tag, (c) => c.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 p = Point.fromPrivateKey(d_);
-  const scalar = p.hasEvenY() ? d_ : modN(-d_);
+  const scalar = hasEven(p.y) ? d_ : modN(-d_);
   return { scalar, bytes: pointToBytes(p) };
 }
 function lift_x(x2) {
-  aInRange("x", x2, _1n6, secp256k1P);
+  aInRange("x", x2, _1n6, secp256k1_CURVE.p);
   const xx = modP(x2 * x2);
   const c = modP(xx * x2 + BigInt(7));
   let y = sqrtMod(c);
-  if (y % _2n4 !== _0n6)
+  if (!hasEven(y))
     y = modP(-y);
-  const p = new Point(x2, y, _1n6);
+  const p = Point.fromAffine({ x: x2, y });
   p.assertValidity();
   return p;
 }
@@ -13494,21 +13551,22 @@ function schnorrVerify(signature, message, publicKey) {
   try {
     const P = lift_x(num(pub));
     const r2 = num(sig.subarray(0, 32));
-    if (!inRange(r2, _1n6, secp256k1P))
+    if (!inRange(r2, _1n6, secp256k1_CURVE.p))
       return false;
     const s2 = num(sig.subarray(32, 64));
-    if (!inRange(s2, _1n6, secp256k1N))
+    if (!inRange(s2, _1n6, secp256k1_CURVE.n))
       return false;
     const e2 = challenge(numTo32b(r2), pointToBytes(P), m2);
-    const R = GmulAdd(P, s2, modN(-e2));
-    if (!R || !R.hasEvenY() || R.toAffine().x !== r2)
+    const R = Point.BASE.multiplyUnsafe(s2).add(P.multiplyUnsafe(modN(-e2)));
+    const { x: x2, y } = R.toAffine();
+    if (R.is0() || !hasEven(y) || x2 !== r2)
       return false;
     return true;
   } catch (error) {
     return false;
   }
 }
-var secp256k1P, secp256k1N, _0n6, _1n6, _2n4, divNearest, Fpk1, secp256k1, TAGGED_HASH_PREFIXES, pointToBytes, numTo32b, modP, modN, Point, GmulAdd, num, schnorr, isoMap, mapSWU, secp256k1_hasher, hashToCurve, encodeToCurve;
+var secp256k1_CURVE, _0n6, _1n6, _2n4, divNearest, Fpk1, secp256k1, TAGGED_HASH_PREFIXES, pointToBytes, numTo32b, modP, modN, Point, hasEven, num, schnorr, isoMap, mapSWU, secp256k1_hasher, hashToCurve, encodeToCurve;
 var init_secp256k1 = __esm({
   "node_modules/viem/node_modules/@noble/curves/esm/secp256k1.js"() {
     "use strict";
@@ -13517,30 +13575,32 @@ var init_secp256k1 = __esm({
     init_shortw_utils();
     init_hash_to_curve();
     init_modular();
-    init_utils4();
     init_weierstrass();
-    secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
-    secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
+    init_utils4();
+    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);
     divNearest = (a, b) => (a + b / _2n4) / b;
-    Fpk1 = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
+    Fpk1 = Field(secp256k1_CURVE.p, void 0, void 0, { 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,
       // Allow only low-S signatures by default in sign() and verify()
       endo: {
         // Endomorphism, see above
         beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
         splitScalar: (k) => {
-          const n = secp256k1N;
+          const n = secp256k1_CURVE.n;
           const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
           const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
           const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
@@ -13564,12 +13624,12 @@ var init_secp256k1 = __esm({
       }
     }, sha256);
     TAGGED_HASH_PREFIXES = {};
-    pointToBytes = (point) => point.toRawBytes(true).slice(1);
+    pointToBytes = (point) => point.toBytes(true).slice(1);
     numTo32b = (n) => numberToBytesBE(n, 32);
-    modP = (x2) => mod(x2, secp256k1P);
-    modN = (x2) => mod(x2, secp256k1N);
-    Point = /* @__PURE__ */ (() => secp256k1.ProjectivePoint)();
-    GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
+    modP = (x2) => mod(x2, secp256k1_CURVE.p);
+    modN = (x2) => mod(x2, secp256k1_CURVE.n);
+    Point = /* @__PURE__ */ (() => secp256k1.Point)();
+    hasEven = (y) => y % _2n4 === _0n6;
     num = bytesToNumberBE;
     schnorr = /* @__PURE__ */ (() => ({
       getPublicKey: schnorrGetPublicKey,
@@ -13621,7 +13681,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: x2, y } = mapSWU(Fpk1.create(scalars[0]));
       return isoMap(x2, y);
     }, {
@@ -14212,6 +14272,80 @@ var init_decodeFunctionResult = __esm({
   }
 });
 
+// node_modules/ox/node_modules/@noble/hashes/esm/utils.js
+function isBytes2(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber2(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function abytes2(b, ...lengths) {
+  if (!isBytes2(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists2(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput2(out, instance) {
+  abytes2(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function u322(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean2(...arrays) {
+  for (let i2 = 0; i2 < arrays.length; i2++) {
+    arrays[i2].fill(0);
+  }
+}
+function byteSwap2(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap322(arr) {
+  for (let i2 = 0; i2 < arr.length; i2++) {
+    arr[i2] = byteSwap2(arr[i2]);
+  }
+  return arr;
+}
+function utf8ToBytes2(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes3(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes2(data);
+  abytes2(data);
+  return data;
+}
+function createHasher3(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes3(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+var isLE2, swap32IfBE2, Hash2;
+var init_utils5 = __esm({
+  "node_modules/ox/node_modules/@noble/hashes/esm/utils.js"() {
+    "use strict";
+    isLE2 = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+    swap32IfBE2 = isLE2 ? (u) => u : byteSwap322;
+    Hash2 = class {
+    };
+  }
+});
+
 // node_modules/ox/_esm/core/version.js
 var version4;
 var init_version3 = __esm({
@@ -15421,7 +15555,7 @@ async function localBatchGatewayRequest(parameters) {
   const responses = [];
   await Promise.all(queries.map(async (query, i2) => {
     try {
-      responses[i2] = await ccipRequest2(query);
+      responses[i2] = query.urls.includes(localBatchGatewayUrl) ? await localBatchGatewayRequest({ data: query.data, ccipRequest: ccipRequest2 }) : await ccipRequest2(query);
       failures[i2] = false;
     } catch (err) {
       failures[i2] = true;
@@ -15597,7 +15731,7 @@ var init_ccip2 = __esm({
 
 // node_modules/viem/_esm/actions/public/call.js
 async function call(client, args) {
-  const { account: account_ = client.account, authorizationList, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = "pending", accessList, blobs, blockOverrides, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
+  const { account: account_ = client.account, authorizationList, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = "latest", accessList, blobs, blockOverrides, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
   const account = account_ ? parseAccount(account_) : void 0;
   if (code && (factory || factoryData))
     throw new BaseError2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
@@ -15706,7 +15840,7 @@ function shouldPerformMulticall({ request }) {
 }
 async function scheduleMulticall(client, args) {
   const { batchSize = 1024, wait: wait2 = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
-  const { blockNumber, blockTag = "pending", data, multicallAddress: multicallAddress_, to } = args;
+  const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
   let multicallAddress = multicallAddress_;
   if (!multicallAddress) {
     if (!client.chain)
@@ -15896,8 +16030,8 @@ var require_re = __commonJS({
     createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
     createToken("MAINVERSION", `(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})`);
     createToken("MAINVERSIONLOOSE", `(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})`);
-    createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NUMERICIDENTIFIER]}|${src[t2.NONNUMERICIDENTIFIER]})`);
-    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NUMERICIDENTIFIERLOOSE]}|${src[t2.NONNUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NONNUMERICIDENTIFIER]}|${src[t2.NUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NONNUMERICIDENTIFIER]}|${src[t2.NUMERICIDENTIFIERLOOSE]})`);
     createToken("PRERELEASE", `(?:-(${src[t2.PRERELEASEIDENTIFIER]}(?:\\.${src[t2.PRERELEASEIDENTIFIER]})*))`);
     createToken("PRERELEASELOOSE", `(?:-?(${src[t2.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t2.PRERELEASEIDENTIFIERLOOSE]})*))`);
     createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
@@ -15987,7 +16121,7 @@ var require_semver = __commonJS({
     "use strict";
     var debug = require_debug();
     var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
-    var { safeRe: re, safeSrc: src, t: t2 } = require_re();
+    var { safeRe: re, t: t2 } = require_re();
     var parseOptions = require_parse_options();
     var { compareIdentifiers } = require_identifiers();
     var SemVer = class _SemVer {
@@ -16132,8 +16266,7 @@ var require_semver = __commonJS({
             throw new Error("invalid increment argument: identifier is empty");
           }
           if (identifier) {
-            const r2 = new RegExp(`^${this.options.loose ? src[t2.PRERELEASELOOSE] : src[t2.PRERELEASE]}$`);
-            const match = `-${identifier}`.match(r2);
+            const match = `-${identifier}`.match(this.options.loose ? re[t2.PRERELEASELOOSE] : re[t2.PRERELEASE]);
             if (!match || match[1] !== identifier) {
               throw new Error(`invalid identifier: ${identifier}`);
             }
@@ -17723,7 +17856,7 @@ var require_semver2 = __commonJS({
 import { program } from "commander";
 
 // package.json
-var version = "0.22.0";
+var version = "0.23.0";
 var package_default = {
   name: "genlayer",
   version,
@@ -17770,7 +17903,7 @@ var package_default = {
     "@types/uuid": "^10.0.0",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
-    "@vitest/coverage-v8": "^2.1.4",
+    "@vitest/coverage-v8": "^3.0.0",
     "cross-env": "^7.0.3",
     esbuild: ">=0.25.0",
     eslint: "^9.0.0",
@@ -17785,9 +17918,9 @@ var package_default = {
   },
   dependencies: {
     chalk: "^5.4.1",
-    commander: "^13.1.0",
+    commander: "^14.0.0",
     dockerode: "^4.0.2",
-    dotenv: "^16.4.5",
+    dotenv: "^17.0.0",
     ethers: "^6.13.4",
     "fs-extra": "^11.3.0",
     "genlayer-js": "^0.11.0",
@@ -17798,7 +17931,7 @@ var package_default = {
     "update-check": "^1.5.4",
     uuid: "^11.0.0",
     viem: "^2.21.54",
-    vitest: "^2.1.4"
+    vitest: "^3.0.0"
   },
   overrides: {
     vite: {
@@ -21690,7 +21823,7 @@ async function estimateGas(client, args) {
       const { block: block2, request: request2, rpcStateOverride: rpcStateOverride2 } = parameters;
       return client.request({
         method: "eth_estimateGas",
-        params: rpcStateOverride2 ? [request2, block2 ?? "pending", rpcStateOverride2] : block2 ? [request2, block2] : [request2]
+        params: rpcStateOverride2 ? [request2, block2 ?? "latest", rpcStateOverride2] : block2 ? [request2, block2] : [request2]
       });
     };
     var estimateGas_rpc = estimateGas_rpc2;
@@ -21819,26 +21952,25 @@ function decodeEventLog(parameters) {
   const [signature, ...argTopics] = topics;
   if (!signature)
     throw new AbiEventSignatureEmptyTopicsError({ docsPath: docsPath3 });
-  const abiItem = (() => {
-    if (abi2.length === 1)
-      return abi2[0];
-    return abi2.find((x2) => x2.type === "event" && signature === toEventSelector(formatAbiItem2(x2)));
-  })();
+  const abiItem = abi2.find((x2) => x2.type === "event" && signature === toEventSelector(formatAbiItem2(x2)));
   if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
     throw new AbiEventSignatureNotFoundError(signature, { docsPath: docsPath3 });
   const { name, inputs } = abiItem;
   const isUnnamed = inputs?.some((x2) => !("name" in x2 && x2.name));
-  let args = isUnnamed ? [] : {};
-  const indexedInputs = inputs.filter((x2) => "indexed" in x2 && x2.indexed);
+  const args = isUnnamed ? [] : {};
+  const indexedInputs = inputs.map((x2, i2) => [x2, i2]).filter(([x2]) => "indexed" in x2 && x2.indexed);
   for (let i2 = 0; i2 < indexedInputs.length; i2++) {
-    const param = indexedInputs[i2];
+    const [param, argIndex] = indexedInputs[i2];
     const topic = argTopics[i2];
     if (!topic)
       throw new DecodeLogTopicsMismatch({
         abiItem,
         param
       });
-    args[isUnnamed ? i2 : param.name || i2] = decodeTopic({ param, value: topic });
+    args[isUnnamed ? argIndex : param.name || argIndex] = decodeTopic({
+      param,
+      value: topic
+    });
   }
   const nonIndexedInputs = inputs.filter((x2) => !("indexed" in x2 && x2.indexed));
   if (nonIndexedInputs.length > 0) {
@@ -21847,12 +21979,11 @@ function decodeEventLog(parameters) {
         const decodedData = decodeAbiParameters(nonIndexedInputs, data);
         if (decodedData) {
           if (isUnnamed)
-            args = [...args, ...decodedData];
-          else {
-            for (let i2 = 0; i2 < nonIndexedInputs.length; i2++) {
+            for (let i2 = 0; i2 < inputs.length; i2++)
+              args[i2] = args[i2] ?? decodedData.shift();
+          else
+            for (let i2 = 0; i2 < nonIndexedInputs.length; i2++)
               args[nonIndexedInputs[i2].name] = decodedData[i2];
-            }
-          }
         }
       } catch (err) {
         if (strict) {
@@ -22152,8 +22283,12 @@ 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 p = cleanup2();
+      if (p instanceof Promise)
+        p.catch(() => {
+        });
+    }
     unsubscribe();
   };
   const listeners = getListeners();
@@ -22296,9 +22431,9 @@ function watchContractEvent(client, parameters) {
       return poll_;
     if (typeof fromBlock === "bigint")
       return true;
-    if (client.transport.type === "webSocket")
+    if (client.transport.type === "webSocket" || client.transport.type === "ipc")
       return false;
-    if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
+    if (client.transport.type === "fallback" && (client.transport.transports[0].config.type === "webSocket" || client.transport.transports[0].config.type === "ipc"))
       return false;
     return true;
   })();
@@ -22401,7 +22536,7 @@ function watchContractEvent(client, parameters) {
         try {
           const transport = (() => {
             if (client.transport.type === "fallback") {
-              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
+              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket" || transport3.config.type === "ipc");
               if (!transport2)
                 return client.transport;
               return transport2.value;
@@ -22757,10 +22892,6 @@ var fallbackTransactionErrorMagicIdentifier = numberToHex(0, {
 });
 async function sendCalls(client, parameters) {
   const { account: account_ = client.account, capabilities, chain = client.chain, experimental_fallback, experimental_fallbackDelay = 32, forceAtomic = false, id, version: version5 = "2.0.0" } = parameters;
-  if (typeof account_ === "undefined")
-    throw new AccountNotFoundError({
-      docsPath: "/docs/actions/wallet/sendCalls"
-    });
   const account = account_ ? parseAccount(account_) : null;
   const calls = parameters.calls.map((call_) => {
     const call2 = call_;
@@ -22770,7 +22901,7 @@ async function sendCalls(client, parameters) {
       args: call2.args
     }) : call2.data;
     return {
-      data,
+      data: call2.dataSuffix && data ? concat([data, call2.dataSuffix]) : data,
       to: call2.to,
       value: call2.value ? numberToHex(call2.value) : void 0
     };
@@ -22795,7 +22926,7 @@ async function sendCalls(client, parameters) {
     return response;
   } catch (err) {
     const error = err;
-    if (experimental_fallback && (error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError" || error.details.toLowerCase().includes("does not exist / is not available") || error.details.toLowerCase().includes("missing or invalid. request()") || error.details.toLowerCase().includes("did not match any variant of untagged enum"))) {
+    if (experimental_fallback && (error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError" || error.name === "UnknownRpcError" || error.details.toLowerCase().includes("does not exist / is not available") || error.details.toLowerCase().includes("missing or invalid. request()") || error.details.toLowerCase().includes("did not match any variant of untagged enum") || error.details.toLowerCase().includes("account upgraded to unsupported contract") || error.details.toLowerCase().includes("eip-7702 not supported") || error.details.toLowerCase().includes("unsupported wc_ method"))) {
       if (capabilities) {
         const hasNonOptionalCapability = Object.values(capabilities).some((capability) => !capability.optional);
         if (hasNonOptionalCapability) {
@@ -22974,8 +23105,11 @@ function uid(length = 11) {
 
 // node_modules/viem/_esm/clients/createClient.js
 function createClient(parameters) {
-  const { batch, cacheTime = parameters.pollingInterval ?? 4e3, ccipRead, key = "base", name = "Base Client", pollingInterval = 4e3, type = "base" } = parameters;
-  const chain = parameters.chain;
+  const { batch, chain, ccipRead, key = "base", name = "Base Client", type = "base" } = parameters;
+  const blockTime = chain?.blockTime ?? 12e3;
+  const defaultPollingInterval = Math.min(Math.max(Math.floor(blockTime / 2), 500), 4e3);
+  const pollingInterval = parameters.pollingInterval ?? defaultPollingInterval;
+  const cacheTime = parameters.cacheTime ?? pollingInterval;
   const account = parameters.account ? parseAccount(parameters.account) : void 0;
   const { config, request, value } = parameters.transport({
     chain,
@@ -24464,13 +24598,13 @@ function serializeTransactionEIP7702(transaction, signature) {
   return concatHex([
     "0x04",
     toRlp([
-      toHex(chainId),
-      nonce ? toHex(nonce) : "0x",
-      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
-      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
-      gas ? toHex(gas) : "0x",
+      numberToHex(chainId),
+      nonce ? numberToHex(nonce) : "0x",
+      maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
+      maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
+      gas ? numberToHex(gas) : "0x",
       to ?? "0x",
-      value ? toHex(value) : "0x",
+      value ? numberToHex(value) : "0x",
       data ?? "0x",
       serializedAccessList,
       serializedAuthorizationList,
@@ -24501,16 +24635,16 @@ function serializeTransactionEIP4844(transaction, signature) {
   }
   const serializedAccessList = serializeAccessList(accessList);
   const serializedTransaction = [
-    toHex(chainId),
-    nonce ? toHex(nonce) : "0x",
-    maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
-    maxFeePerGas ? toHex(maxFeePerGas) : "0x",
-    gas ? toHex(gas) : "0x",
+    numberToHex(chainId),
+    nonce ? numberToHex(nonce) : "0x",
+    maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
+    maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
+    gas ? numberToHex(gas) : "0x",
     to ?? "0x",
-    value ? toHex(value) : "0x",
+    value ? numberToHex(value) : "0x",
     data ?? "0x",
     serializedAccessList,
-    maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
+    maxFeePerBlobGas ? numberToHex(maxFeePerBlobGas) : "0x",
     blobVersionedHashes ?? [],
     ...toYParitySignatureArray(transaction, signature)
   ];
@@ -24540,13 +24674,13 @@ function serializeTransactionEIP1559(transaction, signature) {
   assertTransactionEIP1559(transaction);
   const serializedAccessList = serializeAccessList(accessList);
   const serializedTransaction = [
-    toHex(chainId),
-    nonce ? toHex(nonce) : "0x",
-    maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
-    maxFeePerGas ? toHex(maxFeePerGas) : "0x",
-    gas ? toHex(gas) : "0x",
+    numberToHex(chainId),
+    nonce ? numberToHex(nonce) : "0x",
+    maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
+    maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
+    gas ? numberToHex(gas) : "0x",
     to ?? "0x",
-    value ? toHex(value) : "0x",
+    value ? numberToHex(value) : "0x",
     data ?? "0x",
     serializedAccessList,
     ...toYParitySignatureArray(transaction, signature)
@@ -24561,12 +24695,12 @@ function serializeTransactionEIP2930(transaction, signature) {
   assertTransactionEIP2930(transaction);
   const serializedAccessList = serializeAccessList(accessList);
   const serializedTransaction = [
-    toHex(chainId),
-    nonce ? toHex(nonce) : "0x",
-    gasPrice ? toHex(gasPrice) : "0x",
-    gas ? toHex(gas) : "0x",
+    numberToHex(chainId),
+    nonce ? numberToHex(nonce) : "0x",
+    gasPrice ? numberToHex(gasPrice) : "0x",
+    gas ? numberToHex(gas) : "0x",
     to ?? "0x",
-    value ? toHex(value) : "0x",
+    value ? numberToHex(value) : "0x",
     data ?? "0x",
     serializedAccessList,
     ...toYParitySignatureArray(transaction, signature)
@@ -24580,11 +24714,11 @@ function serializeTransactionLegacy(transaction, signature) {
   const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
   assertTransactionLegacy(transaction);
   let serializedTransaction = [
-    nonce ? toHex(nonce) : "0x",
-    gasPrice ? toHex(gasPrice) : "0x",
-    gas ? toHex(gas) : "0x",
+    nonce ? numberToHex(nonce) : "0x",
+    gasPrice ? numberToHex(gasPrice) : "0x",
+    gas ? numberToHex(gas) : "0x",
     to ?? "0x",
-    value ? toHex(value) : "0x",
+    value ? numberToHex(value) : "0x",
     data ?? "0x"
   ];
   if (signature) {
@@ -24606,14 +24740,14 @@ function serializeTransactionLegacy(transaction, signature) {
     const s2 = trim(signature.s);
     serializedTransaction = [
       ...serializedTransaction,
-      toHex(v),
+      numberToHex(v),
       r2 === "0x00" ? "0x" : r2,
       s2 === "0x00" ? "0x" : s2
     ];
   } else if (chainId > 0) {
     serializedTransaction = [
       ...serializedTransaction,
-      toHex(chainId),
+      numberToHex(chainId),
       "0x",
       "0x"
     ];
@@ -24633,12 +24767,12 @@ function toYParitySignatureArray(transaction, signature_) {
   const s2 = trim(signature.s);
   const yParity_ = (() => {
     if (typeof yParity === "number")
-      return yParity ? toHex(1) : "0x";
+      return yParity ? numberToHex(1) : "0x";
     if (v === 0n)
       return "0x";
     if (v === 1n)
-      return toHex(1);
-    return v === 27n ? "0x" : toHex(1);
+      return numberToHex(1);
+    return v === 27n ? "0x" : numberToHex(1);
   })();
   return [yParity_, r2 === "0x00" ? "0x" : r2, s2 === "0x00" ? "0x" : s2];
 }
@@ -25009,13 +25143,14 @@ init_contract();
 init_node();
 init_decodeFunctionResult();
 init_encodeFunctionData();
+init_concat();
 init_toHex();
 init_getNodeError();
 init_transactionRequest();
 init_stateOverride2();
 init_assertRequest();
 async function simulateBlocks(client, parameters) {
-  const { blockNumber, blockTag = "pending", blocks, returnFullTransactions, traceTransfers, validation } = parameters;
+  const { blockNumber, blockTag = "latest", blocks, returnFullTransactions, traceTransfers, validation } = parameters;
   try {
     const blockStateCalls = [];
     for (const block2 of blocks) {
@@ -25023,9 +25158,10 @@ async function simulateBlocks(client, parameters) {
       const calls = block2.calls.map((call_) => {
         const call2 = call_;
         const account = call2.account ? parseAccount(call2.account) : void 0;
+        const data = call2.abi ? encodeFunctionData(call2) : call2.data;
         const request = {
           ...call2,
-          data: call2.abi ? encodeFunctionData(call2) : call2.data,
+          data: call2.dataSuffix ? concat([data || "0x", call2.dataSuffix]) : data,
           from: call2.from ?? account?.address
         };
         assertRequest(request);
@@ -25072,7 +25208,7 @@ async function simulateBlocks(client, parameters) {
             return void 0;
           return getContractError(error2, {
             abi: abi2 ?? [],
-            address: to,
+            address: to ?? "0x",
             args,
             functionName: functionName ?? "<unknown>"
           });
@@ -25103,74 +25239,6 @@ async function simulateBlocks(client, parameters) {
 init_exports();
 init_Errors();
 
-// node_modules/ox/node_modules/@noble/hashes/esm/utils.js
-function isBytes3(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-function anumber2(n) {
-  if (!Number.isSafeInteger(n) || n < 0)
-    throw new Error("positive integer expected, got " + n);
-}
-function abytes3(b, ...lengths) {
-  if (!isBytes3(b))
-    throw new Error("Uint8Array expected");
-  if (lengths.length > 0 && !lengths.includes(b.length))
-    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
-}
-function aexists2(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function aoutput2(out, instance) {
-  abytes3(out);
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error("digestInto() expects output buffer of length at least " + min);
-  }
-}
-function u322(arr) {
-  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-function clean2(...arrays) {
-  for (let i2 = 0; i2 < arrays.length; i2++) {
-    arrays[i2].fill(0);
-  }
-}
-var isLE2 = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-function byteSwap2(word) {
-  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
-}
-function byteSwap322(arr) {
-  for (let i2 = 0; i2 < arr.length; i2++) {
-    arr[i2] = byteSwap2(arr[i2]);
-  }
-  return arr;
-}
-var swap32IfBE2 = isLE2 ? (u) => u : byteSwap322;
-function utf8ToBytes3(str) {
-  if (typeof str !== "string")
-    throw new Error("string expected");
-  return new Uint8Array(new TextEncoder().encode(str));
-}
-function toBytes3(data) {
-  if (typeof data === "string")
-    data = utf8ToBytes3(data);
-  abytes3(data);
-  return data;
-}
-var Hash2 = class {
-};
-function createHasher3(hashCons) {
-  const hashC = (msg) => hashCons().update(toBytes3(msg)).digest();
-  const tmp = hashCons();
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.create = () => hashCons();
-  return hashC;
-}
-
 // node_modules/ox/node_modules/@noble/hashes/esm/_u64.js
 var U32_MASK642 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
 var _32n2 = /* @__PURE__ */ BigInt(32);
@@ -25195,6 +25263,7 @@ var rotlBH2 = (h2, l, s2) => l << s2 - 32 | h2 >>> 64 - s2;
 var rotlBL2 = (h2, l, s2) => h2 << s2 - 32 | l >>> 64 - s2;
 
 // node_modules/ox/node_modules/@noble/hashes/esm/sha3.js
+init_utils5();
 var _0n7 = BigInt(0);
 var _1n7 = BigInt(1);
 var _2n5 = BigInt(2);
@@ -25294,7 +25363,7 @@ var Keccak2 = class _Keccak extends Hash2 {
   update(data) {
     aexists2(this);
     data = toBytes3(data);
-    abytes3(data);
+    abytes2(data);
     const { blockLen, state } = this;
     const len = data.length;
     for (let pos = 0; pos < len; ) {
@@ -25319,7 +25388,7 @@ var Keccak2 = class _Keccak extends Hash2 {
   }
   writeInto(out) {
     aexists2(this, false);
-    abytes3(out);
+    abytes2(out);
     this.finish();
     const bufferOut = this.state;
     const { blockLen } = this;
@@ -26285,14 +26354,6 @@ async function simulateCalls(client, parameters) {
     });
     return accessList.map(({ address, storageKeys }) => storageKeys.length > 0 ? address : null);
   })).then((x2) => x2.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,
@@ -26324,12 +26385,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 ? [
         // ETH post balances
@@ -26589,9 +26649,9 @@ function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onB
   const enablePolling = (() => {
     if (typeof poll_ !== "undefined")
       return poll_;
-    if (client.transport.type === "webSocket")
+    if (client.transport.type === "webSocket" || client.transport.type === "ipc")
       return false;
-    if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
+    if (client.transport.type === "fallback" && (client.transport.transports[0].config.type === "webSocket" || client.transport.transports[0].config.type === "ipc"))
       return false;
     return true;
   })();
@@ -26643,7 +26703,7 @@ function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onB
         try {
           const transport = (() => {
             if (client.transport.type === "fallback") {
-              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
+              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket" || transport3.config.type === "ipc");
               if (!transport2)
                 return client.transport;
               return transport2.value;
@@ -26799,9 +26859,9 @@ function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBe
   const enablePolling = (() => {
     if (typeof poll_ !== "undefined")
       return poll_;
-    if (client.transport.type === "webSocket")
+    if (client.transport.type === "webSocket" || client.transport.type === "ipc")
       return false;
-    if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
+    if (client.transport.type === "fallback" && (client.transport.transports[0].config.type === "webSocket" || client.transport.transports[0].config.type === "ipc"))
       return false;
     return true;
   })();
@@ -26876,7 +26936,7 @@ function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBe
         }
         const transport = (() => {
           if (client.transport.type === "fallback") {
-            const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
+            const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket" || transport3.config.type === "ipc");
             if (!transport2)
               return client.transport;
             return transport2.value;
@@ -26889,7 +26949,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(() => {
             });
@@ -26925,9 +26985,9 @@ function watchEvent(client, { address, args, batch = true, event, events, fromBl
       return poll_;
     if (typeof fromBlock === "bigint")
       return true;
-    if (client.transport.type === "webSocket")
+    if (client.transport.type === "webSocket" || client.transport.type === "ipc")
       return false;
-    if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
+    if (client.transport.type === "fallback" && (client.transport.transports[0].config.type === "webSocket" || client.transport.transports[0].config.type === "ipc"))
       return false;
     return true;
   })();
@@ -27015,7 +27075,7 @@ function watchEvent(client, { address, args, batch = true, event, events, fromBl
       try {
         const transport = (() => {
           if (client.transport.type === "fallback") {
-            const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
+            const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket" || transport3.config.type === "ipc");
             if (!transport2)
               return client.transport;
             return transport2.value;
@@ -27084,7 +27144,7 @@ function watchEvent(client, { address, args, batch = true, event, events, fromBl
 // node_modules/viem/_esm/actions/public/watchPendingTransactions.js
 init_stringify();
 function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval }) {
-  const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
+  const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket" && client.transport.type !== "ipc";
   const pollPendingTransactions = () => {
     const observerId = stringify([
       "watchPendingTransactions",
@@ -27595,7 +27655,7 @@ init_encodeFunctionData();
 init_toHex();
 init_fromHex();
 
-// node_modules/genlayer-js/dist/chunk-565IJBV4.js
+// node_modules/genlayer-js/dist/chunk-GEN4SJ6K.js
 var chains_exports = {};
 __export2(chains_exports, {
   localnet: () => localnet,
@@ -35622,7 +35682,7 @@ var studionet = defineChain({
 var TESTNET_JSON_RPC_URL = " http://34.32.169.58:9151";
 var EXPLORER_URL2 = "https://explorer-asimov.genlayer.com/";
 var CONSENSUS_MAIN_CONTRACT3 = {
-  address: "0x174782d5819dD26F3d6967c995EE43db7DB824F8",
+  address: "0xe30293d600fF9B2C865d91307826F28006A458f4",
   abi: [
     {
       inputs: [],
@@ -36086,25 +36146,6 @@ var CONSENSUS_MAIN_CONTRACT3 = {
       name: "TransactionActivated",
       type: "event"
     },
-    {
-      anonymous: false,
-      inputs: [
-        {
-          indexed: true,
-          internalType: "uint256",
-          name: "batchId",
-          type: "uint256"
-        },
-        {
-          indexed: false,
-          internalType: "address[]",
-          name: "validators",
-          type: "address[]"
-        }
-      ],
-      name: "TransactionActivatedValidators",
-      type: "event"
-    },
     {
       anonymous: false,
       inputs: [
@@ -36383,19 +36424,6 @@ var CONSENSUS_MAIN_CONTRACT3 = {
       stateMutability: "view",
       type: "function"
     },
-    {
-      inputs: [],
-      name: "EVENTS_BATCH_SIZE",
-      outputs: [
-        {
-          internalType: "uint256",
-          name: "",
-          type: "uint256"
-        }
-      ],
-      stateMutability: "view",
-      type: "function"
-    },
     {
       inputs: [],
       name: "acceptOwnership",
@@ -36496,11 +36524,6 @@ var CONSENSUS_MAIN_CONTRACT3 = {
           internalType: "bytes32",
           name: "_commitHash",
           type: "bytes32"
-        },
-        {
-          internalType: "uint256",
-          name: "_validatorIndex",
-          type: "uint256"
         }
       ],
       name: "commitVote",
@@ -36913,11 +36936,6 @@ var CONSENSUS_MAIN_CONTRACT3 = {
           internalType: "uint256",
           name: "_nonce",
           type: "uint256"
-        },
-        {
-          internalType: "uint256",
-          name: "_validatorIndex",
-          type: "uint256"
         }
       ],
       name: "revealVote",
@@ -37053,7 +37071,7 @@ var CONSENSUS_MAIN_CONTRACT3 = {
   bytecode: ""
 };
 var CONSENSUS_DATA_CONTRACT3 = {
-  address: "0x88B0F18613Db92Bf970FfE264E02496e20a74D16",
+  address: "0x2a50afD9d3E0ACC824aC4850d7B4c5561aB5D27a",
   abi: [
     {
       inputs: [],
@@ -38601,6 +38619,16 @@ var CONSENSUS_DATA_CONTRACT3 = {
           internalType: "address",
           name: "ghostAddress",
           type: "address"
+        },
+        {
+          internalType: "uint256",
+          name: "numOfMessagesIssuedOnAcceptance",
+          type: "uint256"
+        },
+        {
+          internalType: "uint256",
+          name: "numOfMessagesIssuedOnFinalization",
+          type: "uint256"
         }
       ],
       stateMutability: "view",
@@ -39008,6 +39036,26 @@ var CONSENSUS_DATA_CONTRACT3 = {
               internalType: "struct ITransactions.RoundData[]",
               name: "roundData",
               type: "tuple[]"
+            },
+            {
+              internalType: "uint256",
+              name: "numOfMessagesIssuedOnAcceptance",
+              type: "uint256"
+            },
+            {
+              internalType: "uint256",
+              name: "numOfMessagesIssuedOnFinalization",
+              type: "uint256"
+            },
+            {
+              internalType: "address",
+              name: "txOrigin",
+              type: "address"
+            },
+            {
+              internalType: "uint256",
+              name: "initialRotations",
+              type: "uint256"
             }
           ],
           internalType: "struct ITransactions.Transaction",
@@ -41163,7 +41211,7 @@ import updateCheck from "update-check";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/lib/clients/system.ts
-import util from "node:util";
+import util2 from "node:util";
 import { exec } from "child_process";
 
 // node_modules/open/index.js
@@ -41171,6 +41219,7 @@ import process14 from "node:process";
 import { Buffer as Buffer4 } from "node:buffer";
 import path2 from "node:path";
 import { fileURLToPath } from "node:url";
+import util from "node:util";
 import childProcess from "node:child_process";
 import fs6, { constants as fsConstants } from "node:fs/promises";
 
@@ -41360,6 +41409,7 @@ async function defaultBrowser2() {
 }
 
 // node_modules/open/index.js
+var execFile5 = util.promisify(childProcess.execFile);
 var __dirname = path2.dirname(fileURLToPath(import.meta.url));
 var localXdgOpenPath = path2.join(__dirname, "xdg-open");
 var { platform, arch } = process14;
@@ -41390,6 +41440,34 @@ var getWslDrivesMountPoint = /* @__PURE__ */ (() => {
     return mountPoint;
   };
 })();
+var getPowershellPathFromWsl = async () => {
+  const mountPoint = await getWslDrivesMountPoint();
+  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+async function getWindowsDefaultBrowserFromWsl() {
+  const powershellPath = await getPowershellPathFromWsl();
+  const rawCommand = '(Get-ItemProperty -Path "HKCU:\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice").ProgId';
+  const encodedCommand = Buffer4.from(rawCommand, "utf16le").toString("base64");
+  const { stdout } = await execFile5(
+    powershellPath,
+    [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-EncodedCommand",
+      encodedCommand
+    ],
+    { encoding: "utf8" }
+  );
+  const progId = stdout.trim();
+  const browserMap = {
+    ChromeHTML: "com.google.chrome",
+    MSEdgeHTM: "com.microsoft.edge",
+    FirefoxURL: "org.mozilla.firefox"
+  };
+  return browserMap[progId] ? { id: browserMap[progId] } : {};
+}
 var pTryEach = async (array, mapper) => {
   let latestError;
   for (const item of array) {
@@ -41442,7 +41520,7 @@ var baseOpen = async (options) => {
       firefox: "--private-window",
       edge: "--inPrivate"
     };
-    const browser = await defaultBrowser2();
+    const browser = is_wsl_default ? await getWindowsDefaultBrowserFromWsl() : await defaultBrowser2();
     if (browser.id in ids) {
       const browserName = ids[browser.id];
       if (app === "browserPrivate") {
@@ -41476,8 +41554,7 @@ var baseOpen = async (options) => {
       cliArguments.push("-a", app);
     }
   } else if (platform === "win32" || is_wsl_default && !isInsideContainer() && !app) {
-    const mountPoint = await getWslDrivesMountPoint();
-    command = is_wsl_default ? `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe` : `${process14.env.SYSTEMROOT || process14.env.windir || "C:\\Windows"}\\System32\\WindowsPowerShell\\v1.0\\powershell`;
+    command = is_wsl_default ? await getPowershellPathFromWsl() : `${process14.env.SYSTEMROOT || process14.env.windir || "C:\\Windows"}\\System32\\WindowsPowerShell\\v1.0\\powershell`;
     cliArguments.push(
       "-NoProfile",
       "-NonInteractive",
@@ -41619,7 +41696,7 @@ var MissingRequirementError = class extends Error {
 // src/lib/clients/system.ts
 async function checkCommand(command, toolName) {
   try {
-    await util.promisify(exec)(command);
+    await util2.promisify(exec)(command);
   } catch (error) {
     if (error.stderr) {
       throw new MissingRequirementError(toolName);
@@ -41630,7 +41707,7 @@ async function executeCommand(cmdsByPlatform, toolName) {
   const runningPlatform = getPlatform();
   const command = cmdsByPlatform[runningPlatform];
   try {
-    return await util.promisify(exec)(command);
+    return await util2.promisify(exec)(command);
   } catch (error) {
     throw new Error(`Error executing ${toolName || command}: ${error.message}.`);
   }
@@ -41647,7 +41724,7 @@ function openUrl(url) {
 }
 async function getVersion2(toolName) {
   try {
-    const toolResponse = await util.promisify(exec)(`${toolName} --version`);
+    const toolResponse = await util2.promisify(exec)(`${toolName} --version`);
     if (toolResponse.stderr) {
       throw new Error(toolResponse.stderr);
     }
@@ -42832,6 +42909,51 @@ function initializeNetworkCommands(program2) {
   return program2;
 }
 
+// src/commands/transactions/receipt.ts
+var ReceiptAction = class extends BaseAction {
+  constructor() {
+    super();
+  }
+  validateTransactionStatus(status) {
+    const upperStatus = status.toUpperCase();
+    if (!(upperStatus in TransactionStatus)) {
+      const validStatuses = Object.values(TransactionStatus);
+      this.failSpinner(
+        "Invalid transaction status",
+        `Invalid status: ${status}. Valid values are: ${validStatuses.join(", ")}`
+      );
+      return;
+    }
+    return TransactionStatus[upperStatus];
+  }
+  async receipt({
+    txId,
+    status = TransactionStatus.FINALIZED,
+    retries,
+    interval,
+    rpc
+  }) {
+    const client = await this.getClient(rpc);
+    await client.initializeConsensusSmartContract();
+    this.startSpinner(`Waiting for transaction receipt ${txId} (status: ${status})...`);
+    try {
+      let validatedStatus = this.validateTransactionStatus(status);
+      if (!validatedStatus) {
+        return;
+      }
+      const result = await client.waitForTransactionReceipt({
+        hash: txId,
+        status: validatedStatus,
+        retries,
+        interval
+      });
+      this.succeedSpinner("Transaction receipt retrieved successfully", result);
+    } catch (error) {
+      this.failSpinner("Error retrieving transaction receipt", error);
+    }
+  }
+};
+
 // src/commands/transactions/appeal.ts
 var AppealAction = class extends BaseAction {
   constructor() {
@@ -42861,7 +42983,16 @@ var AppealAction = class extends BaseAction {
 };
 
 // src/commands/transactions/index.ts
+function parseIntOption(value, fallback2) {
+  const parsed = parseInt(value, 10);
+  return isNaN(parsed) ? fallback2 : parsed;
+}
 function initializeTransactionsCommands(program2) {
+  const validStatuses = Object.values(TransactionStatus).join(", ");
+  program2.command("receipt <txId>").description("Get transaction receipt by hash").option("--status <status>", `Transaction status to wait for (${validStatuses})`, TransactionStatus.FINALIZED).option("--retries <retries>", "Number of retries", (value) => parseIntOption(value, 100), 100).option("--interval <interval>", "Interval between retries in milliseconds", (value) => parseIntOption(value, 5e3), 5e3).option("--rpc <rpcUrl>", "RPC URL for the network").action(async (txId, options) => {
+    const receiptAction = new ReceiptAction();
+    await receiptAction.receipt({ txId, ...options });
+  });
   program2.command("appeal <txId>").description("Appeal a transaction by its hash").option("--rpc <rpcUrl>", "RPC URL for the network").action(async (txId, options) => {
     const appealAction = new AppealAction();
     await appealAction.appeal({ txId, ...options });
@@ -42907,27 +43038,15 @@ formdata-polyfill/esm.min.js:
 node-domexception/index.js:
   (*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)
 
+@noble/hashes/esm/utils.js:
 @noble/hashes/esm/utils.js:
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
-@noble/curves/esm/abstract/utils.js:
-  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
+@noble/curves/esm/utils.js:
 @noble/curves/esm/abstract/modular.js:
-  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
 @noble/curves/esm/abstract/curve.js:
-  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
 @noble/curves/esm/abstract/weierstrass.js:
-  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
 @noble/curves/esm/_shortw_utils.js:
-  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
 @noble/curves/esm/secp256k1.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
-@noble/hashes/esm/utils.js:
-  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */