starknet 11.0.0 → 11.0.2

package/dist/index.mjs

@@ -39,6 +39,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,
@@ -278,6 +279,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"
@@ -755,6 +757,7 @@ __export(num_exports, {
   hexToBytes: () => hexToBytes,
   hexToDecimalString: () => hexToDecimalString,
   isBigNumberish: () => isBigNumberish,
+  isEmptyHex: () => isEmptyHex,
   isHex: () => isHex,
   isHexString: () => isHexString2,
   isStringWholeNumber: () => isStringWholeNumber,
@@ -810,6 +813,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) {
@@ -834,13 +838,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) {
@@ -893,8 +897,11 @@ function stringToSha256ToArrayBuff4(str) {
   const result = int31(BigInt(addHexPrefix(buf2hex(sha256(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();
@@ -1478,16 +1485,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")
    * ```
@@ -1499,6 +1508,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);
@@ -2315,7 +2325,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();
@@ -2403,11 +2413,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
@@ -2422,6 +2432,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,
@@ -3053,25 +3064,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");
@@ -3085,18 +3108,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"
@@ -3305,25 +3341,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.");
@@ -3339,20 +3387,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,
@@ -3524,7 +3585,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();
@@ -3612,11 +3673,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
@@ -3631,6 +3692,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,
@@ -4017,7 +4079,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();
@@ -4107,11 +4169,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
@@ -4126,6 +4188,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,
@@ -4216,7 +4279,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();
@@ -4304,11 +4367,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
@@ -4323,6 +4386,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,
@@ -4413,7 +4477,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();
@@ -4501,11 +4565,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
@@ -4520,6 +4584,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,
@@ -4610,7 +4675,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();
@@ -4698,11 +4763,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
@@ -4717,6 +4782,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,
@@ -4803,15 +4869,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) {
@@ -4823,6 +4891,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
@@ -4831,9 +4902,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);
     }
@@ -4912,11 +4988,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
@@ -4931,6 +5008,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,
@@ -5021,15 +5099,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) {
@@ -5041,6 +5121,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
@@ -5049,9 +5132,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);
     }
@@ -5130,11 +5218,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
@@ -5149,6 +5237,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,
@@ -5239,15 +5328,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) {
@@ -5259,6 +5350,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
@@ -5267,9 +5361,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);
     }
@@ -5348,11 +5447,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
@@ -5367,6 +5466,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,
@@ -5457,15 +5557,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) {
@@ -5477,6 +5579,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
@@ -5485,9 +5590,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);
     }
@@ -5566,11 +5676,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
@@ -5585,6 +5695,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,
@@ -5675,15 +5786,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) {
@@ -5695,6 +5808,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
@@ -5703,9 +5819,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);
     }
@@ -5784,11 +5905,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
@@ -5803,6 +5924,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,
@@ -5893,7 +6015,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();
@@ -5966,21 +6088,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}`
@@ -6095,7 +6224,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();
@@ -6142,22 +6273,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");
@@ -6170,20 +6311,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`);
@@ -7326,9 +7474,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();
@@ -7383,21 +7531,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?
@@ -7476,7 +7637,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();
@@ -7531,11 +7692,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
@@ -7543,11 +7705,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}]`
@@ -7632,7 +7800,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();
@@ -7688,10 +7856,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
@@ -7699,11 +7869,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}]`
@@ -13420,7 +13596,7 @@ function ethRandomPrivateKey() {
   return sanitizeHex(buf2hex(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;
@@ -17574,6 +17750,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");
@@ -20068,10 +20247,10 @@ function supportedWalletApi3(walletWSF) {
 function subscribeWalletEvent2(walletWSF, callback) {
   return walletWSF.features["standard:events"].on("change", callback);
 }
-function strk20Balances(walletWSF, tokens) {
+function strk20Balances(walletWSF, tokens, valid_until) {
   return walletWSF.features["starknet:walletApi"].request({
     type: "wallet_strk20Balances",
-    params: { tokens }
+    params: { tokens, valid_until }
   });
 }
 function strk20PrepareInvoke(walletWSF, actions, simulate) {
@@ -20124,16 +20303,26 @@ var WalletAccountV6 = class _WalletAccountV6 extends WalletAccountV5 {
   }
   /**
    * Get the private balances held by the user inside the STRK20 privacy pool.
+   *
+   * Reading a shielded balance requires the user approval, and this approval is time
+   * limited : `validUntil` requests when it expires. When it is omitted, the wallet applies
+   * its own default window.
    * @param {Address[]} tokens - The tokens to get the private balance of. An empty array returns every shielded token.
+   * @param {number} [validUntil] - Requested expiry of the balance read authorization, as a Unix timestamp in seconds. Omit it to let the wallet apply its default window.
    * @returns {Promise<STRK20_BALANCE_ENTRY[]>} One entry per token.
    * @example
    * ```typescript
    * const balances = await myWalletAccount.strk20Balances([strkAddress]);
-   * // balances = [{ token: '0x4718...', amount: '0x2386f26fc10000' }]
+   * // balances = [{ token: '0x4718...', balance: '0x2386f26fc10000' }]
+   *
+   * // Asking for a 5 minutes authorization window :
+   * const expiry = Math.floor(Date.now() / 1000) + 300;
+   * const fresh = await myWalletAccount.strk20Balances([strkAddress], expiry);
+   * // fresh = [{ token: '0x4718...', balance: '0x2386f26fc10000' }]
    * ```
    */
-  strk20Balances(tokens) {
-    return strk20Balances(this.v6Provider, tokens);
+  strk20Balances(tokens, validUntil) {
+    return strk20Balances(this.v6Provider, tokens, validUntil);
   }
   /**
    * Build the Starknet call and the SNIP-36 zero-knowledge proof of a STRK20 transaction,