starknet 5.0.2 → 5.1.1

package/dist/index.global.js

@@ -546,11 +546,11 @@ var starknet = (() => {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.output = exports.exists = exports.hash = exports.bytes = exports.bool = exports.number = void 0;
-      function number2(n) {
+      function number3(n) {
         if (!Number.isSafeInteger(n) || n < 0)
           throw new Error(`Wrong positive integer: ${n}`);
       }
-      exports.number = number2;
+      exports.number = number3;
       function bool2(b) {
         if (typeof b !== "boolean")
           throw new Error(`Expected boolean, not ${b}`);
@@ -566,8 +566,8 @@ var starknet = (() => {
       function hash2(hash3) {
         if (typeof hash3 !== "function" || typeof hash3.create !== "function")
           throw new Error("Hash should be wrapped by utils.wrapConstructor");
-        number2(hash3.outputLen);
-        number2(hash3.blockLen);
+        number3(hash3.outputLen);
+        number3(hash3.blockLen);
       }
       exports.hash = hash2;
       function exists2(instance, checkFinished = true) {
@@ -586,7 +586,7 @@ var starknet = (() => {
       }
       exports.output = output2;
       var assert3 = {
-        number: number2,
+        number: number3,
         bool: bool2,
         bytes: bytes2,
         hash: hash2,
@@ -749,16 +749,16 @@ var starknet = (() => {
         }
       }
       exports.asyncLoop = asyncLoop;
-      function utf8ToBytes2(str) {
+      function utf8ToBytes3(str) {
         if (typeof str !== "string") {
           throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);
         }
         return new TextEncoder().encode(str);
       }
-      exports.utf8ToBytes = utf8ToBytes2;
+      exports.utf8ToBytes = utf8ToBytes3;
       function toBytes2(data) {
         if (typeof data === "string")
-          data = utf8ToBytes2(data);
+          data = utf8ToBytes3(data);
         if (!(data instanceof Uint8Array))
           throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);
         return data;
@@ -1502,7 +1502,7 @@ var starknet = (() => {
               }
               return arr.reverse();
             }
-            return function(str, baseIn, baseOut, sign, callerIsToString) {
+            return function(str, baseIn, baseOut, sign2, callerIsToString) {
               var alphabet, d, e, k, r, x, xc, y, i = str.indexOf("."), dp = DECIMAL_PLACES, rm = ROUNDING_MODE;
               if (i >= 0) {
                 k = POW_PRECISION;
@@ -1530,7 +1530,7 @@ var starknet = (() => {
               } else {
                 x.c = xc;
                 x.e = e;
-                x.s = sign;
+                x.s = sign2;
                 x = div(x, y, dp, rm, baseOut);
                 xc = x.c;
                 r = x.r;
@@ -2755,8 +2755,8 @@ var starknet = (() => {
           ch = text.charAt(at);
           at += 1;
           return ch;
-        }, number2 = function() {
-          var number3, string2 = "";
+        }, number3 = function() {
+          var number4, string2 = "";
           if (ch === "-") {
             string2 = "-";
             next("-");
@@ -2783,8 +2783,8 @@ var starknet = (() => {
               next();
             }
           }
-          number3 = +string2;
-          if (!isFinite(number3)) {
+          number4 = +string2;
+          if (!isFinite(number4)) {
             error("Bad number");
           } else {
             if (BigNumber == null)
@@ -2792,7 +2792,7 @@ var starknet = (() => {
             if (string2.length > 15)
               return _options.storeAsString ? string2 : _options.useNativeBigInt ? BigInt(string2) : new BigNumber(string2);
             else
-              return !_options.alwaysParseAsBig ? number3 : _options.useNativeBigInt ? BigInt(number3) : new BigNumber(number3);
+              return !_options.alwaysParseAsBig ? number4 : _options.useNativeBigInt ? BigInt(number4) : new BigNumber(number4);
           }
         }, string = function() {
           var hex, i, string2 = "", uffff;
@@ -2933,9 +2933,9 @@ var starknet = (() => {
             case '"':
               return string();
             case "-":
-              return number2();
+              return number3();
             default:
-              return ch >= "0" && ch <= "9" ? number2() : word();
+              return ch >= "0" && ch <= "9" ? number3() : word();
           }
         };
         return function(source, reviver) {
@@ -3080,7 +3080,8 @@ var starknet = (() => {
     isUrl: () => isUrl,
     json: () => json_exports,
     merkle: () => merkle_exports,
-    number: () => number_exports,
+    num: () => num_exports,
+    number: () => number2,
     shortString: () => shortString_exports,
     stark: () => stark_exports2,
     transaction: () => transaction_exports,
@@ -3141,11 +3142,12 @@ var starknet = (() => {
     getSelector: () => getSelector,
     getSelectorFromName: () => getSelectorFromName,
     keccakBn: () => keccakBn,
+    poseidon: () => poseidon_exports,
     starknetKeccak: () => starknetKeccak,
     transactionVersion: () => transactionVersion
   });
   var import_keccak = __toESM(require_keccak());
-  var import_utils8 = __toESM(require_utils2());
+  var import_utils11 = __toESM(require_utils2());
 
   // src/constants.ts
   var constants_exports = {};
@@ -5302,9 +5304,9 @@ var starknet = (() => {
     ]
   ];
 
-  // src/utils/number.ts
-  var number_exports = {};
-  __export(number_exports, {
+  // src/utils/num.ts
+  var num_exports = {};
+  __export(num_exports, {
     assertInRange: () => assertInRange,
     bigNumberishArrayToDecimalStringArray: () => bigNumberishArrayToDecimalStringArray,
     bigNumberishArrayToHexadecimalStringArray: () => bigNumberishArrayToHexadecimalStringArray,
@@ -5329,7 +5331,7 @@ var starknet = (() => {
     }
   }
 
-  // src/utils/number.ts
+  // src/utils/num.ts
   function isHex(hex) {
     return /^0x[0-9a-f]*$/i.test(hex);
   }
@@ -5339,8 +5341,8 @@ var starknet = (() => {
   function isBigInt(value) {
     return typeof value === "bigint";
   }
-  function toHex(number2) {
-    return addHexPrefix(toBigInt(number2).toString(16));
+  function toHex(number3) {
+    return addHexPrefix(toBigInt(number3).toString(16));
   }
   function hexToDecimalString(hex) {
     return BigInt(addHexPrefix(hex)).toString(10);
@@ -5501,30 +5503,33 @@ var starknet = (() => {
     weierstrass: () => weierstrass_exports
   });
 
-  // node_modules/@noble/curves/lib/esm/stark.js
+  // node_modules/@noble/curves/esm/stark.js
   var stark_exports = {};
   __export(stark_exports, {
     CURVE: () => CURVE,
-    Point: () => Point,
+    Fp251: () => Fp251,
+    Fp253: () => Fp253,
     ProjectivePoint: () => ProjectivePoint,
     Signature: () => Signature,
-    bytesToHexEth: () => bytesToHexEth,
+    _poseidonMDS: () => _poseidonMDS,
+    _starkCurve: () => _starkCurve,
     computeHashOnElements: () => computeHashOnElements,
     ethSigToPrivate: () => ethSigToPrivate,
     getAccountPath: () => getAccountPath,
-    getPublicKey: () => getPublicKey0x,
-    getSharedSecret: () => getSharedSecret0x,
+    getPublicKey: () => getPublicKey,
+    getSharedSecret: () => getSharedSecret,
     getStarkKey: () => getStarkKey,
     grindKey: () => grindKey,
     hashChain: () => hashChain,
     keccak: () => keccak,
-    numberToHexEth: () => numberToHexEth,
     pedersen: () => pedersen,
-    sign: () => sign0x,
-    starkCurve: () => starkCurve,
-    strip0x: () => strip0x,
+    poseidonBasic: () => poseidonBasic,
+    poseidonCreate: () => poseidonCreate,
+    poseidonHash: () => poseidonHash,
+    poseidonSmall: () => poseidonSmall,
+    sign: () => sign,
     utils: () => utils,
-    verify: () => verify0x
+    verify: () => verify
   });
 
   // node_modules/@noble/hashes/esm/_assert.js
@@ -6154,16 +6159,7 @@ var starknet = (() => {
   var sha256 = wrapConstructor(() => new SHA256());
   var sha224 = wrapConstructor(() => new SHA224());
 
-  // node_modules/@noble/curves/lib/esm/abstract/weierstrass.js
-  var weierstrass_exports = {};
-  __export(weierstrass_exports, {
-    SWUFpSqrtRatio: () => SWUFpSqrtRatio,
-    mapToCurveSimpleSWU: () => mapToCurveSimpleSWU,
-    weierstrass: () => weierstrass,
-    weierstrassPoints: () => weierstrassPoints
-  });
-
-  // node_modules/@noble/curves/lib/esm/abstract/utils.js
+  // node_modules/@noble/curves/esm/abstract/utils.js
   var utils_exports = {};
   __export(utils_exports, {
     bitGet: () => bitGet,
@@ -6174,51 +6170,29 @@ var starknet = (() => {
     bytesToNumberBE: () => bytesToNumberBE,
     bytesToNumberLE: () => bytesToNumberLE,
     concatBytes: () => concatBytes2,
+    createHmacDrbg: () => createHmacDrbg,
     ensureBytes: () => ensureBytes,
     equalBytes: () => equalBytes,
-    hashToPrivateScalar: () => hashToPrivateScalar,
     hexToBytes: () => hexToBytes,
     hexToNumber: () => hexToNumber,
-    isPositiveInt: () => isPositiveInt,
-    nLength: () => nLength,
     numberToBytesBE: () => numberToBytesBE,
     numberToBytesLE: () => numberToBytesLE,
     numberToHexUnpadded: () => numberToHexUnpadded,
-    validateOpts: () => validateOpts
+    numberToVarBytesBE: () => numberToVarBytesBE,
+    utf8ToBytes: () => utf8ToBytes2,
+    validateObject: () => validateObject
   });
   var _0n2 = BigInt(0);
   var _1n2 = BigInt(1);
   var _2n2 = BigInt(2);
-  function isPositiveInt(num) {
-    return typeof num === "number" && Number.isSafeInteger(num) && num > 0;
-  }
-  function validateOpts(curve) {
-    validateField(curve.Fp);
-    for (const i of ["n", "h"]) {
-      const val = curve[i];
-      if (typeof val !== "bigint")
-        throw new Error(`Invalid curve param ${i}=${val} (${typeof val})`);
-    }
-    if (!curve.Fp.isValid(curve.Gx))
-      throw new Error("Invalid generator X coordinate Fp element");
-    if (!curve.Fp.isValid(curve.Gy))
-      throw new Error("Invalid generator Y coordinate Fp element");
-    for (const i of ["nBitLength", "nByteLength"]) {
-      const val = curve[i];
-      if (val === void 0)
-        continue;
-      if (!isPositiveInt(val))
-        throw new Error(`Invalid curve param ${i}=${val} (${typeof val})`);
-    }
-    return Object.freeze({ ...nLength(curve.n, curve.nBitLength), ...curve });
-  }
+  var u8a = (a) => a instanceof Uint8Array;
   var hexes2 = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
-  function bytesToHex(uint8a) {
-    if (!(uint8a instanceof Uint8Array))
-      throw new Error("Expected Uint8Array");
+  function bytesToHex(bytes2) {
+    if (!u8a(bytes2))
+      throw new Error("Uint8Array expected");
     let hex = "";
-    for (let i = 0; i < uint8a.length; i++) {
-      hex += hexes2[uint8a[i]];
+    for (let i = 0; i < bytes2.length; i++) {
+      hex += hexes2[bytes2[i]];
     }
     return hex;
   }
@@ -6227,24 +6201,22 @@ var starknet = (() => {
     return hex.length & 1 ? `0${hex}` : hex;
   }
   function hexToNumber(hex) {
-    if (typeof hex !== "string") {
-      throw new TypeError("hexToNumber: expected string, got " + typeof hex);
-    }
-    return BigInt(`0x${hex}`);
+    if (typeof hex !== "string")
+      throw new Error("hex string expected, got " + typeof hex);
+    return BigInt(hex === "" ? "0" : `0x${hex}`);
   }
   function hexToBytes(hex) {
-    if (typeof hex !== "string") {
-      throw new TypeError("hexToBytes: expected string, got " + typeof hex);
-    }
+    if (typeof hex !== "string")
+      throw new Error("hex string expected, got " + typeof hex);
     if (hex.length % 2)
-      throw new Error("hexToBytes: received invalid unpadded hex " + hex.length);
+      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");
+        throw new Error("invalid byte sequence");
       array[i] = byte;
     }
     return array;
@@ -6252,46 +6224,42 @@ var starknet = (() => {
   function bytesToNumberBE(bytes2) {
     return hexToNumber(bytesToHex(bytes2));
   }
-  function bytesToNumberLE(uint8a) {
-    if (!(uint8a instanceof Uint8Array))
-      throw new Error("Expected Uint8Array");
-    return BigInt("0x" + bytesToHex(Uint8Array.from(uint8a).reverse()));
+  function bytesToNumberLE(bytes2) {
+    if (!u8a(bytes2))
+      throw new Error("Uint8Array expected");
+    return hexToNumber(bytesToHex(Uint8Array.from(bytes2).reverse()));
   }
   var numberToBytesBE = (n, len) => hexToBytes(n.toString(16).padStart(len * 2, "0"));
   var numberToBytesLE = (n, len) => numberToBytesBE(n, len).reverse();
-  function ensureBytes(hex, expectedLength) {
-    const bytes2 = hex instanceof Uint8Array ? Uint8Array.from(hex) : hexToBytes(hex);
-    if (typeof expectedLength === "number" && bytes2.length !== expectedLength)
-      throw new Error(`Expected ${expectedLength} bytes`);
-    return bytes2;
-  }
-  function concatBytes2(...arrays) {
-    if (!arrays.every((b) => b instanceof Uint8Array))
-      throw new Error("Uint8Array list expected");
-    if (arrays.length === 1)
-      return arrays[0];
-    const length = arrays.reduce((a, arr) => a + arr.length, 0);
-    const result = new Uint8Array(length);
-    for (let i = 0, pad = 0; i < arrays.length; i++) {
-      const arr = arrays[i];
-      result.set(arr, pad);
-      pad += arr.length;
+  var numberToVarBytesBE = (n) => hexToBytes(numberToHexUnpadded(n));
+  function ensureBytes(title, hex, expectedLength) {
+    let res;
+    if (typeof hex === "string") {
+      try {
+        res = hexToBytes(hex);
+      } catch (e) {
+        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
+      }
+    } else if (u8a(hex)) {
+      res = Uint8Array.from(hex);
+    } else {
+      throw new Error(`${title} must be hex string or Uint8Array`);
     }
-    return result;
-  }
-  function nLength(n, nBitLength2) {
-    const _nBitLength = nBitLength2 !== void 0 ? nBitLength2 : n.toString(2).length;
-    const nByteLength = Math.ceil(_nBitLength / 8);
-    return { nBitLength: _nBitLength, nByteLength };
+    const len = res.length;
+    if (typeof expectedLength === "number" && len !== expectedLength)
+      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
+    return res;
   }
-  function hashToPrivateScalar(hash2, groupOrder, isLE2 = false) {
-    hash2 = ensureBytes(hash2);
-    const hashLen = hash2.length;
-    const minLen = nLength(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 ? bytesToNumberLE(hash2) : bytesToNumberBE(hash2);
-    return mod(num, groupOrder - _1n2) + _1n2;
+  function concatBytes2(...arrs) {
+    const r = new Uint8Array(arrs.reduce((sum, a) => sum + a.length, 0));
+    let pad = 0;
+    arrs.forEach((a) => {
+      if (!u8a(a))
+        throw new Error("Uint8Array expected");
+      r.set(a, pad);
+      pad += a.length;
+    });
+    return r;
   }
   function equalBytes(b1, b2) {
     if (b1.length !== b2.length)
@@ -6301,6 +6269,12 @@ var starknet = (() => {
         return false;
     return true;
   }
+  function utf8ToBytes2(str) {
+    if (typeof str !== "string") {
+      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+    }
+    return new TextEncoder().encode(str);
+  }
   function bitLen(n) {
     let len;
     for (len = 0; n > 0n; n >>= _1n2, len += 1)
@@ -6310,8 +6284,86 @@ var starknet = (() => {
   var bitGet = (n, pos) => n >> BigInt(pos) & 1n;
   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);
+  var u8fr = (arr) => Uint8Array.from(arr);
+  function createHmacDrbg(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 = u8n(hashLen);
+    let k = u8n(hashLen);
+    let i = 0;
+    const reset = () => {
+      v.fill(1);
+      k.fill(0);
+      i = 0;
+    };
+    const h = (...b) => hmacFn(k, v, ...b);
+    const reseed = (seed = u8n()) => {
+      k = h(u8fr([0]), seed);
+      v = h();
+      if (seed.length === 0)
+        return;
+      k = h(u8fr([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 concatBytes2(...out);
+    };
+    const genUntil = (seed, pred) => {
+      reset();
+      reseed(seed);
+      let res = void 0;
+      while (!(res = pred(gen2())))
+        reseed();
+      reset();
+      return res;
+    };
+    return genUntil;
+  }
+  var validatorFns = {
+    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 validateObject(object, validators, optValidators = {}) {
+    const checkField = (fieldName, type, isOptional) => {
+      const checkVal = validatorFns[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;
+  }
 
-  // node_modules/@noble/curves/lib/esm/abstract/modular.js
+  // node_modules/@noble/curves/esm/abstract/modular.js
   var _0n3 = BigInt(0);
   var _1n3 = BigInt(1);
   var _2n3 = BigInt(2);
@@ -6339,11 +6391,11 @@ var starknet = (() => {
     }
     return res;
   }
-  function invert(number2, modulo) {
-    if (number2 === _0n3 || modulo <= _0n3) {
-      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
+  function invert(number3, modulo) {
+    if (number3 === _0n3 || modulo <= _0n3) {
+      throw new Error(`invert: expected positive integers, got n=${number3} mod=${modulo}`);
     }
-    let a = mod(number2, modulo);
+    let a = mod(number3, modulo);
     let b = modulo;
     let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
     while (a !== _0n3) {
@@ -6369,30 +6421,30 @@ var starknet = (() => {
       const p1div4 = (P + _1n3) / _4n;
       return function tonelliFast(Fp2, n) {
         const root = Fp2.pow(n, p1div4);
-        if (!Fp2.equals(Fp2.square(root), n))
+        if (!Fp2.eql(Fp2.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.negate(Fp2.ONE))
+      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.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.equals(b, Fp2.ONE)) {
-        if (Fp2.equals(b, Fp2.ZERO))
+      while (!Fp2.eql(b, Fp2.ONE)) {
+        if (Fp2.eql(b, Fp2.ZERO))
           return Fp2.ZERO;
         let m = 1;
-        for (let t2 = Fp2.square(b); m < r; m++) {
-          if (Fp2.equals(t2, Fp2.ONE))
+        for (let t2 = Fp2.sqr(b); m < r; m++) {
+          if (Fp2.eql(t2, Fp2.ONE))
             break;
-          t2 = Fp2.square(t2);
+          t2 = Fp2.sqr(t2);
         }
         const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
-        g = Fp2.square(ge);
+        g = Fp2.sqr(ge);
         x = Fp2.mul(x, ge);
         b = Fp2.mul(b, g);
         r = m;
@@ -6405,7 +6457,7 @@ var starknet = (() => {
       const p1div4 = (P + _1n3) / _4n;
       return function sqrt3mod4(Fp2, n) {
         const root = Fp2.pow(n, p1div4);
-        if (!Fp2.equals(Fp2.square(root), n))
+        if (!Fp2.eql(Fp2.sqr(root), n))
           throw new Error("Cannot find square root");
         return root;
       };
@@ -6418,7 +6470,7 @@ var starknet = (() => {
         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.equals(Fp2.square(root), n))
+        if (!Fp2.eql(Fp2.sqr(root), n))
           throw new Error("Cannot find square root");
         return root;
       };
@@ -6430,12 +6482,12 @@ var starknet = (() => {
   var FIELD_FIELDS = [
     "create",
     "isValid",
-    "isZero",
-    "negate",
-    "invert",
+    "is0",
+    "neg",
+    "inv",
     "sqrt",
-    "square",
-    "equals",
+    "sqr",
+    "eql",
     "add",
     "sub",
     "mul",
@@ -6444,21 +6496,20 @@ var starknet = (() => {
     "addN",
     "subN",
     "mulN",
-    "squareN"
+    "sqrN"
   ];
   function validateField(field) {
-    for (const i of ["ORDER", "MASK"]) {
-      if (typeof field[i] !== "bigint")
-        throw new Error(`Invalid field param ${i}=${field[i]} (${typeof field[i]})`);
-    }
-    for (const i of ["BYTES", "BITS"]) {
-      if (typeof field[i] !== "number")
-        throw new Error(`Invalid field param ${i}=${field[i]} (${typeof field[i]})`);
-    }
-    for (const i of FIELD_FIELDS) {
-      if (typeof field[i] !== "function")
-        throw new Error(`Invalid field param ${i}=${field[i]} (${typeof field[i]})`);
-    }
+    const initial = {
+      ORDER: "bigint",
+      MASK: "bigint",
+      BYTES: "isSafeInteger",
+      BITS: "isSafeInteger"
+    };
+    const opts = FIELD_FIELDS.reduce((map, val) => {
+      map[val] = "function";
+      return map;
+    }, initial);
+    return validateObject(field, opts);
   }
   function FpPow(f, num, power) {
     if (power < _0n3)
@@ -6472,7 +6523,7 @@ var starknet = (() => {
     while (power > _0n3) {
       if (power & _1n3)
         p = f.mul(p, d);
-      d = f.square(d);
+      d = f.sqr(d);
       power >>= 1n;
     }
     return p;
@@ -6480,20 +6531,25 @@ var starknet = (() => {
   function FpInvertBatch(f, nums) {
     const tmp = new Array(nums.length);
     const lastMultiplied = nums.reduce((acc, num, i) => {
-      if (f.isZero(num))
+      if (f.is0(num))
         return acc;
       tmp[i] = acc;
       return f.mul(acc, num);
     }, f.ONE);
-    const inverted = f.invert(lastMultiplied);
+    const inverted = f.inv(lastMultiplied);
     nums.reduceRight((acc, num, i) => {
-      if (f.isZero(num))
+      if (f.is0(num))
         return acc;
       tmp[i] = f.mul(acc, tmp[i]);
       return f.mul(acc, num);
     }, inverted);
     return tmp;
   }
+  function nLength(n, nBitLength2) {
+    const _nBitLength = nBitLength2 !== void 0 ? nBitLength2 : n.toString(2).length;
+    const nByteLength = Math.ceil(_nBitLength / 8);
+    return { nBitLength: _nBitLength, nByteLength };
+  }
   function Fp(ORDER, bitLen2, isLE2 = false, redef = {}) {
     if (ORDER <= _0n3)
       throw new Error(`Expected Fp ORDER > 0, got ${ORDER}`);
@@ -6514,21 +6570,21 @@ var starknet = (() => {
           throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);
         return _0n3 <= num && num < ORDER;
       },
-      isZero: (num) => num === _0n3,
+      is0: (num) => num === _0n3,
       isOdd: (num) => (num & _1n3) === _1n3,
-      negate: (num) => mod(-num, ORDER),
-      equals: (lhs, rhs) => lhs === rhs,
-      square: (num) => mod(num * num, ORDER),
+      neg: (num) => mod(-num, ORDER),
+      eql: (lhs, rhs) => lhs === rhs,
+      sqr: (num) => mod(num * num, ORDER),
       add: (lhs, rhs) => mod(lhs + rhs, ORDER),
       sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
       mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
       pow: (num, power) => FpPow(f, num, power),
       div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
-      squareN: (num) => num * num,
+      sqrN: (num) => num * num,
       addN: (lhs, rhs) => lhs + rhs,
       subN: (lhs, rhs) => lhs - rhs,
       mulN: (lhs, rhs) => lhs * rhs,
-      invert: (num) => invert(num, ORDER),
+      inv: (num) => invert(num, ORDER),
       sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
       invertBatch: (lst) => FpInvertBatch(f, lst),
       cmov: (a, b, c) => c ? b : a,
@@ -6541,109 +6597,132 @@ var starknet = (() => {
     });
     return Object.freeze(f);
   }
+  function hashToPrivateScalar(hash2, groupOrder, isLE2 = false) {
+    hash2 = ensureBytes("privateHash", hash2);
+    const hashLen = hash2.length;
+    const minLen = nLength(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 ? bytesToNumberLE(hash2) : bytesToNumberBE(hash2);
+    return mod(num, groupOrder - _1n3) + _1n3;
+  }
 
-  // node_modules/@noble/curves/lib/esm/abstract/hash-to-curve.js
-  function validateHTFOpts(opts) {
-    if (typeof opts.DST !== "string")
-      throw new Error("Invalid htf/DST");
-    if (typeof opts.p !== "bigint")
-      throw new Error("Invalid htf/p");
-    if (typeof opts.m !== "number")
-      throw new Error("Invalid htf/m");
-    if (typeof opts.k !== "number")
-      throw new Error("Invalid htf/k");
-    if (opts.expand !== "xmd" && opts.expand !== "xof" && opts.expand !== void 0)
-      throw new Error("Invalid htf/expand");
-    if (typeof opts.hash !== "function" || !Number.isSafeInteger(opts.hash.outputLen))
-      throw new Error("Invalid htf/hash function");
-  }
-  function stringToBytes(str) {
-    const bytes2 = new Uint8Array(str.length);
-    for (let i = 0; i < str.length; i++)
-      bytes2[i] = str.charCodeAt(i);
-    return bytes2;
-  }
-  function os2ip(bytes2) {
-    let result = 0n;
-    for (let i = 0; i < bytes2.length; i++) {
-      result <<= 8n;
-      result += BigInt(bytes2[i]);
+  // node_modules/@noble/curves/esm/abstract/poseidon.js
+  var poseidon_exports = {};
+  __export(poseidon_exports, {
+    poseidon: () => poseidon,
+    splitConstants: () => splitConstants,
+    validateOpts: () => validateOpts
+  });
+  function validateOpts(opts) {
+    const { Fp: Fp2 } = opts;
+    validateField(Fp2);
+    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) => FpPow(Fp2, n, _sboxPower);
+    if (sboxPower === 3)
+      sboxFn = (n) => Fp2.mul(Fp2.sqrN(n), n);
+    else if (sboxPower === 5)
+      sboxFn = (n) => Fp2.mul(Fp2.sqrN(Fp2.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" || !Fp2.isValid(i))
+          throw new Error(`Poseidon wrong round constant=${i}`);
+        return Fp2.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 Fp2.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 result;
+    return res;
   }
-  function i2osp(value, length) {
-    if (value < 0 || value >= 1 << 8 * length) {
-      throw new Error(`bad I2OSP call: value=${value} length=${length}`);
-    }
-    const res = Array.from({ length }).fill(0);
-    for (let i = length - 1; i >= 0; i--) {
-      res[i] = value & 255;
-      value >>>= 8;
-    }
-    return new Uint8Array(res);
-  }
-  function strxor(a, b) {
-    const arr = new Uint8Array(a.length);
-    for (let i = 0; i < a.length; i++) {
-      arr[i] = a[i] ^ b[i];
-    }
-    return arr;
-  }
-  function expand_message_xmd(msg, DST, lenInBytes, H) {
-    if (DST.length > 255)
-      DST = H(concatBytes2(stringToBytes("H2C-OVERSIZE-DST-"), DST));
-    const b_in_bytes = H.outputLen;
-    const r_in_bytes = H.blockLen;
-    const ell = Math.ceil(lenInBytes / b_in_bytes);
-    if (ell > 255)
-      throw new Error("Invalid xmd length");
-    const DST_prime = concatBytes2(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(concatBytes2(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
-    b[0] = H(concatBytes2(b_0, i2osp(1, 1), DST_prime));
-    for (let i = 1; i <= ell; i++) {
-      const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
-      b[i] = H(concatBytes2(...args));
-    }
-    const pseudo_random_bytes = concatBytes2(...b);
-    return pseudo_random_bytes.slice(0, lenInBytes);
-  }
-  function expand_message_xof(msg, DST, lenInBytes, k, H) {
-    if (DST.length > 255) {
-      const dkLen = Math.ceil(2 * k / 8);
-      DST = H.create({ dkLen }).update(stringToBytes("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) {
-    const log2p = options.p.toString(2).length;
-    const L = Math.ceil((log2p + options.k) / 8);
-    const len_in_bytes = count * options.m * L;
-    const DST = stringToBytes(options.DST);
-    let pseudo_random_bytes = msg;
-    if (options.expand === "xmd") {
-      pseudo_random_bytes = expand_message_xmd(msg, DST, len_in_bytes, options.hash);
-    } else if (options.expand === "xof") {
-      pseudo_random_bytes = expand_message_xof(msg, DST, len_in_bytes, options.k, options.hash);
-    }
-    const u = new Array(count);
-    for (let i = 0; i < count; i++) {
-      const e = new Array(options.m);
-      for (let j = 0; j < options.m; j++) {
-        const elm_offset = L * (j + i * options.m);
-        const tv = pseudo_random_bytes.subarray(elm_offset, elm_offset + L);
-        e[j] = mod(os2ip(tv), options.p);
-      }
-      u[i] = e;
-    }
-    return u;
+  function poseidon(opts) {
+    const { t, Fp: Fp2, 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]));
+      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));
+      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 Fp2.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;
   }
 
-  // node_modules/@noble/curves/lib/esm/abstract/group.js
+  // 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
   var _0n4 = BigInt(0);
   var _1n4 = BigInt(1);
   function wNAF(c, bits) {
@@ -6711,163 +6790,235 @@ var starknet = (() => {
           }
         }
         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 validateBasic(curve2) {
+    validateField(curve2.Fp);
+    validateObject(curve2, {
+      n: "bigint",
+      h: "bigint",
+      Gx: "field",
+      Gy: "field"
+    }, {
+      nBitLength: "isSafeInteger",
+      nByteLength: "isSafeInteger"
+    });
+    return Object.freeze({ ...nLength(curve2.n, curve2.nBitLength), ...curve2 });
+  }
 
-  // node_modules/@noble/curves/lib/esm/abstract/weierstrass.js
-  var DERError = class extends Error {
-    constructor(message) {
-      super(message);
-    }
-  };
-  var DER = {
-    slice(s) {
-      return Number.parseInt(s[0], 16) >= 8 ? "00" + s : s;
-    },
-    parseInt(data) {
-      if (data.length < 2 || data[0] !== 2) {
-        throw new DERError(`Invalid signature integer tag: ${bytesToHex(data)}`);
-      }
-      const len = data[1];
-      const res = data.subarray(2, len + 2);
-      if (!len || res.length !== len) {
-        throw new DERError(`Invalid signature integer: wrong length`);
-      }
-      if (res[0] === 0 && res[1] <= 127) {
-        throw new DERError("Invalid signature integer: trailing length");
-      }
-      return { data: bytesToNumberBE(res), left: data.subarray(len + 2) };
-    },
-    parseSig(data) {
-      if (data.length < 2 || data[0] != 48) {
-        throw new DERError(`Invalid signature tag: ${bytesToHex(data)}`);
-      }
-      if (data[1] !== data.length - 2) {
-        throw new DERError("Invalid signature: incorrect length");
-      }
-      const { data: r, left: sBytes } = DER.parseInt(data.subarray(2));
-      const { data: s, left: rBytesLeft } = DER.parseInt(sBytes);
-      if (rBytesLeft.length) {
-        throw new DERError(`Invalid signature: left bytes after parsing: ${bytesToHex(rBytesLeft)}`);
-      }
-      return { r, s };
-    }
-  };
-  function validatePointOpts(curve) {
-    const opts = validateOpts(curve);
-    const Fp2 = opts.Fp;
-    for (const i of ["a", "b"]) {
-      if (!Fp2.isValid(curve[i]))
-        throw new Error(`Invalid curve param ${i}=${opts[i]} (${typeof opts[i]})`);
-    }
-    for (const i of ["isTorsionFree", "clearCofactor", "mapToCurve"]) {
-      if (curve[i] === void 0)
-        continue;
-      if (typeof curve[i] !== "function")
-        throw new Error(`Invalid ${i} function`);
-    }
-    const endo = opts.endo;
+  // 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"
+    }, {
+      allowedPrivateKeyLengths: "array",
+      wrapPrivateKey: "boolean",
+      isTorsionFree: "function",
+      clearCofactor: "function",
+      allowInfinityPoint: "boolean"
+    });
+    const { endo, Fp: Fp2, a } = opts;
     if (endo) {
-      if (!Fp2.equals(opts.a, Fp2.ZERO)) {
+      if (!Fp2.eql(a, Fp2.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");
       }
     }
-    if (typeof opts.fromBytes !== "function")
-      throw new Error("Invalid fromBytes function");
-    if (typeof opts.toBytes !== "function")
-      throw new Error("Invalid fromBytes function");
-    if (opts.htfDefaults !== void 0)
-      validateHTFOpts(opts.htfDefaults);
     return Object.freeze({ ...opts });
   }
+  var { bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports;
+  var DER = {
+    Err: class DERErr extends Error {
+      constructor(m = "") {
+        super(m);
+      }
+    },
+    _parseInt(data) {
+      const { Err: E } = DER;
+      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: b2n(res), l: data.subarray(len + 2) };
+    },
+    toSig(hex) {
+      const { Err: E } = DER;
+      const data = typeof hex === "string" ? h2b(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 } = DER._parseInt(data.subarray(2));
+      const { d: s, l: rBytesLeft } = DER._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 _0n5 = BigInt(0);
   var _1n5 = BigInt(1);
-  var _3n2 = BigInt(3);
   function weierstrassPoints(opts) {
     const CURVE2 = validatePointOpts(opts);
     const { Fp: Fp2 } = CURVE2;
     function weierstrassEquation(x) {
       const { a, b } = CURVE2;
-      const x2 = Fp2.square(x);
+      const x2 = Fp2.sqr(x);
       const x3 = Fp2.mul(x2, x);
       return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b);
     }
     function isWithinCurveOrder(num) {
-      return _0n5 < num && num < CURVE2.n;
+      return typeof num === "bigint" && _0n5 < num && num < CURVE2.n;
+    }
+    function assertGE(num) {
+      if (!isWithinCurveOrder(num))
+        throw new Error("Expected valid bigint: 0 < bigint < curve.n");
     }
-    function normalizePrivateKey2(key) {
-      const { normalizePrivateKey: custom, nByteLength: groupLen, wrapPrivateKey, n: order } = CURVE2;
-      if (typeof custom === "function")
-        key = custom(key);
+    function normPrivateKeyToScalar(key) {
+      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE2;
+      if (lengths && typeof key !== "bigint") {
+        if (key instanceof Uint8Array)
+          key = bytesToHex(key);
+        if (typeof key !== "string" || !lengths.includes(key.length))
+          throw new Error("Invalid key");
+        key = key.padStart(nByteLength * 2, "0");
+      }
       let num;
-      if (typeof key === "bigint") {
-        num = key;
-      } else if (isPositiveInt(key)) {
-        num = BigInt(key);
-      } else if (typeof key === "string") {
-        if (key.length !== 2 * groupLen)
-          throw new Error(`Expected ${groupLen} bytes of private key`);
-        num = hexToNumber(key);
-      } else if (key instanceof Uint8Array) {
-        if (key.length !== groupLen)
-          throw new Error(`Expected ${groupLen} bytes of private key`);
-        num = bytesToNumberBE(key);
-      } else {
-        throw new TypeError("Expected valid private key");
+      try {
+        num = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
+      } catch (error) {
+        throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
       }
       if (wrapPrivateKey)
-        num = mod(num, order);
-      if (!isWithinCurveOrder(num))
-        throw new Error("Expected private key: 0 < key < n");
+        num = mod(num, n);
+      assertGE(num);
       return num;
     }
-    function normalizeScalar(num) {
-      if (isPositiveInt(num))
-        return BigInt(num);
-      if (typeof num === "bigint" && isWithinCurveOrder(num))
-        return num;
-      throw new TypeError("Expected valid private scalar: 0 < scalar < curve.n");
-    }
-    class ProjectivePoint2 {
-      constructor(x, y, z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
+    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 || !Fp2.isValid(px))
+          throw new Error("x required");
+        if (py == null || !Fp2.isValid(py))
+          throw new Error("y required");
+        if (pz == null || !Fp2.isValid(pz))
+          throw new Error("z required");
       }
       static fromAffine(p) {
-        if (!(p instanceof Point2)) {
-          throw new TypeError("ProjectivePoint#fromAffine: expected Point");
-        }
-        if (p.equals(Point2.ZERO))
-          return ProjectivePoint2.ZERO;
-        return new ProjectivePoint2(p.x, p.y, Fp2.ONE);
-      }
-      static toAffineBatch(points) {
-        const toInv = Fp2.invertBatch(points.map((p) => p.z));
-        return points.map((p, i) => p.toAffine(toInv[i]));
+        const { x, y } = p || {};
+        if (!p || !Fp2.isValid(x) || !Fp2.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);
+        if (is0(x) && is0(y))
+          return Point.ZERO;
+        return new Point(x, y, Fp2.ONE);
+      }
+      get x() {
+        return this.toAffine().x;
+      }
+      get y() {
+        return this.toAffine().y;
       }
       static normalizeZ(points) {
-        return ProjectivePoint2.toAffineBatch(points).map(ProjectivePoint2.fromAffine);
+        const toInv = Fp2.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)));
+        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 (!Fp2.isValid(x) || !Fp2.isValid(y))
+          throw new Error("bad point: x or y not FE");
+        const left = Fp2.sqr(y);
+        const right = weierstrassEquation(x);
+        if (!Fp2.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);
+        throw new Error("Field doesn't support isOdd");
       }
       equals(other) {
         assertPrjPoint(other);
-        const { x: X1, y: Y1, z: Z1 } = this;
-        const { x: X2, y: Y2, z: Z2 } = other;
-        const U1 = Fp2.equals(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1));
-        const U2 = Fp2.equals(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1));
+        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));
         return U1 && U2;
       }
       negate() {
-        return new ProjectivePoint2(this.x, Fp2.negate(this.y), this.z);
+        return new Point(this.px, Fp2.neg(this.py), this.pz);
       }
       double() {
         const { a, b } = CURVE2;
         const b3 = Fp2.mul(b, 3n);
-        const { x: X1, y: Y1, z: Z1 } = this;
+        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);
@@ -6900,12 +7051,12 @@ var starknet = (() => {
         Z3 = Fp2.mul(t2, t1);
         Z3 = Fp2.add(Z3, Z3);
         Z3 = Fp2.add(Z3, Z3);
-        return new ProjectivePoint2(X3, Y3, Z3);
+        return new Point(X3, Y3, Z3);
       }
       add(other) {
         assertPrjPoint(other);
-        const { x: X1, y: Y1, z: Z1 } = this;
-        const { x: X2, y: Y2, z: Z2 } = 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;
         const a = CURVE2.a;
         const b3 = Fp2.mul(CURVE2.b, 3n);
@@ -6949,23 +7100,33 @@ var starknet = (() => {
         t0 = Fp2.mul(t3, t1);
         Z3 = Fp2.mul(t5, Z3);
         Z3 = Fp2.add(Z3, t0);
-        return new ProjectivePoint2(X3, Y3, Z3);
+        return new Point(X3, Y3, Z3);
       }
       subtract(other) {
         return this.add(other.negate());
       }
-      multiplyUnsafe(scalar) {
-        const P0 = ProjectivePoint2.ZERO;
-        if (typeof scalar === "bigint" && scalar === _0n5)
-          return P0;
-        let n = normalizeScalar(scalar);
+      is0() {
+        return this.equals(Point.ZERO);
+      }
+      wNAF(n) {
+        return wnaf.wNAFCached(this, pointPrecomputes, n, (comp) => {
+          const toInv = Fp2.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 === _0n5)
+          return I;
+        assertGE(n);
         if (n === _1n5)
           return this;
-        if (!CURVE2.endo)
+        const { endo } = CURVE2;
+        if (!endo)
           return wnaf.unsafeLadder(this, n);
-        let { k1neg, k1, k2neg, k2 } = CURVE2.endo.splitScalar(n);
-        let k1p = P0;
-        let k2p = P0;
+        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
+        let k1p = I;
+        let k2p = I;
         let d = this;
         while (k1 > _0n5 || k2 > _0n5) {
           if (k1 & _1n5)
@@ -6980,63 +7141,56 @@ var starknet = (() => {
           k1p = k1p.negate();
         if (k2neg)
           k2p = k2p.negate();
-        k2p = new ProjectivePoint2(Fp2.mul(k2p.x, CURVE2.endo.beta), k2p.y, k2p.z);
+        k2p = new Point(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
         return k1p.add(k2p);
       }
-      wNAF(n, affinePoint) {
-        if (!affinePoint && this.equals(ProjectivePoint2.BASE))
-          affinePoint = Point2.BASE;
-        const W = affinePoint && affinePoint._WINDOW_SIZE || 1;
-        let precomputes = affinePoint && pointPrecomputes.get(affinePoint);
-        if (!precomputes) {
-          precomputes = wnaf.precomputeWindow(this, W);
-          if (affinePoint && W !== 1) {
-            precomputes = ProjectivePoint2.normalizeZ(precomputes);
-            pointPrecomputes.set(affinePoint, precomputes);
-          }
-        }
-        return wnaf.wNAF(W, precomputes, n);
-      }
-      multiply(scalar, affinePoint) {
-        let n = normalizeScalar(scalar);
-        let point;
-        let fake;
-        if (CURVE2.endo) {
-          const { k1neg, k1, k2neg, k2 } = CURVE2.endo.splitScalar(n);
-          let { p: k1p, f: f1p } = this.wNAF(k1, affinePoint);
-          let { p: k2p, f: f2p } = this.wNAF(k2, affinePoint);
+      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 ProjectivePoint2(Fp2.mul(k2p.x, CURVE2.endo.beta), k2p.y, k2p.z);
+          k2p = new Point(Fp2.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
           point = k1p.add(k2p);
           fake = f1p.add(f2p);
         } else {
-          const { p, f } = this.wNAF(n, affinePoint);
+          const { p, f } = this.wNAF(n);
           point = p;
           fake = f;
         }
-        return ProjectivePoint2.normalizeZ([point, fake])[0];
+        return Point.normalizeZ([point, fake])[0];
       }
-      toAffine(invZ) {
-        const { x, y, z } = this;
-        const is0 = this.equals(ProjectivePoint2.ZERO);
-        if (invZ == null)
-          invZ = is0 ? Fp2.ONE : Fp2.invert(z);
-        const ax = Fp2.mul(x, invZ);
-        const ay = Fp2.mul(y, invZ);
-        const zz = Fp2.mul(z, invZ);
+      multiplyAndAddUnsafe(Q, a, b) {
+        const G = Point.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));
+        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 ? Fp2.ONE : Fp2.inv(z);
+        const ax = Fp2.mul(x, iz);
+        const ay = Fp2.mul(y, iz);
+        const zz = Fp2.mul(z, iz);
         if (is0)
-          return Point2.ZERO;
-        if (!Fp2.equals(zz, Fp2.ONE))
+          return { x: Fp2.ZERO, y: Fp2.ZERO };
+        if (!Fp2.eql(zz, Fp2.ONE))
           throw new Error("invZ was invalid");
-        return new Point2(ax, ay);
+        return { x: ax, y: ay };
       }
       isTorsionFree() {
         const { h: cofactor, isTorsionFree } = CURVE2;
         if (cofactor === _1n5)
           return true;
         if (isTorsionFree)
-          return isTorsionFree(ProjectivePoint2, this);
+          return isTorsionFree(Point, this);
         throw new Error("isTorsionFree() has not been declared for the elliptic curve");
       }
       clearCofactor() {
@@ -7044,269 +7198,101 @@ var starknet = (() => {
         if (cofactor === _1n5)
           return this;
         if (clearCofactor)
-          return clearCofactor(ProjectivePoint2, this);
+          return clearCofactor(Point, this);
         return this.multiplyUnsafe(CURVE2.h);
       }
-    }
-    ProjectivePoint2.BASE = new ProjectivePoint2(CURVE2.Gx, CURVE2.Gy, Fp2.ONE);
-    ProjectivePoint2.ZERO = new ProjectivePoint2(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
-    const _bits = CURVE2.nBitLength;
-    const wnaf = wNAF(ProjectivePoint2, CURVE2.endo ? Math.ceil(_bits / 2) : _bits);
-    function assertPrjPoint(other) {
-      if (!(other instanceof ProjectivePoint2))
-        throw new TypeError("ProjectivePoint expected");
-    }
-    const pointPrecomputes = /* @__PURE__ */ new WeakMap();
-    class Point2 {
-      constructor(x, y) {
-        this.x = x;
-        this.y = y;
-      }
-      _setWindowSize(windowSize) {
-        this._WINDOW_SIZE = windowSize;
-        pointPrecomputes.delete(this);
-      }
-      hasEvenY() {
-        if (Fp2.isOdd)
-          return !Fp2.isOdd(this.y);
-        throw new Error("Field doesn't support isOdd");
-      }
-      static fromHex(hex) {
-        const { x, y } = CURVE2.fromBytes(ensureBytes(hex));
-        const point = new Point2(x, y);
-        point.assertValidity();
-        return point;
-      }
-      static fromPrivateKey(privateKey) {
-        return Point2.BASE.multiply(normalizePrivateKey2(privateKey));
-      }
-      toRawBytes(isCompressed = false) {
+      toRawBytes(isCompressed = true) {
         this.assertValidity();
-        return CURVE2.toBytes(Point2, this, isCompressed);
+        return CURVE2.toBytes(Point, this, isCompressed);
       }
-      toHex(isCompressed = false) {
+      toHex(isCompressed = true) {
         return bytesToHex(this.toRawBytes(isCompressed));
       }
-      assertValidity() {
-        if (this.equals(Point2.ZERO)) {
-          if (CURVE2.allowInfinityPoint)
-            return;
-          throw new Error("Point at infinity");
-        }
-        const msg = "Point is not on elliptic curve";
-        const { x, y } = this;
-        if (!Fp2.isValid(x) || !Fp2.isValid(y))
-          throw new Error(msg);
-        const left = Fp2.square(y);
-        const right = weierstrassEquation(x);
-        if (!Fp2.equals(left, right))
-          throw new Error(msg);
-        if (!this.isTorsionFree())
-          throw new Error("Point must be of prime-order subgroup");
-      }
-      equals(other) {
-        if (!(other instanceof Point2))
-          throw new TypeError("Point#equals: expected Point");
-        return Fp2.equals(this.x, other.x) && Fp2.equals(this.y, other.y);
-      }
-      negate() {
-        return new Point2(this.x, Fp2.negate(this.y));
-      }
-      toProj() {
-        return ProjectivePoint2.fromAffine(this);
-      }
-      double() {
-        return this.toProj().double().toAffine();
-      }
-      add(other) {
-        return this.toProj().add(ProjectivePoint2.fromAffine(other)).toAffine();
-      }
-      subtract(other) {
-        return this.add(other.negate());
-      }
-      multiply(scalar) {
-        return this.toProj().multiply(scalar, this).toAffine();
-      }
-      multiplyUnsafe(scalar) {
-        return this.toProj().multiplyUnsafe(scalar).toAffine();
-      }
-      clearCofactor() {
-        return this.toProj().clearCofactor().toAffine();
-      }
-      isTorsionFree() {
-        return this.toProj().isTorsionFree();
-      }
-      multiplyAndAddUnsafe(Q, a, b) {
-        const P = this.toProj();
-        const aP = a === _0n5 || a === _1n5 || this !== Point2.BASE ? P.multiplyUnsafe(a) : P.multiply(a);
-        const bQ = ProjectivePoint2.fromAffine(Q).multiplyUnsafe(b);
-        const sum = aP.add(bQ);
-        return sum.equals(ProjectivePoint2.ZERO) ? void 0 : sum.toAffine();
-      }
-      static hashToCurve(msg, options) {
-        const { mapToCurve } = CURVE2;
-        if (!mapToCurve)
-          throw new Error("CURVE.mapToCurve() has not been defined");
-        msg = ensureBytes(msg);
-        const u = hash_to_field(msg, 2, { ...CURVE2.htfDefaults, ...options });
-        const { x: x0, y: y0 } = mapToCurve(u[0]);
-        const { x: x1, y: y1 } = mapToCurve(u[1]);
-        return new Point2(x0, y0).add(new Point2(x1, y1)).clearCofactor();
-      }
-      static encodeToCurve(msg, options) {
-        const { mapToCurve } = CURVE2;
-        if (!mapToCurve)
-          throw new Error("CURVE.mapToCurve() has not been defined");
-        msg = ensureBytes(msg);
-        const u = hash_to_field(msg, 1, { ...CURVE2.htfDefaults, ...options });
-        const { x, y } = mapToCurve(u[0]);
-        return new Point2(x, y).clearCofactor();
-      }
-    }
-    Point2.BASE = new Point2(CURVE2.Gx, CURVE2.Gy);
-    Point2.ZERO = new Point2(Fp2.ZERO, Fp2.ZERO);
+    }
+    Point.BASE = new Point(CURVE2.Gx, CURVE2.Gy, Fp2.ONE);
+    Point.ZERO = new Point(Fp2.ZERO, Fp2.ONE, Fp2.ZERO);
+    const _bits = CURVE2.nBitLength;
+    const wnaf = wNAF(Point, CURVE2.endo ? Math.ceil(_bits / 2) : _bits);
     return {
-      Point: Point2,
-      ProjectivePoint: ProjectivePoint2,
-      normalizePrivateKey: normalizePrivateKey2,
+      ProjectivePoint: Point,
+      normPrivateKeyToScalar,
       weierstrassEquation,
       isWithinCurveOrder
     };
   }
-  function validateOpts2(curve) {
-    const opts = validateOpts(curve);
-    if (typeof opts.hash !== "function" || !isPositiveInt(opts.hash.outputLen))
-      throw new Error("Invalid hash function");
-    if (typeof opts.hmac !== "function")
-      throw new Error("Invalid hmac function");
-    if (typeof opts.randomBytes !== "function")
-      throw new Error("Invalid randomBytes function");
+  function validateOpts2(curve2) {
+    const opts = validateBasic(curve2);
+    validateObject(opts, {
+      hash: "hash",
+      hmac: "function",
+      randomBytes: "function"
+    }, {
+      bits2int: "function",
+      bits2int_modN: "function",
+      lowS: "boolean"
+    });
     return Object.freeze({ lowS: true, ...opts });
   }
-  var HmacDrbg = class {
-    constructor(hashLen, qByteLen, hmacFn) {
-      this.hashLen = hashLen;
-      this.qByteLen = qByteLen;
-      this.hmacFn = 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");
-      this.v = new Uint8Array(hashLen).fill(1);
-      this.k = new Uint8Array(hashLen).fill(0);
-      this.counter = 0;
-    }
-    hmacSync(...values) {
-      return this.hmacFn(this.k, ...values);
-    }
-    incr() {
-      if (this.counter >= 1e3)
-        throw new Error("Tried 1,000 k values for sign(), all were invalid");
-      this.counter += 1;
-    }
-    reseedSync(seed = new Uint8Array()) {
-      this.k = this.hmacSync(this.v, Uint8Array.from([0]), seed);
-      this.v = this.hmacSync(this.v);
-      if (seed.length === 0)
-        return;
-      this.k = this.hmacSync(this.v, Uint8Array.from([1]), seed);
-      this.v = this.hmacSync(this.v);
-    }
-    generateSync() {
-      this.incr();
-      let len = 0;
-      const out = [];
-      while (len < this.qByteLen) {
-        this.v = this.hmacSync(this.v);
-        const sl = this.v.slice();
-        out.push(sl);
-        len += this.v.length;
-      }
-      return concatBytes2(...out);
-    }
-  };
   function weierstrass(curveDef) {
     const CURVE2 = validateOpts2(curveDef);
-    const CURVE_ORDER = CURVE2.n;
+    const CURVE_ORDER2 = CURVE2.n;
     const Fp2 = CURVE2.Fp;
     const compressedLen = Fp2.BYTES + 1;
     const uncompressedLen = 2 * Fp2.BYTES + 1;
     function isValidFieldElement(num) {
       return _0n5 < num && num < Fp2.ORDER;
     }
-    const { Point: Point2, ProjectivePoint: ProjectivePoint2, normalizePrivateKey: normalizePrivateKey2, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
+    function modN(a) {
+      return mod(a, CURVE_ORDER2);
+    }
+    function invN(a) {
+      return invert(a, CURVE_ORDER2);
+    }
+    const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
       ...CURVE2,
       toBytes(c, point, isCompressed) {
-        const x = Fp2.toBytes(point.x);
+        const a = point.toAffine();
+        const x = Fp2.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(point.y));
+          return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
         }
       },
       fromBytes(bytes2) {
         const len = bytes2.length;
-        const header = bytes2[0];
-        if (len === compressedLen && (header === 2 || header === 3)) {
-          const x = bytesToNumberBE(bytes2.subarray(1));
+        const head = bytes2[0];
+        const tail = bytes2.subarray(1);
+        if (len === compressedLen && (head === 2 || head === 3)) {
+          const x = bytesToNumberBE(tail);
           if (!isValidFieldElement(x))
             throw new Error("Point is not on curve");
           const y2 = weierstrassEquation(x);
           let y = Fp2.sqrt(y2);
           const isYOdd = (y & _1n5) === _1n5;
-          const isFirstByteOdd = (bytes2[0] & 1) === 1;
-          if (isFirstByteOdd !== isYOdd)
-            y = Fp2.negate(y);
+          const isHeadOdd = (head & 1) === 1;
+          if (isHeadOdd !== isYOdd)
+            y = Fp2.neg(y);
           return { x, y };
-        } else if (len === uncompressedLen && header === 4) {
-          const x = Fp2.fromBytes(bytes2.subarray(1, Fp2.BYTES + 1));
-          const y = Fp2.fromBytes(bytes2.subarray(Fp2.BYTES + 1, 2 * Fp2.BYTES + 1));
+        } 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));
           return { x, y };
         } else {
-          throw new Error(`Point.fromHex: received invalid point. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes, not ${len}`);
+          throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
         }
       }
     });
-    function numToField(num) {
-      if (typeof num !== "bigint")
-        throw new Error("Expected bigint");
-      if (!(_0n5 <= num && num < Fp2.MASK))
-        throw new Error(`Expected number < 2^${Fp2.BYTES * 8}`);
-      return Fp2.toBytes(num);
-    }
-    const numToFieldStr = (num) => bytesToHex(numToField(num));
-    function normalizePublicKey(publicKey) {
-      if (publicKey instanceof Point2) {
-        publicKey.assertValidity();
-        return publicKey;
-      } else if (publicKey instanceof Uint8Array || typeof publicKey === "string") {
-        return Point2.fromHex(publicKey);
-      } else
-        throw new Error(`Unknown type of public key: ${publicKey}`);
-    }
-    function isBiggerThanHalfOrder(number2) {
-      const HALF = CURVE_ORDER >> _1n5;
-      return number2 > HALF;
+    const numToNByteStr = (num) => bytesToHex(numberToBytesBE(num, CURVE2.nByteLength));
+    function isBiggerThanHalfOrder(number3) {
+      const HALF = CURVE_ORDER2 >> _1n5;
+      return number3 > HALF;
     }
     function normalizeS(s) {
-      return isBiggerThanHalfOrder(s) ? mod(-s, CURVE_ORDER) : s;
+      return isBiggerThanHalfOrder(s) ? modN(-s) : s;
     }
-    function bits2int_2(bytes2) {
-      const delta = bytes2.length * 8 - CURVE2.nBitLength;
-      const num = bytesToNumberBE(bytes2);
-      return delta > 0 ? num >> BigInt(delta) : num;
-    }
-    function _truncateHash(hash2, truncateOnly = false) {
-      const h = bits2int_2(hash2);
-      if (truncateOnly)
-        return h;
-      const { n } = CURVE2;
-      return h >= n ? h - n : h;
-    }
-    const truncateHash = CURVE2.truncateHash || _truncateHash;
+    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
     class Signature3 {
       constructor(r, s, recovery) {
         this.r = r;
@@ -7315,53 +7301,39 @@ var starknet = (() => {
         this.assertValidity();
       }
       static fromCompact(hex) {
-        const arr = hex instanceof Uint8Array;
-        const name = "Signature.fromCompact";
-        if (typeof hex !== "string" && !arr)
-          throw new TypeError(`${name}: Expected string or Uint8Array`);
-        const str = arr ? bytesToHex(hex) : hex;
-        const gl = CURVE2.nByteLength * 2;
-        if (str.length !== 2 * gl)
-          throw new Error(`${name}: Expected ${gl / 2}-byte hex`);
-        const slice = (from, to) => hexToNumber(str.slice(from, to));
-        return new Signature3(slice(0, gl), slice(gl, 2 * gl));
+        const l = CURVE2.nByteLength;
+        hex = ensureBytes("compactSignature", hex, l * 2);
+        return new Signature3(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
       }
       static fromDER(hex) {
-        const arr = hex instanceof Uint8Array;
-        if (typeof hex !== "string" && !arr)
-          throw new TypeError(`Signature.fromDER: Expected string or Uint8Array`);
-        const { r, s } = DER.parseSig(arr ? hex : hexToBytes(hex));
+        const { r, s } = DER.toSig(ensureBytes("DER", hex));
         return new Signature3(r, s);
       }
       assertValidity() {
-        const { r, s } = this;
-        if (!isWithinCurveOrder(r))
-          throw new Error("Invalid Signature: r must be 0 < r < n");
-        if (!isWithinCurveOrder(s))
-          throw new Error("Invalid Signature: s must be 0 < s < n");
+        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");
       }
-      copyWithRecoveryBit(recovery) {
+      addRecoveryBit(recovery) {
         return new Signature3(this.r, this.s, recovery);
       }
       recoverPublicKey(msgHash) {
-        const { r, s, recovery } = this;
-        if (recovery == null)
-          throw new Error("Cannot recover: recovery bit is not present");
-        if (![0, 1, 2, 3].includes(recovery))
-          throw new Error("Cannot recover: invalid recovery bit");
-        const h = truncateHash(ensureBytes(msgHash));
-        const { n } = CURVE2;
-        const radj = recovery === 2 || recovery === 3 ? r + n : r;
+        const { r, s, recovery: rec } = this;
+        const h = 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 ? r + CURVE2.n : r;
         if (radj >= Fp2.ORDER)
-          throw new Error("Cannot recover: bit 2/3 is invalid with current r");
-        const rinv = invert(radj, n);
-        const u1 = mod(-h * rinv, n);
-        const u2 = mod(s * rinv, n);
-        const prefix = recovery & 1 ? "03" : "02";
-        const R = Point2.fromHex(prefix + numToFieldStr(radj));
-        const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
+          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("Cannot recover: point at infinify");
+          throw new Error("point at infinify");
         Q.assertValidity();
         return Q;
       }
@@ -7369,56 +7341,44 @@ var starknet = (() => {
         return isBiggerThanHalfOrder(this.s);
       }
       normalizeS() {
-        return this.hasHighS() ? new Signature3(this.r, mod(-this.s, CURVE_ORDER), this.recovery) : this;
+        return this.hasHighS() ? new Signature3(this.r, modN(-this.s), this.recovery) : this;
       }
       toDERRawBytes() {
         return hexToBytes(this.toDERHex());
       }
       toDERHex() {
-        const { numberToHexUnpadded: toHex2 } = utils_exports;
-        const sHex = DER.slice(toHex2(this.s));
-        const rHex = DER.slice(toHex2(this.r));
-        const sHexL = sHex.length / 2;
-        const rHexL = rHex.length / 2;
-        const sLen = toHex2(sHexL);
-        const rLen = toHex2(rHexL);
-        const length = toHex2(rHexL + sHexL + 4);
-        return `30${length}02${rLen}${rHex}02${sLen}${sHex}`;
+        return DER.hexFromSig({ r: this.r, s: this.s });
       }
       toCompactRawBytes() {
         return hexToBytes(this.toCompactHex());
       }
       toCompactHex() {
-        return numToFieldStr(this.r) + numToFieldStr(this.s);
+        return numToNByteStr(this.r) + numToNByteStr(this.s);
       }
     }
     const utils2 = {
       isValidPrivateKey(privateKey) {
         try {
-          normalizePrivateKey2(privateKey);
+          normPrivateKeyToScalar(privateKey);
           return true;
         } catch (error) {
           return false;
         }
       },
-      _bigintToBytes: numToField,
-      _bigintToString: numToFieldStr,
-      _normalizePrivateKey: normalizePrivateKey2,
-      _normalizePublicKey: normalizePublicKey,
-      _isWithinCurveOrder: isWithinCurveOrder,
-      _isValidFieldElement: isValidFieldElement,
-      _weierstrassEquation: weierstrassEquation,
-      hashToPrivateKey: (hash2) => numToField(hashToPrivateScalar(hash2, CURVE_ORDER)),
-      randomPrivateKey: () => utils2.hashToPrivateKey(CURVE2.randomBytes(Fp2.BYTES + 8)),
-      precompute(windowSize = 8, point = Point2.BASE) {
-        const cached = point === Point2.BASE ? point : new Point2(point.x, point.y);
-        cached._setWindowSize(windowSize);
-        cached.multiply(_3n2);
-        return cached;
+      normPrivateKeyToScalar,
+      randomPrivateKey: () => {
+        const rand = CURVE2.randomBytes(Fp2.BYTES + 8);
+        const num = hashToPrivateScalar(rand, CURVE_ORDER2);
+        return numberToBytesBE(num, CURVE2.nByteLength);
+      },
+      precompute(windowSize = 8, point = Point.BASE) {
+        point._setWindowSize(windowSize);
+        point.multiply(BigInt(3));
+        return point;
       }
     };
-    function getPublicKey(privateKey, isCompressed = false) {
-      return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
+    function getPublicKey2(privateKey, isCompressed = true) {
+      return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
     }
     function isProbPub(item) {
       const arr = item instanceof Uint8Array;
@@ -7428,134 +7388,141 @@ var starknet = (() => {
         return len === compressedLen || len === uncompressedLen;
       if (str)
         return len === 2 * compressedLen || len === 2 * uncompressedLen;
-      if (item instanceof Point2)
+      if (item instanceof Point)
         return true;
       return false;
     }
-    function getSharedSecret(privateA, publicB, isCompressed = false) {
+    function getSharedSecret2(privateA, publicB, isCompressed = true) {
       if (isProbPub(privateA))
-        throw new TypeError("getSharedSecret: first arg must be private key");
+        throw new Error("first arg must be private key");
       if (!isProbPub(publicB))
-        throw new TypeError("getSharedSecret: second arg must be public key");
-      const b = normalizePublicKey(publicB);
-      b.assertValidity();
-      return b.multiply(normalizePrivateKey2(privateA)).toRawBytes(isCompressed);
-    }
-    function bits2int(bytes2) {
-      const { nByteLength } = CURVE2;
-      if (!(bytes2 instanceof Uint8Array))
-        throw new Error("Expected Uint8Array");
-      const slice = bytes2.length > nByteLength ? bytes2.slice(0, nByteLength) : bytes2;
-      let num = bytesToNumberBE(slice);
-      return num;
-    }
-    function bits2octets(bytes2) {
-      const z1 = bits2int(bytes2);
-      const z2 = mod(z1, CURVE_ORDER);
-      return int2octets(z2 < _0n5 ? z1 : z2);
+        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 = bytesToNumberBE(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 = bitMask(CURVE2.nBitLength);
     function int2octets(num) {
-      return numToField(num);
-    }
-    function initSigArgs(msgHash, privateKey, extraEntropy) {
-      if (msgHash == null)
-        throw new Error(`sign: expected valid message hash, not "${msgHash}"`);
-      const h1 = numToField(truncateHash(ensureBytes(msgHash)));
-      const d = normalizePrivateKey2(privateKey);
-      const seedArgs = [int2octets(d), bits2octets(h1)];
-      if (extraEntropy != null) {
-        if (extraEntropy === true)
-          extraEntropy = CURVE2.randomBytes(Fp2.BYTES);
-        const e = ensureBytes(extraEntropy);
-        if (e.length !== Fp2.BYTES)
-          throw new Error(`sign: Expected ${Fp2.BYTES} bytes of extra data`);
-        seedArgs.push(e);
+      if (typeof num !== "bigint")
+        throw new Error("bigint expected");
+      if (!(_0n5 <= num && num < ORDER_MASK))
+        throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`);
+      return numberToBytesBE(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 = ensureBytes("msgHash", msgHash);
+      if (prehash)
+        msgHash = ensureBytes("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(Fp2.BYTES) : ent;
+        seedArgs.push(ensureBytes("extraEntropy", e, Fp2.BYTES));
       }
       const seed = concatBytes2(...seedArgs);
-      const m = bits2int(h1);
-      return { seed, m, d };
+      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 === _0n5)
+          return;
+        const b = bytesToNumberBE(utils2.randomPrivateKey());
+        const bi = invN(b);
+        const bdr = modN(b * d * r);
+        const bm = modN(b * m);
+        const mrx = modN(bi * modN(bdr + bm));
+        const s = modN(ik * mrx);
+        if (s === _0n5)
+          return;
+        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
+        let normS = s;
+        if (lowS && isBiggerThanHalfOrder(s)) {
+          normS = normalizeS(s);
+          recovery ^= 1;
+        }
+        return new Signature3(r, normS, recovery);
+      }
+      return { seed, k2sig };
     }
-    function kmdToSig(kBytes, m, d, lowS = true) {
-      const { n } = CURVE2;
-      const k = truncateHash(kBytes, true);
-      if (!isWithinCurveOrder(k))
-        return;
-      const kinv = invert(k, n);
-      const q = Point2.BASE.multiply(k);
-      const r = mod(q.x, n);
-      if (r === _0n5)
-        return;
-      const s = mod(kinv * mod(m + mod(d * r, n), n), n);
-      if (s === _0n5)
-        return;
-      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
-      let normS = s;
-      if (lowS && isBiggerThanHalfOrder(s)) {
-        normS = normalizeS(s);
-        recovery ^= 1;
-      }
-      return new Signature3(r, normS, recovery);
-    }
-    const defaultSigOpts = { lowS: CURVE2.lowS };
-    function sign(msgHash, privKey, opts = defaultSigOpts) {
-      const { seed, m, d } = initSigArgs(msgHash, privKey, opts.extraEntropy);
-      const drbg = new HmacDrbg(CURVE2.hash.outputLen, CURVE2.nByteLength, CURVE2.hmac);
-      drbg.reseedSync(seed);
-      let sig;
-      while (!(sig = kmdToSig(drbg.generateSync(), m, d, opts.lowS)))
-        drbg.reseedSync();
-      return sig;
-    }
-    function signUnhashed(msg, privKey, opts = defaultSigOpts) {
-      return sign(CURVE2.hash(ensureBytes(msg)), privKey, opts);
-    }
-    Point2.BASE._setWindowSize(8);
-    function verify(signature, msgHash, publicKey, opts = { lowS: CURVE2.lowS }) {
+    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 = createHmacDrbg(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 = ensureBytes("msgHash", msgHash);
+      publicKey = ensureBytes("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 (signature instanceof Signature3) {
-          signature.assertValidity();
-        } else {
+        if (typeof sg === "string" || sg instanceof Uint8Array) {
           try {
-            signature = Signature3.fromDER(signature);
+            _sig = Signature3.fromDER(sg);
           } catch (derError) {
-            if (!(derError instanceof DERError))
+            if (!(derError instanceof DER.Err))
               throw derError;
-            signature = Signature3.fromCompact(signature);
+            _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");
         }
-        msgHash = ensureBytes(msgHash);
+        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 (opts.lowS && signature.hasHighS())
+      if (lowS && _sig.hasHighS())
         return false;
-      let P;
-      try {
-        P = normalizePublicKey(publicKey);
-      } catch (error) {
-        return false;
-      }
-      const { n } = CURVE2;
-      const { r, s } = signature;
-      const h = truncateHash(msgHash);
-      const sinv = invert(s, n);
-      const u1 = mod(h * sinv, n);
-      const u2 = mod(r * sinv, n);
-      const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2);
+      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 = mod(R.x, n);
+      const v = modN(R.x);
       return v === r;
     }
     return {
       CURVE: CURVE2,
-      getPublicKey,
-      getSharedSecret,
-      sign,
-      signUnhashed,
-      verify,
-      Point: Point2,
-      ProjectivePoint: ProjectivePoint2,
+      getPublicKey: getPublicKey2,
+      getSharedSecret: getSharedSecret2,
+      sign: sign2,
+      verify: verify2,
+      ProjectivePoint: Point,
       Signature: Signature3,
       utils: utils2
     };
@@ -7575,7 +7542,7 @@ var starknet = (() => {
     let sqrtRatio = (u, v) => {
       let tv1 = c6;
       let tv2 = Fp2.pow(v, c4);
-      let tv3 = Fp2.square(tv2);
+      let tv3 = Fp2.sqr(tv2);
       tv3 = Fp2.mul(tv3, v);
       let tv5 = Fp2.mul(u, tv3);
       tv5 = Fp2.pow(tv5, c3);
@@ -7584,7 +7551,7 @@ var starknet = (() => {
       tv3 = Fp2.mul(tv5, u);
       let tv4 = Fp2.mul(tv3, tv2);
       tv5 = Fp2.pow(tv4, c5);
-      let isQR = Fp2.equals(tv5, Fp2.ONE);
+      let isQR = Fp2.eql(tv5, Fp2.ONE);
       tv2 = Fp2.mul(tv3, c7);
       tv5 = Fp2.mul(tv4, tv1);
       tv3 = Fp2.cmov(tv2, tv3, isQR);
@@ -7592,7 +7559,7 @@ var starknet = (() => {
       for (let i = c1; i > 1; i--) {
         let tv52 = 2n ** (i - 2n);
         let tvv5 = Fp2.pow(tv4, tv52);
-        const e1 = Fp2.equals(tvv5, Fp2.ONE);
+        const e1 = Fp2.eql(tvv5, Fp2.ONE);
         tv2 = Fp2.mul(tv3, tv1);
         tv1 = Fp2.mul(tv1, tv1);
         tvv5 = Fp2.mul(tv4, tv1);
@@ -7603,16 +7570,16 @@ var starknet = (() => {
     };
     if (Fp2.ORDER % 4n === 3n) {
       const c12 = (Fp2.ORDER - 3n) / 4n;
-      const c22 = Fp2.sqrt(Fp2.negate(Z));
+      const c22 = Fp2.sqrt(Fp2.neg(Z));
       sqrtRatio = (u, v) => {
-        let tv1 = Fp2.square(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.square(y1), v);
-        const isQR = Fp2.equals(tv3, u);
+        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 };
       };
@@ -7628,16 +7595,16 @@ var starknet = (() => {
       throw new Error("Fp.isOdd is not implemented!");
     return (u) => {
       let tv1, tv2, tv3, tv4, tv5, tv6, x, y;
-      tv1 = Fp2.square(u);
+      tv1 = Fp2.sqr(u);
       tv1 = Fp2.mul(tv1, opts.Z);
-      tv2 = Fp2.square(tv1);
+      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.negate(tv2), !Fp2.equals(tv2, Fp2.ZERO));
+      tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO));
       tv4 = Fp2.mul(tv4, opts.A);
-      tv2 = Fp2.square(tv3);
-      tv6 = Fp2.square(tv4);
+      tv2 = Fp2.sqr(tv3);
+      tv6 = Fp2.sqr(tv4);
       tv5 = Fp2.mul(tv6, opts.A);
       tv2 = Fp2.add(tv2, tv5);
       tv2 = Fp2.mul(tv2, tv3);
@@ -7651,7 +7618,7 @@ var starknet = (() => {
       x = Fp2.cmov(x, tv3, isValid);
       y = Fp2.cmov(y, value, isValid);
       const e1 = Fp2.isOdd(u) === Fp2.isOdd(y);
-      y = Fp2.cmov(Fp2.negate(y), y, e1);
+      y = Fp2.cmov(Fp2.neg(y), y, e1);
       x = Fp2.div(x, tv4);
       return { x, y };
     };
@@ -7722,7 +7689,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/lib/esm/_shortw_utils.js
+  // node_modules/@noble/curves/esm/_shortw_utils.js
   function getHash(hash2) {
     return {
       hash: hash2,
@@ -7731,118 +7698,92 @@ var starknet = (() => {
     };
   }
 
-  // node_modules/@noble/curves/lib/esm/stark.js
-  var CURVE_N = BigInt("3618502788666131213697322783095070105526743751716087489154079457884512865583");
+  // node_modules/@noble/curves/esm/stark.js
+  var CURVE_ORDER = BigInt("3618502788666131213697322783095070105526743751716087489154079457884512865583");
   var nBitLength = 252;
-  var starkCurve = weierstrass({
+  function bits2int(bytes2) {
+    while (bytes2[0] === 0)
+      bytes2 = bytes2.subarray(1);
+    const delta = bytes2.length * 8 - nBitLength;
+    const num = bytesToNumberBE(bytes2);
+    return delta > 0 ? num >> BigInt(delta) : num;
+  }
+  function hex0xToBytes(hex) {
+    if (typeof hex === "string") {
+      hex = strip0x(hex);
+      if (hex.length & 1)
+        hex = "0" + hex;
+    }
+    return hexToBytes(hex);
+  }
+  var curve = weierstrass({
     a: BigInt(1),
     b: BigInt("3141592653589793238462643383279502884197169399375105820974944592307816406665"),
     Fp: Fp(BigInt("0x800000000000011000000000000000000000000000000000000000000000001")),
-    n: CURVE_N,
+    n: CURVE_ORDER,
     nBitLength,
     Gx: BigInt("874739451078007766457464989774322083649278607533249481151382481072868806602"),
     Gy: BigInt("152666792071518830868575557812948353041420400780739481342941381225525861407"),
     h: BigInt(1),
     lowS: false,
     ...getHash(sha256),
-    truncateHash: (hash2, truncateOnly = false) => {
-      if (!truncateOnly) {
-        let hashS = bytesToNumber0x(hash2).toString(16);
-        if (hashS.length === 63) {
-          hashS += "0";
-          hash2 = hexToBytes0x(hashS);
-        }
-      }
-      while (hash2[0] === 0)
-        hash2 = hash2.subarray(1);
-      const byteLength = hash2.length;
-      const delta = byteLength * 8 - nBitLength;
-      let h = hash2.length ? bytesToNumber0x(hash2) : 0n;
-      if (delta > 0)
-        h = h >> BigInt(delta);
-      if (!truncateOnly && h >= CURVE_N)
-        h -= CURVE_N;
-      return h;
+    bits2int,
+    bits2int_modN: (bytes2) => {
+      const hex = bytesToNumberBE(bytes2).toString(16);
+      if (hex.length === 63)
+        bytes2 = hex0xToBytes(hex + "0");
+      return mod(bits2int(bytes2), CURVE_ORDER);
     }
   });
-  function hexToBytes0x(hex) {
-    if (typeof hex !== "string") {
-      throw new TypeError("hexToBytes: expected string, got " + typeof hex);
-    }
-    hex = strip0x(hex);
-    if (hex.length & 1)
-      hex = "0" + hex;
-    if (hex.length % 2)
-      throw new Error("hexToBytes: received invalid unpadded hex " + 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 hexToNumber0x(hex) {
-    if (typeof hex !== "string") {
-      throw new TypeError("hexToNumber: expected string, got " + typeof hex);
-    }
-    return BigInt(`0x${strip0x(hex)}`);
+  var _starkCurve = curve;
+  function ensureBytes2(hex) {
+    return ensureBytes("", typeof hex === "string" ? hex0xToBytes(hex) : hex);
   }
-  function bytesToNumber0x(bytes2) {
-    return hexToNumber0x(bytesToHex(bytes2));
+  function normPrivKey(privKey) {
+    return bytesToHex(ensureBytes2(privKey)).padStart(64, "0");
   }
-  function ensureBytes0x(hex) {
-    return hex instanceof Uint8Array ? Uint8Array.from(hex) : hexToBytes0x(hex);
+  function getPublicKey(privKey, isCompressed = false) {
+    return curve.getPublicKey(normPrivKey(privKey), isCompressed);
   }
-  function normalizePrivateKey(privKey) {
-    return bytesToHex(ensureBytes0x(privKey)).padStart(32 * 2, "0");
+  function getSharedSecret(privKeyA, pubKeyB) {
+    return curve.getSharedSecret(normPrivKey(privKeyA), pubKeyB);
   }
-  function getPublicKey0x(privKey, isCompressed) {
-    return starkCurve.getPublicKey(normalizePrivateKey(privKey), isCompressed);
+  function sign(msgHash, privKey, opts) {
+    return curve.sign(ensureBytes2(msgHash), normPrivKey(privKey), opts);
   }
-  function getSharedSecret0x(privKeyA, pubKeyB) {
-    return starkCurve.getSharedSecret(normalizePrivateKey(privKeyA), pubKeyB);
+  function verify(signature, msgHash, pubKey) {
+    const sig = signature instanceof Signature ? signature : ensureBytes2(signature);
+    return curve.verify(sig, ensureBytes2(msgHash), ensureBytes2(pubKey));
   }
-  function sign0x(msgHash, privKey, opts) {
-    if (typeof privKey === "string")
-      privKey = strip0x(privKey).padStart(64, "0");
-    return starkCurve.sign(ensureBytes0x(msgHash), normalizePrivateKey(privKey), opts);
+  var { CURVE, ProjectivePoint, Signature, utils } = curve;
+  function extractX(bytes2) {
+    const hex = bytesToHex(bytes2.subarray(1));
+    const stripped = hex.replace(/^0+/gm, "");
+    return `0x${stripped}`;
   }
-  function verify0x(signature, msgHash, pubKey) {
-    const sig = signature instanceof Signature ? signature : ensureBytes0x(signature);
-    return starkCurve.verify(sig, ensureBytes0x(msgHash), ensureBytes0x(pubKey));
+  function strip0x(hex) {
+    return hex.replace(/^0x/i, "");
   }
-  var { CURVE, Point, ProjectivePoint, Signature } = starkCurve;
-  var utils = starkCurve.utils;
-  var stripLeadingZeros = (s) => s.replace(/^0+/gm, "");
-  var bytesToHexEth = (uint8a) => `0x${stripLeadingZeros(bytesToHex(uint8a))}`;
-  var strip0x = (hex) => hex.replace(/^0x/i, "");
-  var numberToHexEth = (num) => `0x${num.toString(16)}`;
-  function hashKeyWithIndex(key, index) {
-    let indexHex = numberToHexUnpadded(index);
-    if (indexHex.length & 1)
-      indexHex = "0" + indexHex;
-    return bytesToNumber0x(sha256(concatBytes2(key, hexToBytes0x(indexHex))));
+  function numberTo0x16(num) {
+    return `0x${num.toString(16)}`;
   }
   function grindKey(seed) {
-    const _seed = ensureBytes0x(seed);
+    const _seed = ensureBytes2(seed);
     const sha256mask = 2n ** 256n;
-    const Fn = Fp(CURVE.n);
-    const limit = sha256mask - Fn.create(sha256mask);
+    const limit = sha256mask - mod(sha256mask, CURVE_ORDER);
     for (let i = 0; ; i++) {
-      const key = hashKeyWithIndex(_seed, i);
+      const key = sha256Num(concatBytes2(_seed, numberToVarBytesBE(BigInt(i))));
       if (key < limit)
-        return Fn.create(key).toString(16);
+        return mod(key, CURVE_ORDER).toString(16);
+      if (i === 1e5)
+        throw new Error("grindKey is broken: tried 100k vals");
     }
   }
   function getStarkKey(privateKey) {
-    return bytesToHexEth(getPublicKey0x(privateKey, true).slice(1));
+    return extractX(getPublicKey(privateKey, true));
   }
   function ethSigToPrivate(signature) {
-    signature = strip0x(signature.replace(/^0x/, ""));
+    signature = strip0x(signature);
     if (signature.length !== 130)
       throw new Error("Wrong ethereum signature");
     return grindKey(signature.substring(0, 64));
@@ -7850,19 +7791,18 @@ var starknet = (() => {
   var MASK_31 = 2n ** 31n - 1n;
   var int31 = (n) => Number(n & MASK_31);
   function getAccountPath(layer, application, ethereumAddress, index) {
-    const layerNum = int31(bytesToNumber0x(sha256(layer)));
-    const applicationNum = int31(bytesToNumber0x(sha256(application)));
-    const eth = hexToNumber0x(ethereumAddress);
+    const layerNum = int31(sha256Num(layer));
+    const applicationNum = int31(sha256Num(application));
+    const eth = hexToNumber(strip0x(ethereumAddress));
     return `m/2645'/${layerNum}'/${applicationNum}'/${int31(eth)}'/${int31(eth >> 31n)}'/${index}`;
   }
-  var PEDERSEN_POINTS_AFFINE = [
-    new Point(2089986280348253421170679821480865132823066470938446095505822317253594081284n, 1713931329540660377023406109199410414810705867260802078187082345529207694986n),
-    new Point(996781205833008774514500082376783249102396023663454813447423147977397232763n, 1668503676786377725805489344771023921079126552019160156920634619255970485781n),
-    new Point(2251563274489750535117886426533222435294046428347329203627021249169616184184n, 1798716007562728905295480679789526322175868328062420237419143593021674992973n),
-    new Point(2138414695194151160943305727036575959195309218611738193261179310511854807447n, 113410276730064486255102093846540133784865286929052426931474106396135072156n),
-    new Point(2379962749567351885752724891227938183011949129833673362440656643086021394946n, 776496453633298175483985398648758586525933812536653089401905292063708816422n)
+  var PEDERSEN_POINTS = [
+    new ProjectivePoint(2089986280348253421170679821480865132823066470938446095505822317253594081284n, 1713931329540660377023406109199410414810705867260802078187082345529207694986n, 1n),
+    new ProjectivePoint(996781205833008774514500082376783249102396023663454813447423147977397232763n, 1668503676786377725805489344771023921079126552019160156920634619255970485781n, 1n),
+    new ProjectivePoint(2251563274489750535117886426533222435294046428347329203627021249169616184184n, 1798716007562728905295480679789526322175868328062420237419143593021674992973n, 1n),
+    new ProjectivePoint(2138414695194151160943305727036575959195309218611738193261179310511854807447n, 113410276730064486255102093846540133784865286929052426931474106396135072156n, 1n),
+    new ProjectivePoint(2379962749567351885752724891227938183011949129833673362440656643086021394946n, 776496453633298175483985398648758586525933812536653089401905292063708816422n, 1n)
   ];
-  var PEDERSEN_POINTS = PEDERSEN_POINTS_AFFINE.map(ProjectivePoint.fromAffine);
   function pedersenPrecompute(p1, p2) {
     const out = [];
     let p = p1;
@@ -7881,15 +7821,16 @@ var starknet = (() => {
   var PEDERSEN_POINTS2 = pedersenPrecompute(PEDERSEN_POINTS[3], PEDERSEN_POINTS[4]);
   function pedersenArg(arg) {
     let value;
-    if (typeof arg === "bigint")
+    if (typeof arg === "bigint") {
       value = arg;
-    else if (typeof arg === "number") {
+    } else if (typeof arg === "number") {
       if (!Number.isSafeInteger(arg))
         throw new Error(`Invalid pedersenArg: ${arg}`);
       value = BigInt(arg);
-    } else
-      value = bytesToNumber0x(ensureBytes0x(arg));
-    if (!(0n <= value && value < starkCurve.CURVE.Fp.ORDER))
+    } else {
+      value = bytesToNumberBE(ensureBytes2(arg));
+    }
+    if (!(0n <= value && value < curve.CURVE.Fp.ORDER))
       throw new Error(`PedersenArg should be 0 <= value < CURVE.P: ${value}`);
     return value;
   }
@@ -7897,7 +7838,7 @@ var starknet = (() => {
     let x = pedersenArg(value);
     for (let j = 0; j < 252; j++) {
       const pt = constants2[j];
-      if (pt.x === point.x)
+      if (pt.px === point.px)
         throw new Error("Same point");
       if ((x & 1n) !== 0n)
         point = point.add(pt);
@@ -7909,18 +7850,73 @@ var starknet = (() => {
     let point = PEDERSEN_POINTS[0];
     point = pedersenSingle(point, x, PEDERSEN_POINTS1);
     point = pedersenSingle(point, y, PEDERSEN_POINTS2);
-    return bytesToHexEth(point.toAffine().toRawBytes(true).slice(1));
+    return extractX(point.toRawBytes(true));
   }
   function hashChain(data, fn = pedersen) {
     if (!Array.isArray(data) || data.length < 1)
       throw new Error("data should be array of at least 1 element");
     if (data.length === 1)
-      return numberToHexEth(pedersenArg(data[0]));
+      return numberTo0x16(pedersenArg(data[0]));
     return Array.from(data).reverse().reduce((acc, i) => fn(i, acc));
   }
   var computeHashOnElements = (data, fn = pedersen) => [0, ...data, data.length].reduce((x, y) => fn(x, y));
-  var MASK_2502 = 2n ** 250n - 1n;
-  var keccak = (data) => bytesToNumber0x(keccak_256(data)) & MASK_2502;
+  var MASK_2502 = bitMask(250);
+  var keccak = (data) => bytesToNumberBE(keccak_256(data)) & MASK_2502;
+  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);
+  }
+  function _poseidonMDS(Fp2, 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));
+    }
+    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))));
+  }
+  var MDS_SMALL = [
+    [3, 1, 1],
+    [1, -1, 1],
+    [1, 1, -2]
+  ].map((i) => i.map(BigInt));
+  function poseidonBasic(opts, mds) {
+    validateField(opts.Fp);
+    if (!Number.isSafeInteger(opts.rate) || !Number.isSafeInteger(opts.capacity))
+      throw new Error(`Wrong poseidon opts: ${opts}`);
+    const m = opts.rate + opts.capacity;
+    const rounds = opts.roundsFull + opts.roundsPartial;
+    const roundConstants = [];
+    for (let i = 0; i < rounds; i++) {
+      const row = [];
+      for (let j = 0; j < m; j++)
+        row.push(poseidonRoundConstant(opts.Fp, "Hades", m * i + j));
+      roundConstants.push(row);
+    }
+    return poseidon({
+      ...opts,
+      t: m,
+      sboxPower: 3,
+      reversePartialPowIdx: true,
+      mds,
+      roundConstants
+    });
+  }
+  function poseidonCreate(opts, mdsAttempt = 0) {
+    const m = opts.rate + opts.capacity;
+    if (!Number.isSafeInteger(mdsAttempt))
+      throw new Error(`Wrong mdsAttempt=${mdsAttempt}`);
+    return poseidonBasic(opts, _poseidonMDS(opts.Fp, "HadesMDS", m, mdsAttempt));
+  }
+  var poseidonSmall = poseidonBasic({ Fp: Fp251, rate: 2, capacity: 1, roundsFull: 8, roundsPartial: 83 }, MDS_SMALL);
+  function poseidonHash(x, y, fn = poseidonSmall) {
+    return fn([x, y, 2n])[0];
+  }
 
   // src/utils/json.ts
   var json_exports = {};
@@ -7950,7 +7946,7 @@ var starknet = (() => {
   function keccakBn(value) {
     const hexWithoutPrefix = removeHexPrefix(toHex(BigInt(value)));
     const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
-    return addHexPrefix(buf2hex((0, import_keccak.keccak256)((0, import_utils8.hexToBytes)(evenHex))));
+    return addHexPrefix(buf2hex((0, import_keccak.keccak256)((0, import_utils11.hexToBytes)(evenHex))));
   }
   function keccakHex(value) {
     return addHexPrefix(buf2hex((0, import_keccak.keccak256)(utf8ToArray(value))));
@@ -15413,6 +15409,9 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
   function validateChecksumAddress(address) {
     return getChecksumAddress(address) === address;
   }
+
+  // src/index.ts
+  var number2 = num_exports;
   return __toCommonJS(src_exports);
 })();
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */