starknet 11.0.1 → 11.0.3

package/dist/index.js

@@ -246,6 +246,7 @@ __export(constants_exports, {
   OutsideExecutionCallerAny: () => OutsideExecutionCallerAny,
   PAYMASTER_RPC_NODES: () => PAYMASTER_RPC_NODES,
   PRIME: () => PRIME,
+  RANGE_CLASS_HASH: () => RANGE_CLASS_HASH,
   RANGE_CONTRACT_ADDRESS: () => RANGE_CONTRACT_ADDRESS,
   RANGE_ETH_ADDRESS: () => RANGE_ETH_ADDRESS,
   RANGE_FELT: () => RANGE_FELT,
@@ -484,6 +485,7 @@ var RANGE_I64 = range(-(2n ** 63n), 2n ** 63n - 1n);
 var RANGE_I128 = range(-(2n ** 127n), 2n ** 127n - 1n);
 var RANGE_ETH_ADDRESS = range(ZERO, 2n ** 160n - 1n);
 var RANGE_CONTRACT_ADDRESS = range(ZERO, ADDR_BOUND - 1n);
+var RANGE_CLASS_HASH = range(ZERO, 2n ** 251n - 1n);
 var LegacyUDC = {
   ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf",
   ENTRYPOINT: "deployContract"
@@ -961,6 +963,7 @@ __export(num_exports, {
   hexToBytes: () => hexToBytes,
   hexToDecimalString: () => hexToDecimalString,
   isBigNumberish: () => isBigNumberish,
+  isEmptyHex: () => isEmptyHex,
   isHex: () => isHex,
   isHexString: () => isHexString2,
   isStringWholeNumber: () => isStringWholeNumber,
@@ -1016,6 +1019,7 @@ function isHex(hex) {
 }
 var isHexString2 = isHex;
 function toBigInt(value) {
+  assert(!isEmptyHex(value), "Invalid input: '0x' holds no hexadecimal digit");
   return BigInt(value);
 }
 function tryToBigInt(value) {
@@ -1040,13 +1044,13 @@ function hexToDecimalString(hex) {
   return BigInt(addHexPrefix(hex)).toString(10);
 }
 function assertInRange(input, lowerBound, upperBound, inputName = "") {
-  const messageSuffix = inputName === "" ? "invalid length" : `invalid ${inputName} length`;
   const inputBigInt = BigInt(input);
   const lowerBoundBigInt = BigInt(lowerBound);
   const upperBoundBigInt = BigInt(upperBound);
+  const rangeName = inputName === "" ? "range" : `${inputName} range`;
   assert(
     inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt,
-    `Message not signable, ${messageSuffix}.`
+    `Value is out of ${rangeName} [${lowerBoundBigInt}, ${upperBoundBigInt}]`
   );
 }
 function bigNumberishArrayToDecimalStringArray(data) {
@@ -1099,8 +1103,11 @@ function stringToSha256ToArrayBuff4(str) {
   const result = int31(BigInt(addHexPrefix(buf2hex((0, import_sha2.sha256)((0, import_utils2.utf8ToBytes)(str))))));
   return hexToBytes(toHex(result));
 }
+function isEmptyHex(value) {
+  return isString(value) && /^0x$/i.test(value);
+}
 function isBigNumberish(input) {
-  return isNumber(input) || isBigInt(input) || isString(input) && (isHex(input) || isStringWholeNumber(input));
+  return isNumber(input) || isBigInt(input) || isString(input) && (isHex(input) && !isEmptyHex(input) || isStringWholeNumber(input));
 }
 function getNext(iterator) {
   const it = iterator.next();
@@ -1684,16 +1691,18 @@ var CairoFelt252 = class _CairoFelt252 {
   /**
    * Throw unless the value can be carried by a felt252.
    *
-   * Null, undefined and any type this class does not read are refused first, each with its own
-   * message, then the value is converted and its range checked. A negative number does not reach
-   * that range check : converting it fails earlier, and the message comes from the conversion.
+   * Null, undefined, any type this class does not read, and `'0x'` are refused first, each with its
+   * own message, then the value is converted and its range checked. A negative number does not
+   * reach that range check : converting it fails earlier, and the message comes from the conversion.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, of an unread type, or outside [0, P)
+   * @throws {Error} when the value is null, undefined, of an unread type, `'0x'`, or outside [0, P)
    * @example
    * ```typescript
    * CairoFelt252.validate('Hello'); // passes
    * CairoFelt252.validate({});
    * // throws Error("Unsupported data type 'object' for felt252. Expected string, number, bigint, or boolean")
+   * CairoFelt252.validate('0x');
+   * // throws Error("Invalid input: '0x' holds no hexadecimal digit")
    * CairoFelt252.validate(-1);
    * // throws Error("Cannot convert negative bigint -1 to Uint8Array")
    * ```
@@ -1705,6 +1714,7 @@ var CairoFelt252 = class _CairoFelt252 {
       isString(data) || isNumber(data) || isBigInt(data) || isBoolean(data),
       `Unsupported data type '${typeof data}' for felt252. Expected string, number, bigint, or boolean`
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoFelt252.__processData(data);
     const bn = uint8ArrayToBigInt(value);
     _CairoFelt252.assertRange(bn);
@@ -2521,7 +2531,7 @@ var CairoUint32 = class _CairoUint32 {
    * otherwise. Text therefore only fits here up to 4 ASCII characters : one more already
    * makes a number past 4294967295.
    * @param {BigNumberish | boolean} data the value to carry, within [0, 4294967295]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoUint32('abcd').toApiRequest();
@@ -2609,11 +2619,11 @@ var CairoUint32 = class _CairoUint32 {
   /**
    * Throw unless the value can be carried by a u32.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [0, 4294967295]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [0, 4294967295]. A text string reaches
    * that last check as the number its bytes spell, so `'abcde'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoUint32.validate(70000); // passes
@@ -2628,6 +2638,7 @@ var CairoUint32 = class _CairoUint32 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoUint32.__processData(data);
     assert(
       value >= RANGE_U32.min && value <= RANGE_U32.max,
@@ -3215,7 +3226,6 @@ var CairoUint256 = class _CairoUint256 {
    * ```
    */
   low;
-  // TODO should be u128
   /**
    * The top 128 bits of the value.
    * @example
@@ -3225,7 +3235,6 @@ var CairoUint256 = class _CairoUint256 {
    * ```
    */
   high;
-  // TODO should be u128
   /**
    * The abi type this class serializes.
    * @example
@@ -3259,25 +3268,37 @@ var CairoUint256 = class _CairoUint256 {
    * Throw unless a whole value can be represented as a u256, and give back its number.
    *
    * A string is only accepted while it spells a number, in base 10 or 16 : one that does not is
-   * refused for its type.
+   * refused as text, and `'0x'`, which holds no digit, is refused too. So is an object, a `Uint256`
+   * one included : its two halves are checked by {@link CairoUint256.validateProps}, which is what
+   * the constructor calls for it.
    * @param {BigNumberish} bigNumberish the value to check
    * @returns {bigint} the value as a number, once accepted
-   * @throws {Error} when the value is null, undefined, of an unread type, or out of range
+   * @throws {Error} when the value is null, undefined, text, `'0x'`, of an unread type, a decimal number, or out of range
    * @example
    * ```typescript
    * const result = CairoUint256.validate(255);
    * // result = 255n
    * CairoUint256.validate(-1);
    * // throws Error("bigNumberish is smaller than UINT_256_MIN")
+   * CairoUint256.validate('abc');
+   * // throws Error("Invalid input: a u256 cannot be built from text")
+   * CairoUint256.validate(1.5);
+   * // throws Error("Invalid input: decimal numbers are not supported, only integers")
    * ```
    */
   static validate(bigNumberish) {
     assert(bigNumberish !== null, "null value is not allowed for u256");
     assert(bigNumberish !== void 0, "undefined value is not allowed for u256");
+    assert(!isText(bigNumberish), "Invalid input: a u256 cannot be built from text");
+    assert(!isEmptyHex(bigNumberish), "Invalid input: '0x' holds no hexadecimal digit");
     assert(
-      isBigNumberish(bigNumberish) || isObject(bigNumberish),
+      isBigNumberish(bigNumberish),
       `Unsupported data type '${typeof bigNumberish}' for u256. Expected a numeric string (decimal or hexadecimal), number, bigint, or Uint256 object`
     );
+    assert(
+      !isNumber(bigNumberish) || Number.isInteger(bigNumberish),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
     const bigInt = BigInt(bigNumberish);
     assert(bigInt >= UINT_256_MIN, "bigNumberish is smaller than UINT_256_MIN");
     assert(bigInt <= UINT_256_MAX, "bigNumberish is bigger than UINT_256_MAX");
@@ -3291,18 +3312,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"
@@ -3439,7 +3473,6 @@ var CairoUint512 = class _CairoUint512 {
    * ```
    */
   limb0;
-  // TODO should be u128
   /**
    * Bits 128 to 255 of the value.
    * @example
@@ -3449,7 +3482,6 @@ var CairoUint512 = class _CairoUint512 {
    * ```
    */
   limb1;
-  // TODO should be u128
   /**
    * Bits 256 to 383 of the value.
    * @example
@@ -3459,7 +3491,6 @@ var CairoUint512 = class _CairoUint512 {
    * ```
    */
   limb2;
-  // TODO should be u128
   /**
    * Bits 384 to 511 of the value.
    * @example
@@ -3469,7 +3500,6 @@ var CairoUint512 = class _CairoUint512 {
    * ```
    */
   limb3;
-  // TODO should be u128
   /**
    * The abi type this class serializes.
    * @example
@@ -3511,25 +3541,37 @@ var CairoUint512 = class _CairoUint512 {
    * Throw unless a whole value can be represented as a u512, and give back its number.
    *
    * A string is only accepted while it spells a number, in base 10 or 16 : one that does not is
-   * refused for its type.
+   * refused as text, and `'0x'`, which holds no digit, is refused too. So is an object, a `Uint512`
+   * one included : its four limbs are checked by {@link CairoUint512.validateProps}, which is what
+   * the constructor calls for it.
    * @param {BigNumberish} bigNumberish the value to check
    * @returns {bigint} the value as a number, once accepted
-   * @throws {Error} when the value is null, undefined, of an unread type, or out of range
+   * @throws {Error} when the value is null, undefined, text, `'0x'`, of an unread type, a decimal number, or out of range
    * @example
    * ```typescript
    * const result = CairoUint512.validate(255);
    * // result = 255n
    * CairoUint512.validate(-1);
    * // throws Error("bigNumberish is smaller than UINT_512_MIN.")
+   * CairoUint512.validate('abc');
+   * // throws Error("Invalid input: a u512 cannot be built from text")
+   * CairoUint512.validate(1.5);
+   * // throws Error("Invalid input: decimal numbers are not supported, only integers")
    * ```
    */
   static validate(bigNumberish) {
     assert(bigNumberish !== null, "null value is not allowed for u512");
     assert(bigNumberish !== void 0, "undefined value is not allowed for u512");
+    assert(!isText(bigNumberish), "Invalid input: a u512 cannot be built from text");
+    assert(!isEmptyHex(bigNumberish), "Invalid input: '0x' holds no hexadecimal digit");
     assert(
-      isBigNumberish(bigNumberish) || isObject(bigNumberish),
+      isBigNumberish(bigNumberish),
       `Unsupported data type '${typeof bigNumberish}' for u512. Expected a numeric string (decimal or hexadecimal), number, bigint, or Uint512 object`
     );
+    assert(
+      !isNumber(bigNumberish) || Number.isInteger(bigNumberish),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
     const bigInt = BigInt(bigNumberish);
     assert(bigInt >= UINT_512_MIN, "bigNumberish is smaller than UINT_512_MIN.");
     assert(bigInt <= UINT_512_MAX, "bigNumberish is bigger than UINT_512_MAX.");
@@ -3545,20 +3587,33 @@ var CairoUint512 = class _CairoUint512 {
    * @param {BigNumberish} limb2 bits 256 to 383
    * @param {BigNumberish} limb3 bits 384 to 511
    * @returns {{limb0: bigint, limb1: bigint, limb2: bigint, limb3: bigint}} the four limbs as numbers
-   * @throws {Error} when any limb is outside the u128 range
+   * @throws {Error} when any limb is null, undefined, text, `'0x'`, not a number, a decimal number, or outside the u128 range
    * @example
    * ```typescript
    * const result = CairoUint512.validateProps(7, 0, 0, 64);
    * // result = { limb0: 7n, limb1: 0n, limb2: 0n, limb3: 64n }
    * CairoUint512.validateProps(-1, 0, 0, 0);
    * // throws Error("limb0 is not in the range of a u128 number")
+   * CairoUint512.validateProps(1.5, 0, 0, 0);
+   * // throws Error("limb0 must be an integer")
+   * CairoUint512.validateProps('abc', 0, 0, 0);
+   * // throws Error("limb0 cannot be built from text")
    * ```
    */
   static validateProps(limb0, limb1, limb2, limb3) {
-    const l0 = BigInt(limb0);
-    const l1 = BigInt(limb1);
-    const l2 = BigInt(limb2);
-    const l3 = BigInt(limb3);
+    const validateLimb = (limb, name) => {
+      assert(limb !== null, `${name} cannot be null`);
+      assert(limb !== void 0, `${name} cannot be undefined`);
+      assert(!isText(limb), `${name} cannot be built from text`);
+      assert(!isEmptyHex(limb), `${name} cannot be '0x', which holds no hexadecimal digit`);
+      assert(isBigNumberish(limb), `${name} must be a BigNumberish`);
+      assert(!isNumber(limb) || Number.isInteger(limb), `${name} must be an integer`);
+      return BigInt(limb);
+    };
+    const l0 = validateLimb(limb0, "limb0");
+    const l1 = validateLimb(limb1, "limb1");
+    const l2 = validateLimb(limb2, "limb2");
+    const l3 = validateLimb(limb3, "limb3");
     [l0, l1, l2, l3].forEach((value, index) => {
       assert(
         value >= UINT_128_MIN && value <= UINT_128_MAX,
@@ -3730,7 +3785,7 @@ var CairoUint96 = class _CairoUint96 {
    * otherwise. Text therefore only fits here up to 12 ASCII characters : one more already
    * makes a number past 79228162514264337593543950335.
    * @param {BigNumberish | boolean} data the value to carry, within [0, 79228162514264337593543950335]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoUint96('abcdefghijkl').toApiRequest();
@@ -3818,11 +3873,11 @@ var CairoUint96 = class _CairoUint96 {
   /**
    * Throw unless the value can be carried by a u96.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [0, 79228162514264337593543950335]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [0, 79228162514264337593543950335]. A text string reaches
    * that last check as the number its bytes spell, so `'abcdefghijklm'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoUint96.validate(5000000000); // passes
@@ -3837,6 +3892,7 @@ var CairoUint96 = class _CairoUint96 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoUint96.__processData(data);
     assert(
       value >= RANGE_U96.min && value <= RANGE_U96.max,
@@ -4223,7 +4279,7 @@ var CairoUint8 = class _CairoUint8 {
    * otherwise. Text therefore only fits here while it is a single ASCII character : two characters
    * already make a number past 255.
    * @param {BigNumberish | boolean} data the value to carry, within [0, 255]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoUint8('a').toApiRequest();
@@ -4313,11 +4369,11 @@ var CairoUint8 = class _CairoUint8 {
   /**
    * Throw unless the value can be carried by a u8.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [0, 255]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [0, 255]. A text string reaches
    * that last check as the number its bytes spell, so `'ab'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoUint8.validate(44); // passes
@@ -4332,6 +4388,7 @@ var CairoUint8 = class _CairoUint8 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoUint8.__processData(data);
     assert(
       value >= RANGE_U8.min && value <= RANGE_U8.max,
@@ -4422,7 +4479,7 @@ var CairoUint16 = class _CairoUint16 {
    * otherwise. Text therefore only fits here up to 2 ASCII characters : one more already
    * makes a number past 65535.
    * @param {BigNumberish | boolean} data the value to carry, within [0, 65535]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoUint16('ab').toApiRequest();
@@ -4510,11 +4567,11 @@ var CairoUint16 = class _CairoUint16 {
   /**
    * Throw unless the value can be carried by a u16.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [0, 65535]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [0, 65535]. A text string reaches
    * that last check as the number its bytes spell, so `'abc'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoUint16.validate(300); // passes
@@ -4529,6 +4586,7 @@ var CairoUint16 = class _CairoUint16 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoUint16.__processData(data);
     assert(
       value >= RANGE_U16.min && value <= RANGE_U16.max,
@@ -4619,7 +4677,7 @@ var CairoUint64 = class _CairoUint64 {
    * otherwise. Text therefore only fits here up to 8 ASCII characters : one more already
    * makes a number past 18446744073709551615.
    * @param {BigNumberish | boolean} data the value to carry, within [0, 18446744073709551615]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoUint64('abcdefgh').toApiRequest();
@@ -4707,11 +4765,11 @@ var CairoUint64 = class _CairoUint64 {
   /**
    * Throw unless the value can be carried by a u64.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [0, 18446744073709551615]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [0, 18446744073709551615]. A text string reaches
    * that last check as the number its bytes spell, so `'abcdefghi'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoUint64.validate(5000000000); // passes
@@ -4726,6 +4784,7 @@ var CairoUint64 = class _CairoUint64 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoUint64.__processData(data);
     assert(
       value >= RANGE_U64.min && value <= RANGE_U64.max,
@@ -4816,7 +4875,7 @@ var CairoUint128 = class _CairoUint128 {
    * otherwise. Text therefore only fits here up to 16 ASCII characters : one more already
    * makes a number past 340282366920938463463374607431768211455.
    * @param {BigNumberish | boolean} data the value to carry, within [0, 340282366920938463463374607431768211455]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoUint128('abcdefghijklmnop').toApiRequest();
@@ -4904,11 +4963,11 @@ var CairoUint128 = class _CairoUint128 {
   /**
    * Throw unless the value can be carried by a u128.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [0, 340282366920938463463374607431768211455]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [0, 340282366920938463463374607431768211455]. A text string reaches
    * that last check as the number its bytes spell, so `'abcdefghijklmnopq'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoUint128.validate(5000000000); // passes
@@ -4923,6 +4982,7 @@ var CairoUint128 = class _CairoUint128 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoUint128.__processData(data);
     assert(
       value >= RANGE_U128.min && value <= RANGE_U128.max,
@@ -5009,15 +5069,17 @@ var CairoInt8 = class _CairoInt8 {
   /**
    * Build from a number, a string or a boolean, refusing anything out of the i8 range.
    *
-   * A string is read as a number when it spells one — decimal or hexadecimal — and as UTF-8 text
-   * otherwise. Text therefore only fits here up to a single ASCII character : one more already
-   * makes a number past 127.
+   * A string is read as a number when it spells one — decimal or hexadecimal, with or without a
+   * leading minus sign — and as UTF-8 text otherwise. Text therefore only fits here up to a single
+   * ASCII character : one more already makes a number past 127.
    * @param {BigNumberish | boolean} data the value to carry, within [-128, 127]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoInt8('a').toApiRequest();
    * // result = ["97"]
+   * const result2 = new CairoInt8('-5').toApiRequest();
+   * // result2 = ["3618502788666131213697322783095070105623107215331596699973092056135872020476"]
    * ```
    */
   constructor(data) {
@@ -5029,6 +5091,9 @@ var CairoInt8 = class _CairoInt8 {
    *
    * Nothing here refuses a value : `validate` is what reads this number and decides. So an input
    * far outside the i8 range comes back untouched rather than raising.
+   *
+   * A minus sign in front of a number makes it negative rather than text : `'-5'` and `'-0x5'` are
+   * both -5. This holds for the signed integers only — for any other type, such a string is text.
    * @param {BigNumberish | boolean} data the value to convert
    * @returns {bigint} the number the input spells, of whatever size
    * @example
@@ -5037,9 +5102,14 @@ var CairoInt8 = class _CairoInt8 {
    * // result = 97n
    * const result2 = CairoInt8.__processData('ab');
    * // result2 = 24930n     (past the i8 range, and returned all the same)
+   * const result3 = CairoInt8.__processData('-0x5');
+   * // result3 = -5n     (a negative number, not the text "-0x5")
    * ```
    */
   static __processData(data) {
+    if (isString(data) && data.startsWith("-") && isBigNumberish(data.slice(1))) {
+      return -BigInt(data.slice(1));
+    }
     if (isString(data) && isText(data)) {
       return utf8ToBigInt(data);
     }
@@ -5118,11 +5188,12 @@ var CairoInt8 = class _CairoInt8 {
   /**
    * Throw unless the value can be carried by an i8.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [-128, 127]. A text string reaches
-   * that last check as the number its bytes spell, so `'ab'` is refused for being out of range.
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [-128, 127]. A text string
+   * reaches that last check as the number its bytes spell, so `'ab'` is refused for being out of
+   * range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoInt8.validate(5); // passes
@@ -5137,6 +5208,7 @@ var CairoInt8 = class _CairoInt8 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoInt8.__processData(data);
     assert(
       value >= RANGE_I8.min && value <= RANGE_I8.max,
@@ -5227,15 +5299,17 @@ var CairoInt16 = class _CairoInt16 {
   /**
    * Build from a number, a string or a boolean, refusing anything out of the i16 range.
    *
-   * A string is read as a number when it spells one — decimal or hexadecimal — and as UTF-8 text
-   * otherwise. Text therefore only fits here up to 2 ASCII characters : one more already
-   * makes a number past 32767.
+   * A string is read as a number when it spells one — decimal or hexadecimal, with or without a
+   * leading minus sign — and as UTF-8 text otherwise. Text therefore only fits here up to 2 ASCII
+   * characters : one more already makes a number past 32767.
    * @param {BigNumberish | boolean} data the value to carry, within [-32768, 32767]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoInt16('ab').toApiRequest();
    * // result = ["24930"]
+   * const result2 = new CairoInt16('-5').toApiRequest();
+   * // result2 = ["3618502788666131213697322783095070105623107215331596699973092056135872020476"]
    * ```
    */
   constructor(data) {
@@ -5247,6 +5321,9 @@ var CairoInt16 = class _CairoInt16 {
    *
    * Nothing here refuses a value : `validate` is what reads this number and decides. So an input
    * far outside the i16 range comes back untouched rather than raising.
+   *
+   * A minus sign in front of a number makes it negative rather than text : `'-5'` and `'-0x5'` are
+   * both -5. This holds for the signed integers only — for any other type, such a string is text.
    * @param {BigNumberish | boolean} data the value to convert
    * @returns {bigint} the number the input spells, of whatever size
    * @example
@@ -5255,9 +5332,14 @@ var CairoInt16 = class _CairoInt16 {
    * // result = 24930n
    * const result2 = CairoInt16.__processData('abc');
    * // result2 = 6382179n     (past the i16 range, and returned all the same)
+   * const result3 = CairoInt16.__processData('-0x5');
+   * // result3 = -5n     (a negative number, not the text "-0x5")
    * ```
    */
   static __processData(data) {
+    if (isString(data) && data.startsWith("-") && isBigNumberish(data.slice(1))) {
+      return -BigInt(data.slice(1));
+    }
     if (isString(data) && isText(data)) {
       return utf8ToBigInt(data);
     }
@@ -5336,11 +5418,11 @@ var CairoInt16 = class _CairoInt16 {
   /**
    * Throw unless the value can be carried by an i16.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [-32768, 32767]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [-32768, 32767]. A text string reaches
    * that last check as the number its bytes spell, so `'abc'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoInt16.validate(300); // passes
@@ -5355,6 +5437,7 @@ var CairoInt16 = class _CairoInt16 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoInt16.__processData(data);
     assert(
       value >= RANGE_I16.min && value <= RANGE_I16.max,
@@ -5445,15 +5528,17 @@ var CairoInt32 = class _CairoInt32 {
   /**
    * Build from a number, a string or a boolean, refusing anything out of the i32 range.
    *
-   * A string is read as a number when it spells one — decimal or hexadecimal — and as UTF-8 text
-   * otherwise. Text therefore only fits here up to 4 ASCII characters : one more already
-   * makes a number past 2147483647.
+   * A string is read as a number when it spells one — decimal or hexadecimal, with or without a
+   * leading minus sign — and as UTF-8 text otherwise. Text therefore only fits here up to 4 ASCII
+   * characters : one more already makes a number past 2147483647.
    * @param {BigNumberish | boolean} data the value to carry, within [-2147483648, 2147483647]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoInt32('abcd').toApiRequest();
    * // result = ["1633837924"]
+   * const result2 = new CairoInt32('-5').toApiRequest();
+   * // result2 = ["3618502788666131213697322783095070105623107215331596699973092056135872020476"]
    * ```
    */
   constructor(data) {
@@ -5465,6 +5550,9 @@ var CairoInt32 = class _CairoInt32 {
    *
    * Nothing here refuses a value : `validate` is what reads this number and decides. So an input
    * far outside the i32 range comes back untouched rather than raising.
+   *
+   * A minus sign in front of a number makes it negative rather than text : `'-5'` and `'-0x5'` are
+   * both -5. This holds for the signed integers only — for any other type, such a string is text.
    * @param {BigNumberish | boolean} data the value to convert
    * @returns {bigint} the number the input spells, of whatever size
    * @example
@@ -5473,9 +5561,14 @@ var CairoInt32 = class _CairoInt32 {
    * // result = 1633837924n
    * const result2 = CairoInt32.__processData('abcde');
    * // result2 = 418262508645n     (past the i32 range, and returned all the same)
+   * const result3 = CairoInt32.__processData('-0x5');
+   * // result3 = -5n     (a negative number, not the text "-0x5")
    * ```
    */
   static __processData(data) {
+    if (isString(data) && data.startsWith("-") && isBigNumberish(data.slice(1))) {
+      return -BigInt(data.slice(1));
+    }
     if (isString(data) && isText(data)) {
       return utf8ToBigInt(data);
     }
@@ -5554,11 +5647,11 @@ var CairoInt32 = class _CairoInt32 {
   /**
    * Throw unless the value can be carried by an i32.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [-2147483648, 2147483647]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [-2147483648, 2147483647]. A text string reaches
    * that last check as the number its bytes spell, so `'abcde'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoInt32.validate(70000); // passes
@@ -5573,6 +5666,7 @@ var CairoInt32 = class _CairoInt32 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoInt32.__processData(data);
     assert(
       value >= RANGE_I32.min && value <= RANGE_I32.max,
@@ -5663,15 +5757,17 @@ var CairoInt64 = class _CairoInt64 {
   /**
    * Build from a number, a string or a boolean, refusing anything out of the i64 range.
    *
-   * A string is read as a number when it spells one — decimal or hexadecimal — and as UTF-8 text
-   * otherwise. Text therefore only fits here up to 8 ASCII characters : one more already
-   * makes a number past 9223372036854775807.
+   * A string is read as a number when it spells one — decimal or hexadecimal, with or without a
+   * leading minus sign — and as UTF-8 text otherwise. Text therefore only fits here up to 8 ASCII
+   * characters : one more already makes a number past 9223372036854775807.
    * @param {BigNumberish | boolean} data the value to carry, within [-9223372036854775808, 9223372036854775807]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoInt64('abcdefgh').toApiRequest();
    * // result = ["7017280452245743464"]
+   * const result2 = new CairoInt64('-5').toApiRequest();
+   * // result2 = ["3618502788666131213697322783095070105623107215331596699973092056135872020476"]
    * ```
    */
   constructor(data) {
@@ -5683,6 +5779,9 @@ var CairoInt64 = class _CairoInt64 {
    *
    * Nothing here refuses a value : `validate` is what reads this number and decides. So an input
    * far outside the i64 range comes back untouched rather than raising.
+   *
+   * A minus sign in front of a number makes it negative rather than text : `'-5'` and `'-0x5'` are
+   * both -5. This holds for the signed integers only — for any other type, such a string is text.
    * @param {BigNumberish | boolean} data the value to convert
    * @returns {bigint} the number the input spells, of whatever size
    * @example
@@ -5691,9 +5790,14 @@ var CairoInt64 = class _CairoInt64 {
    * // result = 7017280452245743464n
    * const result2 = CairoInt64.__processData('abcdefghi');
    * // result2 = 1796423795774910326889n     (past the i64 range, and returned all the same)
+   * const result3 = CairoInt64.__processData('-0x5');
+   * // result3 = -5n     (a negative number, not the text "-0x5")
    * ```
    */
   static __processData(data) {
+    if (isString(data) && data.startsWith("-") && isBigNumberish(data.slice(1))) {
+      return -BigInt(data.slice(1));
+    }
     if (isString(data) && isText(data)) {
       return utf8ToBigInt(data);
     }
@@ -5772,11 +5876,11 @@ var CairoInt64 = class _CairoInt64 {
   /**
    * Throw unless the value can be carried by an i64.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [-9223372036854775808, 9223372036854775807]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [-9223372036854775808, 9223372036854775807]. A text string reaches
    * that last check as the number its bytes spell, so `'abcdefghi'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoInt64.validate(5000000000); // passes
@@ -5791,6 +5895,7 @@ var CairoInt64 = class _CairoInt64 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoInt64.__processData(data);
     assert(
       value >= RANGE_I64.min && value <= RANGE_I64.max,
@@ -5881,15 +5986,17 @@ var CairoInt128 = class _CairoInt128 {
   /**
    * Build from a number, a string or a boolean, refusing anything out of the i128 range.
    *
-   * A string is read as a number when it spells one — decimal or hexadecimal — and as UTF-8 text
-   * otherwise. Text therefore only fits here up to 16 ASCII characters : one more already
-   * makes a number past 170141183460469231731687303715884105727.
+   * A string is read as a number when it spells one — decimal or hexadecimal, with or without a
+   * leading minus sign — and as UTF-8 text otherwise. Text therefore only fits here up to 16 ASCII
+   * characters : one more already makes a number past 170141183460469231731687303715884105727.
    * @param {BigNumberish | boolean} data the value to carry, within [-170141183460469231731687303715884105728, 170141183460469231731687303715884105727]
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * const result = new CairoInt128('abcdefghijklmnop').toApiRequest();
    * // result = ["129445976596022050476432668810952994672"]
+   * const result2 = new CairoInt128('-5').toApiRequest();
+   * // result2 = ["3618502788666131213697322783095070105623107215331596699973092056135872020476"]
    * ```
    */
   constructor(data) {
@@ -5901,6 +6008,9 @@ var CairoInt128 = class _CairoInt128 {
    *
    * Nothing here refuses a value : `validate` is what reads this number and decides. So an input
    * far outside the i128 range comes back untouched rather than raising.
+   *
+   * A minus sign in front of a number makes it negative rather than text : `'-5'` and `'-0x5'` are
+   * both -5. This holds for the signed integers only — for any other type, such a string is text.
    * @param {BigNumberish | boolean} data the value to convert
    * @returns {bigint} the number the input spells, of whatever size
    * @example
@@ -5909,9 +6019,14 @@ var CairoInt128 = class _CairoInt128 {
    * // result = 129445976596022050476432668810952994672n
    * const result2 = CairoInt128.__processData('abcdefghijklmnopq');
    * // result2 = 33138170008581644921966763215603966636145n     (past the i128 range, and returned all the same)
+   * const result3 = CairoInt128.__processData('-0x5');
+   * // result3 = -5n     (a negative number, not the text "-0x5")
    * ```
    */
   static __processData(data) {
+    if (isString(data) && data.startsWith("-") && isBigNumberish(data.slice(1))) {
+      return -BigInt(data.slice(1));
+    }
     if (isString(data) && isText(data)) {
       return utf8ToBigInt(data);
     }
@@ -5990,11 +6105,11 @@ var CairoInt128 = class _CairoInt128 {
   /**
    * Throw unless the value can be carried by an i128.
    *
-   * Four things are refused, each with its own message : a null or undefined value, an object or
-   * an array, a number with a decimal part, and a value outside [-170141183460469231731687303715884105728, 170141183460469231731687303715884105727]. A text string reaches
+   * Five things are refused, each with its own message : a null or undefined value, an object or
+   * an array, a number with a decimal part, `'0x'`, and a value outside [-170141183460469231731687303715884105728, 170141183460469231731687303715884105727]. A text string reaches
    * that last check as the number its bytes spell, so `'abcdefghijklmnopq'` is refused for being out of range.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is null, undefined, an object, a decimal number, or out of range
+   * @throws {Error} when the value is null, undefined, an object, a decimal number, `'0x'`, or out of range
    * @example
    * ```typescript
    * CairoInt128.validate(5000000000); // passes
@@ -6009,6 +6124,7 @@ var CairoInt128 = class _CairoInt128 {
       !isNumber(data) || Number.isInteger(data),
       "Invalid input: decimal numbers are not supported, only integers"
     );
+    assert(!isEmptyHex(data), "Invalid input: '0x' holds no hexadecimal digit");
     const value = _CairoInt128.__processData(data);
     assert(
       value >= RANGE_I128.min && value <= RANGE_I128.max,
@@ -6099,7 +6215,7 @@ var CairoBool = class _CairoBool {
   /**
    * Build from a boolean, or from the numbers 0 and 1.
    * @param {BigNumberish | boolean} data the value to carry : a boolean, 0 or 1
-   * @throws {Error} when the value is text, is not a felt252 input, or is a number other than 0 or 1
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or a number other than 0 or 1
    * @example
    * ```typescript
    * const result = new CairoBool(false).toApiRequest();
@@ -6172,21 +6288,28 @@ var CairoBool = class _CairoBool {
   /**
    * Throw unless the value can be carried by a bool.
    *
-   * Text is refused first, then the value is read as a felt252 — which is what refuses a null, an
-   * object or an unsupported type — and finally checked to be one of the only two numbers a bool
-   * can hold.
+   * Text is refused first, then a number with a decimal part. A number or a bigint is read as it
+   * is, so that a negative one reaches the last check. Anything else is read as a felt252 — which
+   * is what refuses a null, an object or an unsupported type. The value is finally checked to be
+   * one of the only two numbers a bool can hold.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is text, is not a felt252 input, or is a number other than 0 or 1
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or a number other than 0 or 1
    * @example
    * ```typescript
    * CairoBool.validate(true); // passes
    * CairoBool.validate(2);
    * // throws Error("Only values 0 or 1 are possible in a core::bool, received 2")
+   * CairoBool.validate(-1);
+   * // throws Error("Only values 0 or 1 are possible in a core::bool, received -1")
    * ```
    */
   static validate(data) {
     assert(!isText(data), "Invalid input: a core::bool cannot be built from text");
-    const value = new CairoFelt252(data).toBigInt();
+    assert(
+      !isNumber(data) || Number.isInteger(data),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
+    const value = isNumber(data) || isBigInt(data) ? BigInt(data) : new CairoFelt252(data).toBigInt();
     assert(
       value === 0n || value === 1n,
       `Only values 0 or 1 are possible in a core::bool, received ${value}`
@@ -6301,7 +6424,9 @@ var CairoSecp256k1Point = class _CairoSecp256k1Point {
   /**
    * @param {any[]} arr either one value — a 512-bit number or a {@link Secp256k1PointStruct} — or
    * the four limbs
-   * @throws {Error} when a value is out of range, or when the argument count is neither 1 nor 4
+   * @throws {Error} when a value is null, undefined, of an unread type, text, a decimal number, or out
+   * of range — see {@link CairoSecp256k1Point.validate} and {@link CairoSecp256k1Point.validateProps}
+   * — or when the argument count is neither 1 nor 4
    * @example
    * ```typescript
    * const result = new CairoSecp256k1Point(1n).toApiRequest();
@@ -6348,22 +6473,32 @@ var CairoSecp256k1Point = class _CairoSecp256k1Point {
    * the constructor needs it, and computing it twice would mean splitting a 512-bit value twice.
    * @param {BigNumberish} input the 512-bit value to check
    * @returns {bigint} the value, once checked
-   * @throws {Error} when the value is null, undefined, of an unread type, or outside [0, 2^512 - 1]
+   * @throws {Error} when the value is null, undefined, text, `'0x'`, of an unread type, a decimal number, or outside [0, 2^512 - 1]
    * @example
    * ```typescript
    * const result = CairoSecp256k1Point.validate('0x1234');
    * // result = 4660n
    * CairoSecp256k1Point.validate(SECP256K1_POINT_MAX + 1n);
    * // throws Error("input is bigger than SECP256K1_POINT_MAX")
+   * CairoSecp256k1Point.validate('abc');
+   * // throws Error("Invalid input: a Secp256k1Point cannot be built from text")
+   * CairoSecp256k1Point.validate(1.5);
+   * // throws Error("Invalid input: decimal numbers are not supported, only integers")
    * ```
    */
   static validate(input) {
     assert(input !== null, "null value is not allowed for Secp256k1Point");
     assert(input !== void 0, "undefined value is not allowed for Secp256k1Point");
+    assert(!isText(input), "Invalid input: a Secp256k1Point cannot be built from text");
+    assert(!isEmptyHex(input), "Invalid input: '0x' holds no hexadecimal digit");
     assert(
       isBigNumberish(input),
       `Unsupported input for Secp256k1Point. Expected a number, a bigint, or a string spelling one, received '${typeof input}'`
     );
+    assert(
+      !isNumber(input) || Number.isInteger(input),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
     const bigInt = BigInt(input);
     assert(bigInt >= SECP256K1_POINT_MIN, "input is smaller than SECP256K1_POINT_MIN");
     assert(bigInt <= SECP256K1_POINT_MAX, "input is bigger than SECP256K1_POINT_MAX");
@@ -6376,20 +6511,27 @@ var CairoSecp256k1Point = class _CairoSecp256k1Point {
    * @param {BigNumberish} yLow the low 128 bits of y
    * @param {BigNumberish} yHigh the high 128 bits of y
    * @returns {{xLow: bigint, xHigh: bigint, yLow: bigint, yHigh: bigint}} the four limbs, checked
-   * @throws {Error} when a limb is null, undefined, not a number, negative, or wider than 128 bits
+   * @throws {Error} when a limb is null, undefined, text, `'0x'`, not a number, a decimal number, negative, or wider than 128 bits
    * @example
    * ```typescript
    * const result = CairoSecp256k1Point.validateProps(1, 2, 3, 4);
    * // result = { xLow: 1n, xHigh: 2n, yLow: 3n, yHigh: 4n }
    * CairoSecp256k1Point.validateProps(1, 2, 3, 2n ** 128n);
    * // throws Error("yHigh must fit in 128 bits")
+   * CairoSecp256k1Point.validateProps(1.5, 2, 3, 4);
+   * // throws Error("xLow must be an integer")
+   * CairoSecp256k1Point.validateProps('abc', 2, 3, 4);
+   * // throws Error("xLow cannot be built from text")
    * ```
    */
   static validateProps(xLow, xHigh, yLow, yHigh) {
     const validateLimb = (limb, name) => {
       assert(limb !== null, `${name} cannot be null`);
       assert(limb !== void 0, `${name} cannot be undefined`);
+      assert(!isText(limb), `${name} cannot be built from text`);
+      assert(!isEmptyHex(limb), `${name} cannot be '0x', which holds no hexadecimal digit`);
       assert(isBigNumberish(limb), `${name} must be a BigNumberish`);
+      assert(!isNumber(limb) || Number.isInteger(limb), `${name} must be an integer`);
       const bigInt = BigInt(limb);
       assert(bigInt >= 0n, `${name} must be non-negative`);
       assert(bigInt <= UINT_128_MAX, `${name} must fit in 128 bits`);
@@ -7532,9 +7674,9 @@ var CairoClassHash = class _CairoClassHash {
    */
   static abiSelector = Literal.ClassHash;
   /**
-   * Build from a number or a numeric string, refusing text and anything wider than 252 bits.
-   * @param {BigNumberish | boolean} data the hash to carry, within [0, 2^252 - 1]
-   * @throws {Error} when the value is text, is not a felt252 input, or is out of the ClassHash range
+   * Build from a number or a numeric string, refusing text and anything outside the ClassHash range.
+   * @param {BigNumberish | boolean} data the hash to carry, within [0, 2^251 - 1]
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of the ClassHash range
    * @example
    * ```typescript
    * const result = new CairoClassHash('0x1234').toApiRequest();
@@ -7589,21 +7731,34 @@ var CairoClassHash = class _CairoClassHash {
   /**
    * Throw unless the value can be carried by a ClassHash.
    *
-   * Text is refused first, then the value is read as a felt252 — which is what refuses a null, an
-   * object or an unsupported type, and what bounds the value. There is no narrower bound to add:
-   * a class hash is a hash output, so any field element is one.
+   * Text is refused first, then a number with a decimal part. A number or a bigint is read as it
+   * is, so that a negative one reaches the range check. Anything else is read as a felt252 — which
+   * is what refuses a null, an object or an unsupported type. The value is finally checked against
+   * the range of the Cairo `ClassHash` type, [0, 2^251), which is narrower than the field.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is text, is not a felt252 input, or is outside the field
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of the ClassHash range
    * @example
    * ```typescript
    * CairoClassHash.validate('0x1234'); // passes
    * CairoClassHash.validate('abc');
    * // throws Error("Invalid input: a ClassHash cannot be built from text")
+   * CairoClassHash.validate(2n ** 251n);
+   * // throws Error("Value is out of ClassHash range [0, 3618502788666131106986593281521497120414687020801267626233049500247285301247]")
+   * CairoClassHash.validate(-1);
+   * // throws Error("Value is out of ClassHash range [0, 3618502788666131106986593281521497120414687020801267626233049500247285301247]")
    * ```
    */
   static validate(data) {
     assert(!isText(data), "Invalid input: a ClassHash cannot be built from text");
-    CairoFelt252.validate(data);
+    assert(
+      !isNumber(data) || Number.isInteger(data),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
+    const value = isNumber(data) || isBigInt(data) ? BigInt(data) : new CairoFelt252(data).toBigInt();
+    assert(
+      value >= RANGE_CLASS_HASH.min && value <= RANGE_CLASS_HASH.max,
+      `Value is out of ClassHash range [${RANGE_CLASS_HASH.min}, ${RANGE_CLASS_HASH.max}]`
+    );
   }
   /**
    * Can this value be carried by a ClassHash?
@@ -7682,7 +7837,7 @@ var CairoContractAddress = class _CairoContractAddress {
   /**
    * Build from a number or a numeric string, refusing text and anything wider than 252 bits.
    * @param {BigNumberish | boolean} data the address to carry, within [0, 2^252 - 1]
-   * @throws {Error} when the value is text, is not a felt252 input, or is out of range
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of range
    * @example
    * ```typescript
    * const result = new CairoContractAddress('0x1234').toApiRequest();
@@ -7737,11 +7892,12 @@ var CairoContractAddress = class _CairoContractAddress {
   /**
    * Throw unless the value can be carried by a ContractAddress.
    *
-   * Text is refused first, then the value is read as a felt252 — which is what refuses a null, an
-   * object or an unsupported type — and finally checked against the bound an address has, which
-   * is narrower than the field.
+   * Text is refused first, then a number with a decimal part. A number or a bigint is read as it
+   * is, so that a negative one reaches the range check. Anything else is read as a felt252 — which
+   * is what refuses a null, an object or an unsupported type. The value is finally checked against
+   * the bound an address has, which is narrower than the field.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is text, is not a felt252 input, or is out of range
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of range
    * @example
    * ```typescript
    * CairoContractAddress.validate('0x1234'); // passes
@@ -7749,11 +7905,17 @@ var CairoContractAddress = class _CairoContractAddress {
    * // throws Error("Invalid input: a ContractAddress cannot be built from text")
    * CairoContractAddress.validate(2n ** 251n);
    * // throws Error("Value is out of ContractAddress range [0, 3618502788666131106986593281521497120414687020801267626233049500247285300991]")
+   * CairoContractAddress.validate(-1);
+   * // throws Error("Value is out of ContractAddress range [0, 3618502788666131106986593281521497120414687020801267626233049500247285300991]")
    * ```
    */
   static validate(data) {
     assert(!isText(data), "Invalid input: a ContractAddress cannot be built from text");
-    const value = new CairoFelt252(data).toBigInt();
+    assert(
+      !isNumber(data) || Number.isInteger(data),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
+    const value = isNumber(data) || isBigInt(data) ? BigInt(data) : new CairoFelt252(data).toBigInt();
     assert(
       value >= RANGE_CONTRACT_ADDRESS.min && value <= RANGE_CONTRACT_ADDRESS.max,
       `Value is out of ContractAddress range [${RANGE_CONTRACT_ADDRESS.min}, ${RANGE_CONTRACT_ADDRESS.max}]`
@@ -7838,7 +8000,7 @@ var CairoEthAddress = class _CairoEthAddress {
   /**
    * Build from a number or a numeric string, refusing text and anything wider than 160 bits.
    * @param {BigNumberish | boolean} data the address to carry, within [0, 2^160 - 1]
-   * @throws {Error} when the value is text, is not a felt252 input, or is out of the EthAddress range
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of the EthAddress range
    * @example
    * ```typescript
    * const result = new CairoEthAddress('0x1234').toApiRequest();
@@ -7894,10 +8056,12 @@ var CairoEthAddress = class _CairoEthAddress {
    * Throw unless the value can be carried by an EthAddress.
    *
    * Text is refused first, since an address spelled as words is a mistake rather than a value to
-   * encode. What remains is read as a felt252 — which is what refuses a null, an object or an
-   * unsupported type — then checked against the 160 bits an Ethereum address occupies.
+   * encode, then a number with a decimal part. A number or a bigint is read as it is, so that a
+   * negative one reaches the range check below. Anything else is read as a felt252 — which is what
+   * refuses a null, an object or an unsupported type. The value is finally checked against the 160
+   * bits an Ethereum address occupies.
    * @param {BigNumberish | boolean} data the value to check
-   * @throws {Error} when the value is text, is not a felt252 input, or is out of the EthAddress range
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of the EthAddress range
    * @example
    * ```typescript
    * CairoEthAddress.validate('0x1234'); // passes
@@ -7905,11 +8069,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}]`
@@ -8584,7 +8754,13 @@ var CairoTypeOption = class _CairoTypeOption {
    * 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
@@ -8595,11 +8771,11 @@ var CairoTypeOption = class _CairoTypeOption {
    * @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>';
@@ -8644,6 +8820,10 @@ var CairoTypeOption = class _CairoTypeOption {
       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;
@@ -11105,11 +11285,17 @@ function errorU512(key) {
     `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);
     }
@@ -11222,14 +11408,8 @@ function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
   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,
@@ -11243,10 +11423,7 @@ function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
     }
     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,
@@ -11261,10 +11438,7 @@ function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
       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;
       }
@@ -13626,7 +13800,7 @@ function ethRandomPrivateKey() {
   return sanitizeHex(buf2hex(import_secp256k1.secp256k1.utils.randomSecretKey()));
 }
 function validateAndParseEthAddress(address) {
-  assertInRange(address, ZERO, 2n ** 160n - 1n, "Ethereum Address ");
+  assertInRange(address, ZERO, 2n ** 160n - 1n, "Ethereum Address");
   const result = addHexPrefix(removeHexPrefix(toHex(address)).padStart(40, "0"));
   assert(Boolean(result.match(/^(0x)?[0-9a-f]{40}$/)), "Invalid Ethereum Address Format");
   return result;
@@ -17780,6 +17954,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");