starknet 5.9.0 → 5.9.2

package/dist/index.global.js

@@ -9,8 +9,8 @@ var starknet = (() => {
   var __esm = (fn, res) => function __init() {
     return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
   };
-  var __commonJS = (cb, mod2) => function __require() {
-    return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+  var __commonJS = (cb, mod3) => function __require() {
+    return mod3 || (0, cb[__getOwnPropNames(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.exports;
   };
   var __export = (target, all) => {
     for (var name in all)
@@ -24,11 +24,11 @@ var starknet = (() => {
     }
     return to;
   };
-  var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
-    isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
-    mod2
+  var __toESM = (mod3, isNodeMode, target) => (target = mod3 != null ? __create(__getProtoOf(mod3)) : {}, __copyProps(
+    isNodeMode || !mod3 || !mod3.__esModule ? __defProp(target, "default", { value: mod3, enumerable: true }) : target,
+    mod3
   ));
-  var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+  var __toCommonJS = (mod3) => __copyProps(__defProp({}, "__esModule", { value: true }), mod3);
 
   // node_modules/whatwg-fetch/fetch.js
   var fetch_exports = {};
@@ -760,7 +760,7 @@ var starknet = (() => {
     verify: () => verify
   });
 
-  // node_modules/@noble/hashes/esm/_assert.js
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/_assert.js
   function number(n) {
     if (!Number.isSafeInteger(n) || n < 0)
       throw new Error(`Wrong positive integer: ${n}`);
@@ -804,7 +804,7 @@ var starknet = (() => {
   };
   var assert_default = assert2;
 
-  // node_modules/@noble/hashes/esm/_u64.js
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/_u64.js
   var U32_MASK64 = BigInt(2 ** 32 - 1);
   var _32n = BigInt(32);
   function fromBig(n, le = false) {
@@ -870,10 +870,10 @@ var starknet = (() => {
   };
   var u64_default = u64;
 
-  // node_modules/@noble/hashes/esm/crypto.js
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/crypto.js
   var crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
 
-  // node_modules/@noble/hashes/esm/utils.js
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/utils.js
   var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
   var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
   var rotr = (word, shift) => word << 32 - shift | word >>> shift;
@@ -936,7 +936,7 @@ var starknet = (() => {
     throw new Error("crypto.getRandomValues must be defined");
   }
 
-  // node_modules/@noble/hashes/esm/sha3.js
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/sha3.js
   var [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
   var _0n = BigInt(0);
   var _1n = BigInt(1);
@@ -1115,7 +1115,7 @@ var starknet = (() => {
   var shake128 = genShake(31, 168, 128 / 8);
   var shake256 = genShake(31, 136, 256 / 8);
 
-  // node_modules/@noble/hashes/esm/_sha2.js
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/_sha2.js
   function setBigUint64(view, byteOffset, value, isLE2) {
     if (typeof view.setBigUint64 === "function")
       return view.setBigUint64(byteOffset, value, isLE2);
@@ -1215,7 +1215,7 @@ var starknet = (() => {
     }
   };
 
-  // node_modules/@noble/hashes/esm/sha256.js
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/sha256.js
   var Chi = (a, b, c) => a & b ^ ~a & c;
   var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
   var SHA256_K = new Uint32Array([
@@ -1381,7 +1381,7 @@ var starknet = (() => {
   var sha256 = wrapConstructor(() => new SHA256());
   var sha224 = wrapConstructor(() => new SHA224());
 
-  // node_modules/@noble/curves/esm/abstract/utils.js
+  // node_modules/micro-starknet/node_modules/@noble/curves/esm/abstract/utils.js
   var utils_exports = {};
   __export(utils_exports, {
     bitGet: () => bitGet,
@@ -1499,11 +1499,11 @@ var starknet = (() => {
   }
   function bitLen(n) {
     let len;
-    for (len = 0; n > 0n; n >>= _1n2, len += 1)
+    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
       ;
     return len;
   }
-  var bitGet = (n, pos) => n >> BigInt(pos) & 1n;
+  var bitGet = (n, pos) => n >> BigInt(pos) & _1n2;
   var bitSet = (n, pos, value) => n | (value ? _1n2 : _0n2) << BigInt(pos);
   var bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
   var u8n = (data) => new Uint8Array(data);
@@ -1585,7 +1585,7 @@ var starknet = (() => {
     return object;
   }
 
-  // node_modules/@noble/curves/esm/abstract/modular.js
+  // node_modules/micro-starknet/node_modules/@noble/curves/esm/abstract/modular.js
   var _0n3 = BigInt(0);
   var _1n3 = BigInt(1);
   var _2n3 = BigInt(2);
@@ -1641,34 +1641,34 @@ var starknet = (() => {
       ;
     if (S === 1) {
       const p1div4 = (P + _1n3) / _4n;
-      return function tonelliFast(Fp2, n) {
-        const root = Fp2.pow(n, p1div4);
-        if (!Fp2.eql(Fp2.sqr(root), n))
+      return function tonelliFast(Fp, n) {
+        const root = Fp.pow(n, p1div4);
+        if (!Fp.eql(Fp.sqr(root), n))
           throw new Error("Cannot find square root");
         return root;
       };
     }
     const Q1div2 = (Q + _1n3) / _2n3;
-    return function tonelliSlow(Fp2, n) {
-      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
+    return function tonelliSlow(Fp, n) {
+      if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))
         throw new Error("Cannot find square root");
       let r = S;
-      let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
-      let x = Fp2.pow(n, Q1div2);
-      let b = Fp2.pow(n, Q);
-      while (!Fp2.eql(b, Fp2.ONE)) {
-        if (Fp2.eql(b, Fp2.ZERO))
-          return Fp2.ZERO;
+      let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q);
+      let x = Fp.pow(n, Q1div2);
+      let b = Fp.pow(n, Q);
+      while (!Fp.eql(b, Fp.ONE)) {
+        if (Fp.eql(b, Fp.ZERO))
+          return Fp.ZERO;
         let m = 1;
-        for (let t2 = Fp2.sqr(b); m < r; m++) {
-          if (Fp2.eql(t2, Fp2.ONE))
+        for (let t2 = Fp.sqr(b); m < r; m++) {
+          if (Fp.eql(t2, Fp.ONE))
             break;
-          t2 = Fp2.sqr(t2);
+          t2 = Fp.sqr(t2);
         }
-        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
-        g = Fp2.sqr(ge);
-        x = Fp2.mul(x, ge);
-        b = Fp2.mul(b, g);
+        const ge = Fp.pow(g, _1n3 << BigInt(r - m - 1));
+        g = Fp.sqr(ge);
+        x = Fp.mul(x, ge);
+        b = Fp.mul(b, g);
         r = m;
       }
       return x;
@@ -1677,22 +1677,22 @@ var starknet = (() => {
   function FpSqrt(P) {
     if (P % _4n === _3n) {
       const p1div4 = (P + _1n3) / _4n;
-      return function sqrt3mod4(Fp2, n) {
-        const root = Fp2.pow(n, p1div4);
-        if (!Fp2.eql(Fp2.sqr(root), n))
+      return function sqrt3mod4(Fp, n) {
+        const root = Fp.pow(n, p1div4);
+        if (!Fp.eql(Fp.sqr(root), n))
           throw new Error("Cannot find square root");
         return root;
       };
     }
     if (P % _8n === _5n) {
       const c1 = (P - _5n) / _8n;
-      return function sqrt5mod8(Fp2, n) {
-        const n2 = Fp2.mul(n, _2n3);
-        const v = Fp2.pow(n2, c1);
-        const nv = Fp2.mul(n, v);
-        const i = Fp2.mul(Fp2.mul(nv, _2n3), v);
-        const root = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
-        if (!Fp2.eql(Fp2.sqr(root), n))
+      return function sqrt5mod8(Fp, n) {
+        const n2 = Fp.mul(n, _2n3);
+        const v = Fp.pow(n2, c1);
+        const nv = Fp.mul(n, v);
+        const i = Fp.mul(Fp.mul(nv, _2n3), v);
+        const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
+        if (!Fp.eql(Fp.sqr(root), n))
           throw new Error("Cannot find square root");
         return root;
       };
@@ -1746,7 +1746,7 @@ var starknet = (() => {
       if (power & _1n3)
         p = f.mul(p, d);
       d = f.sqr(d);
-      power >>= 1n;
+      power >>= _1n3;
     }
     return p;
   }
@@ -1772,10 +1772,10 @@ var starknet = (() => {
     const nByteLength = Math.ceil(_nBitLength / 8);
     return { nBitLength: _nBitLength, nByteLength };
   }
-  function Fp(ORDER, bitLen2, isLE2 = false, redef = {}) {
+  function Field(ORDER, bitLen3, isLE2 = false, redef = {}) {
     if (ORDER <= _0n3)
       throw new Error(`Expected Fp ORDER > 0, got ${ORDER}`);
-    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
+    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen3);
     if (BYTES > 2048)
       throw new Error("Field lengths over 2048 bytes are not supported");
     const sqrtP = FpSqrt(ORDER);
@@ -1829,16 +1829,10 @@ var starknet = (() => {
     return mod(num, groupOrder - _1n3) + _1n3;
   }
 
-  // node_modules/@noble/curves/esm/abstract/poseidon.js
-  var poseidon_exports = {};
-  __export(poseidon_exports, {
-    poseidon: () => poseidon,
-    splitConstants: () => splitConstants,
-    validateOpts: () => validateOpts
-  });
+  // node_modules/micro-starknet/node_modules/@noble/curves/esm/abstract/poseidon.js
   function validateOpts(opts) {
-    const { Fp: Fp2 } = opts;
-    validateField(Fp2);
+    const { Fp } = opts;
+    validateField(Fp);
     for (const i of ["t", "roundsFull", "roundsPartial"]) {
       if (typeof opts[i] !== "number" || !Number.isSafeInteger(opts[i]))
         throw new Error(`Poseidon: invalid param ${i}=${opts[i]} (${typeof opts[i]})`);
@@ -1851,11 +1845,11 @@ var starknet = (() => {
     if (typeof sboxPower !== "number" || !Number.isSafeInteger(sboxPower))
       throw new Error(`Poseidon wrong sboxPower=${sboxPower}`);
     const _sboxPower = BigInt(sboxPower);
-    let sboxFn = (n) => FpPow(Fp2, n, _sboxPower);
+    let sboxFn = (n) => FpPow(Fp, n, _sboxPower);
     if (sboxPower === 3)
-      sboxFn = (n) => Fp2.mul(Fp2.sqrN(n), n);
+      sboxFn = (n) => Fp.mul(Fp.sqrN(n), n);
     else if (sboxPower === 5)
-      sboxFn = (n) => Fp2.mul(Fp2.sqrN(Fp2.sqrN(n)), n);
+      sboxFn = (n) => Fp.mul(Fp.sqrN(Fp.sqrN(n)), n);
     if (opts.roundsFull % 2 !== 0)
       throw new Error(`Poseidon roundsFull is not even: ${opts.roundsFull}`);
     const rounds = opts.roundsFull + opts.roundsPartial;
@@ -1865,9 +1859,9 @@ var starknet = (() => {
       if (!Array.isArray(rc) || rc.length !== opts.t)
         throw new Error(`Poseidon wrong round constants: ${rc}`);
       return rc.map((i) => {
-        if (typeof i !== "bigint" || !Fp2.isValid(i))
+        if (typeof i !== "bigint" || !Fp.isValid(i))
           throw new Error(`Poseidon wrong round constant=${i}`);
-        return Fp2.create(i);
+        return Fp.create(i);
       });
     });
     if (!Array.isArray(opts.mds) || opts.mds.length !== opts.t)
@@ -1878,38 +1872,22 @@ var starknet = (() => {
       return mdsRow.map((i) => {
         if (typeof i !== "bigint")
           throw new Error(`Poseidon MDS matrix value=${i}`);
-        return Fp2.create(i);
+        return Fp.create(i);
       });
     });
     return Object.freeze({ ...opts, rounds, sboxFn, roundConstants, mds });
   }
-  function splitConstants(rc, t) {
-    if (typeof t !== "number")
-      throw new Error("poseidonSplitConstants: wrong t");
-    if (!Array.isArray(rc) || rc.length % t)
-      throw new Error("poseidonSplitConstants: wrong rc");
-    const res = [];
-    let tmp = [];
-    for (let i = 0; i < rc.length; i++) {
-      tmp.push(rc[i]);
-      if (tmp.length === t) {
-        res.push(tmp);
-        tmp = [];
-      }
-    }
-    return res;
-  }
   function poseidon(opts) {
-    const { t, Fp: Fp2, rounds, sboxFn, reversePartialPowIdx } = validateOpts(opts);
+    const { t, Fp, rounds, sboxFn, reversePartialPowIdx } = validateOpts(opts);
     const halfRoundsFull = Math.floor(opts.roundsFull / 2);
     const partialIdx = reversePartialPowIdx ? t - 1 : 0;
     const poseidonRound = (values, isFull, idx) => {
-      values = values.map((i, j) => Fp2.add(i, opts.roundConstants[idx][j]));
+      values = values.map((i, j) => Fp.add(i, opts.roundConstants[idx][j]));
       if (isFull)
         values = values.map((i) => sboxFn(i));
       else
         values[partialIdx] = sboxFn(values[partialIdx]);
-      values = opts.mds.map((i) => i.reduce((acc, i2, j) => Fp2.add(acc, Fp2.mulN(i2, values[j])), Fp2.ZERO));
+      values = opts.mds.map((i) => i.reduce((acc, i2, j) => Fp.add(acc, Fp.mulN(i2, values[j])), Fp.ZERO));
       return values;
     };
     const poseidonHash2 = function poseidonHash3(values) {
@@ -1918,7 +1896,7 @@ var starknet = (() => {
       values = values.map((i) => {
         if (typeof i !== "bigint")
           throw new Error(`Poseidon: wrong value=${i} (${typeof i})`);
-        return Fp2.create(i);
+        return Fp.create(i);
       });
       let round = 0;
       for (let i = 0; i < halfRoundsFull; i++)
@@ -1935,16 +1913,7 @@ var starknet = (() => {
     return poseidonHash2;
   }
 
-  // node_modules/@noble/curves/esm/abstract/weierstrass.js
-  var weierstrass_exports = {};
-  __export(weierstrass_exports, {
-    SWUFpSqrtRatio: () => SWUFpSqrtRatio,
-    mapToCurveSimpleSWU: () => mapToCurveSimpleSWU,
-    weierstrass: () => weierstrass,
-    weierstrassPoints: () => weierstrassPoints
-  });
-
-  // node_modules/@noble/curves/esm/abstract/curve.js
+  // node_modules/micro-starknet/node_modules/@noble/curves/esm/abstract/curve.js
   var _0n4 = BigInt(0);
   var _1n4 = BigInt(1);
   function wNAF(c, bits) {
@@ -2037,27 +2006,31 @@ var starknet = (() => {
       nBitLength: "isSafeInteger",
       nByteLength: "isSafeInteger"
     });
-    return Object.freeze({ ...nLength(curve2.n, curve2.nBitLength), ...curve2 });
+    return Object.freeze({
+      ...nLength(curve2.n, curve2.nBitLength),
+      ...curve2,
+      ...{ p: curve2.Fp.ORDER }
+    });
   }
 
-  // node_modules/@noble/curves/esm/abstract/weierstrass.js
+  // node_modules/micro-starknet/node_modules/@noble/curves/esm/abstract/weierstrass.js
   function validatePointOpts(curve2) {
     const opts = validateBasic(curve2);
     validateObject(opts, {
       a: "field",
-      b: "field",
-      fromBytes: "function",
-      toBytes: "function"
+      b: "field"
     }, {
       allowedPrivateKeyLengths: "array",
       wrapPrivateKey: "boolean",
       isTorsionFree: "function",
       clearCofactor: "function",
-      allowInfinityPoint: "boolean"
+      allowInfinityPoint: "boolean",
+      fromBytes: "function",
+      toBytes: "function"
     });
-    const { endo, Fp: Fp2, a } = opts;
+    const { endo, Fp, a } = opts;
     if (endo) {
-      if (!Fp2.eql(a, Fp2.ZERO)) {
+      if (!Fp.eql(a, Fp.ZERO)) {
         throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
       }
       if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
@@ -2081,8 +2054,10 @@ var starknet = (() => {
       const res = data.subarray(2, len + 2);
       if (!len || res.length !== len)
         throw new E("Invalid signature integer: wrong length");
-      if (res[0] === 0 && res[1] <= 127)
-        throw new E("Invalid signature integer: trailing length");
+      if (res[0] & 128)
+        throw new E("Invalid signature integer: negative");
+      if (res[0] === 0 && !(res[1] & 128))
+        throw new E("Invalid signature integer: unnecessary leading zero");
       return { d: b2n(res), l: data.subarray(len + 2) };
     },
     toSig(hex) {
@@ -2102,7 +2077,7 @@ var starknet = (() => {
       return { r, s };
     },
     hexFromSig(sig) {
-      const slice = (s2) => Number.parseInt(s2[0], 16) >= 8 ? "00" + s2 : s2;
+      const slice = (s2) => Number.parseInt(s2[0], 16) & 8 ? "00" + s2 : s2;
       const h = (num) => {
         const hex = num.toString(16);
         return hex.length & 1 ? `0${hex}` : hex;
@@ -2118,15 +2093,30 @@ var starknet = (() => {
   };
   var _0n5 = BigInt(0);
   var _1n5 = BigInt(1);
+  var _2n4 = BigInt(2);
+  var _3n2 = BigInt(3);
+  var _4n2 = BigInt(4);
   function weierstrassPoints(opts) {
     const CURVE2 = validatePointOpts(opts);
-    const { Fp: Fp2 } = CURVE2;
+    const { Fp } = CURVE2;
+    const toBytes2 = CURVE2.toBytes || ((c, point, isCompressed) => {
+      const a = point.toAffine();
+      return concatBytes2(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
+    });
+    const fromBytes = CURVE2.fromBytes || ((bytes2) => {
+      const tail = bytes2.subarray(1);
+      const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
+      const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
+      return { x, y };
+    });
     function weierstrassEquation(x) {
       const { a, b } = CURVE2;
-      const x2 = Fp2.sqr(x);
-      const x3 = Fp2.mul(x2, x);
-      return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b);
+      const x2 = Fp.sqr(x);
+      const x3 = Fp.mul(x2, x);
+      return Fp.add(Fp.add(x3, Fp.mul(x, a)), b);
     }
+    if (!Fp.eql(Fp.sqr(CURVE2.Gy), weierstrassEquation(CURVE2.Gx)))
+      throw new Error("bad generator point: equation left != right");
     function isWithinCurveOrder(num) {
       return typeof num === "bigint" && _0n5 < num && num < CURVE2.n;
     }
@@ -2164,23 +2154,23 @@ var starknet = (() => {
         this.px = px;
         this.py = py;
         this.pz = pz;
-        if (px == null || !Fp2.isValid(px))
+        if (px == null || !Fp.isValid(px))
           throw new Error("x required");
-        if (py == null || !Fp2.isValid(py))
+        if (py == null || !Fp.isValid(py))
           throw new Error("y required");
-        if (pz == null || !Fp2.isValid(pz))
+        if (pz == null || !Fp.isValid(pz))
           throw new Error("z required");
       }
       static fromAffine(p) {
         const { x, y } = p || {};
-        if (!p || !Fp2.isValid(x) || !Fp2.isValid(y))
+        if (!p || !Fp.isValid(x) || !Fp.isValid(y))
           throw new Error("invalid affine point");
         if (p instanceof Point)
           throw new Error("projective point not allowed");
-        const is0 = (i) => Fp2.eql(i, Fp2.ZERO);
+        const is0 = (i) => Fp.eql(i, Fp.ZERO);
         if (is0(x) && is0(y))
           return Point.ZERO;
-        return new Point(x, y, Fp2.ONE);
+        return new Point(x, y, Fp.ONE);
       }
       get x() {
         return this.toAffine().x;
@@ -2189,11 +2179,11 @@ var starknet = (() => {
         return this.toAffine().y;
       }
       static normalizeZ(points) {
-        const toInv = Fp2.invertBatch(points.map((p) => p.pz));
+        const toInv = Fp.invertBatch(points.map((p) => p.pz));
         return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
       }
       static fromHex(hex) {
-        const P = Point.fromAffine(CURVE2.fromBytes(ensureBytes("pointHex", hex)));
+        const P = Point.fromAffine(fromBytes(ensureBytes("pointHex", hex)));
         P.assertValidity();
         return P;
       }
@@ -2211,117 +2201,117 @@ var starknet = (() => {
           throw new Error("bad point: ZERO");
         }
         const { x, y } = this.toAffine();
-        if (!Fp2.isValid(x) || !Fp2.isValid(y))
+        if (!Fp.isValid(x) || !Fp.isValid(y))
           throw new Error("bad point: x or y not FE");
-        const left = Fp2.sqr(y);
+        const left = Fp.sqr(y);
         const right = weierstrassEquation(x);
-        if (!Fp2.eql(left, right))
+        if (!Fp.eql(left, right))
           throw new Error("bad point: equation left != right");
         if (!this.isTorsionFree())
           throw new Error("bad point: not in prime-order subgroup");
       }
       hasEvenY() {
         const { y } = this.toAffine();
-        if (Fp2.isOdd)
-          return !Fp2.isOdd(y);
+        if (Fp.isOdd)
+          return !Fp.isOdd(y);
         throw new Error("Field doesn't support isOdd");
       }
       equals(other) {
         assertPrjPoint(other);
         const { px: X1, py: Y1, pz: Z1 } = this;
         const { px: X2, py: Y2, pz: Z2 } = other;
-        const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
-        const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
+        const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
+        const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
         return U1 && U2;
       }
       negate() {
-        return new Point(this.px, Fp2.neg(this.py), this.pz);
+        return new Point(this.px, Fp.neg(this.py), this.pz);
       }
       double() {
         const { a, b } = CURVE2;
-        const b3 = Fp2.mul(b, 3n);
+        const b3 = Fp.mul(b, _3n2);
         const { px: X1, py: Y1, pz: Z1 } = this;
-        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
-        let t0 = Fp2.mul(X1, X1);
-        let t1 = Fp2.mul(Y1, Y1);
-        let t2 = Fp2.mul(Z1, Z1);
-        let t3 = Fp2.mul(X1, Y1);
-        t3 = Fp2.add(t3, t3);
-        Z3 = Fp2.mul(X1, Z1);
-        Z3 = Fp2.add(Z3, Z3);
-        X3 = Fp2.mul(a, Z3);
-        Y3 = Fp2.mul(b3, t2);
-        Y3 = Fp2.add(X3, Y3);
-        X3 = Fp2.sub(t1, Y3);
-        Y3 = Fp2.add(t1, Y3);
-        Y3 = Fp2.mul(X3, Y3);
-        X3 = Fp2.mul(t3, X3);
-        Z3 = Fp2.mul(b3, Z3);
-        t2 = Fp2.mul(a, t2);
-        t3 = Fp2.sub(t0, t2);
-        t3 = Fp2.mul(a, t3);
-        t3 = Fp2.add(t3, Z3);
-        Z3 = Fp2.add(t0, t0);
-        t0 = Fp2.add(Z3, t0);
-        t0 = Fp2.add(t0, t2);
-        t0 = Fp2.mul(t0, t3);
-        Y3 = Fp2.add(Y3, t0);
-        t2 = Fp2.mul(Y1, Z1);
-        t2 = Fp2.add(t2, t2);
-        t0 = Fp2.mul(t2, t3);
-        X3 = Fp2.sub(X3, t0);
-        Z3 = Fp2.mul(t2, t1);
-        Z3 = Fp2.add(Z3, Z3);
-        Z3 = Fp2.add(Z3, Z3);
+        let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+        let t0 = Fp.mul(X1, X1);
+        let t1 = Fp.mul(Y1, Y1);
+        let t2 = Fp.mul(Z1, Z1);
+        let t3 = Fp.mul(X1, Y1);
+        t3 = Fp.add(t3, t3);
+        Z3 = Fp.mul(X1, Z1);
+        Z3 = Fp.add(Z3, Z3);
+        X3 = Fp.mul(a, Z3);
+        Y3 = Fp.mul(b3, t2);
+        Y3 = Fp.add(X3, Y3);
+        X3 = Fp.sub(t1, Y3);
+        Y3 = Fp.add(t1, Y3);
+        Y3 = Fp.mul(X3, Y3);
+        X3 = Fp.mul(t3, X3);
+        Z3 = Fp.mul(b3, Z3);
+        t2 = Fp.mul(a, t2);
+        t3 = Fp.sub(t0, t2);
+        t3 = Fp.mul(a, t3);
+        t3 = Fp.add(t3, Z3);
+        Z3 = Fp.add(t0, t0);
+        t0 = Fp.add(Z3, t0);
+        t0 = Fp.add(t0, t2);
+        t0 = Fp.mul(t0, t3);
+        Y3 = Fp.add(Y3, t0);
+        t2 = Fp.mul(Y1, Z1);
+        t2 = Fp.add(t2, t2);
+        t0 = Fp.mul(t2, t3);
+        X3 = Fp.sub(X3, t0);
+        Z3 = Fp.mul(t2, t1);
+        Z3 = Fp.add(Z3, Z3);
+        Z3 = Fp.add(Z3, Z3);
         return new Point(X3, Y3, Z3);
       }
       add(other) {
         assertPrjPoint(other);
         const { px: X1, py: Y1, pz: Z1 } = this;
         const { px: X2, py: Y2, pz: Z2 } = other;
-        let X3 = Fp2.ZERO, Y3 = Fp2.ZERO, Z3 = Fp2.ZERO;
+        let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
         const a = CURVE2.a;
-        const b3 = Fp2.mul(CURVE2.b, 3n);
-        let t0 = Fp2.mul(X1, X2);
-        let t1 = Fp2.mul(Y1, Y2);
-        let t2 = Fp2.mul(Z1, Z2);
-        let t3 = Fp2.add(X1, Y1);
-        let t4 = Fp2.add(X2, Y2);
-        t3 = Fp2.mul(t3, t4);
-        t4 = Fp2.add(t0, t1);
-        t3 = Fp2.sub(t3, t4);
-        t4 = Fp2.add(X1, Z1);
-        let t5 = Fp2.add(X2, Z2);
-        t4 = Fp2.mul(t4, t5);
-        t5 = Fp2.add(t0, t2);
-        t4 = Fp2.sub(t4, t5);
-        t5 = Fp2.add(Y1, Z1);
-        X3 = Fp2.add(Y2, Z2);
-        t5 = Fp2.mul(t5, X3);
-        X3 = Fp2.add(t1, t2);
-        t5 = Fp2.sub(t5, X3);
-        Z3 = Fp2.mul(a, t4);
-        X3 = Fp2.mul(b3, t2);
-        Z3 = Fp2.add(X3, Z3);
-        X3 = Fp2.sub(t1, Z3);
-        Z3 = Fp2.add(t1, Z3);
-        Y3 = Fp2.mul(X3, Z3);
-        t1 = Fp2.add(t0, t0);
-        t1 = Fp2.add(t1, t0);
-        t2 = Fp2.mul(a, t2);
-        t4 = Fp2.mul(b3, t4);
-        t1 = Fp2.add(t1, t2);
-        t2 = Fp2.sub(t0, t2);
-        t2 = Fp2.mul(a, t2);
-        t4 = Fp2.add(t4, t2);
-        t0 = Fp2.mul(t1, t4);
-        Y3 = Fp2.add(Y3, t0);
-        t0 = Fp2.mul(t5, t4);
-        X3 = Fp2.mul(t3, X3);
-        X3 = Fp2.sub(X3, t0);
-        t0 = Fp2.mul(t3, t1);
-        Z3 = Fp2.mul(t5, Z3);
-        Z3 = Fp2.add(Z3, t0);
+        const b3 = Fp.mul(CURVE2.b, _3n2);
+        let t0 = Fp.mul(X1, X2);
+        let t1 = Fp.mul(Y1, Y2);
+        let t2 = Fp.mul(Z1, Z2);
+        let t3 = Fp.add(X1, Y1);
+        let t4 = Fp.add(X2, Y2);
+        t3 = Fp.mul(t3, t4);
+        t4 = Fp.add(t0, t1);
+        t3 = Fp.sub(t3, t4);
+        t4 = Fp.add(X1, Z1);
+        let t5 = Fp.add(X2, Z2);
+        t4 = Fp.mul(t4, t5);
+        t5 = Fp.add(t0, t2);
+        t4 = Fp.sub(t4, t5);
+        t5 = Fp.add(Y1, Z1);
+        X3 = Fp.add(Y2, Z2);
+        t5 = Fp.mul(t5, X3);
+        X3 = Fp.add(t1, t2);
+        t5 = Fp.sub(t5, X3);
+        Z3 = Fp.mul(a, t4);
+        X3 = Fp.mul(b3, t2);
+        Z3 = Fp.add(X3, Z3);
+        X3 = Fp.sub(t1, Z3);
+        Z3 = Fp.add(t1, Z3);
+        Y3 = Fp.mul(X3, Z3);
+        t1 = Fp.add(t0, t0);
+        t1 = Fp.add(t1, t0);
+        t2 = Fp.mul(a, t2);
+        t4 = Fp.mul(b3, t4);
+        t1 = Fp.add(t1, t2);
+        t2 = Fp.sub(t0, t2);
+        t2 = Fp.mul(a, t2);
+        t4 = Fp.add(t4, t2);
+        t0 = Fp.mul(t1, t4);
+        Y3 = Fp.add(Y3, t0);
+        t0 = Fp.mul(t5, t4);
+        X3 = Fp.mul(t3, X3);
+        X3 = Fp.sub(X3, t0);
+        t0 = Fp.mul(t3, t1);
+        Z3 = Fp.mul(t5, Z3);
+        Z3 = Fp.add(Z3, t0);
         return new Point(X3, Y3, Z3);
       }
       subtract(other) {
@@ -2332,7 +2322,7 @@ var starknet = (() => {
       }
       wNAF(n) {
         return wnaf.wNAFCached(this, pointPrecomputes, n, (comp) => {
-          const toInv = Fp2.invertBatch(comp.map((p) => p.pz));
+          const toInv = Fp.invertBatch(comp.map((p) => p.pz));
           return comp.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
         });
       }
@@ -2363,7 +2353,7 @@ var starknet = (() => {
           k1p = k1p.negate();
         if (k2neg)
           k2p = k2p.negate();
-        k2p = new Point(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
+        k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
         return k1p.add(k2p);
       }
       multiply(scalar) {
@@ -2377,7 +2367,7 @@ var starknet = (() => {
           let { p: k2p, f: f2p } = this.wNAF(k2);
           k1p = wnaf.constTimeNegate(k1neg, k1p);
           k2p = wnaf.constTimeNegate(k2neg, k2p);
-          k2p = new Point(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
+          k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
           point = k1p.add(k2p);
           fake = f1p.add(f2p);
         } else {
@@ -2397,13 +2387,13 @@ var starknet = (() => {
         const { px: x, py: y, pz: z } = this;
         const is0 = this.is0();
         if (iz == null)
-          iz = is0 ? Fp2.ONE : Fp2.inv(z);
-        const ax = Fp2.mul(x, iz);
-        const ay = Fp2.mul(y, iz);
-        const zz = Fp2.mul(z, iz);
+          iz = is0 ? Fp.ONE : Fp.inv(z);
+        const ax = Fp.mul(x, iz);
+        const ay = Fp.mul(y, iz);
+        const zz = Fp.mul(z, iz);
         if (is0)
-          return { x: Fp2.ZERO, y: Fp2.ZERO };
-        if (!Fp2.eql(zz, Fp2.ONE))
+          return { x: Fp.ZERO, y: Fp.ZERO };
+        if (!Fp.eql(zz, Fp.ONE))
           throw new Error("invZ was invalid");
         return { x: ax, y: ay };
       }
@@ -2425,17 +2415,18 @@ var starknet = (() => {
       }
       toRawBytes(isCompressed = true) {
         this.assertValidity();
-        return CURVE2.toBytes(Point, this, isCompressed);
+        return toBytes2(Point, this, isCompressed);
       }
       toHex(isCompressed = true) {
         return bytesToHex(this.toRawBytes(isCompressed));
       }
     }
-    Point.BASE = new Point(CURVE2.Gx, CURVE2.Gy, Fp2.ONE);
-    Point.ZERO = new Point(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
+    Point.BASE = new Point(CURVE2.Gx, CURVE2.Gy, Fp.ONE);
+    Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
     const _bits = CURVE2.nBitLength;
     const wnaf = wNAF(Point, CURVE2.endo ? Math.ceil(_bits / 2) : _bits);
     return {
+      CURVE: CURVE2,
       ProjectivePoint: Point,
       normPrivateKeyToScalar,
       weierstrassEquation,
@@ -2457,12 +2448,11 @@ var starknet = (() => {
   }
   function weierstrass(curveDef) {
     const CURVE2 = validateOpts2(curveDef);
-    const CURVE_ORDER2 = CURVE2.n;
-    const Fp2 = CURVE2.Fp;
-    const compressedLen = Fp2.BYTES + 1;
-    const uncompressedLen = 2 * Fp2.BYTES + 1;
+    const { Fp, n: CURVE_ORDER2 } = CURVE2;
+    const compressedLen = Fp.BYTES + 1;
+    const uncompressedLen = 2 * Fp.BYTES + 1;
     function isValidFieldElement(num) {
-      return _0n5 < num && num < Fp2.ORDER;
+      return _0n5 < num && num < Fp.ORDER;
     }
     function modN(a) {
       return mod(a, CURVE_ORDER2);
@@ -2474,12 +2464,12 @@ var starknet = (() => {
       ...CURVE2,
       toBytes(c, point, isCompressed) {
         const a = point.toAffine();
-        const x = Fp2.toBytes(a.x);
+        const x = Fp.toBytes(a.x);
         const cat = concatBytes2;
         if (isCompressed) {
           return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
         } else {
-          return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
+          return cat(Uint8Array.from([4]), x, Fp.toBytes(a.y));
         }
       },
       fromBytes(bytes2) {
@@ -2491,15 +2481,15 @@ var starknet = (() => {
           if (!isValidFieldElement(x))
             throw new Error("Point is not on curve");
           const y2 = weierstrassEquation(x);
-          let y = Fp2.sqrt(y2);
+          let y = Fp.sqrt(y2);
           const isYOdd = (y & _1n5) === _1n5;
           const isHeadOdd = (head & 1) === 1;
           if (isHeadOdd !== isYOdd)
-            y = Fp2.neg(y);
+            y = Fp.neg(y);
           return { x, y };
         } else if (len === uncompressedLen && head === 4) {
-          const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
-          const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
+          const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
+          const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
           return { x, y };
         } else {
           throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
@@ -2546,7 +2536,7 @@ var starknet = (() => {
         if (rec == null || ![0, 1, 2, 3].includes(rec))
           throw new Error("recovery id invalid");
         const radj = rec === 2 || rec === 3 ? r + CURVE2.n : r;
-        if (radj >= Fp2.ORDER)
+        if (radj >= Fp.ORDER)
           throw new Error("recovery id 2 or 3 invalid");
         const prefix = (rec & 1) === 0 ? "02" : "03";
         const R = Point.fromHex(prefix + numToNByteStr(radj));
@@ -2589,7 +2579,7 @@ var starknet = (() => {
       },
       normPrivateKeyToScalar,
       randomPrivateKey: () => {
-        const rand = CURVE2.randomBytes(Fp2.BYTES + 8);
+        const rand = CURVE2.randomBytes(Fp.BYTES + 8);
         const num = hashToPrivateScalar(rand, CURVE_ORDER2);
         return numberToBytesBE(num, CURVE2.nByteLength);
       },
@@ -2652,8 +2642,8 @@ var starknet = (() => {
       const d = normPrivateKeyToScalar(privateKey);
       const seedArgs = [int2octets(d), int2octets(h1int)];
       if (ent != null) {
-        const e = ent === true ? randomBytes2(Fp2.BYTES) : ent;
-        seedArgs.push(ensureBytes("extraEntropy", e, Fp2.BYTES));
+        const e = ent === true ? randomBytes2(Fp.BYTES) : ent;
+        seedArgs.push(ensureBytes("extraEntropy", e, Fp.BYTES));
       }
       const seed = concatBytes2(...seedArgs);
       const m = h1int;
@@ -2744,104 +2734,8 @@ var starknet = (() => {
       utils: utils2
     };
   }
-  function SWUFpSqrtRatio(Fp2, Z) {
-    const q = Fp2.ORDER;
-    let l = 0n;
-    for (let o = q - 1n; o % 2n === 0n; o /= 2n)
-      l += 1n;
-    const c1 = l;
-    const c2 = (q - 1n) / 2n ** c1;
-    const c3 = (c2 - 1n) / 2n;
-    const c4 = 2n ** c1 - 1n;
-    const c5 = 2n ** (c1 - 1n);
-    const c6 = Fp2.pow(Z, c2);
-    const c7 = Fp2.pow(Z, (c2 + 1n) / 2n);
-    let sqrtRatio = (u, v) => {
-      let tv1 = c6;
-      let tv2 = Fp2.pow(v, c4);
-      let tv3 = Fp2.sqr(tv2);
-      tv3 = Fp2.mul(tv3, v);
-      let tv5 = Fp2.mul(u, tv3);
-      tv5 = Fp2.pow(tv5, c3);
-      tv5 = Fp2.mul(tv5, tv2);
-      tv2 = Fp2.mul(tv5, v);
-      tv3 = Fp2.mul(tv5, u);
-      let tv4 = Fp2.mul(tv3, tv2);
-      tv5 = Fp2.pow(tv4, c5);
-      let isQR = Fp2.eql(tv5, Fp2.ONE);
-      tv2 = Fp2.mul(tv3, c7);
-      tv5 = Fp2.mul(tv4, tv1);
-      tv3 = Fp2.cmov(tv2, tv3, isQR);
-      tv4 = Fp2.cmov(tv5, tv4, isQR);
-      for (let i = c1; i > 1; i--) {
-        let tv52 = 2n ** (i - 2n);
-        let tvv5 = Fp2.pow(tv4, tv52);
-        const e1 = Fp2.eql(tvv5, Fp2.ONE);
-        tv2 = Fp2.mul(tv3, tv1);
-        tv1 = Fp2.mul(tv1, tv1);
-        tvv5 = Fp2.mul(tv4, tv1);
-        tv3 = Fp2.cmov(tv2, tv3, e1);
-        tv4 = Fp2.cmov(tvv5, tv4, e1);
-      }
-      return { isValid: isQR, value: tv3 };
-    };
-    if (Fp2.ORDER % 4n === 3n) {
-      const c12 = (Fp2.ORDER - 3n) / 4n;
-      const c22 = Fp2.sqrt(Fp2.neg(Z));
-      sqrtRatio = (u, v) => {
-        let tv1 = Fp2.sqr(v);
-        const tv2 = Fp2.mul(u, v);
-        tv1 = Fp2.mul(tv1, tv2);
-        let y1 = Fp2.pow(tv1, c12);
-        y1 = Fp2.mul(y1, tv2);
-        const y2 = Fp2.mul(y1, c22);
-        const tv3 = Fp2.mul(Fp2.sqr(y1), v);
-        const isQR = Fp2.eql(tv3, u);
-        let y = Fp2.cmov(y2, y1, isQR);
-        return { isValid: isQR, value: y };
-      };
-    }
-    return sqrtRatio;
-  }
-  function mapToCurveSimpleSWU(Fp2, opts) {
-    validateField(Fp2);
-    if (!Fp2.isValid(opts.A) || !Fp2.isValid(opts.B) || !Fp2.isValid(opts.Z))
-      throw new Error("mapToCurveSimpleSWU: invalid opts");
-    const sqrtRatio = SWUFpSqrtRatio(Fp2, opts.Z);
-    if (!Fp2.isOdd)
-      throw new Error("Fp.isOdd is not implemented!");
-    return (u) => {
-      let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
-      tv1 = Fp2.sqr(u);
-      tv1 = Fp2.mul(tv1, opts.Z);
-      tv2 = Fp2.sqr(tv1);
-      tv2 = Fp2.add(tv2, tv1);
-      tv3 = Fp2.add(tv2, Fp2.ONE);
-      tv3 = Fp2.mul(tv3, opts.B);
-      tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO));
-      tv4 = Fp2.mul(tv4, opts.A);
-      tv2 = Fp2.sqr(tv3);
-      tv6 = Fp2.sqr(tv4);
-      tv5 = Fp2.mul(tv6, opts.A);
-      tv2 = Fp2.add(tv2, tv5);
-      tv2 = Fp2.mul(tv2, tv3);
-      tv6 = Fp2.mul(tv6, tv4);
-      tv5 = Fp2.mul(tv6, opts.B);
-      tv2 = Fp2.add(tv2, tv5);
-      x = Fp2.mul(tv1, tv3);
-      const { isValid, value } = sqrtRatio(tv2, tv6);
-      y = Fp2.mul(tv1, u);
-      y = Fp2.mul(y, value);
-      x = Fp2.cmov(x, tv3, isValid);
-      y = Fp2.cmov(y, value, isValid);
-      const e1 = Fp2.isOdd(u) === Fp2.isOdd(y);
-      y = Fp2.cmov(Fp2.neg(y), y, e1);
-      x = Fp2.div(x, tv4);
-      return { x, y };
-    };
-  }
 
-  // node_modules/@noble/hashes/esm/hmac.js
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/hmac.js
   var HMAC = class extends Hash {
     constructor(hash2, _key) {
       super();
@@ -2906,7 +2800,7 @@ var starknet = (() => {
   var hmac = (hash2, key, message) => new HMAC(hash2, key).update(message).digest();
   hmac.create = (hash2, key) => new HMAC(hash2, key);
 
-  // node_modules/@noble/curves/esm/_shortw_utils.js
+  // node_modules/micro-starknet/node_modules/@noble/curves/esm/_shortw_utils.js
   function getHash(hash2) {
     return {
       hash: hash2,
@@ -2936,7 +2830,7 @@ var starknet = (() => {
   var curve = weierstrass({
     a: BigInt(1),
     b: BigInt("3141592653589793238462643383279502884197169399375105820974944592307816406665"),
-    Fp: Fp(BigInt("0x800000000000011000000000000000000000000000000000000000000000001")),
+    Fp: Field(BigInt("0x800000000000011000000000000000000000000000000000000000000000001")),
     n: CURVE_ORDER,
     nBitLength,
     Gx: BigInt("874739451078007766457464989774322083649278607533249481151382481072868806602"),
@@ -3080,22 +2974,22 @@ var starknet = (() => {
   var MASK_250 = bitMask(250);
   var keccak = (data) => bytesToNumberBE(keccak_256(data)) & MASK_250;
   var sha256Num = (data) => bytesToNumberBE(sha256(data));
-  var Fp253 = Fp(BigInt("14474011154664525231415395255581126252639794253786371766033694892385558855681"));
-  var Fp251 = Fp(BigInt("3618502788666131213697322783095070105623107215331596699973092056135872020481"));
-  function poseidonRoundConstant(Fp2, name, idx) {
-    const val = Fp2.fromBytes(sha256(utf8ToBytes(`${name}${idx}`)));
-    return Fp2.create(val);
+  var Fp253 = Field(BigInt("14474011154664525231415395255581126252639794253786371766033694892385558855681"));
+  var Fp251 = Field(BigInt("3618502788666131213697322783095070105623107215331596699973092056135872020481"));
+  function poseidonRoundConstant(Fp, name, idx) {
+    const val = Fp.fromBytes(sha256(utf8ToBytes(`${name}${idx}`)));
+    return Fp.create(val);
   }
-  function _poseidonMDS(Fp2, name, m, attempt = 0) {
+  function _poseidonMDS(Fp, name, m, attempt = 0) {
     const x_values = [];
     const y_values = [];
     for (let i = 0; i < m; i++) {
-      x_values.push(poseidonRoundConstant(Fp2, `${name}x`, attempt * m + i));
-      y_values.push(poseidonRoundConstant(Fp2, `${name}y`, attempt * m + i));
+      x_values.push(poseidonRoundConstant(Fp, `${name}x`, attempt * m + i));
+      y_values.push(poseidonRoundConstant(Fp, `${name}y`, attempt * m + i));
     }
     if ((/* @__PURE__ */ new Set([...x_values, ...y_values])).size !== 2 * m)
       throw new Error("X and Y values are not distinct");
-    return x_values.map((x) => y_values.map((y) => Fp2.inv(Fp2.sub(x, y))));
+    return x_values.map((x) => y_values.map((y) => Fp.inv(Fp.sub(x, y))));
   }
   var MDS_SMALL = [
     [3, 1, 1],
@@ -5347,7 +5241,7 @@ var starknet = (() => {
     getDecimalString: () => getDecimalString,
     getHexString: () => getHexString,
     getHexStringArray: () => getHexStringArray,
-    hexToBytes: () => hexToBytes2,
+    hexToBytes: () => hexToBytes3,
     hexToDecimalString: () => hexToDecimalString,
     isBigInt: () => isBigInt,
     isHex: () => isHex,
@@ -5357,6 +5251,212 @@ var starknet = (() => {
     toHex: () => toHex,
     toHexString: () => toHexString
   });
+
+  // node_modules/@noble/curves/esm/abstract/utils.js
+  var utils_exports2 = {};
+  __export(utils_exports2, {
+    bitGet: () => bitGet2,
+    bitLen: () => bitLen2,
+    bitMask: () => bitMask2,
+    bitSet: () => bitSet2,
+    bytesToHex: () => bytesToHex2,
+    bytesToNumberBE: () => bytesToNumberBE2,
+    bytesToNumberLE: () => bytesToNumberLE2,
+    concatBytes: () => concatBytes3,
+    createHmacDrbg: () => createHmacDrbg2,
+    ensureBytes: () => ensureBytes3,
+    equalBytes: () => equalBytes2,
+    hexToBytes: () => hexToBytes2,
+    hexToNumber: () => hexToNumber2,
+    numberToBytesBE: () => numberToBytesBE2,
+    numberToBytesLE: () => numberToBytesLE2,
+    numberToHexUnpadded: () => numberToHexUnpadded2,
+    numberToVarBytesBE: () => numberToVarBytesBE2,
+    utf8ToBytes: () => utf8ToBytes3,
+    validateObject: () => validateObject2
+  });
+  var _0n6 = BigInt(0);
+  var _1n6 = BigInt(1);
+  var _2n5 = BigInt(2);
+  var u8a2 = (a) => a instanceof Uint8Array;
+  var hexes3 = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
+  function bytesToHex2(bytes2) {
+    if (!u8a2(bytes2))
+      throw new Error("Uint8Array expected");
+    let hex = "";
+    for (let i = 0; i < bytes2.length; i++) {
+      hex += hexes3[bytes2[i]];
+    }
+    return hex;
+  }
+  function numberToHexUnpadded2(num) {
+    const hex = num.toString(16);
+    return hex.length & 1 ? `0${hex}` : hex;
+  }
+  function hexToNumber2(hex) {
+    if (typeof hex !== "string")
+      throw new Error("hex string expected, got " + typeof hex);
+    return BigInt(hex === "" ? "0" : `0x${hex}`);
+  }
+  function hexToBytes2(hex) {
+    if (typeof hex !== "string")
+      throw new Error("hex string expected, got " + typeof hex);
+    if (hex.length % 2)
+      throw new Error("hex string is invalid: unpadded " + hex.length);
+    const array = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < array.length; i++) {
+      const j = i * 2;
+      const hexByte = hex.slice(j, j + 2);
+      const byte = Number.parseInt(hexByte, 16);
+      if (Number.isNaN(byte) || byte < 0)
+        throw new Error("invalid byte sequence");
+      array[i] = byte;
+    }
+    return array;
+  }
+  function bytesToNumberBE2(bytes2) {
+    return hexToNumber2(bytesToHex2(bytes2));
+  }
+  function bytesToNumberLE2(bytes2) {
+    if (!u8a2(bytes2))
+      throw new Error("Uint8Array expected");
+    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
+  }
+  var numberToBytesBE2 = (n, len) => hexToBytes2(n.toString(16).padStart(len * 2, "0"));
+  var numberToBytesLE2 = (n, len) => numberToBytesBE2(n, len).reverse();
+  var numberToVarBytesBE2 = (n) => hexToBytes2(numberToHexUnpadded2(n));
+  function ensureBytes3(title, hex, expectedLength) {
+    let res;
+    if (typeof hex === "string") {
+      try {
+        res = hexToBytes2(hex);
+      } catch (e) {
+        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
+      }
+    } else if (u8a2(hex)) {
+      res = Uint8Array.from(hex);
+    } else {
+      throw new Error(`${title} must be hex string or Uint8Array`);
+    }
+    const len = res.length;
+    if (typeof expectedLength === "number" && len !== expectedLength)
+      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
+    return res;
+  }
+  function concatBytes3(...arrs) {
+    const r = new Uint8Array(arrs.reduce((sum, a) => sum + a.length, 0));
+    let pad = 0;
+    arrs.forEach((a) => {
+      if (!u8a2(a))
+        throw new Error("Uint8Array expected");
+      r.set(a, pad);
+      pad += a.length;
+    });
+    return r;
+  }
+  function equalBytes2(b1, b2) {
+    if (b1.length !== b2.length)
+      return false;
+    for (let i = 0; i < b1.length; i++)
+      if (b1[i] !== b2[i])
+        return false;
+    return true;
+  }
+  function utf8ToBytes3(str) {
+    if (typeof str !== "string") {
+      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+    }
+    return new TextEncoder().encode(str);
+  }
+  function bitLen2(n) {
+    let len;
+    for (len = 0; n > 0n; n >>= _1n6, len += 1)
+      ;
+    return len;
+  }
+  var bitGet2 = (n, pos) => n >> BigInt(pos) & 1n;
+  var bitSet2 = (n, pos, value) => n | (value ? _1n6 : _0n6) << BigInt(pos);
+  var bitMask2 = (n) => (_2n5 << BigInt(n - 1)) - _1n6;
+  var u8n2 = (data) => new Uint8Array(data);
+  var u8fr2 = (arr) => Uint8Array.from(arr);
+  function createHmacDrbg2(hashLen, qByteLen, hmacFn) {
+    if (typeof hashLen !== "number" || hashLen < 2)
+      throw new Error("hashLen must be a number");
+    if (typeof qByteLen !== "number" || qByteLen < 2)
+      throw new Error("qByteLen must be a number");
+    if (typeof hmacFn !== "function")
+      throw new Error("hmacFn must be a function");
+    let v = u8n2(hashLen);
+    let k = u8n2(hashLen);
+    let i = 0;
+    const reset = () => {
+      v.fill(1);
+      k.fill(0);
+      i = 0;
+    };
+    const h = (...b) => hmacFn(k, v, ...b);
+    const reseed = (seed = u8n2()) => {
+      k = h(u8fr2([0]), seed);
+      v = h();
+      if (seed.length === 0)
+        return;
+      k = h(u8fr2([1]), seed);
+      v = h();
+    };
+    const gen2 = () => {
+      if (i++ >= 1e3)
+        throw new Error("drbg: tried 1000 values");
+      let len = 0;
+      const out = [];
+      while (len < qByteLen) {
+        v = h();
+        const sl = v.slice();
+        out.push(sl);
+        len += v.length;
+      }
+      return concatBytes3(...out);
+    };
+    const genUntil = (seed, pred) => {
+      reset();
+      reseed(seed);
+      let res = void 0;
+      while (!(res = pred(gen2())))
+        reseed();
+      reset();
+      return res;
+    };
+    return genUntil;
+  }
+  var validatorFns2 = {
+    bigint: (val) => typeof val === "bigint",
+    function: (val) => typeof val === "function",
+    boolean: (val) => typeof val === "boolean",
+    string: (val) => typeof val === "string",
+    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)
+  };
+  function validateObject2(object, validators, optValidators = {}) {
+    const checkField = (fieldName, type, isOptional) => {
+      const checkVal = validatorFns2[type];
+      if (typeof checkVal !== "function")
+        throw new Error(`Invalid validator "${type}", expected function`);
+      const val = object[fieldName];
+      if (isOptional && val === void 0)
+        return;
+      if (!checkVal(val, object)) {
+        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
+      }
+    };
+    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;
+  }
+
+  // src/utils/num.ts
   function isHex(hex) {
     return /^0x[0-9a-f]*$/i.test(hex);
   }
@@ -5413,14 +5513,14 @@ var starknet = (() => {
     return value.map((el) => getHexString(el));
   }
   var toCairoBool = (value) => (+value).toString();
-  function hexToBytes2(value) {
+  function hexToBytes3(value) {
     if (!isHex(value))
       throw new Error(`${value} need to be a hex-string`);
     let adaptedValue = removeHexPrefix(value);
     if (adaptedValue.length % 2 !== 0) {
       adaptedValue = `0${adaptedValue}`;
     }
-    return hexToBytes(adaptedValue);
+    return hexToBytes2(adaptedValue);
   }
 
   // src/utils/shortString.ts
@@ -5569,35 +5669,1038 @@ var starknet = (() => {
     weierstrass: () => weierstrass_exports
   });
 
-  // src/utils/json.ts
-  var json_exports = {};
-  __export(json_exports, {
-    parse: () => parse2,
-    parseAlwaysAsBig: () => parseAlwaysAsBig,
-    stringify: () => stringify2,
-    stringifyAlwaysAsBig: () => stringifyAlwaysAsBig
+  // node_modules/@noble/curves/esm/abstract/weierstrass.js
+  var weierstrass_exports = {};
+  __export(weierstrass_exports, {
+    SWUFpSqrtRatio: () => SWUFpSqrtRatio,
+    mapToCurveSimpleSWU: () => mapToCurveSimpleSWU,
+    weierstrass: () => weierstrass2,
+    weierstrassPoints: () => weierstrassPoints2
   });
 
-  // node_modules/lossless-json/lib/esm/utils.js
-  function isInteger(value) {
-    return INTEGER_REGEX.test(value);
-  }
-  var INTEGER_REGEX = /^-?[0-9]+$/;
-  function isNumber(value) {
-    return NUMBER_REGEX.test(value);
+  // node_modules/@noble/curves/esm/abstract/modular.js
+  var _0n7 = BigInt(0);
+  var _1n7 = BigInt(1);
+  var _2n6 = BigInt(2);
+  var _3n3 = BigInt(3);
+  var _4n3 = BigInt(4);
+  var _5n2 = BigInt(5);
+  var _8n2 = BigInt(8);
+  var _9n2 = BigInt(9);
+  var _16n2 = BigInt(16);
+  function mod2(a, b) {
+    const result = a % b;
+    return result >= _0n7 ? result : b + result;
   }
-  var NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-  function isSafeNumber(value, config) {
-    var num = parseFloat(value);
-    var str = String(num);
-    var v = extractSignificantDigits(value);
-    var s = extractSignificantDigits(str);
-    if (v === s) {
-      return true;
+  function invert2(number3, modulo) {
+    if (number3 === _0n7 || modulo <= _0n7) {
+      throw new Error(`invert: expected positive integers, got n=${number3} mod=${modulo}`);
     }
-    if ((config === null || config === void 0 ? void 0 : config.approx) === true) {
-      var requiredDigits = 14;
-      if (!isInteger(value) && s.length >= requiredDigits && v.startsWith(s.substring(0, requiredDigits))) {
+    let a = mod2(number3, modulo);
+    let b = modulo;
+    let x = _0n7, y = _1n7, u = _1n7, v = _0n7;
+    while (a !== _0n7) {
+      const q = b / a;
+      const r = b % a;
+      const m = x - u * q;
+      const n = y - v * q;
+      b = a, a = r, x = u, y = v, u = m, v = n;
+    }
+    const gcd = b;
+    if (gcd !== _1n7)
+      throw new Error("invert: does not exist");
+    return mod2(x, modulo);
+  }
+  var FIELD_FIELDS2 = [
+    "create",
+    "isValid",
+    "is0",
+    "neg",
+    "inv",
+    "sqrt",
+    "sqr",
+    "eql",
+    "add",
+    "sub",
+    "mul",
+    "pow",
+    "div",
+    "addN",
+    "subN",
+    "mulN",
+    "sqrN"
+  ];
+  function validateField2(field) {
+    const initial = {
+      ORDER: "bigint",
+      MASK: "bigint",
+      BYTES: "isSafeInteger",
+      BITS: "isSafeInteger"
+    };
+    const opts = FIELD_FIELDS2.reduce((map, val) => {
+      map[val] = "function";
+      return map;
+    }, initial);
+    return validateObject2(field, opts);
+  }
+  function FpPow2(f, num, power) {
+    if (power < _0n7)
+      throw new Error("Expected power > 0");
+    if (power === _0n7)
+      return f.ONE;
+    if (power === _1n7)
+      return num;
+    let p = f.ONE;
+    let d = num;
+    while (power > _0n7) {
+      if (power & _1n7)
+        p = f.mul(p, d);
+      d = f.sqr(d);
+      power >>= 1n;
+    }
+    return p;
+  }
+  function nLength2(n, nBitLength2) {
+    const _nBitLength = nBitLength2 !== void 0 ? nBitLength2 : n.toString(2).length;
+    const nByteLength = Math.ceil(_nBitLength / 8);
+    return { nBitLength: _nBitLength, nByteLength };
+  }
+  function hashToPrivateScalar2(hash2, groupOrder, isLE2 = false) {
+    hash2 = ensureBytes3("privateHash", hash2);
+    const hashLen = hash2.length;
+    const minLen = nLength2(groupOrder).nByteLength + 8;
+    if (minLen < 24 || hashLen < minLen || hashLen > 1024)
+      throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);
+    const num = isLE2 ? bytesToNumberLE2(hash2) : bytesToNumberBE2(hash2);
+    return mod2(num, groupOrder - _1n7) + _1n7;
+  }
+
+  // node_modules/@noble/curves/esm/abstract/curve.js
+  var _0n8 = BigInt(0);
+  var _1n8 = BigInt(1);
+  function wNAF2(c, bits) {
+    const constTimeNegate = (condition, item) => {
+      const neg = item.negate();
+      return condition ? neg : item;
+    };
+    const opts = (W) => {
+      const windows = Math.ceil(bits / W) + 1;
+      const windowSize = 2 ** (W - 1);
+      return { windows, windowSize };
+    };
+    return {
+      constTimeNegate,
+      unsafeLadder(elm, n) {
+        let p = c.ZERO;
+        let d = elm;
+        while (n > _0n8) {
+          if (n & _1n8)
+            p = p.add(d);
+          d = d.double();
+          n >>= _1n8;
+        }
+        return p;
+      },
+      precomputeWindow(elm, W) {
+        const { windows, windowSize } = opts(W);
+        const points = [];
+        let p = elm;
+        let base = p;
+        for (let window2 = 0; window2 < windows; window2++) {
+          base = p;
+          points.push(base);
+          for (let i = 1; i < windowSize; i++) {
+            base = base.add(p);
+            points.push(base);
+          }
+          p = base.double();
+        }
+        return points;
+      },
+      wNAF(W, precomputes, n) {
+        const { windows, windowSize } = opts(W);
+        let p = c.ZERO;
+        let f = c.BASE;
+        const mask = BigInt(2 ** W - 1);
+        const maxNumber = 2 ** W;
+        const shiftBy = BigInt(W);
+        for (let window2 = 0; window2 < windows; window2++) {
+          const offset = window2 * windowSize;
+          let wbits = Number(n & mask);
+          n >>= shiftBy;
+          if (wbits > windowSize) {
+            wbits -= maxNumber;
+            n += _1n8;
+          }
+          const offset1 = offset;
+          const offset2 = offset + Math.abs(wbits) - 1;
+          const cond1 = window2 % 2 !== 0;
+          const cond2 = wbits < 0;
+          if (wbits === 0) {
+            f = f.add(constTimeNegate(cond1, precomputes[offset1]));
+          } else {
+            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
+          }
+        }
+        return { p, f };
+      },
+      wNAFCached(P, precomputesMap, n, transform) {
+        const W = P._WINDOW_SIZE || 1;
+        let comp = precomputesMap.get(P);
+        if (!comp) {
+          comp = this.precomputeWindow(P, W);
+          if (W !== 1) {
+            precomputesMap.set(P, transform(comp));
+          }
+        }
+        return this.wNAF(W, comp, n);
+      }
+    };
+  }
+  function validateBasic2(curve2) {
+    validateField2(curve2.Fp);
+    validateObject2(curve2, {
+      n: "bigint",
+      h: "bigint",
+      Gx: "field",
+      Gy: "field"
+    }, {
+      nBitLength: "isSafeInteger",
+      nByteLength: "isSafeInteger"
+    });
+    return Object.freeze({ ...nLength2(curve2.n, curve2.nBitLength), ...curve2 });
+  }
+
+  // node_modules/@noble/curves/esm/abstract/weierstrass.js
+  function validatePointOpts2(curve2) {
+    const opts = validateBasic2(curve2);
+    validateObject2(opts, {
+      a: "field",
+      b: "field",
+      fromBytes: "function",
+      toBytes: "function"
+    }, {
+      allowedPrivateKeyLengths: "array",
+      wrapPrivateKey: "boolean",
+      isTorsionFree: "function",
+      clearCofactor: "function",
+      allowInfinityPoint: "boolean"
+    });
+    const { endo, Fp, a } = opts;
+    if (endo) {
+      if (!Fp.eql(a, Fp.ZERO)) {
+        throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
+      }
+      if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
+        throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
+      }
+    }
+    return Object.freeze({ ...opts });
+  }
+  var { bytesToNumberBE: b2n2, hexToBytes: h2b2 } = utils_exports2;
+  var DER2 = {
+    Err: class DERErr2 extends Error {
+      constructor(m = "") {
+        super(m);
+      }
+    },
+    _parseInt(data) {
+      const { Err: E } = DER2;
+      if (data.length < 2 || data[0] !== 2)
+        throw new E("Invalid signature integer tag");
+      const len = data[1];
+      const res = data.subarray(2, len + 2);
+      if (!len || res.length !== len)
+        throw new E("Invalid signature integer: wrong length");
+      if (res[0] === 0 && res[1] <= 127)
+        throw new E("Invalid signature integer: trailing length");
+      return { d: b2n2(res), l: data.subarray(len + 2) };
+    },
+    toSig(hex) {
+      const { Err: E } = DER2;
+      const data = typeof hex === "string" ? h2b2(hex) : hex;
+      if (!(data instanceof Uint8Array))
+        throw new Error("ui8a expected");
+      let l = data.length;
+      if (l < 2 || data[0] != 48)
+        throw new E("Invalid signature tag");
+      if (data[1] !== l - 2)
+        throw new E("Invalid signature: incorrect length");
+      const { d: r, l: sBytes } = DER2._parseInt(data.subarray(2));
+      const { d: s, l: rBytesLeft } = DER2._parseInt(sBytes);
+      if (rBytesLeft.length)
+        throw new E("Invalid signature: left bytes after parsing");
+      return { r, s };
+    },
+    hexFromSig(sig) {
+      const slice = (s2) => Number.parseInt(s2[0], 16) >= 8 ? "00" + s2 : s2;
+      const h = (num) => {
+        const hex = num.toString(16);
+        return hex.length & 1 ? `0${hex}` : hex;
+      };
+      const s = slice(h(sig.s));
+      const r = slice(h(sig.r));
+      const shl = s.length / 2;
+      const rhl = r.length / 2;
+      const sl = h(shl);
+      const rl = h(rhl);
+      return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
+    }
+  };
+  var _0n9 = BigInt(0);
+  var _1n9 = BigInt(1);
+  function weierstrassPoints2(opts) {
+    const CURVE2 = validatePointOpts2(opts);
+    const { Fp } = CURVE2;
+    function weierstrassEquation(x) {
+      const { a, b } = CURVE2;
+      const x2 = Fp.sqr(x);
+      const x3 = Fp.mul(x2, x);
+      return Fp.add(Fp.add(x3, Fp.mul(x, a)), b);
+    }
+    function isWithinCurveOrder(num) {
+      return typeof num === "bigint" && _0n9 < num && num < CURVE2.n;
+    }
+    function assertGE(num) {
+      if (!isWithinCurveOrder(num))
+        throw new Error("Expected valid bigint: 0 < bigint < curve.n");
+    }
+    function normPrivateKeyToScalar(key) {
+      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE2;
+      if (lengths && typeof key !== "bigint") {
+        if (key instanceof Uint8Array)
+          key = bytesToHex2(key);
+        if (typeof key !== "string" || !lengths.includes(key.length))
+          throw new Error("Invalid key");
+        key = key.padStart(nByteLength * 2, "0");
+      }
+      let num;
+      try {
+        num = typeof key === "bigint" ? key : bytesToNumberBE2(ensureBytes3("private key", key, nByteLength));
+      } catch (error) {
+        throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
+      }
+      if (wrapPrivateKey)
+        num = mod2(num, n);
+      assertGE(num);
+      return num;
+    }
+    const pointPrecomputes = /* @__PURE__ */ new Map();
+    function assertPrjPoint(other) {
+      if (!(other instanceof Point))
+        throw new Error("ProjectivePoint expected");
+    }
+    class Point {
+      constructor(px, py, pz) {
+        this.px = px;
+        this.py = py;
+        this.pz = pz;
+        if (px == null || !Fp.isValid(px))
+          throw new Error("x required");
+        if (py == null || !Fp.isValid(py))
+          throw new Error("y required");
+        if (pz == null || !Fp.isValid(pz))
+          throw new Error("z required");
+      }
+      static fromAffine(p) {
+        const { x, y } = p || {};
+        if (!p || !Fp.isValid(x) || !Fp.isValid(y))
+          throw new Error("invalid affine point");
+        if (p instanceof Point)
+          throw new Error("projective point not allowed");
+        const is0 = (i) => Fp.eql(i, Fp.ZERO);
+        if (is0(x) && is0(y))
+          return Point.ZERO;
+        return new Point(x, y, Fp.ONE);
+      }
+      get x() {
+        return this.toAffine().x;
+      }
+      get y() {
+        return this.toAffine().y;
+      }
+      static normalizeZ(points) {
+        const toInv = Fp.invertBatch(points.map((p) => p.pz));
+        return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
+      }
+      static fromHex(hex) {
+        const P = Point.fromAffine(CURVE2.fromBytes(ensureBytes3("pointHex", hex)));
+        P.assertValidity();
+        return P;
+      }
+      static fromPrivateKey(privateKey) {
+        return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
+      }
+      _setWindowSize(windowSize) {
+        this._WINDOW_SIZE = windowSize;
+        pointPrecomputes.delete(this);
+      }
+      assertValidity() {
+        if (this.is0()) {
+          if (CURVE2.allowInfinityPoint)
+            return;
+          throw new Error("bad point: ZERO");
+        }
+        const { x, y } = this.toAffine();
+        if (!Fp.isValid(x) || !Fp.isValid(y))
+          throw new Error("bad point: x or y not FE");
+        const left = Fp.sqr(y);
+        const right = weierstrassEquation(x);
+        if (!Fp.eql(left, right))
+          throw new Error("bad point: equation left != right");
+        if (!this.isTorsionFree())
+          throw new Error("bad point: not in prime-order subgroup");
+      }
+      hasEvenY() {
+        const { y } = this.toAffine();
+        if (Fp.isOdd)
+          return !Fp.isOdd(y);
+        throw new Error("Field doesn't support isOdd");
+      }
+      equals(other) {
+        assertPrjPoint(other);
+        const { px: X1, py: Y1, pz: Z1 } = this;
+        const { px: X2, py: Y2, pz: Z2 } = other;
+        const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
+        const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
+        return U1 && U2;
+      }
+      negate() {
+        return new Point(this.px, Fp.neg(this.py), this.pz);
+      }
+      double() {
+        const { a, b } = CURVE2;
+        const b3 = Fp.mul(b, 3n);
+        const { px: X1, py: Y1, pz: Z1 } = this;
+        let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+        let t0 = Fp.mul(X1, X1);
+        let t1 = Fp.mul(Y1, Y1);
+        let t2 = Fp.mul(Z1, Z1);
+        let t3 = Fp.mul(X1, Y1);
+        t3 = Fp.add(t3, t3);
+        Z3 = Fp.mul(X1, Z1);
+        Z3 = Fp.add(Z3, Z3);
+        X3 = Fp.mul(a, Z3);
+        Y3 = Fp.mul(b3, t2);
+        Y3 = Fp.add(X3, Y3);
+        X3 = Fp.sub(t1, Y3);
+        Y3 = Fp.add(t1, Y3);
+        Y3 = Fp.mul(X3, Y3);
+        X3 = Fp.mul(t3, X3);
+        Z3 = Fp.mul(b3, Z3);
+        t2 = Fp.mul(a, t2);
+        t3 = Fp.sub(t0, t2);
+        t3 = Fp.mul(a, t3);
+        t3 = Fp.add(t3, Z3);
+        Z3 = Fp.add(t0, t0);
+        t0 = Fp.add(Z3, t0);
+        t0 = Fp.add(t0, t2);
+        t0 = Fp.mul(t0, t3);
+        Y3 = Fp.add(Y3, t0);
+        t2 = Fp.mul(Y1, Z1);
+        t2 = Fp.add(t2, t2);
+        t0 = Fp.mul(t2, t3);
+        X3 = Fp.sub(X3, t0);
+        Z3 = Fp.mul(t2, t1);
+        Z3 = Fp.add(Z3, Z3);
+        Z3 = Fp.add(Z3, Z3);
+        return new Point(X3, Y3, Z3);
+      }
+      add(other) {
+        assertPrjPoint(other);
+        const { px: X1, py: Y1, pz: Z1 } = this;
+        const { px: X2, py: Y2, pz: Z2 } = other;
+        let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+        const a = CURVE2.a;
+        const b3 = Fp.mul(CURVE2.b, 3n);
+        let t0 = Fp.mul(X1, X2);
+        let t1 = Fp.mul(Y1, Y2);
+        let t2 = Fp.mul(Z1, Z2);
+        let t3 = Fp.add(X1, Y1);
+        let t4 = Fp.add(X2, Y2);
+        t3 = Fp.mul(t3, t4);
+        t4 = Fp.add(t0, t1);
+        t3 = Fp.sub(t3, t4);
+        t4 = Fp.add(X1, Z1);
+        let t5 = Fp.add(X2, Z2);
+        t4 = Fp.mul(t4, t5);
+        t5 = Fp.add(t0, t2);
+        t4 = Fp.sub(t4, t5);
+        t5 = Fp.add(Y1, Z1);
+        X3 = Fp.add(Y2, Z2);
+        t5 = Fp.mul(t5, X3);
+        X3 = Fp.add(t1, t2);
+        t5 = Fp.sub(t5, X3);
+        Z3 = Fp.mul(a, t4);
+        X3 = Fp.mul(b3, t2);
+        Z3 = Fp.add(X3, Z3);
+        X3 = Fp.sub(t1, Z3);
+        Z3 = Fp.add(t1, Z3);
+        Y3 = Fp.mul(X3, Z3);
+        t1 = Fp.add(t0, t0);
+        t1 = Fp.add(t1, t0);
+        t2 = Fp.mul(a, t2);
+        t4 = Fp.mul(b3, t4);
+        t1 = Fp.add(t1, t2);
+        t2 = Fp.sub(t0, t2);
+        t2 = Fp.mul(a, t2);
+        t4 = Fp.add(t4, t2);
+        t0 = Fp.mul(t1, t4);
+        Y3 = Fp.add(Y3, t0);
+        t0 = Fp.mul(t5, t4);
+        X3 = Fp.mul(t3, X3);
+        X3 = Fp.sub(X3, t0);
+        t0 = Fp.mul(t3, t1);
+        Z3 = Fp.mul(t5, Z3);
+        Z3 = Fp.add(Z3, t0);
+        return new Point(X3, Y3, Z3);
+      }
+      subtract(other) {
+        return this.add(other.negate());
+      }
+      is0() {
+        return this.equals(Point.ZERO);
+      }
+      wNAF(n) {
+        return wnaf.wNAFCached(this, pointPrecomputes, n, (comp) => {
+          const toInv = Fp.invertBatch(comp.map((p) => p.pz));
+          return comp.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
+        });
+      }
+      multiplyUnsafe(n) {
+        const I = Point.ZERO;
+        if (n === _0n9)
+          return I;
+        assertGE(n);
+        if (n === _1n9)
+          return this;
+        const { endo } = CURVE2;
+        if (!endo)
+          return wnaf.unsafeLadder(this, n);
+        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
+        let k1p = I;
+        let k2p = I;
+        let d = this;
+        while (k1 > _0n9 || k2 > _0n9) {
+          if (k1 & _1n9)
+            k1p = k1p.add(d);
+          if (k2 & _1n9)
+            k2p = k2p.add(d);
+          d = d.double();
+          k1 >>= _1n9;
+          k2 >>= _1n9;
+        }
+        if (k1neg)
+          k1p = k1p.negate();
+        if (k2neg)
+          k2p = k2p.negate();
+        k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
+        return k1p.add(k2p);
+      }
+      multiply(scalar) {
+        assertGE(scalar);
+        let n = scalar;
+        let point, fake;
+        const { endo } = CURVE2;
+        if (endo) {
+          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
+          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 Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
+          point = k1p.add(k2p);
+          fake = f1p.add(f2p);
+        } else {
+          const { p, f } = this.wNAF(n);
+          point = p;
+          fake = f;
+        }
+        return Point.normalizeZ([point, fake])[0];
+      }
+      multiplyAndAddUnsafe(Q, a, b) {
+        const G = Point.BASE;
+        const mul = (P, a2) => a2 === _0n9 || a2 === _1n9 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
+        const sum = mul(this, a).add(mul(Q, b));
+        return sum.is0() ? void 0 : sum;
+      }
+      toAffine(iz) {
+        const { px: x, py: y, pz: z } = this;
+        const is0 = this.is0();
+        if (iz == null)
+          iz = is0 ? Fp.ONE : Fp.inv(z);
+        const ax = Fp.mul(x, iz);
+        const ay = Fp.mul(y, iz);
+        const zz = Fp.mul(z, iz);
+        if (is0)
+          return { x: Fp.ZERO, y: Fp.ZERO };
+        if (!Fp.eql(zz, Fp.ONE))
+          throw new Error("invZ was invalid");
+        return { x: ax, y: ay };
+      }
+      isTorsionFree() {
+        const { h: cofactor, isTorsionFree } = CURVE2;
+        if (cofactor === _1n9)
+          return true;
+        if (isTorsionFree)
+          return isTorsionFree(Point, this);
+        throw new Error("isTorsionFree() has not been declared for the elliptic curve");
+      }
+      clearCofactor() {
+        const { h: cofactor, clearCofactor } = CURVE2;
+        if (cofactor === _1n9)
+          return this;
+        if (clearCofactor)
+          return clearCofactor(Point, this);
+        return this.multiplyUnsafe(CURVE2.h);
+      }
+      toRawBytes(isCompressed = true) {
+        this.assertValidity();
+        return CURVE2.toBytes(Point, this, isCompressed);
+      }
+      toHex(isCompressed = true) {
+        return bytesToHex2(this.toRawBytes(isCompressed));
+      }
+    }
+    Point.BASE = new Point(CURVE2.Gx, CURVE2.Gy, Fp.ONE);
+    Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
+    const _bits = CURVE2.nBitLength;
+    const wnaf = wNAF2(Point, CURVE2.endo ? Math.ceil(_bits / 2) : _bits);
+    return {
+      ProjectivePoint: Point,
+      normPrivateKeyToScalar,
+      weierstrassEquation,
+      isWithinCurveOrder
+    };
+  }
+  function validateOpts3(curve2) {
+    const opts = validateBasic2(curve2);
+    validateObject2(opts, {
+      hash: "hash",
+      hmac: "function",
+      randomBytes: "function"
+    }, {
+      bits2int: "function",
+      bits2int_modN: "function",
+      lowS: "boolean"
+    });
+    return Object.freeze({ lowS: true, ...opts });
+  }
+  function weierstrass2(curveDef) {
+    const CURVE2 = validateOpts3(curveDef);
+    const CURVE_ORDER2 = CURVE2.n;
+    const Fp = CURVE2.Fp;
+    const compressedLen = Fp.BYTES + 1;
+    const uncompressedLen = 2 * Fp.BYTES + 1;
+    function isValidFieldElement(num) {
+      return _0n9 < num && num < Fp.ORDER;
+    }
+    function modN(a) {
+      return mod2(a, CURVE_ORDER2);
+    }
+    function invN(a) {
+      return invert2(a, CURVE_ORDER2);
+    }
+    const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints2({
+      ...CURVE2,
+      toBytes(c, point, isCompressed) {
+        const a = point.toAffine();
+        const x = Fp.toBytes(a.x);
+        const cat = concatBytes3;
+        if (isCompressed) {
+          return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
+        } else {
+          return cat(Uint8Array.from([4]), x, Fp.toBytes(a.y));
+        }
+      },
+      fromBytes(bytes2) {
+        const len = bytes2.length;
+        const head = bytes2[0];
+        const tail = bytes2.subarray(1);
+        if (len === compressedLen && (head === 2 || head === 3)) {
+          const x = bytesToNumberBE2(tail);
+          if (!isValidFieldElement(x))
+            throw new Error("Point is not on curve");
+          const y2 = weierstrassEquation(x);
+          let y = Fp.sqrt(y2);
+          const isYOdd = (y & _1n9) === _1n9;
+          const isHeadOdd = (head & 1) === 1;
+          if (isHeadOdd !== isYOdd)
+            y = Fp.neg(y);
+          return { x, y };
+        } else if (len === uncompressedLen && head === 4) {
+          const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
+          const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
+          return { x, y };
+        } else {
+          throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
+        }
+      }
+    });
+    const numToNByteStr = (num) => bytesToHex2(numberToBytesBE2(num, CURVE2.nByteLength));
+    function isBiggerThanHalfOrder(number3) {
+      const HALF = CURVE_ORDER2 >> _1n9;
+      return number3 > HALF;
+    }
+    function normalizeS(s) {
+      return isBiggerThanHalfOrder(s) ? modN(-s) : s;
+    }
+    const slcNum = (b, from, to) => bytesToNumberBE2(b.slice(from, to));
+    class Signature3 {
+      constructor(r, s, recovery) {
+        this.r = r;
+        this.s = s;
+        this.recovery = recovery;
+        this.assertValidity();
+      }
+      static fromCompact(hex) {
+        const l = CURVE2.nByteLength;
+        hex = ensureBytes3("compactSignature", hex, l * 2);
+        return new Signature3(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
+      }
+      static fromDER(hex) {
+        const { r, s } = DER2.toSig(ensureBytes3("DER", hex));
+        return new Signature3(r, s);
+      }
+      assertValidity() {
+        if (!isWithinCurveOrder(this.r))
+          throw new Error("r must be 0 < r < CURVE.n");
+        if (!isWithinCurveOrder(this.s))
+          throw new Error("s must be 0 < s < CURVE.n");
+      }
+      addRecoveryBit(recovery) {
+        return new Signature3(this.r, this.s, recovery);
+      }
+      recoverPublicKey(msgHash) {
+        const { r, s, recovery: rec } = this;
+        const h = bits2int_modN(ensureBytes3("msgHash", msgHash));
+        if (rec == null || ![0, 1, 2, 3].includes(rec))
+          throw new Error("recovery id invalid");
+        const radj = rec === 2 || rec === 3 ? r + CURVE2.n : r;
+        if (radj >= Fp.ORDER)
+          throw new Error("recovery id 2 or 3 invalid");
+        const prefix = (rec & 1) === 0 ? "02" : "03";
+        const R = Point.fromHex(prefix + numToNByteStr(radj));
+        const ir = invN(radj);
+        const u1 = modN(-h * ir);
+        const u2 = modN(s * ir);
+        const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2);
+        if (!Q)
+          throw new Error("point at infinify");
+        Q.assertValidity();
+        return Q;
+      }
+      hasHighS() {
+        return isBiggerThanHalfOrder(this.s);
+      }
+      normalizeS() {
+        return this.hasHighS() ? new Signature3(this.r, modN(-this.s), this.recovery) : this;
+      }
+      toDERRawBytes() {
+        return hexToBytes2(this.toDERHex());
+      }
+      toDERHex() {
+        return DER2.hexFromSig({ r: this.r, s: this.s });
+      }
+      toCompactRawBytes() {
+        return hexToBytes2(this.toCompactHex());
+      }
+      toCompactHex() {
+        return numToNByteStr(this.r) + numToNByteStr(this.s);
+      }
+    }
+    const utils2 = {
+      isValidPrivateKey(privateKey) {
+        try {
+          normPrivateKeyToScalar(privateKey);
+          return true;
+        } catch (error) {
+          return false;
+        }
+      },
+      normPrivateKeyToScalar,
+      randomPrivateKey: () => {
+        const rand = CURVE2.randomBytes(Fp.BYTES + 8);
+        const num = hashToPrivateScalar2(rand, CURVE_ORDER2);
+        return numberToBytesBE2(num, CURVE2.nByteLength);
+      },
+      precompute(windowSize = 8, point = Point.BASE) {
+        point._setWindowSize(windowSize);
+        point.multiply(BigInt(3));
+        return point;
+      }
+    };
+    function getPublicKey2(privateKey, isCompressed = true) {
+      return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
+    }
+    function isProbPub(item) {
+      const arr = item instanceof Uint8Array;
+      const str = typeof item === "string";
+      const len = (arr || str) && item.length;
+      if (arr)
+        return len === compressedLen || len === uncompressedLen;
+      if (str)
+        return len === 2 * compressedLen || len === 2 * uncompressedLen;
+      if (item instanceof Point)
+        return true;
+      return false;
+    }
+    function getSharedSecret2(privateA, publicB, isCompressed = true) {
+      if (isProbPub(privateA))
+        throw new Error("first arg must be private key");
+      if (!isProbPub(publicB))
+        throw new Error("second arg must be public key");
+      const b = Point.fromHex(publicB);
+      return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
+    }
+    const bits2int2 = CURVE2.bits2int || function(bytes2) {
+      const num = bytesToNumberBE2(bytes2);
+      const delta = bytes2.length * 8 - CURVE2.nBitLength;
+      return delta > 0 ? num >> BigInt(delta) : num;
+    };
+    const bits2int_modN = CURVE2.bits2int_modN || function(bytes2) {
+      return modN(bits2int2(bytes2));
+    };
+    const ORDER_MASK = bitMask2(CURVE2.nBitLength);
+    function int2octets(num) {
+      if (typeof num !== "bigint")
+        throw new Error("bigint expected");
+      if (!(_0n9 <= num && num < ORDER_MASK))
+        throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`);
+      return numberToBytesBE2(num, CURVE2.nByteLength);
+    }
+    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 } = CURVE2;
+      let { lowS, prehash, extraEntropy: ent } = opts;
+      if (lowS == null)
+        lowS = true;
+      msgHash = ensureBytes3("msgHash", msgHash);
+      if (prehash)
+        msgHash = ensureBytes3("prehashed msgHash", hash2(msgHash));
+      const h1int = bits2int_modN(msgHash);
+      const d = normPrivateKeyToScalar(privateKey);
+      const seedArgs = [int2octets(d), int2octets(h1int)];
+      if (ent != null) {
+        const e = ent === true ? randomBytes2(Fp.BYTES) : ent;
+        seedArgs.push(ensureBytes3("extraEntropy", e, Fp.BYTES));
+      }
+      const seed = concatBytes3(...seedArgs);
+      const m = h1int;
+      function k2sig(kBytes) {
+        const k = bits2int2(kBytes);
+        if (!isWithinCurveOrder(k))
+          return;
+        const ik = invN(k);
+        const q = Point.BASE.multiply(k).toAffine();
+        const r = modN(q.x);
+        if (r === _0n9)
+          return;
+        const s = modN(ik * modN(m + r * d));
+        if (s === _0n9)
+          return;
+        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n9);
+        let normS = s;
+        if (lowS && isBiggerThanHalfOrder(s)) {
+          normS = normalizeS(s);
+          recovery ^= 1;
+        }
+        return new Signature3(r, normS, recovery);
+      }
+      return { seed, k2sig };
+    }
+    const defaultSigOpts = { lowS: CURVE2.lowS, prehash: false };
+    const defaultVerOpts = { lowS: CURVE2.lowS, prehash: false };
+    function sign2(msgHash, privKey, opts = defaultSigOpts) {
+      const { seed, k2sig } = prepSig(msgHash, privKey, opts);
+      const drbg = createHmacDrbg2(CURVE2.hash.outputLen, CURVE2.nByteLength, CURVE2.hmac);
+      return drbg(seed, k2sig);
+    }
+    Point.BASE._setWindowSize(8);
+    function verify2(signature, msgHash, publicKey, opts = defaultVerOpts) {
+      var _a;
+      const sg = signature;
+      msgHash = ensureBytes3("msgHash", msgHash);
+      publicKey = ensureBytes3("publicKey", publicKey);
+      if ("strict" in opts)
+        throw new Error("options.strict was renamed to lowS");
+      const { lowS, prehash } = opts;
+      let _sig = void 0;
+      let P;
+      try {
+        if (typeof sg === "string" || sg instanceof Uint8Array) {
+          try {
+            _sig = Signature3.fromDER(sg);
+          } catch (derError) {
+            if (!(derError instanceof DER2.Err))
+              throw derError;
+            _sig = Signature3.fromCompact(sg);
+          }
+        } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
+          const { r: r2, s: s2 } = sg;
+          _sig = new Signature3(r2, s2);
+        } else {
+          throw new Error("PARSE");
+        }
+        P = Point.fromHex(publicKey);
+      } catch (error) {
+        if (error.message === "PARSE")
+          throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
+        return false;
+      }
+      if (lowS && _sig.hasHighS())
+        return false;
+      if (prehash)
+        msgHash = CURVE2.hash(msgHash);
+      const { r, s } = _sig;
+      const h = bits2int_modN(msgHash);
+      const is = invN(s);
+      const u1 = modN(h * is);
+      const u2 = modN(r * is);
+      const R = (_a = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)) == null ? void 0 : _a.toAffine();
+      if (!R)
+        return false;
+      const v = modN(R.x);
+      return v === r;
+    }
+    return {
+      CURVE: CURVE2,
+      getPublicKey: getPublicKey2,
+      getSharedSecret: getSharedSecret2,
+      sign: sign2,
+      verify: verify2,
+      ProjectivePoint: Point,
+      Signature: Signature3,
+      utils: utils2
+    };
+  }
+  function SWUFpSqrtRatio(Fp, Z) {
+    const q = Fp.ORDER;
+    let l = 0n;
+    for (let o = q - 1n; o % 2n === 0n; o /= 2n)
+      l += 1n;
+    const c1 = l;
+    const c2 = (q - 1n) / 2n ** c1;
+    const c3 = (c2 - 1n) / 2n;
+    const c4 = 2n ** c1 - 1n;
+    const c5 = 2n ** (c1 - 1n);
+    const c6 = Fp.pow(Z, c2);
+    const c7 = Fp.pow(Z, (c2 + 1n) / 2n);
+    let sqrtRatio = (u, v) => {
+      let tv1 = c6;
+      let tv2 = Fp.pow(v, c4);
+      let tv3 = Fp.sqr(tv2);
+      tv3 = Fp.mul(tv3, v);
+      let tv5 = Fp.mul(u, tv3);
+      tv5 = Fp.pow(tv5, c3);
+      tv5 = Fp.mul(tv5, tv2);
+      tv2 = Fp.mul(tv5, v);
+      tv3 = Fp.mul(tv5, u);
+      let tv4 = Fp.mul(tv3, tv2);
+      tv5 = Fp.pow(tv4, c5);
+      let isQR = Fp.eql(tv5, Fp.ONE);
+      tv2 = Fp.mul(tv3, c7);
+      tv5 = Fp.mul(tv4, tv1);
+      tv3 = Fp.cmov(tv2, tv3, isQR);
+      tv4 = Fp.cmov(tv5, tv4, isQR);
+      for (let i = c1; i > 1; i--) {
+        let tv52 = 2n ** (i - 2n);
+        let tvv5 = Fp.pow(tv4, tv52);
+        const e1 = Fp.eql(tvv5, Fp.ONE);
+        tv2 = Fp.mul(tv3, tv1);
+        tv1 = Fp.mul(tv1, tv1);
+        tvv5 = Fp.mul(tv4, tv1);
+        tv3 = Fp.cmov(tv2, tv3, e1);
+        tv4 = Fp.cmov(tvv5, tv4, e1);
+      }
+      return { isValid: isQR, value: tv3 };
+    };
+    if (Fp.ORDER % 4n === 3n) {
+      const c12 = (Fp.ORDER - 3n) / 4n;
+      const c22 = Fp.sqrt(Fp.neg(Z));
+      sqrtRatio = (u, v) => {
+        let tv1 = Fp.sqr(v);
+        const tv2 = Fp.mul(u, v);
+        tv1 = Fp.mul(tv1, tv2);
+        let y1 = Fp.pow(tv1, c12);
+        y1 = Fp.mul(y1, tv2);
+        const y2 = Fp.mul(y1, c22);
+        const tv3 = Fp.mul(Fp.sqr(y1), v);
+        const isQR = Fp.eql(tv3, u);
+        let y = Fp.cmov(y2, y1, isQR);
+        return { isValid: isQR, value: y };
+      };
+    }
+    return sqrtRatio;
+  }
+  function mapToCurveSimpleSWU(Fp, opts) {
+    validateField2(Fp);
+    if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))
+      throw new Error("mapToCurveSimpleSWU: invalid opts");
+    const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);
+    if (!Fp.isOdd)
+      throw new Error("Fp.isOdd is not implemented!");
+    return (u) => {
+      let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
+      tv1 = Fp.sqr(u);
+      tv1 = Fp.mul(tv1, opts.Z);
+      tv2 = Fp.sqr(tv1);
+      tv2 = Fp.add(tv2, tv1);
+      tv3 = Fp.add(tv2, Fp.ONE);
+      tv3 = Fp.mul(tv3, opts.B);
+      tv4 = Fp.cmov(opts.Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO));
+      tv4 = Fp.mul(tv4, opts.A);
+      tv2 = Fp.sqr(tv3);
+      tv6 = Fp.sqr(tv4);
+      tv5 = Fp.mul(tv6, opts.A);
+      tv2 = Fp.add(tv2, tv5);
+      tv2 = Fp.mul(tv2, tv3);
+      tv6 = Fp.mul(tv6, tv4);
+      tv5 = Fp.mul(tv6, opts.B);
+      tv2 = Fp.add(tv2, tv5);
+      x = Fp.mul(tv1, tv3);
+      const { isValid, value } = sqrtRatio(tv2, tv6);
+      y = Fp.mul(tv1, u);
+      y = Fp.mul(y, value);
+      x = Fp.cmov(x, tv3, isValid);
+      y = Fp.cmov(y, value, isValid);
+      const e1 = Fp.isOdd(u) === Fp.isOdd(y);
+      y = Fp.cmov(Fp.neg(y), y, e1);
+      x = Fp.div(x, tv4);
+      return { x, y };
+    };
+  }
+
+  // src/utils/json.ts
+  var json_exports = {};
+  __export(json_exports, {
+    parse: () => parse2,
+    parseAlwaysAsBig: () => parseAlwaysAsBig,
+    stringify: () => stringify2,
+    stringifyAlwaysAsBig: () => stringifyAlwaysAsBig
+  });
+
+  // node_modules/lossless-json/lib/esm/utils.js
+  function isInteger(value) {
+    return INTEGER_REGEX.test(value);
+  }
+  var INTEGER_REGEX = /^-?[0-9]+$/;
+  function isNumber(value) {
+    return NUMBER_REGEX.test(value);
+  }
+  var NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+  function isSafeNumber(value, config) {
+    var num = parseFloat(value);
+    var str = String(num);
+    var v = extractSignificantDigits(value);
+    var s = extractSignificantDigits(str);
+    if (v === s) {
+      return true;
+    }
+    if ((config === null || config === void 0 ? void 0 : config.approx) === true) {
+      var requiredDigits = 14;
+      if (!isInteger(value) && s.length >= requiredDigits && v.startsWith(s.substring(0, requiredDigits))) {
         return true;
       }
     }
@@ -6236,6 +7339,112 @@ var starknet = (() => {
   var stringify2 = (...p) => stringify(...p);
   var stringifyAlwaysAsBig = stringify2;
 
+  // node_modules/@noble/curves/esm/abstract/poseidon.js
+  var poseidon_exports = {};
+  __export(poseidon_exports, {
+    poseidon: () => poseidon2,
+    splitConstants: () => splitConstants,
+    validateOpts: () => validateOpts4
+  });
+  function validateOpts4(opts) {
+    const { Fp } = opts;
+    validateField2(Fp);
+    for (const i of ["t", "roundsFull", "roundsPartial"]) {
+      if (typeof opts[i] !== "number" || !Number.isSafeInteger(opts[i]))
+        throw new Error(`Poseidon: invalid param ${i}=${opts[i]} (${typeof opts[i]})`);
+    }
+    if (opts.reversePartialPowIdx !== void 0 && typeof opts.reversePartialPowIdx !== "boolean")
+      throw new Error(`Poseidon: invalid param reversePartialPowIdx=${opts.reversePartialPowIdx}`);
+    let sboxPower = opts.sboxPower;
+    if (sboxPower === void 0)
+      sboxPower = 5;
+    if (typeof sboxPower !== "number" || !Number.isSafeInteger(sboxPower))
+      throw new Error(`Poseidon wrong sboxPower=${sboxPower}`);
+    const _sboxPower = BigInt(sboxPower);
+    let sboxFn = (n) => FpPow2(Fp, n, _sboxPower);
+    if (sboxPower === 3)
+      sboxFn = (n) => Fp.mul(Fp.sqrN(n), n);
+    else if (sboxPower === 5)
+      sboxFn = (n) => Fp.mul(Fp.sqrN(Fp.sqrN(n)), n);
+    if (opts.roundsFull % 2 !== 0)
+      throw new Error(`Poseidon roundsFull is not even: ${opts.roundsFull}`);
+    const rounds = opts.roundsFull + opts.roundsPartial;
+    if (!Array.isArray(opts.roundConstants) || opts.roundConstants.length !== rounds)
+      throw new Error("Poseidon: wrong round constants");
+    const roundConstants = opts.roundConstants.map((rc) => {
+      if (!Array.isArray(rc) || rc.length !== opts.t)
+        throw new Error(`Poseidon wrong round constants: ${rc}`);
+      return rc.map((i) => {
+        if (typeof i !== "bigint" || !Fp.isValid(i))
+          throw new Error(`Poseidon wrong round constant=${i}`);
+        return Fp.create(i);
+      });
+    });
+    if (!Array.isArray(opts.mds) || opts.mds.length !== opts.t)
+      throw new Error("Poseidon: wrong MDS matrix");
+    const mds = opts.mds.map((mdsRow) => {
+      if (!Array.isArray(mdsRow) || mdsRow.length !== opts.t)
+        throw new Error(`Poseidon MDS matrix row: ${mdsRow}`);
+      return mdsRow.map((i) => {
+        if (typeof i !== "bigint")
+          throw new Error(`Poseidon MDS matrix value=${i}`);
+        return Fp.create(i);
+      });
+    });
+    return Object.freeze({ ...opts, rounds, sboxFn, roundConstants, mds });
+  }
+  function splitConstants(rc, t) {
+    if (typeof t !== "number")
+      throw new Error("poseidonSplitConstants: wrong t");
+    if (!Array.isArray(rc) || rc.length % t)
+      throw new Error("poseidonSplitConstants: wrong rc");
+    const res = [];
+    let tmp = [];
+    for (let i = 0; i < rc.length; i++) {
+      tmp.push(rc[i]);
+      if (tmp.length === t) {
+        res.push(tmp);
+        tmp = [];
+      }
+    }
+    return res;
+  }
+  function poseidon2(opts) {
+    const { t, Fp, rounds, sboxFn, reversePartialPowIdx } = validateOpts4(opts);
+    const halfRoundsFull = Math.floor(opts.roundsFull / 2);
+    const partialIdx = reversePartialPowIdx ? t - 1 : 0;
+    const poseidonRound = (values, isFull, idx) => {
+      values = values.map((i, j) => Fp.add(i, opts.roundConstants[idx][j]));
+      if (isFull)
+        values = values.map((i) => sboxFn(i));
+      else
+        values[partialIdx] = sboxFn(values[partialIdx]);
+      values = opts.mds.map((i) => i.reduce((acc, i2, j) => Fp.add(acc, Fp.mulN(i2, values[j])), Fp.ZERO));
+      return values;
+    };
+    const poseidonHash2 = function poseidonHash3(values) {
+      if (!Array.isArray(values) || values.length !== t)
+        throw new Error(`Poseidon: wrong values (expected array of bigints with length ${t})`);
+      values = values.map((i) => {
+        if (typeof i !== "bigint")
+          throw new Error(`Poseidon: wrong value=${i} (${typeof i})`);
+        return Fp.create(i);
+      });
+      let round = 0;
+      for (let i = 0; i < halfRoundsFull; i++)
+        values = poseidonRound(values, true, round++);
+      for (let i = 0; i < opts.roundsPartial; i++)
+        values = poseidonRound(values, false, round++);
+      for (let i = 0; i < halfRoundsFull; i++)
+        values = poseidonRound(values, true, round++);
+      if (round !== rounds)
+        throw new Error(`Poseidon: wrong number of rounds: last round=${round}, total=${rounds}`);
+      return values;
+    };
+    poseidonHash2.roundConstants = opts.roundConstants;
+    return poseidonHash2;
+  }
+
   // src/utils/hash.ts
   var transactionVersion = 1n;
   var transactionVersion_2 = 2n;
@@ -6243,7 +7452,7 @@ var starknet = (() => {
   function keccakBn(value) {
     const hexWithoutPrefix = removeHexPrefix(toHex(BigInt(value)));
     const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
-    return addHexPrefix(keccak(hexToBytes2(addHexPrefix(evenHex))).toString(16));
+    return addHexPrefix(keccak(hexToBytes3(addHexPrefix(evenHex))).toString(16));
   }
   function keccakHex(value) {
     return addHexPrefix(keccak(utf8ToArray(value)).toString(16));
@@ -6657,6 +7866,12 @@ var starknet = (() => {
         }, result);
       case (isTypeStruct(type, structs) || isTypeTuple(type)):
         return parseCalldataValue(value, type, structs);
+      case isTypeUint256(type):
+        if (typeof value === "object") {
+          return [felt(value.low), felt(value.high)];
+        }
+        const el_uint256 = uint256(value);
+        return [felt(el_uint256.low), felt(el_uint256.high)];
       default:
         return parseBaseTypes(type, value);
     }
@@ -6744,10 +7959,10 @@ var starknet = (() => {
       );
     }
     assert(
-      typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
-      `Validate: arg ${input.name} of cairo type ${input.type} should be type (String, Number or BigInt)`
+      typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint" || typeof parameter === "object" && "low" in parameter && "high" in parameter,
+      `Validate: arg ${input.name} of cairo ZORG type ${input.type} should be type (String, Number or BigInt)`
     );
-    const param = toBigInt(parameter);
+    const param = typeof parameter === "object" ? uint256ToBN(parameter) : toBigInt(parameter);
     switch (input.type) {
       case "core::integer::u8" /* u8 */:
         assert(
@@ -13580,7 +14795,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
   function getChecksumAddress(address) {
     const chars = removeHexPrefix(validateAndParseAddress(address)).toLowerCase().split("");
     const hex = removeHexPrefix(keccakBn(address));
-    const hashed = hexToBytes(hex.padStart(64, "0"));
+    const hashed = hexToBytes2(hex.padStart(64, "0"));
     for (let i = 0; i < chars.length; i += 2) {
       if (hashed[i >> 1] >> 4 >= 8) {
         chars[i] = chars[i].toUpperCase();