starknet 11.0.1 → 11.0.3

package/dist/index.global.js

@@ -260,6 +260,7 @@ var starknet = (() => {
     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,
@@ -1234,6 +1235,7 @@ var starknet = (() => {
   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"
@@ -2306,6 +2308,7 @@ ${indent}}` : "}";
     hexToBytes: () => hexToBytes3,
     hexToDecimalString: () => hexToDecimalString,
     isBigNumberish: () => isBigNumberish,
+    isEmptyHex: () => isEmptyHex,
     isHex: () => isHex2,
     isHexString: () => isHexString2,
     isStringWholeNumber: () => isStringWholeNumber,
@@ -3052,6 +3055,7 @@ ${indent}}` : "}";
   }
   var isHexString2 = isHex2;
   function toBigInt(value) {
+    assert(!isEmptyHex(value), "Invalid input: '0x' holds no hexadecimal digit");
     return BigInt(value);
   }
   function tryToBigInt(value) {
@@ -3076,13 +3080,13 @@ ${indent}}` : "}";
     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) {
@@ -3135,8 +3139,11 @@ ${indent}}` : "}";
     const result = int312(BigInt(addHexPrefix(buf2hex(sha256(utf8ToBytes(str))))));
     return hexToBytes3(toHex(result));
   }
+  function isEmptyHex(value) {
+    return isString(value) && /^0x$/i.test(value);
+  }
   function isBigNumberish(input) {
-    return isNumber2(input) || isBigInt(input) || isString(input) && (isHex2(input) || isStringWholeNumber(input));
+    return isNumber2(input) || isBigInt(input) || isString(input) && (isHex2(input) && !isEmptyHex(input) || isStringWholeNumber(input));
   }
   function getNext(iterator) {
     const it = iterator.next();
@@ -6625,16 +6632,18 @@ ${indent}}` : "}";
     /**
      * 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")
      * ```
@@ -6646,6 +6655,7 @@ ${indent}}` : "}";
         isString(data) || isNumber2(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);
@@ -7462,7 +7472,7 @@ ${indent}}` : "}";
      * 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();
@@ -7550,11 +7560,11 @@ ${indent}}` : "}";
     /**
      * 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
@@ -7569,6 +7579,7 @@ ${indent}}` : "}";
         !isNumber2(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,
@@ -8156,7 +8167,6 @@ ${indent}}` : "}";
      * ```
      */
     low;
-    // TODO should be u128
     /**
      * The top 128 bits of the value.
      * @example
@@ -8166,7 +8176,6 @@ ${indent}}` : "}";
      * ```
      */
     high;
-    // TODO should be u128
     /**
      * The abi type this class serializes.
      * @example
@@ -8200,25 +8209,37 @@ ${indent}}` : "}";
      * 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) || isObject2(bigNumberish),
+        isBigNumberish(bigNumberish),
         `Unsupported data type '${typeof bigNumberish}' for u256. Expected a numeric string (decimal or hexadecimal), number, bigint, or Uint256 object`
       );
+      assert(
+        !isNumber2(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");
@@ -8232,18 +8253,31 @@ ${indent}}` : "}";
      * @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(!isNumber2(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"
@@ -8380,7 +8414,6 @@ ${indent}}` : "}";
      * ```
      */
     limb0;
-    // TODO should be u128
     /**
      * Bits 128 to 255 of the value.
      * @example
@@ -8390,7 +8423,6 @@ ${indent}}` : "}";
      * ```
      */
     limb1;
-    // TODO should be u128
     /**
      * Bits 256 to 383 of the value.
      * @example
@@ -8400,7 +8432,6 @@ ${indent}}` : "}";
      * ```
      */
     limb2;
-    // TODO should be u128
     /**
      * Bits 384 to 511 of the value.
      * @example
@@ -8410,7 +8441,6 @@ ${indent}}` : "}";
      * ```
      */
     limb3;
