starknet 11.0.1 → 11.0.2

package/dist/index.js

@@ -246,6 +246,7 @@ __export(constants_exports, {
   OutsideExecutionCallerAny: () => OutsideExecutionCallerAny,
   PAYMASTER_RPC_NODES: () => PAYMASTER_RPC_NODES,
   PRIME: () => PRIME,
+  RANGE_CLASS_HASH: () => RANGE_CLASS_HASH,
   RANGE_CONTRACT_ADDRESS: () => RANGE_CONTRACT_ADDRESS,
   RANGE_ETH_ADDRESS: () => RANGE_ETH_ADDRESS,
   RANGE_FELT: () => RANGE_FELT,
@@ -484,6 +485,7 @@ var RANGE_I64 = range(-(2n ** 63n), 2n ** 63n - 1n);
 var RANGE_I128 = range(-(2n ** 127n), 2n ** 127n - 1n);
 var RANGE_ETH_ADDRESS = range(ZERO, 2n ** 160n - 1n);
 var RANGE_CONTRACT_ADDRESS = range(ZERO, ADDR_BOUND - 1n);
+var RANGE_CLASS_HASH = range(ZERO, 2n ** 251n - 1n);
 var LegacyUDC = {
   ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf",
   ENTRYPOINT: "deployContract"
@@ -961,6 +963,7 @@ __export(num_exports, {
   hexToBytes: () => hexToBytes,
   hexToDecimalString: () => hexToDecimalString,
   isBigNumberish: () => isBigNumberish,
+  isEmptyHex: () => isEmptyHex,
   isHex: () => isHex,
   isHexString: () => isHexString2,
   isStringWholeNumber: () => isStringWholeNumber,
@@ -1016,6 +1019,7 @@ function isHex(hex) {
 }
 var isHexString2 = isHex;
 function toBigInt(value) {
+  assert(!isEmptyHex(value), "Invalid input: '0x' holds no hexadecimal digit");
   return BigInt(value);
 }
 function tryToBigInt(value) {
@@ -1040,13 +1044,13 @@ function hexToDecimalString(hex) {
   return BigInt(addHexPrefix(hex)).toString(10);
 }
 function assertInRange(input, lowerBound, upperBound, inputName = "") {
-  const messageSuffix = inputName === "" ? "invalid length" : `invalid ${inputName} length`;
   const inputBigInt = BigInt(input);
   const lowerBoundBigInt = BigInt(lowerBound);
   const upperBoundBigInt = BigInt(upperBound);
+  const rangeName = inputName === "" ? "range" : `${inputName} range`;
   assert(
     inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt,
-    `Message not signable, ${messageSuffix}.`
+    `Value is out of ${rangeName} [${lowerBoundBigInt}, ${upperBoundBigInt}]`
   );
 }
 function bigNumberishArrayToDecimalStringArray(data) {
@@ -1099,8 +1103,11 @@ function stringToSha256ToArrayBuff4(str) {
   const result = int31(BigInt(addHexPrefix(buf2hex((0, import_sha2.sha256)((0, import_utils2.utf8ToBytes)(str))))));
   return hexToBytes(toHex(result));
 }
+function isEmptyHex(value) {
+  return isString(value) && /^0x$/i.test(value);
+}
 function isBigNumberish(input) {
-  return isNumber(input) || isBigInt(input) || isString(input) && (isHex(input) || isStringWholeNumber(input));
+  return isNumber(input) || isBigInt(input) || isString(input) && (isHex(input) && !isEmptyHex(input) || isStringWholeNumber(input));
 }
 function getNext(iterator) {
   const it = iterator.next();
@@ -1684,16 +1691,18 @@ var CairoFelt252 = class _CairoFelt252 {
   /**
    * Throw unless the value can be carried by a felt252.
    *
-   * Null, undefined and any type this class does not read are refused first, each with its own
-   * message, then the value is converted and its range checked. A negative number does not reach
-   * that range check : converting it fails earlier, and the message comes from the conversion.
+   * Null, undefined, any type this class does not read, and `'0x'` are refused first, each with its
+   * own message, then the value is converted and its range checked. A negative number does not
+   * reach that range check : converting it fails earlier, and the message comes from the conversion.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, of an unread type, or outside [0, P)
+   * @throws {Error} when the value is null, undefined, of an unread type, `'0x'`, or outside [0, P)
    * @example
    * ```typescript
    * CairoFelt252.validate('Hello'); // passes
    * CairoFelt252.validate({});
    * // throws Error("Unsupported data type 'object' for felt252. Expected string, number, bigint, or boolean")
+   * CairoFelt252.validate('0x');
+   * // throws Error("Invalid input: '0x' holds no hexadecimal digit")
    * CairoFelt252.validate(-1);
    * // throws Error("Cannot convert negative bigint -1 to Uint8Array")
    * ```
@@ -1705,6 +1714,7 @@ var CairoFelt252 = class _CairoFelt252 {
       isString(data) || isNumber(data) || isBigInt(data) || isBoolean(data),
       `Unsupported data type '${typeof data}' for felt252. Expected string, number, bigint, or boolean`
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoFelt252.__processData(data);
     const bn = uint8ArrayToBigInt(value);
     _CairoFelt252.assertRange(bn);
@@ -2521,7 +2531,7 @@ var CairoUint32 = class _CairoUint32 {
    * otherwise. Text therefore only fits here up to 4 ASCII characters : one more already
    * makes a number past 4294967295.
    * @param {BigNumberish | boolean} data the value to carry, within [0, 4294967295]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoUint32('abcd').toApiRequest();
@@ -2609,11 +2619,11 @@ var CairoUint32 = class _CairoUint32 {
   /**
    * Throw unless the value can be carried by a u32.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [0, 4294967295]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [0, 4294967295]. A text string reaches
    * that last check as the number its bytes spell, so `'abcde'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoUint32.validate(70000); // passes
@@ -2628,6 +2638,7 @@ var CairoUint32 = class _CairoUint32 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoUint32.__processData(data);
     assert(
       value >= RANGE_U32.min && value <= RANGE_U32.max,
@@ -3259,25 +3270,37 @@ var CairoUint256 = class _CairoUint256 {
    * Throw unless a whole value can be represented as a u256, and give back its number.
    *
    * A string is only accepted while it spells a number, in base 10 or 16 : one that does not is
-   * refused for its type.
+   * refused as text, and `'0x'`, which holds no digit, is refused too. So is an object, a `Uint256`
+   * one included : its two halves are checked by {@link CairoUint256.validateProps}, which is what
+   * the constructor calls for it.
    * @param {BigNumberish} bigNumberish the value to check
    * @returns {bigint} the value as a number, once accepted
-   * @throws {Error} when the value is null, undefined, of an unread type, or out of range
+   * @throws {Error} when the value is null, undefined, text, `'0x'`, of an unread type, a decimal number, or out of range
    * @example
    * ```typescript
    * const result = CairoUint256.validate(255);
    * // result = 255n
    * CairoUint256.validate(-1);
    * // throws Error("bigNumberish is smaller than UINT_256_MIN")
+   * CairoUint256.validate('abc');
+   * // throws Error("Invalid input: a u256 cannot be built from text")
+   * CairoUint256.validate(1.5);
+   * // throws Error("Invalid input: decimal numbers are not supported, only integers")
    * ```
    */
   static validate(bigNumberish) {
     assert(bigNumberish !== null, "null value is not allowed for u256");
     assert(bigNumberish !== void 0, "undefined value is not allowed for u256");
+    assert(!isText(bigNumberish), "Invalid input: a u256 cannot be built from text");
+    assert(!isEmptyHex(bigNumberish), "Invalid input: '0x' holds no hexadecimal digit");
     assert(
-      isBigNumberish(bigNumberish) || isObject(bigNumberish),
+      isBigNumberish(bigNumberish),
       `Unsupported data type '${typeof bigNumberish}' for u256. Expected a numeric string (decimal or hexadecimal), number, bigint, or Uint256 object`
     );
+    assert(
+      !isNumber(bigNumberish) || Number.isInteger(bigNumberish),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
     const bigInt = BigInt(bigNumberish);
     assert(bigInt >= UINT_256_MIN, "bigNumberish is smaller than UINT_256_MIN");
     assert(bigInt <= UINT_256_MAX, "bigNumberish is bigger than UINT_256_MAX");
@@ -3291,18 +3314,31 @@ var CairoUint256 = class _CairoUint256 {
    * @param {BigNumberish} low the bottom 128 bits
    * @param {BigNumberish} high the top 128 bits
    * @returns {{low: bigint, high: bigint}} the two halves as numbers
-   * @throws {Error} when either half is outside the u128 range
+   * @throws {Error} when either half is null, undefined, text, `'0x'`, not a number, a decimal number, or outside the u128 range
    * @example
    * ```typescript
    * const result = CairoUint256.validateProps(5, 4);
    * // result = { low: 5n, high: 4n }
    * CairoUint256.validateProps(-1, 4);
    * // throws Error("low is out of range UINT_256_LOW_MIN - UINT_256_LOW_MAX")
+   * CairoUint256.validateProps(1.5, 4);
+   * // throws Error("low must be an integer")
+   * CairoUint256.validateProps('abc', 4);
+   * // throws Error("low cannot be built from text")
    * ```
    */
   static validateProps(low, high) {
-    const bigIntLow = BigInt(low);
-    const bigIntHigh = BigInt(high);
+    const validateHalf = (half, name) => {
+      assert(half !== null, `${name} cannot be null`);
+      assert(half !== void 0, `${name} cannot be undefined`);
+      assert(!isText(half), `${name} cannot be built from text`);
+      assert(!isEmptyHex(half), `${name} cannot be '0x', which holds no hexadecimal digit`);
+      assert(isBigNumberish(half), `${name} must be a BigNumberish`);
+      assert(!isNumber(half) || Number.isInteger(half), `${name} must be an integer`);
+      return BigInt(half);
+    };
+    const bigIntLow = validateHalf(low, "low");
+    const bigIntHigh = validateHalf(high, "high");
     assert(
       bigIntLow >= UINT_256_LOW_MIN && bigIntLow <= UINT_256_LOW_MAX,
       "low is out of range UINT_256_LOW_MIN - UINT_256_LOW_MAX"
@@ -3511,25 +3547,37 @@ var CairoUint512 = class _CairoUint512 {
    * Throw unless a whole value can be represented as a u512, and give back its number.
    *
    * A string is only accepted while it spells a number, in base 10 or 16 : one that does not is
-   * refused for its type.
+   * refused as text, and `'0x'`, which holds no digit, is refused too. So is an object, a `Uint512`
+   * one included : its four limbs are checked by {@link CairoUint512.validateProps}, which is what
+   * the constructor calls for it.
    * @param {BigNumberish} bigNumberish the value to check
    * @returns {bigint} the value as a number, once accepted
-   * @throws {Error} when the value is null, undefined, of an unread type, or out of range
+   * @throws {Error} when the value is null, undefined, text, `'0x'`, of an unread type, a decimal number, or out of range
    * @example
    * ```typescript
    * const result = CairoUint512.validate(255);
    * // result = 255n
    * CairoUint512.validate(-1);
    * // throws Error("bigNumberish is smaller than UINT_512_MIN.")
+   * CairoUint512.validate('abc');
+   * // throws Error("Invalid input: a u512 cannot be built from text")
+   * CairoUint512.validate(1.5);
+   * // throws Error("Invalid input: decimal numbers are not supported, only integers")
    * ```
    */
   static validate(bigNumberish) {
     assert(bigNumberish !== null, "null value is not allowed for u512");
     assert(bigNumberish !== void 0, "undefined value is not allowed for u512");
+    assert(!isText(bigNumberish), "Invalid input: a u512 cannot be built from text");
+    assert(!isEmptyHex(bigNumberish), "Invalid input: '0x' holds no hexadecimal digit");
     assert(
-      isBigNumberish(bigNumberish) || isObject(bigNumberish),
+      isBigNumberish(bigNumberish),
       `Unsupported data type '${typeof bigNumberish}' for u512. Expected a numeric string (decimal or hexadecimal), number, bigint, or Uint512 object`
     );
+    assert(
+      !isNumber(bigNumberish) || Number.isInteger(bigNumberish),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
     const bigInt = BigInt(bigNumberish);
     assert(bigInt >= UINT_512_MIN, "bigNumberish is smaller than UINT_512_MIN.");
     assert(bigInt <= UINT_512_MAX, "bigNumberish is bigger than UINT_512_MAX.");
@@ -3545,20 +3593,33 @@ var CairoUint512 = class _CairoUint512 {
    * @param {BigNumberish} limb2 bits 256 to 383
    * @param {BigNumberish} limb3 bits 384 to 511
    * @returns {{limb0: bigint, limb1: bigint, limb2: bigint, limb3: bigint}} the four limbs as numbers
-   * @throws {Error} when any limb is outside the u128 range
+   * @throws {Error} when any limb is null, undefined, text, `'0x'`, not a number, a decimal number, or outside the u128 range
    * @example
    * ```typescript
    * const result = CairoUint512.validateProps(7, 0, 0, 64);
    * // result = { limb0: 7n, limb1: 0n, limb2: 0n, limb3: 64n }
    * CairoUint512.validateProps(-1, 0, 0, 0);
    * // throws Error("limb0 is not in the range of a u128 number")
+   * CairoUint512.validateProps(1.5, 0, 0, 0);
+   * // throws Error("limb0 must be an integer")
+   * CairoUint512.validateProps('abc', 0, 0, 0);
+   * // throws Error("limb0 cannot be built from text")
    * ```
    */
   static validateProps(limb0, limb1, limb2, limb3) {
-    const l0 = BigInt(limb0);
-    const l1 = BigInt(limb1);
-    const l2 = BigInt(limb2);
-    const l3 = BigInt(limb3);
+    const validateLimb = (limb, name) => {
+      assert(limb !== null, `${name} cannot be null`);
+      assert(limb !== void 0, `${name} cannot be undefined`);
+      assert(!isText(limb), `${name} cannot be built from text`);
+      assert(!isEmptyHex(limb), `${name} cannot be '0x', which holds no hexadecimal digit`);
+      assert(isBigNumberish(limb), `${name} must be a BigNumberish`);
+      assert(!isNumber(limb) || Number.isInteger(limb), `${name} must be an integer`);
+      return BigInt(limb);
+    };
+    const l0 = validateLimb(limb0, "limb0");
+    const l1 = validateLimb(limb1, "limb1");
+    const l2 = validateLimb(limb2, "limb2");
+    const l3 = validateLimb(limb3, "limb3");
     [l0, l1, l2, l3].forEach((value, index) => {
       assert(
         value >= UINT_128_MIN && value <= UINT_128_MAX,
@@ -3730,7 +3791,7 @@ var CairoUint96 = class _CairoUint96 {
    * otherwise. Text therefore only fits here up to 12 ASCII characters : one more already
    * makes a number past 79228162514264337593543950335.
    * @param {BigNumberish | boolean} data the value to carry, within [0, 79228162514264337593543950335]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoUint96('abcdefghijkl').toApiRequest();
@@ -3818,11 +3879,11 @@ var CairoUint96 = class _CairoUint96 {
   /**
    * Throw unless the value can be carried by a u96.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [0, 79228162514264337593543950335]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [0, 79228162514264337593543950335]. A text string reaches
    * that last check as the number its bytes spell, so `'abcdefghijklm'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoUint96.validate(5000000000); // passes
@@ -3837,6 +3898,7 @@ var CairoUint96 = class _CairoUint96 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoUint96.__processData(data);
     assert(
       value >= RANGE_U96.min && value <= RANGE_U96.max,
@@ -4223,7 +4285,7 @@ var CairoUint8 = class _CairoUint8 {
    * otherwise. Text therefore only fits here while it is a single ASCII character : two characters
    * already make a number past 255.
    * @param {BigNumberish | boolean} data the value to carry, within [0, 255]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoUint8('a').toApiRequest();
@@ -4313,11 +4375,11 @@ var CairoUint8 = class _CairoUint8 {
   /**
    * Throw unless the value can be carried by a u8.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [0, 255]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [0, 255]. A text string reaches
    * that last check as the number its bytes spell, so `'ab'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoUint8.validate(44); // passes
@@ -4332,6 +4394,7 @@ var CairoUint8 = class _CairoUint8 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoUint8.__processData(data);
     assert(
       value >= RANGE_U8.min && value <= RANGE_U8.max,
@@ -4422,7 +4485,7 @@ var CairoUint16 = class _CairoUint16 {
    * otherwise. Text therefore only fits here up to 2 ASCII characters : one more already
    * makes a number past 65535.
    * @param {BigNumberish | boolean} data the value to carry, within [0, 65535]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoUint16('ab').toApiRequest();
@@ -4510,11 +4573,11 @@ var CairoUint16 = class _CairoUint16 {
   /**
    * Throw unless the value can be carried by a u16.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [0, 65535]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [0, 65535]. A text string reaches
    * that last check as the number its bytes spell, so `'abc'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoUint16.validate(300); // passes
@@ -4529,6 +4592,7 @@ var CairoUint16 = class _CairoUint16 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoUint16.__processData(data);
     assert(
       value >= RANGE_U16.min && value <= RANGE_U16.max,
@@ -4619,7 +4683,7 @@ var CairoUint64 = class _CairoUint64 {
    * otherwise. Text therefore only fits here up to 8 ASCII characters : one more already
    * makes a number past 18446744073709551615.
    * @param {BigNumberish | boolean} data the value to carry, within [0, 18446744073709551615]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoUint64('abcdefgh').toApiRequest();
@@ -4707,11 +4771,11 @@ var CairoUint64 = class _CairoUint64 {
   /**
    * Throw unless the value can be carried by a u64.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [0, 18446744073709551615]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [0, 18446744073709551615]. A text string reaches
    * that last check as the number its bytes spell, so `'abcdefghi'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoUint64.validate(5000000000); // passes
@@ -4726,6 +4790,7 @@ var CairoUint64 = class _CairoUint64 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoUint64.__processData(data);
     assert(
       value >= RANGE_U64.min && value <= RANGE_U64.max,
@@ -4816,7 +4881,7 @@ var CairoUint128 = class _CairoUint128 {
    * otherwise. Text therefore only fits here up to 16 ASCII characters : one more already
    * makes a number past 340282366920938463463374607431768211455.
    * @param {BigNumberish | boolean} data the value to carry, within [0, 340282366920938463463374607431768211455]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoUint128('abcdefghijklmnop').toApiRequest();
@@ -4904,11 +4969,11 @@ var CairoUint128 = class _CairoUint128 {
   /**
    * Throw unless the value can be carried by a u128.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [0, 340282366920938463463374607431768211455]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [0, 340282366920938463463374607431768211455]. A text string reaches
    * that last check as the number its bytes spell, so `'abcdefghijklmnopq'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoUint128.validate(5000000000); // passes
@@ -4923,6 +4988,7 @@ var CairoUint128 = class _CairoUint128 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoUint128.__processData(data);
     assert(
       value >= RANGE_U128.min && value <= RANGE_U128.max,
@@ -5009,15 +5075,17 @@ var CairoInt8 = class _CairoInt8 {
   /**
    * Build from a number, a string or a boolean, refusing anything out of the i8 range.
    *
-   * A string is read as a number when it spells one — decimal or hexadecimal — and as UTF-8 text
-   * otherwise. Text therefore only fits here up to a single ASCII character : one more already
-   * makes a number past 127.
+   * A string is read as a number when it spells one — decimal or hexadecimal, with or without a
+   * leading minus sign — and as UTF-8 text otherwise. Text therefore only fits here up to a single
+   * ASCII character : one more already makes a number past 127.
    * @param {BigNumberish | boolean} data the value to carry, within [-128, 127]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoInt8('a').toApiRequest();
    * // result = ["97"]
+   * const result2 = new CairoInt8('-5').toApiRequest();
+   * // result2 = ["3618502788666131213697322783095070105623107215331596699973092056135872020476"]
    * ```
    */
   constructor(data) {
@@ -5029,6 +5097,9 @@ var CairoInt8 = class _CairoInt8 {
    *
    * Nothing here refuses a value : `validate` is what reads this number and decides. So an input
    * far outside the i8 range comes back untouched rather than raising.
+   *
+   * A minus sign in front of a number makes it negative rather than text : `'-5'` and `'-0x5'` are
+   * both -5. This holds for the signed integers only — for any other type, such a string is text.
    * @param {BigNumberish | boolean} data the value to convert
    * @returns {bigint} the number the input spells, of whatever size
    * @example
@@ -5037,9 +5108,14 @@ var CairoInt8 = class _CairoInt8 {
    * // result = 97n
    * const result2 = CairoInt8.__processData('ab');
    * // result2 = 24930n     (past the i8 range, and returned all the same)
+   * const result3 = CairoInt8.__processData('-0x5');
+   * // result3 = -5n     (a negative number, not the text "-0x5")
    * ```
    */
   static __processData(data) {
+    if (isString(data) && data.startsWith("-") && isBigNumberish(data.slice(1))) {
+      return -BigInt(data.slice(1));
+    }
     if (isString(data) && isText(data)) {
       return utf8ToBigInt(data);
     }
@@ -5118,11 +5194,12 @@ var CairoInt8 = class _CairoInt8 {
   /**
    * Throw unless the value can be carried by an i8.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [-128, 127]. A text string reaches
-   * that last check as the number its bytes spell, so `'ab'` is refused for being out of range.
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [-128, 127]. A text string
+   * reaches that last check as the number its bytes spell, so `'ab'` is refused for being out of
+   * range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoInt8.validate(5); // passes
@@ -5137,6 +5214,7 @@ var CairoInt8 = class _CairoInt8 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoInt8.__processData(data);
     assert(
       value >= RANGE_I8.min && value <= RANGE_I8.max,
@@ -5227,15 +5305,17 @@ var CairoInt16 = class _CairoInt16 {
   /**
    * Build from a number, a string or a boolean, refusing anything out of the i16 range.
    *
-   * A string is read as a number when it spells one — decimal or hexadecimal — and as UTF-8 text
-   * otherwise. Text therefore only fits here up to 2 ASCII characters : one more already
-   * makes a number past 32767.
+   * A string is read as a number when it spells one — decimal or hexadecimal, with or without a
+   * leading minus sign — and as UTF-8 text otherwise. Text therefore only fits here up to 2 ASCII
+   * characters : one more already makes a number past 32767.
    * @param {BigNumberish | boolean} data the value to carry, within [-32768, 32767]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoInt16('ab').toApiRequest();
    * // result = ["24930"]
+   * const result2 = new CairoInt16('-5').toApiRequest();
+   * // result2 = ["3618502788666131213697322783095070105623107215331596699973092056135872020476"]
    * ```
    */
   constructor(data) {
@@ -5247,6 +5327,9 @@ var CairoInt16 = class _CairoInt16 {
    *
    * Nothing here refuses a value : `validate` is what reads this number and decides. So an input
    * far outside the i16 range comes back untouched rather than raising.
+   *
+   * A minus sign in front of a number makes it negative rather than text : `'-5'` and `'-0x5'` are
+   * both -5. This holds for the signed integers only — for any other type, such a string is text.
    * @param {BigNumberish | boolean} data the value to convert
    * @returns {bigint} the number the input spells, of whatever size
    * @example
@@ -5255,9 +5338,14 @@ var CairoInt16 = class _CairoInt16 {
    * // result = 24930n
    * const result2 = CairoInt16.__processData('abc');
    * // result2 = 6382179n     (past the i16 range, and returned all the same)
+   * const result3 = CairoInt16.__processData('-0x5');
+   * // result3 = -5n     (a negative number, not the text "-0x5")
    * ```
    */
   static __processData(data) {
+    if (isString(data) && data.startsWith("-") && isBigNumberish(data.slice(1))) {
+      return -BigInt(data.slice(1));
+    }
     if (isString(data) && isText(data)) {
       return utf8ToBigInt(data);
     }
@@ -5336,11 +5424,11 @@ var CairoInt16 = class _CairoInt16 {
   /**
    * Throw unless the value can be carried by an i16.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [-32768, 32767]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [-32768, 32767]. A text string reaches
    * that last check as the number its bytes spell, so `'abc'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoInt16.validate(300); // passes
@@ -5355,6 +5443,7 @@ var CairoInt16 = class _CairoInt16 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoInt16.__processData(data);
     assert(
       value >= RANGE_I16.min && value <= RANGE_I16.max,
@@ -5445,15 +5534,17 @@ var CairoInt32 = class _CairoInt32 {
   /**
    * Build from a number, a string or a boolean, refusing anything out of the i32 range.
    *
-   * A string is read as a number when it spells one — decimal or hexadecimal — and as UTF-8 text
-   * otherwise. Text therefore only fits here up to 4 ASCII characters : one more already
-   * makes a number past 2147483647.
+   * A string is read as a number when it spells one — decimal or hexadecimal, with or without a
+   * leading minus sign — and as UTF-8 text otherwise. Text therefore only fits here up to 4 ASCII
+   * characters : one more already makes a number past 2147483647.
    * @param {BigNumberish | boolean} data the value to carry, within [-2147483648, 2147483647]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoInt32('abcd').toApiRequest();
    * // result = ["1633837924"]
+   * const result2 = new CairoInt32('-5').toApiRequest();
+   * // result2 = ["3618502788666131213697322783095070105623107215331596699973092056135872020476"]
    * ```
    */
   constructor(data) {
@@ -5465,6 +5556,9 @@ var CairoInt32 = class _CairoInt32 {
    *
    * Nothing here refuses a value : `validate` is what reads this number and decides. So an input
    * far outside the i32 range comes back untouched rather than raising.
+   *
+   * A minus sign in front of a number makes it negative rather than text : `'-5'` and `'-0x5'` are
+   * both -5. This holds for the signed integers only — for any other type, such a string is text.
    * @param {BigNumberish | boolean} data the value to convert
    * @returns {bigint} the number the input spells, of whatever size
    * @example
@@ -5473,9 +5567,14 @@ var CairoInt32 = class _CairoInt32 {
    * // result = 1633837924n
    * const result2 = CairoInt32.__processData('abcde');
    * // result2 = 418262508645n     (past the i32 range, and returned all the same)
+   * const result3 = CairoInt32.__processData('-0x5');
+   * // result3 = -5n     (a negative number, not the text "-0x5")
    * ```
    */
   static __processData(data) {
+    if (isString(data) && data.startsWith("-") && isBigNumberish(data.slice(1))) {
+      return -BigInt(data.slice(1));
+    }
     if (isString(data) && isText(data)) {
       return utf8ToBigInt(data);
     }
@@ -5554,11 +5653,11 @@ var CairoInt32 = class _CairoInt32 {
   /**
    * Throw unless the value can be carried by an i32.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [-2147483648, 2147483647]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [-2147483648, 2147483647]. A text string reaches
    * that last check as the number its bytes spell, so `'abcde'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoInt32.validate(70000); // passes
@@ -5573,6 +5672,7 @@ var CairoInt32 = class _CairoInt32 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoInt32.__processData(data);
     assert(
       value >= RANGE_I32.min && value <= RANGE_I32.max,
@@ -5663,15 +5763,17 @@ var CairoInt64 = class _CairoInt64 {
   /**
    * Build from a number, a string or a boolean, refusing anything out of the i64 range.
    *
-   * A string is read as a number when it spells one — decimal or hexadecimal — and as UTF-8 text
-   * otherwise. Text therefore only fits here up to 8 ASCII characters : one more already
-   * makes a number past 9223372036854775807.
+   * A string is read as a number when it spells one — decimal or hexadecimal, with or without a
+   * leading minus sign — and as UTF-8 text otherwise. Text therefore only fits here up to 8 ASCII
+   * characters : one more already makes a number past 9223372036854775807.
    * @param {BigNumberish | boolean} data the value to carry, within [-9223372036854775808, 9223372036854775807]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoInt64('abcdefgh').toApiRequest();
    * // result = ["7017280452245743464"]
+   * const result2 = new CairoInt64('-5').toApiRequest();
+   * // result2 = ["3618502788666131213697322783095070105623107215331596699973092056135872020476"]
    * ```
    */
   constructor(data) {
@@ -5683,6 +5785,9 @@ var CairoInt64 = class _CairoInt64 {
    *
    * Nothing here refuses a value : `validate` is what reads this number and decides. So an input
    * far outside the i64 range comes back untouched rather than raising.
+   *
+   * A minus sign in front of a number makes it negative rather than text : `'-5'` and `'-0x5'` are
+   * both -5. This holds for the signed integers only — for any other type, such a string is text.
    * @param {BigNumberish | boolean} data the value to convert
    * @returns {bigint} the number the input spells, of whatever size
    * @example
@@ -5691,9 +5796,14 @@ var CairoInt64 = class _CairoInt64 {
    * // result = 7017280452245743464n
    * const result2 = CairoInt64.__processData('abcdefghi');
    * // result2 = 1796423795774910326889n     (past the i64 range, and returned all the same)
+   * const result3 = CairoInt64.__processData('-0x5');
+   * // result3 = -5n     (a negative number, not the text "-0x5")
    * ```
    */
   static __processData(data) {
+    if (isString(data) && data.startsWith("-") && isBigNumberish(data.slice(1))) {
+      return -BigInt(data.slice(1));
+    }
     if (isString(data) && isText(data)) {
       return utf8ToBigInt(data);
     }
@@ -5772,11 +5882,11 @@ var CairoInt64 = class _CairoInt64 {
   /**
    * Throw unless the value can be carried by an i64.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [-9223372036854775808, 9223372036854775807]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [-9223372036854775808, 9223372036854775807]. A text string reaches
    * that last check as the number its bytes spell, so `'abcdefghi'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoInt64.validate(5000000000); // passes
@@ -5791,6 +5901,7 @@ var CairoInt64 = class _CairoInt64 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoInt64.__processData(data);
     assert(
       value >= RANGE_I64.min && value <= RANGE_I64.max,
@@ -5881,15 +5992,17 @@ var CairoInt128 = class _CairoInt128 {
   /**
    * Build from a number, a string or a boolean, refusing anything out of the i128 range.
    *
-   * A string is read as a number when it spells one — decimal or hexadecimal — and as UTF-8 text
-   * otherwise. Text therefore only fits here up to 16 ASCII characters : one more already
-   * makes a number past 170141183460469231731687303715884105727.
+   * A string is read as a number when it spells one — decimal or hexadecimal, with or without a
+   * leading minus sign — and as UTF-8 text otherwise. Text therefore only fits here up to 16 ASCII
+   * characters : one more already makes a number past 170141183460469231731687303715884105727.
    * @param {BigNumberish | boolean} data the value to carry, within [-170141183460469231731687303715884105728, 170141183460469231731687303715884105727]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoInt128('abcdefghijklmnop').toApiRequest();
    * // result = ["129445976596022050476432668810952994672"]
+   * const result2 = new CairoInt128('-5').toApiRequest();
+   * // result2 = ["3618502788666131213697322783095070105623107215331596699973092056135872020476"]
    * ```
    */
   constructor(data) {
@@ -5901,6 +6014,9 @@ var CairoInt128 = class _CairoInt128 {
    *
    * Nothing here refuses a value : `validate` is what reads this number and decides. So an input
    * far outside the i128 range comes back untouched rather than raising.
+   *
+   * A minus sign in front of a number makes it negative rather than text : `'-5'` and `'-0x5'` are
+   * both -5. This holds for the signed integers only — for any other type, such a string is text.
    * @param {BigNumberish | boolean} data the value to convert
    * @returns {bigint} the number the input spells, of whatever size
    * @example
@@ -5909,9 +6025,14 @@ var CairoInt128 = class _CairoInt128 {
    * // result = 129445976596022050476432668810952994672n
    * const result2 = CairoInt128.__processData('abcdefghijklmnopq');
    * // result2 = 33138170008581644921966763215603966636145n     (past the i128 range, and returned all the same)
+   * const result3 = CairoInt128.__processData('-0x5');
+   * // result3 = -5n     (a negative number, not the text "-0x5")
    * ```
    */
   static __processData(data) {
+    if (isString(data) && data.startsWith("-") && isBigNumberish(data.slice(1))) {
+      return -BigInt(data.slice(1));
+    }
     if (isString(data) && isText(data)) {
       return utf8ToBigInt(data);
     }
@@ -5990,11 +6111,11 @@ var CairoInt128 = class _CairoInt128 {
   /**
    * Throw unless the value can be carried by an i128.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [-170141183460469231731687303715884105728, 170141183460469231731687303715884105727]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [-170141183460469231731687303715884105728, 170141183460469231731687303715884105727]. A text string reaches
    * that last check as the number its bytes spell, so `'abcdefghijklmnopq'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoInt128.validate(5000000000); // passes
@@ -6009,6 +6130,7 @@ var CairoInt128 = class _CairoInt128 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoInt128.__processData(data);
     assert(
       value >= RANGE_I128.min && value <= RANGE_I128.max,
@@ -6099,7 +6221,7 @@ var CairoBool = class _CairoBool {
   /**
    * Build from a boolean, or from the numbers 0 and 1.
    * @param {BigNumberish | boolean} data the value to carry : a boolean, 0 or 1
-   * @throws {Error} when the value is text, is not a felt252 input, or is a number other than 0 or 1
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or a number other than 0 or 1
    * @example
    * ```typescript
    * const result = new CairoBool(false).toApiRequest();
@@ -6172,21 +6294,28 @@ var CairoBool = class _CairoBool {
   /**
    * Throw unless the value can be carried by a bool.
    *
-   * Text is refused first, then the value is read as a felt252 — which is what refuses a null, an
-   * object or an unsupported type — and finally checked to be one of the only two numbers a bool
-   * can hold.
+   * Text is refused first, then a number with a decimal part. A number or a bigint is read as it
+   * is, so that a negative one reaches the last check. Anything else is read as a felt252 — which
+   * is what refuses a null, an object or an unsupported type. The value is finally checked to be
+   * one of the only two numbers a bool can hold.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is text, is not a felt252 input, or is a number other than 0 or 1
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or a number other than 0 or 1
    * @example
    * ```typescript
    * CairoBool.validate(true); // passes
    * CairoBool.validate(2);
    * // throws Error("Only values 0 or 1 are possible in a core::bool, received 2")
+   * CairoBool.validate(-1);
+   * // throws Error("Only values 0 or 1 are possible in a core::bool, received -1")
    * ```
    */
   static validate(data) {
     assert(!isText(data), "Invalid input: a core::bool cannot be built from text");
-    const value = new CairoFelt252(data).toBigInt();
+    assert(
+      !isNumber(data) || Number.isInteger(data),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
+    const value = isNumber(data) || isBigInt(data) ? BigInt(data) : new CairoFelt252(data).toBigInt();
     assert(
       value === 0n || value === 1n,
       `Only values 0 or 1 are possible in a core::bool, received ${value}`
@@ -6301,7 +6430,9 @@ var CairoSecp256k1Point = class _CairoSecp256k1Point {
   /**
    * @param {any[]} arr either one value — a 512-bit number or a {@link Secp256k1PointStruct} — or
    * the four limbs
-   * @throws {Error} when a value is out of range, or when the argument count is neither 1 nor 4
+   * @throws {Error} when a value is null, undefined, of an unread type, text, a decimal number, or out
+   * of range — see {@link CairoSecp256k1Point.validate} and {@link CairoSecp256k1Point.validateProps}
+   * — or when the argument count is neither 1 nor 4
    * @example
    * ```typescript
    * const result = new CairoSecp256k1Point(1n).toApiRequest();
@@ -6348,22 +6479,32 @@ var CairoSecp256k1Point = class _CairoSecp256k1Point {
    * the constructor needs it, and computing it twice would mean splitting a 512-bit value twice.
    * @param {BigNumberish} input the 512-bit value to check
    * @returns {bigint} the value, once checked
-   * @throws {Error} when the value is null, undefined, of an unread type, or outside [0, 2^512 - 1]
+   * @throws {Error} when the value is null, undefined, text, `'0x'`, of an unread type, a decimal number, or outside [0, 2^512 - 1]
    * @example
    * ```typescript
    * const result = CairoSecp256k1Point.validate('0x1234');
    * // result = 4660n
    * CairoSecp256k1Point.validate(SECP256K1_POINT_MAX + 1n);
    * // throws Error("input is bigger than SECP256K1_POINT_MAX")
+   * CairoSecp256k1Point.validate('abc');
+   * // throws Error("Invalid input: a Secp256k1Point cannot be built from text")
+   * CairoSecp256k1Point.validate(1.5);
+   * // throws Error("Invalid input: decimal numbers are not supported, only integers")
    * ```
    */
   static validate(input) {
     assert(input !== null, "null value is not allowed for Secp256k1Point");
     assert(input !== void 0, "undefined value is not allowed for Secp256k1Point");
+    assert(!isText(input), "Invalid input: a Secp256k1Point cannot be built from text");
+    assert(!isEmptyHex(input), "Invalid input: '0x' holds no hexadecimal digit");
     assert(
       isBigNumberish(input),
       `Unsupported input for Secp256k1Point. Expected a number, a bigint, or a string spelling one, received '${typeof input}'`
     );
+    assert(
+      !isNumber(input) || Number.isInteger(input),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
     const bigInt = BigInt(input);
     assert(bigInt >= SECP256K1_POINT_MIN, "input is smaller than SECP256K1_POINT_MIN");
     assert(bigInt <= SECP256K1_POINT_MAX, "input is bigger than SECP256K1_POINT_MAX");
@@ -6376,20 +6517,27 @@ var CairoSecp256k1Point = class _CairoSecp256k1Point {
    * @param {BigNumberish} yLow the low 128 bits of y
    * @param {BigNumberish} yHigh the high 128 bits of y
    * @returns {{xLow: bigint, xHigh: bigint, yLow: bigint, yHigh: bigint}} the four limbs, checked
-   * @throws {Error} when a limb is null, undefined, not a number, negative, or wider than 128 bits
+   * @throws {Error} when a limb is null, undefined, text, `'0x'`, not a number, a decimal number, negative, or wider than 128 bits
    * @example
    * ```typescript
    * const result = CairoSecp256k1Point.validateProps(1, 2, 3, 4);
    * // result = { xLow: 1n, xHigh: 2n, yLow: 3n, yHigh: 4n }
    * CairoSecp256k1Point.validateProps(1, 2, 3, 2n ** 128n);
    * // throws Error("yHigh must fit in 128 bits")
+   * CairoSecp256k1Point.validateProps(1.5, 2, 3, 4);
+   * // throws Error("xLow must be an integer")
+   * CairoSecp256k1Point.validateProps('abc', 2, 3, 4);
+   * // throws Error("xLow cannot be built from text")
    * ```
    */
   static validateProps(xLow, xHigh, yLow, yHigh) {
     const validateLimb = (limb, name) => {
       assert(limb !== null, `${name} cannot be null`);
       assert(limb !== void 0, `${name} cannot be undefined`);
+      assert(!isText(limb), `${name} cannot be built from text`);
+      assert(!isEmptyHex(limb), `${name} cannot be '0x', which holds no hexadecimal digit`);
       assert(isBigNumberish(limb), `${name} must be a BigNumberish`);
+      assert(!isNumber(limb) || Number.isInteger(limb), `${name} must be an integer`);
       const bigInt = BigInt(limb);
       assert(bigInt >= 0n, `${name} must be non-negative`);
       assert(bigInt <= UINT_128_MAX, `${name} must fit in 128 bits`);
@@ -7532,9 +7680,9 @@ var CairoClassHash = class _CairoClassHash {
    */
   static abiSelector = Literal.ClassHash;
   /**
-   * Build from a number or a numeric string, refusing text and anything wider than 252 bits.
-   * @param {BigNumberish | boolean} data the hash to carry, within [0, 2^252 - 1]
-   * @throws {Error} when the value is text, is not a felt252 input, or is out of the ClassHash range
+   * Build from a number or a numeric string, refusing text and anything outside the ClassHash range.
+   * @param {BigNumberish | boolean} data the hash to carry, within [0, 2^251 - 1]
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of the ClassHash range
    * @example
    * ```typescript
    * const result = new CairoClassHash('0x1234').toApiRequest();
@@ -7589,21 +7737,34 @@ var CairoClassHash = class _CairoClassHash {
   /**
    * Throw unless the value can be carried by a ClassHash.
    *
-   * Text is refused first, then the value is read as a felt252 — which is what refuses a null, an
-   * object or an unsupported type, and what bounds the value. There is no narrower bound to add:
-   * a class hash is a hash output, so any field element is one.
+   * Text is refused first, then a number with a decimal part. A number or a bigint is read as it
+   * is, so that a negative one reaches the range check. Anything else is read as a felt252 — which
+   * is what refuses a null, an object or an unsupported type. The value is finally checked against
+   * the range of the Cairo `ClassHash` type, [0, 2^251), which is narrower than the field.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is text, is not a felt252 input, or is outside the field
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of the ClassHash range
    * @example
    * ```typescript
    * CairoClassHash.validate('0x1234'); // passes
    * CairoClassHash.validate('abc');
    * // throws Error("Invalid input: a ClassHash cannot be built from text")
+   * CairoClassHash.validate(2n ** 251n);
+   * // throws Error("Value is out of ClassHash range [0, 3618502788666131106986593281521497120414687020801267626233049500247285301247]")
+   * CairoClassHash.validate(-1);
+   * // throws Error("Value is out of ClassHash range [0, 3618502788666131106986593281521497120414687020801267626233049500247285301247]")
    * ```
    */
   static validate(data) {
     assert(!isText(data), "Invalid input: a ClassHash cannot be built from text");
-    CairoFelt252.validate(data);
+    assert(
+      !isNumber(data) || Number.isInteger(data),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
+    const value = isNumber(data) || isBigInt(data) ? BigInt(data) : new CairoFelt252(data).toBigInt();
+    assert(
+      value >= RANGE_CLASS_HASH.min && value <= RANGE_CLASS_HASH.max,
+      `Value is out of ClassHash range [${RANGE_CLASS_HASH.min}, ${RANGE_CLASS_HASH.max}]`
+    );
   }
   /**
    * Can this value be carried by a ClassHash?
@@ -7682,7 +7843,7 @@ var CairoContractAddress = class _CairoContractAddress {
   /**
    * Build from a number or a numeric string, refusing text and anything wider than 252 bits.
    * @param {BigNumberish | boolean} data the address to carry, within [0, 2^252 - 1]
-   * @throws {Error} when the value is text, is not a felt252 input, or is out of range
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of range
    * @example
    * ```typescript
    * const result = new CairoContractAddress('0x1234').toApiRequest();
@@ -7737,11 +7898,12 @@ var CairoContractAddress = class _CairoContractAddress {
   /**
    * Throw unless the value can be carried by a ContractAddress.
    *
-   * Text is refused first, then the value is read as a felt252 — which is what refuses a null, an
-   * object or an unsupported type — and finally checked against the bound an address has, which
-   * is narrower than the field.
+   * Text is refused first, then a number with a decimal part. A number or a bigint is read as it
+   * is, so that a negative one reaches the range check. Anything else is read as a felt252 — which
+   * is what refuses a null, an object or an unsupported type. The value is finally checked against
+   * the bound an address has, which is narrower than the field.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is text, is not a felt252 input, or is out of range
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of range
    * @example
    * ```typescript
    * CairoContractAddress.validate('0x1234'); // passes
@@ -7749,11 +7911,17 @@ var CairoContractAddress = class _CairoContractAddress {
    * // throws Error("Invalid input: a ContractAddress cannot be built from text")
    * CairoContractAddress.validate(2n ** 251n);
    * // throws Error("Value is out of ContractAddress range [0, 3618502788666131106986593281521497120414687020801267626233049500247285300991]")
+   * CairoContractAddress.validate(-1);
+   * // throws Error("Value is out of ContractAddress range [0, 3618502788666131106986593281521497120414687020801267626233049500247285300991]")
    * ```
    */
   static validate(data) {
     assert(!isText(data), "Invalid input: a ContractAddress cannot be built from text");
-    const value = new CairoFelt252(data).toBigInt();
+    assert(
+      !isNumber(data) || Number.isInteger(data),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
+    const value = isNumber(data) || isBigInt(data) ? BigInt(data) : new CairoFelt252(data).toBigInt();
     assert(
       value >= RANGE_CONTRACT_ADDRESS.min && value <= RANGE_CONTRACT_ADDRESS.max,
       `Value is out of ContractAddress range [${RANGE_CONTRACT_ADDRESS.min}, ${RANGE_CONTRACT_ADDRESS.max}]`
@@ -7838,7 +8006,7 @@ var CairoEthAddress = class _CairoEthAddress {
   /**
    * Build from a number or a numeric string, refusing text and anything wider than 160 bits.
    * @param {BigNumberish | boolean} data the address to carry, within [0, 2^160 - 1]
-   * @throws {Error} when the value is text, is not a felt252 input, or is out of the EthAddress range
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of the EthAddress range
    * @example
    * ```typescript
    * const result = new CairoEthAddress('0x1234').toApiRequest();
@@ -7894,10 +8062,12 @@ var CairoEthAddress = class _CairoEthAddress {
    * Throw unless the value can be carried by an EthAddress.
    *
    * Text is refused first, since an address spelled as words is a mistake rather than a value to
-   * encode. What remains is read as a felt252 — which is what refuses a null, an object or an
-   * unsupported type — then checked against the 160 bits an Ethereum address occupies.
+   * encode, then a number with a decimal part. A number or a bigint is read as it is, so that a
+   * negative one reaches the range check below. Anything else is read as a felt252 — which is what
+   * refuses a null, an object or an unsupported type. The value is finally checked against the 160
+   * bits an Ethereum address occupies.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is text, is not a felt252 input, or is out of the EthAddress range
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of the EthAddress range
    * @example
    * ```typescript
    * CairoEthAddress.validate('0x1234'); // passes
@@ -7905,11 +8075,17 @@ var CairoEthAddress = class _CairoEthAddress {
    * // throws Error("Invalid input: an EthAddress cannot be built from text")
    * CairoEthAddress.validate(2n ** 160n);
    * // throws Error("Value is out of EthAddress range [0, 1461501637330902918203684832716283019655932542975]")
+   * CairoEthAddress.validate(-1);
+   * // throws Error("Value is out of EthAddress range [0, 1461501637330902918203684832716283019655932542975]")
    * ```
    */
   static validate(data) {
     assert(!isText(data), "Invalid input: an EthAddress cannot be built from text");
-    const value = new CairoFelt252(data).toBigInt();
+    assert(
+      !isNumber(data) || Number.isInteger(data),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
+    const value = isNumber(data) || isBigInt(data) ? BigInt(data) : new CairoFelt252(data).toBigInt();
     assert(
       value >= RANGE_ETH_ADDRESS.min && value <= RANGE_ETH_ADDRESS.max,
       `Value is out of EthAddress range [${RANGE_ETH_ADDRESS.min}, ${RANGE_ETH_ADDRESS.max}]`
@@ -13626,7 +13802,7 @@ function ethRandomPrivateKey() {
   return sanitizeHex(buf2hex(import_secp256k1.secp256k1.utils.randomSecretKey()));
 }
 function validateAndParseEthAddress(address) {
-  assertInRange(address, ZERO, 2n ** 160n - 1n, "Ethereum Address ");
+  assertInRange(address, ZERO, 2n ** 160n - 1n, "Ethereum Address");
   const result = addHexPrefix(removeHexPrefix(toHex(address)).padStart(40, "0"));
   assert(Boolean(result.match(/^(0x)?[0-9a-f]{40}$/)), "Invalid Ethereum Address Format");
   return result;
@@ -17780,6 +17956,9 @@ function addAddressPadding(address) {
   return addHexPrefix(padded);
 }
 function validateAndParseAddress(address) {
+  if (isString(address) && !/^(0x)?[0-9a-f]+$/i.test(address)) {
+    throw new Error("Invalid Address Format");
+  }
   const result = addAddressPadding(address);
   if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
     throw new Error("Invalid Address Format");