starknet 5.0.0 → 5.0.1

package/dist/index.global.js

@@ -30,21 +30,6 @@ var starknet = (() => {
   ));
   var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
 
-  // node_modules/minimalistic-assert/index.js
-  var require_minimalistic_assert = __commonJS({
-    "node_modules/minimalistic-assert/index.js"(exports, module) {
-      module.exports = assert7;
-      function assert7(val, msg) {
-        if (!val)
-          throw new Error(msg || "Assertion failed");
-      }
-      assert7.equal = function assertEqual(l, r, msg) {
-        if (l != r)
-          throw new Error(msg || "Assertion failed: " + l + " != " + r);
-      };
-    }
-  });
-
   // node_modules/whatwg-fetch/fetch.js
   var fetch_exports = {};
   __export(fetch_exports, {
@@ -600,7 +585,7 @@ var starknet = (() => {
         }
       }
       exports.output = output2;
-      var assert7 = {
+      var assert3 = {
         number: number2,
         bool: bool2,
         bytes: bytes2,
@@ -608,7 +593,7 @@ var starknet = (() => {
         exists: exists2,
         output: output2
       };
-      exports.default = assert7;
+      exports.default = assert3;
     }
   });
 
@@ -3105,9 +3090,6 @@ var starknet = (() => {
     validateChecksumAddress: () => validateChecksumAddress
   });
 
-  // src/contract/default.ts
-  var import_minimalistic_assert4 = __toESM(require_minimalistic_assert());
-
   // src/types/lib.ts
   var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
     TransactionStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
@@ -5339,7 +5321,15 @@ var starknet = (() => {
     toHex: () => toHex,
     toHexString: () => toHexString
   });
-  var import_minimalistic_assert = __toESM(require_minimalistic_assert());
+
+  // src/utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failure");
+    }
+  }
+
+  // src/utils/number.ts
   function isHex(hex) {
     return /^0x[0-9a-f]*$/i.test(hex);
   }