-    // TODO should be u128
     /**
      * The abi type this class serializes.
      * @example
@@ -8452,25 +8482,37 @@ ${indent}}` : "}";
      * 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) || isObject2(bigNumberish),
+        isBigNumberish(bigNumberish),
         `Unsupported data type '${typeof bigNumberish}' for u512. Expected a numeric string (decimal or hexadecimal), number, bigint, or Uint512 object`
       );
+      assert(
+        !isNumber2(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.");
@@ -8486,20 +8528,33 @@ ${indent}}` : "}";
      * @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(!isNumber2(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,
@@ -8671,7 +8726,7 @@ ${indent}}` : "}";
      * 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();
@@ -8759,11 +8814,11 @@ ${indent}}` : "}";
     /**
      * 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
@@ -8778,6 +8833,7 @@ ${indent}}` : "}";
         !isNumber2(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,
@@ -9164,7 +9220,7 @@ ${indent}}` : "}";
      * 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();
@@ -9254,11 +9310,11 @@ ${indent}}` : "}";
     /**
      * 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
@@ -9273,6 +9329,7 @@ ${indent}}` : "}";
         !isNumber2(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,
@@ -9363,7 +9420,7 @@ ${indent}}` : "}";
      * 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();
@@ -9451,11 +9508,11 @@ ${indent}}` : "}";
     /**
      * 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
@@ -9470,6 +9527,7 @@ ${indent}}` : "}";
         !isNumber2(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,
@@ -9560,7 +9618,7 @@ ${indent}}` : "}";
      * 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();
@@ -9648,11 +9706,11 @@ ${indent}}` : "}";
     /**
      * 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
@@ -9667,6 +9725,7 @@ ${indent}}` : "}";
         !isNumber2(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,
@@ -9757,7 +9816,7 @@ ${indent}}` : "}";
      * 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();
@@ -9845,11 +9904,11 @@ ${indent}}` : "}";
     /**
      * 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
@@ -9864,6 +9923,7 @@ ${indent}}` : "}";
         !isNumber2(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,
@@ -9950,15 +10010,17 @@ ${indent}}` : "}";
     /**
      * 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) {
@@ -9970,6 +10032,9 @@ ${indent}}` : "}";
      *
      * 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
@@ -9978,9 +10043,14 @@ ${indent}}` : "}";
      * // 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);
       }
@@ -10059,11 +10129,12 @@ ${indent}}` : "}";
     /**
      * 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
@@ -10078,6 +10149,7 @@ ${indent}}` : "}";
         !isNumber2(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,
@@ -10168,15 +10240,17 @@ ${indent}}` : "}";
     /**
      * 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) {
@@ -10188,6 +10262,9 @@ ${indent}}` : "}";
      *
      * 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
@@ -10196,9 +10273,14 @@ ${indent}}` : "}";
      * // 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);
       }
@@ -10277,11 +10359,11 @@ ${indent}}` : "}";
     /**
      * 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
@@ -10296,6 +10378,7 @@ ${indent}}` : "}";
         !isNumber2(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,
@@ -10386,15 +10469,17 @@ ${indent}}` : "}";
     /**
      * 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) {
@@ -10406,6 +10491,9 @@ ${indent}}` : "}";
      *
      * 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
@@ -10414,9 +10502,14 @@ ${indent}}` : "}";
      * // 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);
       }
@@ -10495,11 +10588,11 @@ ${indent}}` : "}";
     /**
      * 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
@@ -10514,6 +10607,7 @@ ${indent}}` : "}";
         !isNumber2(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,
@@ -10604,15 +10698,17 @@ ${indent}}` : "}";
     /**
      * 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) {
@@ -10624,6 +10720,9 @@ ${indent}}` : "}";
      *
      * 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
@@ -10632,9 +10731,14 @@ ${indent}}` : "}";
      * // 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);
       }
@@ -10713,11 +10817,11 @@ ${indent}}` : "}";
     /**
      * 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
@@ -10732,6 +10836,7 @@ ${indent}}` : "}";
         !isNumber2(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,
@@ -10822,15 +10927,17 @@ ${indent}}` : "}";
     /**
      * 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) {
@@ -10842,6 +10949,9 @@ ${indent}}` : "}";
      *
      * 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
@@ -10850,9 +10960,14 @@ ${indent}}` : "}";
      * // 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);
       }
@@ -10931,11 +11046,11 @@ ${indent}}` : "}";
     /**
      * 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
@@ -10950,6 +11065,7 @@ ${indent}}` : "}";
         !isNumber2(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,
@@ -11040,7 +11156,7 @@ ${indent}}` : "}";
     /**
      * 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();
@@ -11113,21 +11229,28 @@ ${indent}}` : "}";
     /**
      * 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(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = isNumber2(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}`
@@ -11242,7 +11365,9 @@ ${indent}}` : "}";
     /**
      * @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();
@@ -11289,22 +11414,32 @@ ${indent}}` : "}";
      * 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(
+        !isNumber2(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");
@@ -11317,20 +11452,27 @@ ${indent}}` : "}";
      * @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(!isNumber2(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`);
@@ -12473,9 +12615,9 @@ ${indent}}` : "}";
      */
     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();
@@ -12530,21 +12672,34 @@ ${indent}}` : "}";
     /**
      * 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(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = isNumber2(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?
@@ -12623,7 +12778,7 @@ ${indent}}` : "}";
     /**
      * 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();
@@ -12678,11 +12833,12 @@ ${indent}}` : "}";
     /**
      * 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
@@ -12690,11 +12846,17 @@ ${indent}}` : "}";
      * // 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(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = isNumber2(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}]`
@@ -12779,7 +12941,7 @@ ${indent}}` : "}";
     /**
      * 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();
@@ -12835,10 +12997,12 @@ ${indent}}` : "}";
      * 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
@@ -12846,11 +13010,17 @@ ${indent}}` : "}";
      * // 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(
+        !isNumber2(data) || Number.isInteger(data),
+        "Invalid input: decimal numbers are not supported, only integers"
+      );
+      const value = isNumber2(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}]`
@@ -13525,7 +13695,13 @@ ${indent}}` : "}";
      * Build an option, from a value a caller passed or from the felts of a response.
      *
      * A {@link CairoOption} says its own branch, so `variant` is not given with one — nor with the
-     * response iterator, which reads the branch off the wire. Anywhere else it is required.
+     * response iterator, which reads the branch off the wire, nor with a `CairoTypeOption`, which
+     * is copied as it is. Anywhere else it is required.
+     *
+     * For the same reason, a `CairoOption` that holds a `CairoTypeOption` is refused: once it is
+     * unwrapped, the variant comes with the `CairoTypeOption`. Accepted, it would lose one level:
+     * `Some(Some(1))` would be sent as `Some(None)`. Write a nested value with `CairoOption`
+     * only, or build one `CairoTypeOption` for the whole type.
      *
      * `subType` is what makes an option of options work. Handed a `CairoOption`, this constructor
      * unwraps it and calls itself with what was inside, which for a nested option is another
@@ -13536,11 +13712,11 @@ ${indent}}` : "}";
      * @param {string} optionCairoType the abi type, `core::option::Option::<T>`
      * @param {AllowArray<CairoTypeStrategy>} parsingStrategy how to build the value
      * @param {CairoOptionVariant | number} [variant] which branch, when the content does not say.
-     * Must be omitted when `content` is the response iterator.
+     * Must be omitted when `content` is the response iterator or a `CairoTypeOption`.
      * @param {boolean} [subType=false] true when called from the unwrapping of a nested
      * `CairoOption`, which is the only caller that should set it
-     * @throws {Error} when the type is not an option, when the variant is missing, absurd, or
-     * contradicts the content
+     * @throws {Error} when the type is not an option, or when the variant is missing, absurd,
+     * contradicts the content, or is given with a `CairoTypeOption`
      * @example
      * ```typescript
      * const type = 'core::option::Option::<core::integer::u8>';
@@ -13585,6 +13761,10 @@ ${indent}}` : "}";
         return;
       }
       if (content instanceof _CairoTypeOption) {
+        assert(
+          isUndefined(variant),
+          'when "content" parameter is a CairoTypeOption, do not define "variant" parameter.'
+        );
         this.content = content.content;
         this.isVariantSome = content.isVariantSome;
         this.optionCairoType = content.optionCairoType;
@@ -16046,11 +16226,17 @@ ${indent}}` : "}";
       `Your object includes the property : ${key}, containing an Uint512 object without the 'limb0' to 'limb3' keys.`
     );
   }
+  function getVariantType(abiEnum, variantName) {
+    return abiEnum.variants?.find((abiVariant) => abiVariant.name === variantName)?.type ?? "";
+  }
   function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
     const orderInput = (unorderedItem, abiType) => {
       if (CairoFixedArray.isTypeFixedArray(abiType)) {
         return orderFixedArray(unorderedItem, abiType);
       }
+      if (isCairoType(unorderedItem)) {
+        return unorderedItem;
+      }
       if (isTypeArray(abiType)) {
         return orderArray(unorderedItem, abiType);
       }
@@ -16163,14 +16349,8 @@ ${indent}}` : "}";
     const orderEnum = (unorderedObject2, abiObject) => {
       if (isTypeResult(abiObject.name)) {
         const unorderedResult = unorderedObject2;
-        const resultOkType = abiObject.name.substring(
-          abiObject.name.indexOf("<") + 1,
-          abiObject.name.lastIndexOf(",")
-        );
-        const resultErrType = abiObject.name.substring(
-          abiObject.name.indexOf(",") + 1,
-          abiObject.name.lastIndexOf(">")
-        );
+        const resultOkType = getVariantType(abiObject, "Ok");
+        const resultErrType = getVariantType(abiObject, "Err");
         if (unorderedResult.isOk()) {
           return new CairoResult(
             CairoResultVariant.Ok,
@@ -16184,10 +16364,7 @@ ${indent}}` : "}";
       }
       if (isTypeOption(abiObject.name)) {
         const unorderedOption = unorderedObject2;
-        const resultSomeType = abiObject.name.substring(
-          abiObject.name.indexOf("<") + 1,
-          abiObject.name.lastIndexOf(">")
-        );
+        const resultSomeType = getVariantType(abiObject, "Some");
         if (unorderedOption.isSome()) {
           return new CairoOption(
             CairoOptionVariant.Some,
@@ -16202,10 +16379,7 @@ ${indent}}` : "}";
         if (isUndefined(variant[1])) {
           return variant;
         }
-        const variantType = abiObject.type.substring(
-          abiObject.type.lastIndexOf("<") + 1,
-          abiObject.type.lastIndexOf(">")
-        );
+        const variantType = getVariantType(abiObject, variant[0]);
         if (variantType === "()") {
           return variant;
         }
@@ -19097,7 +19271,7 @@ ${indent}}` : "}";
     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;
@@ -23329,6 +23503,9 @@ ${indent}}` : "}";
     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");