@@ -5361,7 +5351,7 @@ var starknet = (() => {
     const inputBigInt = BigInt(input);
     const lowerBoundBigInt = BigInt(lowerBound);
     const upperBoundBigInt = BigInt(upperBound);
-    (0, import_minimalistic_assert.default)(
+    assert(
       inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt,
       `Message not signable, ${messageSuffix}.`
     );
@@ -6174,24 +6164,51 @@ var starknet = (() => {
   });
 
   // node_modules/@noble/curves/lib/esm/abstract/utils.js
+  var utils_exports = {};
+  __export(utils_exports, {
+    bitGet: () => bitGet,
+    bitLen: () => bitLen,
+    bitMask: () => bitMask,
+    bitSet: () => bitSet,
+    bytesToHex: () => bytesToHex,
+    bytesToNumberBE: () => bytesToNumberBE,
+    bytesToNumberLE: () => bytesToNumberLE,
+    concatBytes: () => concatBytes2,
+    ensureBytes: () => ensureBytes,
+    equalBytes: () => equalBytes,
+    hashToPrivateScalar: () => hashToPrivateScalar,
+    hexToBytes: () => hexToBytes,
+    hexToNumber: () => hexToNumber,
+    isPositiveInt: () => isPositiveInt,
+    nLength: () => nLength,
+    numberToBytesBE: () => numberToBytesBE,
+    numberToBytesLE: () => numberToBytesLE,
+    numberToHexUnpadded: () => numberToHexUnpadded,
+    validateOpts: () => validateOpts
+  });
   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"]) {
-      if (typeof curve[i] !== "bigint")
-        throw new Error(`Invalid curve param ${i}=${curve[i]} (${typeof curve[i]})`);
+      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"]) {
-      if (curve[i] === void 0)
+      const val = curve[i];
+      if (val === void 0)
         continue;
-      if (!Number.isSafeInteger(curve[i]))
-        throw new Error(`Invalid curve param ${i}=${curve[i]} (${typeof curve[i]})`);
+      if (!isPositiveInt(val))
+        throw new Error(`Invalid curve param ${i}=${val} (${typeof val})`);
     }
     return Object.freeze({ ...nLength(curve.n, curve.nBitLength), ...curve });
   }
@@ -6267,15 +6284,31 @@ var starknet = (() => {
     const nByteLength = Math.ceil(_nBitLength / 8);
     return { nBitLength: _nBitLength, nByteLength };
   }
-  function hashToPrivateScalar(hash2, CURVE_ORDER, isLE2 = false) {
+  function hashToPrivateScalar(hash2, groupOrder, isLE2 = false) {
     hash2 = ensureBytes(hash2);
-    const orderLen = nLength(CURVE_ORDER).nByteLength;
-    const minLen = orderLen + 8;
-    if (orderLen < 16 || hash2.length < minLen || hash2.length > 1024)
-      throw new Error("Expected valid bytes of private key as per FIPS 186");
+    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, CURVE_ORDER - _1n2) + _1n2;
+    return mod(num, groupOrder - _1n2) + _1n2;
   }
+  function equalBytes(b1, b2) {
+    if (b1.length !== b2.length)
+      return false;
+    for (let i = 0; i < b1.length; i++)
+      if (b1[i] !== b2[i])
+        return false;
+    return true;
+  }
+  function bitLen(n) {
+    let len;
+    for (len = 0; n > 0n; n >>= _1n2, len += 1)
+      ;
+    return len;
+  }
+  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;
 
   // node_modules/@noble/curves/lib/esm/abstract/modular.js
@@ -6343,28 +6376,28 @@ var starknet = (() => {
     }
     const Q1div2 = (Q + _1n3) / _2n3;
     return function tonelliSlow(Fp2, n) {
-      if (Fp2.pow(n, legendreC) !== Fp2.ONE)
+      if (Fp2.pow(n, legendreC) === Fp2.negate(Fp2.ONE))
         throw new Error("Cannot find square root");
-      let s = S;
-      let c = pow(Z, Q, P);
-      let r = Fp2.pow(n, Q1div2);
-      let t = Fp2.pow(n, Q);
-      let t2 = Fp2.ZERO;
-      while (!Fp2.equals(Fp2.sub(t, Fp2.ONE), Fp2.ZERO)) {
-        t2 = Fp2.square(t);
-        let i;
-        for (i = 1; i < s; i++) {
-          if (Fp2.equals(Fp2.sub(t2, Fp2.ONE), Fp2.ZERO))
+      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))
+          return Fp2.ZERO;
+        let m = 1;
+        for (let t2 = Fp2.square(b); m < r; m++) {
+          if (Fp2.equals(t2, Fp2.ONE))
             break;
           t2 = Fp2.square(t2);
         }
-        let b = pow(c, BigInt(1 << s - i - 1), P);
-        r = Fp2.mul(r, b);
-        c = mod(b * b, P);
-        t = Fp2.mul(t, c);
-        s = i;
+        const ge = Fp2.pow(g, _1n3 << BigInt(r - m - 1));
+        g = Fp2.square(ge);
+        x = Fp2.mul(x, ge);
+        b = Fp2.mul(b, g);
+        r = m;
       }
-      return r;
+      return x;
     };
   }
   function FpSqrt(P) {
@@ -6461,10 +6494,10 @@ var starknet = (() => {
     }, inverted);
     return tmp;
   }
-  function Fp(ORDER, bitLen, isLE2 = false, redef = {}) {
+  function Fp(ORDER, bitLen2, isLE2 = false, redef = {}) {
     if (ORDER <= _0n3)
       throw new Error(`Expected Fp ORDER > 0, got ${ORDER}`);
-    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);
+    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
     if (BYTES > 2048)
       throw new Error("Field lengths over 2048 bytes are not supported");
     const sqrtP = FpSqrt(ORDER);
@@ -6688,40 +6721,39 @@ var starknet = (() => {
       super(message);
     }
   };
-  function sliceDER(s) {
-    return Number.parseInt(s[0], 16) >= 8 ? "00" + s : s;
-  }
-  function parseDERInt(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) };
-  }
-  function parseDERSignature(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 } = parseDERInt(data.subarray(2));
-    const { data: s, left: rBytesLeft } = parseDERInt(sBytes);
-    if (rBytesLeft.length) {
-      throw new DERError(`Invalid signature: left bytes after parsing: ${bytesToHex(rBytesLeft)}`);
+  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 };
     }
-    return { r, s };
-  }
-  var _0n5 = BigInt(0);
-  var _1n5 = BigInt(1);
-  var _3n2 = BigInt(3);
+  };
   function validatePointOpts(curve) {
     const opts = validateOpts(curve);
     const Fp2 = opts.Fp;
@@ -6752,11 +6784,12 @@ var starknet = (() => {
       validateHTFOpts(opts.htfDefaults);
     return Object.freeze({ ...opts });
   }
+  var _0n5 = BigInt(0);
+  var _1n5 = BigInt(1);
+  var _3n2 = BigInt(3);
   function weierstrassPoints(opts) {
     const CURVE2 = validatePointOpts(opts);
-    const Fp2 = CURVE2.Fp;
-    const { nByteLength, nBitLength: nBitLength2 } = CURVE2;
-    const groupLen = nByteLength;
+    const { Fp: Fp2 } = CURVE2;
     function weierstrassEquation(x) {
       const { a, b } = CURVE2;
       const x2 = Fp2.square(x);
@@ -6767,13 +6800,13 @@ var starknet = (() => {
       return _0n5 < num && num < CURVE2.n;
     }
     function normalizePrivateKey2(key) {
-      if (typeof CURVE2.normalizePrivateKey === "function") {
-        key = CURVE2.normalizePrivateKey(key);
-      }
+      const { normalizePrivateKey: custom, nByteLength: groupLen, wrapPrivateKey, n: order } = CURVE2;
+      if (typeof custom === "function")
+        key = custom(key);
       let num;
       if (typeof key === "bigint") {
         num = key;
-      } else if (typeof key === "number" && Number.isSafeInteger(key) && key > 0) {
+      } else if (isPositiveInt(key)) {
         num = BigInt(key);
       } else if (typeof key === "string") {
         if (key.length !== 2 * groupLen)
@@ -6786,14 +6819,14 @@ var starknet = (() => {
       } else {
         throw new TypeError("Expected valid private key");
       }
-      if (CURVE2.wrapPrivateKey)
-        num = mod(num, CURVE2.n);
+      if (wrapPrivateKey)
+        num = mod(num, order);
       if (!isWithinCurveOrder(num))
         throw new Error("Expected private key: 0 < key < n");
       return num;
     }
     function normalizeScalar(num) {
-      if (typeof num === "number" && Number.isSafeInteger(num) && num > 0)
+      if (isPositiveInt(num))
         return BigInt(num);
       if (typeof num === "bigint" && isWithinCurveOrder(num))
         return num;
@@ -6831,9 +6864,6 @@ var starknet = (() => {
       negate() {
         return new ProjectivePoint2(this.x, Fp2.negate(this.y), this.z);
       }
-      doubleAdd() {
-        return this.add(this);
-      }
       double() {
         const { a, b } = CURVE2;
         const b3 = Fp2.mul(b, 3n);
@@ -7002,23 +7032,26 @@ var starknet = (() => {
         return new Point2(ax, ay);
       }
       isTorsionFree() {
-        if (CURVE2.h === _1n5)
+        const { h: cofactor, isTorsionFree } = CURVE2;
+        if (cofactor === _1n5)
           return true;
-        if (CURVE2.isTorsionFree)
-          return CURVE2.isTorsionFree(ProjectivePoint2, this);
-        throw new Error("Unsupported!");
+        if (isTorsionFree)
+          return isTorsionFree(ProjectivePoint2, this);
+        throw new Error("isTorsionFree() has not been declared for the elliptic curve");
       }
       clearCofactor() {
-        if (CURVE2.h === _1n5)
+        const { h: cofactor, clearCofactor } = CURVE2;
+        if (cofactor === _1n5)
           return this;
-        if (CURVE2.clearCofactor)
-          return CURVE2.clearCofactor(ProjectivePoint2, this);
+        if (clearCofactor)
+          return clearCofactor(ProjectivePoint2, 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 wnaf = wNAF(ProjectivePoint2, CURVE2.endo ? nBitLength2 / 2 : nBitLength2);
+    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");
@@ -7058,7 +7091,7 @@ var starknet = (() => {
         if (this.equals(Point2.ZERO)) {
           if (CURVE2.allowInfinityPoint)
             return;
-          throw new Error("Point is infinity");
+          throw new Error("Point at infinity");
         }
         const msg = "Point is not on elliptic curve";
         const { x, y } = this;
@@ -7079,50 +7112,54 @@ var starknet = (() => {
       negate() {
         return new Point2(this.x, Fp2.negate(this.y));
       }
+      toProj() {
+        return ProjectivePoint2.fromAffine(this);
+      }
       double() {
-        return ProjectivePoint2.fromAffine(this).double().toAffine();
+        return this.toProj().double().toAffine();
       }
       add(other) {
-        return ProjectivePoint2.fromAffine(this).add(ProjectivePoint2.fromAffine(other)).toAffine();
+        return this.toProj().add(ProjectivePoint2.fromAffine(other)).toAffine();
       }
       subtract(other) {
         return this.add(other.negate());
       }
       multiply(scalar) {
-        return ProjectivePoint2.fromAffine(this).multiply(scalar, this).toAffine();
+        return this.toProj().multiply(scalar, this).toAffine();
       }
       multiplyUnsafe(scalar) {
-        return ProjectivePoint2.fromAffine(this).multiplyUnsafe(scalar).toAffine();
+        return this.toProj().multiplyUnsafe(scalar).toAffine();
       }
       clearCofactor() {
-        return ProjectivePoint2.fromAffine(this).clearCofactor().toAffine();
+        return this.toProj().clearCofactor().toAffine();
       }
       isTorsionFree() {
-        return ProjectivePoint2.fromAffine(this).isTorsionFree();
+        return this.toProj().isTorsionFree();
       }
       multiplyAndAddUnsafe(Q, a, b) {
-        const P = ProjectivePoint2.fromAffine(this);
+        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) {
-        if (!CURVE2.mapToCurve)
-          throw new Error("No mapToCurve defined for curve");
+        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 } = CURVE2.mapToCurve(u[0]);
-        const { x: x1, y: y1 } = CURVE2.mapToCurve(u[1]);
-        const p = new Point2(x0, y0).add(new Point2(x1, y1)).clearCofactor();
-        return p;
+        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) {
-        if (!CURVE2.mapToCurve)
-          throw new Error("No mapToCurve defined for curve");
+        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 } = CURVE2.mapToCurve(u[0]);
+        const { x, y } = mapToCurve(u[0]);
         return new Point2(x, y).clearCofactor();
       }
     }
@@ -7138,7 +7175,7 @@ var starknet = (() => {
   }
   function validateOpts2(curve) {
     const opts = validateOpts(curve);
-    if (typeof opts.hash !== "function" || !Number.isSafeInteger(opts.hash.outputLen))
+    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");
@@ -7202,10 +7239,12 @@ var starknet = (() => {
     const { Point: Point2, ProjectivePoint: ProjectivePoint2, normalizePrivateKey: normalizePrivateKey2, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
       ...CURVE2,
       toBytes(c, point, isCompressed) {
+        const x = Fp2.toBytes(point.x);
+        const cat = concatBytes2;
         if (isCompressed) {
-          return concatBytes2(new Uint8Array([point.hasEvenY() ? 2 : 3]), Fp2.toBytes(point.x));
+          return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
         } else {
-          return concatBytes2(new Uint8Array([4]), Fp2.toBytes(point.x), Fp2.toBytes(point.y));
+          return cat(Uint8Array.from([4]), x, Fp2.toBytes(point.y));
         }
       },
       fromBytes(bytes2) {
@@ -7255,16 +7294,17 @@ var starknet = (() => {
     function normalizeS(s) {
       return isBiggerThanHalfOrder(s) ? mod(-s, CURVE_ORDER) : 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 { n, nBitLength: nBitLength2 } = CURVE2;
-      const byteLength = hash2.length;
-      const delta = byteLength * 8 - nBitLength2;
-      let h = bytesToNumberBE(hash2);
-      if (delta > 0)
-        h = h >> BigInt(delta);
-      if (!truncateOnly && h >= n)
-        h -= n;
-      return h;
+      const h = bits2int_2(hash2);
+      if (truncateOnly)
+        return h;
+      const { n } = CURVE2;
+      return h >= n ? h - n : h;
     }
     const truncateHash = CURVE2.truncateHash || _truncateHash;
     class Signature3 {
@@ -7280,15 +7320,17 @@ var starknet = (() => {
         if (typeof hex !== "string" && !arr)
           throw new TypeError(`${name}: Expected string or Uint8Array`);
         const str = arr ? bytesToHex(hex) : hex;
-        if (str.length !== 128)
-          throw new Error(`${name}: Expected 64-byte hex`);
-        return new Signature3(hexToNumber(str.slice(0, 64)), hexToNumber(str.slice(64, 128)));
+        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));
       }
       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 } = parseDERSignature(arr ? hex : hexToBytes(hex));
+        const { r, s } = DER.parseSig(arr ? hex : hexToBytes(hex));
         return new Signature3(r, s);
       }
       assertValidity() {
@@ -7305,15 +7347,18 @@ var starknet = (() => {
         const { r, s, recovery } = this;
         if (recovery == null)
           throw new Error("Cannot recover: recovery bit is not present");
-        if (recovery !== 0 && recovery !== 1)
+        if (![0, 1, 2, 3].includes(recovery))
           throw new Error("Cannot recover: invalid recovery bit");
         const h = truncateHash(ensureBytes(msgHash));
         const { n } = CURVE2;
-        const rinv = invert(r, n);
+        const radj = recovery === 2 || recovery === 3 ? r + 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(r));
+        const R = Point2.fromHex(prefix + numToFieldStr(radj));
         const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
         if (!Q)
           throw new Error("Cannot recover: point at infinify");
@@ -7326,17 +7371,18 @@ var starknet = (() => {
       normalizeS() {
         return this.hasHighS() ? new Signature3(this.r, mod(-this.s, CURVE_ORDER), this.recovery) : this;
       }
-      toDERRawBytes(isCompressed = false) {
-        return hexToBytes(this.toDERHex(isCompressed));
-      }
-      toDERHex(isCompressed = false) {
-        const sHex = sliceDER(numberToHexUnpadded(this.s));
-        if (isCompressed)
-          return sHex;
-        const rHex = sliceDER(numberToHexUnpadded(this.r));
-        const rLen = numberToHexUnpadded(rHex.length / 2);
-        const sLen = numberToHexUnpadded(sHex.length / 2);
-        const length = numberToHexUnpadded(rHex.length / 2 + sHex.length / 2 + 4);
+      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}`;
       }
       toCompactRawBytes() {
@@ -7347,8 +7393,6 @@ var starknet = (() => {
       }
     }
     const utils2 = {
-      mod: (n, modulo = Fp2.ORDER) => mod(n, modulo),
-      invert: Fp2.invert,
       isValidPrivateKey(privateKey) {
         try {
           normalizePrivateKey2(privateKey);
@@ -7398,8 +7442,12 @@ var starknet = (() => {
       return b.multiply(normalizePrivateKey2(privateA)).toRawBytes(isCompressed);
     }
     function bits2int(bytes2) {
-      const slice = bytes2.length > Fp2.BYTES ? bytes2.slice(0, Fp2.BYTES) : bytes2;
-      return bytesToNumberBE(slice);
+      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);
@@ -7448,7 +7496,8 @@ var starknet = (() => {
       }
       return new Signature3(r, normS, recovery);
     }
-    function sign(msgHash, privKey, opts = { lowS: CURVE2.lowS }) {
+    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);
@@ -7457,6 +7506,9 @@ var starknet = (() => {
         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 }) {
       try {
@@ -7500,6 +7552,7 @@ var starknet = (() => {
       getPublicKey,
       getSharedSecret,
       sign,
+      signUnhashed,
       verify,
       Point: Point2,
       ProjectivePoint: ProjectivePoint2,
@@ -7777,11 +7830,12 @@ var starknet = (() => {
   function grindKey(seed) {
     const _seed = ensureBytes0x(seed);
     const sha256mask = 2n ** 256n;
-    const limit = sha256mask - starkCurve.utils.mod(sha256mask, starkCurve.CURVE.n);
+    const Fn = Fp(CURVE.n);
+    const limit = sha256mask - Fn.create(sha256mask);
     for (let i = 0; ; i++) {
       const key = hashKeyWithIndex(_seed, i);
       if (key < limit)
-        return starkCurve.utils.mod(key, starkCurve.CURVE.n).toString(16);
+        return Fn.create(key).toString(16);
     }
   }
   function getStarkKey(privateKey) {
@@ -12411,7 +12465,7 @@ var starknet = (() => {
   }
   function getStarknetIdContract(chainId) {
     const starknetIdMainnetContract = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678";
-    const starknetIdTestnetContract = "0x05cf267a0af6101667013fc6bd3f6c11116a14cda9b8c4b1198520d59f900b17";
+    const starknetIdTestnetContract = "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce";
     switch (chainId) {
       case "0x534e5f4d41494e" /* SN_MAIN */:
         return starknetIdMainnetContract;
@@ -13495,9 +13549,6 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
   // src/provider/index.ts
   var defaultProvider = new Provider();
 
-  // src/utils/calldata/index.ts
-  var import_minimalistic_assert3 = __toESM(require_minimalistic_assert());
-
   // src/utils/calldata/formatter.ts
   var guard = {
     isBN: (data, type, key) => {
@@ -13723,27 +13774,26 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
   }
 
   // src/utils/calldata/validate.ts
-  var import_minimalistic_assert2 = __toESM(require_minimalistic_assert());
   var validateFelt = (parameter, input) => {
-    (0, import_minimalistic_assert2.default)(
+    assert(
       typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
       `Validate: arg ${input.name} should be a felt (string, number, BigNumber)`
     );
   };
   var validateStruct = (parameter, input, structs) => {
-    (0, import_minimalistic_assert2.default)(
+    assert(
       typeof parameter === "object" && !Array.isArray(parameter),
       `Validate: arg ${input.name} is cairo type struct (${input.type}), and should be defined as js object (not array)`
     );
     structs[input.type].members.forEach(({ name }) => {
-      (0, import_minimalistic_assert2.default)(
+      assert(
         Object.keys(parameter).includes(name),
         `Validate: arg ${input.name} should have a property ${name}`
       );
     });
   };
   var validateTuple = (parameter, input) => {
-    (0, import_minimalistic_assert2.default)(
+    assert(
       typeof parameter === "object" && !Array.isArray(parameter),
       `Validate: arg ${input.name} should be a tuple (defined as object)`
     );
@@ -13752,7 +13802,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     const baseType = input.type.replace("*", "");
     if (isTypeFelt(baseType) && isLongText(parameter))
       return;
-    (0, import_minimalistic_assert2.default)(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
+    assert(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
     switch (true) {
       case isTypeFelt(baseType):
         parameter.forEach((param) => validateFelt(param, input));
@@ -13812,7 +13862,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
           const isView = abi.stateMutability === "view";
           return type === "INVOKE" ? !isView : isView;
         }).map((abi) => abi.name);
-        (0, import_minimalistic_assert3.default)(
+        assert(
           invocableFunctionNames.includes(method),
           `${type === "INVOKE" ? "invocable" : "viewable"} method not found in abi`
         );
@@ -14011,7 +14061,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     }
     async call(method, args = [], options = { parseRequest: true, parseResponse: true, formatResponse: void 0 }) {
       var _a;
-      (0, import_minimalistic_assert4.default)(this.address !== null, "contract is not connected to an address");
+      assert(this.address !== null, "contract is not connected to an address");
       const blockIdentifier = (options == null ? void 0 : options.blockIdentifier) || void 0;
       let calldata = args[0];
       if (options.parseRequest && !((_a = args[0]) == null ? void 0 : _a.compiled)) {
@@ -14039,7 +14089,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     invoke(method, args = [], options = {
       parseRequest: true
     }) {
-      (0, import_minimalistic_assert4.default)(this.address !== null, "contract is not connected to an address");
+      assert(this.address !== null, "contract is not connected to an address");
       let calldata = args == null ? void 0 : args[0];
       if (options.parseRequest && !(calldata == null ? void 0 : calldata.compiled)) {
         const { inputs } = this.abi.find((abi) => abi.name === method);
@@ -14073,7 +14123,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     }
     async estimate(method, args = []) {
       var _a;
-      (0, import_minimalistic_assert4.default)(this.address !== null, "contract is not connected to an address");
+      assert(this.address !== null, "contract is not connected to an address");
       if (!((_a = args[0]) == null ? void 0 : _a.compiled)) {
         this.callData.validate("INVOKE", method, args);
       }
@@ -14100,7 +14150,6 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
   };
 
   // src/contract/contractFactory.ts
-  var import_minimalistic_assert5 = __toESM(require_minimalistic_assert());
   var ContractFactory = class {
     constructor(compiledContract, classHash, account, abi = compiledContract.abi) {
       this.abi = abi;
@@ -14138,7 +14187,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         constructorCalldata,
         salt: addressSalt
       });
-      (0, import_minimalistic_assert5.default)(Boolean(contract_address), "Deployment of the contract failed");
+      assert(Boolean(contract_address), "Deployment of the contract failed");
       const contractInstance = new Contract(
         this.compiledContract.abi,
         contract_address,