starknet 11.0.1 → 11.0.2

package/dist/index.d.ts

@@ -615,6 +615,21 @@ declare const BlockTag: {
 type WeierstrassSignatureType = weierstrass.ECDSASignature;
 type ArraySignatureType = string[];
 type Signature = ArraySignatureType | WeierstrassSignatureType;
+/**
+ * A number, in any of the three forms JavaScript carries one : a `number`, a `bigint`, or a
+ * `string` spelling it in decimal or in `0x` hexadecimal.
+ *
+ * The type itself accepts any string ; `num.isBigNumberish` is the check made at runtime. A number
+ * or a bigint may be negative, whereas a string is unsigned : `'-1'` is text to the library, except
+ * for the signed integer types `i8` to `i128`, which read it as -1.
+ * @example
+ * ```typescript
+ * const decimals: BigNumberish = 18;
+ * const amount: BigNumberish = 10n ** 18n;
+ * // the selector of balanceOf
+ * const selector: BigNumberish = '0x2e4263afad30923c891518314c3c95dbe830a16874e8abc5777a9a20b54c76e';
+ * ```
+ */
 type BigNumberish = string | number | bigint;
 type ByteArray = {
     data: BigNumberish[];
@@ -4167,7 +4182,7 @@ declare 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();
@@ -4226,16 +4241,19 @@ declare 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: BigNumberish | boolean | unknown): void;
@@ -4378,7 +4396,7 @@ declare class CairoUint512 {
      * A `Uint512` object is accepted here too : it already carries the four limbs, and each is
      * checked as a u128 rather than the whole being cut again.
      * @param {BigNumberish | Uint512} bigNumberish the value to carry, within [0, 2^512 - 1]
-     * @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 = new CairoUint512(255).toApiRequest();
@@ -4392,7 +4410,7 @@ declare class CairoUint512 {
      * @param {BigNumberish} limb1 bits 128 to 255
      * @param {BigNumberish} limb2 bits 256 to 383
      * @param {BigNumberish} limb3 bits 384 to 511
-     * @throws {Error} when any limb is out of 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 = new CairoUint512(7, 0, 0, 64).toBigInt() === 2n ** 390n + 7n;
@@ -4404,16 +4422,22 @@ declare 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: BigNumberish | unknown): bigint;
@@ -4427,13 +4451,17 @@ declare 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: BigNumberish, limb1: BigNumberish, limb2: BigNumberish, limb3: BigNumberish): {
@@ -4582,7 +4610,7 @@ declare 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();
@@ -4656,11 +4684,11 @@ declare 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
@@ -4760,7 +4788,7 @@ declare 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();
@@ -4832,11 +4860,11 @@ declare 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
@@ -4936,7 +4964,7 @@ declare 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();
@@ -5008,11 +5036,11 @@ declare 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
@@ -5112,7 +5140,7 @@ declare 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();
@@ -5184,11 +5212,11 @@ declare 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
@@ -5301,7 +5329,7 @@ declare 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();
@@ -5373,11 +5401,11 @@ declare 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
@@ -5484,7 +5512,7 @@ declare 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();
@@ -5556,11 +5584,11 @@ declare 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
@@ -5622,6 +5650,10 @@ declare class CairoUint128 {
  * `'97'` and `'0x61'` give the same i8. A string that reads as text rather than as a
  * number is taken for its UTF-8 bytes, which is why `'a'` is 97 and not a rejected input.
  *
+ * A minus sign in front of a number is read as a sign, not as text : `'-5'` is -5, as `-5` and
+ * `-5n` are. Only the signed integers read a string this way — for every other type, `'-5'` is
+ * text, encoded or refused as such.
+ *
  * An already built instance is **not** an accepted input : handed back to the constructor it is
  * seen as an object and refused. Inside the library it is `unwrapCairoScalar` that reduces an
  * instance to its number before an abi slot receives it.
@@ -5632,6 +5664,11 @@ declare class CairoUint128 {
  * new CairoInt8('97').toBigInt(); //   97n
  * new CairoInt8('0x61').toBigInt(); // 97n
  * new CairoInt8('a').toBigInt(); //    97n     the UTF-8 bytes of the text
+ *
+ * // a negative value, reached three ways
+ * new CairoInt8(-5).toBigInt(); //     -5n
+ * new CairoInt8('-5').toBigInt(); //   -5n
+ * new CairoInt8('-0x5').toBigInt(); // -5n     a sign, not the text "-0x5"
  * ```
  */
 declare class CairoInt8 {
@@ -5656,15 +5693,17 @@ declare 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: BigNumberish | boolean | unknown);
@@ -5673,6 +5712,9 @@ declare 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
@@ -5681,6 +5723,8 @@ declare 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: BigNumberish | boolean | unknown): bigint;
@@ -5742,11 +5786,12 @@ declare 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
@@ -5809,6 +5854,10 @@ declare class CairoInt8 {
  * `'24930'` and `'0x6162'` give the same i16. A string that reads as text rather than as a
  * number is taken for its UTF-8 bytes, which is why `'ab'` is 24930 and not a rejected input.
  *
+ * A minus sign in front of a number is read as a sign, not as text : `'-5'` is -5, as `-5` and
+ * `-5n` are. Only the signed integers read a string this way — for every other type, `'-5'` is
+ * text, encoded or refused as such.
+ *
  * An already built instance is **not** an accepted input : handed back to the constructor it is
  * seen as an object and refused. Inside the library it is `unwrapCairoScalar` that reduces an
  * instance to its number before an abi slot receives it.
@@ -5819,6 +5868,11 @@ declare class CairoInt8 {
  * new CairoInt16('24930').toBigInt(); //   24930n
  * new CairoInt16('0x6162').toBigInt(); // 24930n
  * new CairoInt16('ab').toBigInt(); //    24930n     the UTF-8 bytes of the text
+ *
+ * // a negative value, reached three ways
+ * new CairoInt16(-5).toBigInt(); //     -5n
+ * new CairoInt16('-5').toBigInt(); //   -5n
+ * new CairoInt16('-0x5').toBigInt(); // -5n     a sign, not the text "-0x5"
  * ```
  */
 declare class CairoInt16 {
@@ -5843,15 +5897,17 @@ declare 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: BigNumberish | boolean | unknown);
@@ -5860,6 +5916,9 @@ declare 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
@@ -5868,6 +5927,8 @@ declare 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: BigNumberish | boolean | unknown): bigint;
@@ -5929,11 +5990,11 @@ declare 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
@@ -5996,6 +6057,10 @@ declare class CairoInt16 {
  * `'1633837924'` and `'0x61626364'` give the same i32. A string that reads as text rather than as a
  * number is taken for its UTF-8 bytes, which is why `'abcd'` is 1633837924 and not a rejected input.
  *
+ * A minus sign in front of a number is read as a sign, not as text : `'-5'` is -5, as `-5` and
+ * `-5n` are. Only the signed integers read a string this way — for every other type, `'-5'` is
+ * text, encoded or refused as such.
+ *
  * An already built instance is **not** an accepted input : handed back to the constructor it is
  * seen as an object and refused. Inside the library it is `unwrapCairoScalar` that reduces an
  * instance to its number before an abi slot receives it.
@@ -6006,6 +6071,11 @@ declare class CairoInt16 {
  * new CairoInt32('1633837924').toBigInt(); //   1633837924n
  * new CairoInt32('0x61626364').toBigInt(); // 1633837924n
  * new CairoInt32('abcd').toBigInt(); //    1633837924n     the UTF-8 bytes of the text
+ *
+ * // a negative value, reached three ways
+ * new CairoInt32(-5).toBigInt(); //     -5n
+ * new CairoInt32('-5').toBigInt(); //   -5n
+ * new CairoInt32('-0x5').toBigInt(); // -5n     a sign, not the text "-0x5"
  * ```
  */
 declare class CairoInt32 {
@@ -6030,15 +6100,17 @@ declare 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: BigNumberish | boolean | unknown);
@@ -6047,6 +6119,9 @@ declare 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
@@ -6055,6 +6130,8 @@ declare 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: BigNumberish | boolean | unknown): bigint;
@@ -6116,11 +6193,11 @@ declare 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
@@ -6183,6 +6260,10 @@ declare class CairoInt32 {
  * `'7017280452245743464'` and `'0x6162636465666768'` give the same i64. A string that reads as text rather than as a
  * number is taken for its UTF-8 bytes, which is why `'abcdefgh'` is 7017280452245743464 and not a rejected input.
  *
+ * A minus sign in front of a number is read as a sign, not as text : `'-5'` is -5, as `-5` and
+ * `-5n` are. Only the signed integers read a string this way — for every other type, `'-5'` is
+ * text, encoded or refused as such.
+ *
  * An already built instance is **not** an accepted input : handed back to the constructor it is
  * seen as an object and refused. Inside the library it is `unwrapCairoScalar` that reduces an
  * instance to its number before an abi slot receives it.
@@ -6193,6 +6274,11 @@ declare class CairoInt32 {
  * new CairoInt64('7017280452245743464').toBigInt(); //   7017280452245743464n
  * new CairoInt64('0x6162636465666768').toBigInt(); // 7017280452245743464n
  * new CairoInt64('abcdefgh').toBigInt(); //    7017280452245743464n     the UTF-8 bytes of the text
+ *
+ * // a negative value, reached three ways
+ * new CairoInt64(-5).toBigInt(); //     -5n
+ * new CairoInt64('-5').toBigInt(); //   -5n
+ * new CairoInt64('-0x5').toBigInt(); // -5n     a sign, not the text "-0x5"
  * ```
  */
 declare class CairoInt64 {
@@ -6217,15 +6303,17 @@ declare 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: BigNumberish | boolean | unknown);
@@ -6234,6 +6322,9 @@ declare 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
@@ -6242,6 +6333,8 @@ declare 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: BigNumberish | boolean | unknown): bigint;
@@ -6303,11 +6396,11 @@ declare 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
@@ -6370,6 +6463,10 @@ declare class CairoInt64 {
  * `'129445976596022050476432668810952994672'` and `'0x6162636465666768696a6b6c6d6e6f70'` give the same i128. A string that reads as text rather than as a
  * number is taken for its UTF-8 bytes, which is why `'abcdefghijklmnop'` is 129445976596022050476432668810952994672 and not a rejected input.
  *
+ * A minus sign in front of a number is read as a sign, not as text : `'-5'` is -5, as `-5` and
+ * `-5n` are. Only the signed integers read a string this way — for every other type, `'-5'` is
+ * text, encoded or refused as such.
+ *
  * An already built instance is **not** an accepted input : handed back to the constructor it is
  * seen as an object and refused. Inside the library it is `unwrapCairoScalar` that reduces an
  * instance to its number before an abi slot receives it.
@@ -6380,6 +6477,11 @@ declare class CairoInt64 {
  * new CairoInt128('129445976596022050476432668810952994672').toBigInt(); //   129445976596022050476432668810952994672n
  * new CairoInt128('0x6162636465666768696a6b6c6d6e6f70').toBigInt(); // 129445976596022050476432668810952994672n
  * new CairoInt128('abcdefghijklmnop').toBigInt(); //    129445976596022050476432668810952994672n     the UTF-8 bytes of the text
+ *
+ * // a negative value, reached three ways
+ * new CairoInt128(-5).toBigInt(); //     -5n
+ * new CairoInt128('-5').toBigInt(); //   -5n
+ * new CairoInt128('-0x5').toBigInt(); // -5n     a sign, not the text "-0x5"
  * ```
  */
 declare class CairoInt128 {
@@ -6404,15 +6506,17 @@ declare 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: BigNumberish | boolean | unknown);
@@ -6421,6 +6525,9 @@ declare 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
@@ -6429,6 +6536,8 @@ declare 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: BigNumberish | boolean | unknown): bigint;
@@ -6490,11 +6599,11 @@ declare 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
@@ -7973,6 +8082,10 @@ declare const RANGE_CONTRACT_ADDRESS: {
     readonly min: bigint;
     readonly max: bigint;
 };
+declare const RANGE_CLASS_HASH: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
 declare const LegacyUDC: {
     readonly ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf";
     readonly ENTRYPOINT: "deployContract";
@@ -8113,6 +8226,7 @@ declare const constants_MAX_STORAGE_ITEM_SIZE: typeof MAX_STORAGE_ITEM_SIZE;
 declare const constants_OutsideExecutionCallerAny: typeof OutsideExecutionCallerAny;
 declare const constants_PAYMASTER_RPC_NODES: typeof PAYMASTER_RPC_NODES;
 declare const constants_PRIME: typeof PRIME;
+declare const constants_RANGE_CLASS_HASH: typeof RANGE_CLASS_HASH;
 declare const constants_RANGE_CONTRACT_ADDRESS: typeof RANGE_CONTRACT_ADDRESS;
 declare const constants_RANGE_ETH_ADDRESS: typeof RANGE_ETH_ADDRESS;
 declare const constants_RANGE_FELT: typeof RANGE_FELT;
@@ -8139,7 +8253,7 @@ declare const constants_TEXT_TO_FELT_MAX_LEN: typeof TEXT_TO_FELT_MAX_LEN;
 declare const constants_UDC: typeof UDC;
 declare const constants_ZERO: typeof ZERO;
 declare namespace constants {
-  export { constants_ADDR_BOUND as ADDR_BOUND, constants_API_VERSION as API_VERSION, type constants_ChannelDefaultOptions as ChannelDefaultOptions, type constants_ChannelDefaults as ChannelDefaults, type constants_ChannelMethodOptions as ChannelMethodOptions, constants_DEFAULT_GLOBAL_CONFIG as DEFAULT_GLOBAL_CONFIG, constants_HARDENING_4BYTES as HARDENING_4BYTES, constants_HARDENING_BYTE as HARDENING_BYTE, constants_IS_BROWSER as IS_BROWSER, constants_LegacyUDC as LegacyUDC, constants_MASK_250 as MASK_250, constants_MASK_31 as MASK_31, constants_MAX_STORAGE_ITEM_SIZE as MAX_STORAGE_ITEM_SIZE, _NetworkName as NetworkName, constants_OutsideExecutionCallerAny as OutsideExecutionCallerAny, constants_PAYMASTER_RPC_NODES as PAYMASTER_RPC_NODES, constants_PRIME as PRIME, constants_RANGE_CONTRACT_ADDRESS as RANGE_CONTRACT_ADDRESS, constants_RANGE_ETH_ADDRESS as RANGE_ETH_ADDRESS, constants_RANGE_FELT as RANGE_FELT, constants_RANGE_I128 as RANGE_I128, constants_RANGE_I16 as RANGE_I16, constants_RANGE_I32 as RANGE_I32, constants_RANGE_I64 as RANGE_I64, constants_RANGE_I8 as RANGE_I8, constants_RANGE_U128 as RANGE_U128, constants_RANGE_U16 as RANGE_U16, constants_RANGE_U32 as RANGE_U32, constants_RANGE_U64 as RANGE_U64, constants_RANGE_U8 as RANGE_U8, constants_RANGE_U96 as RANGE_U96, constants_RPC_DEFAULT_NODES as RPC_DEFAULT_NODES, constants_SNIP9_V1_INTERFACE_ID as SNIP9_V1_INTERFACE_ID, constants_SNIP9_V2_INTERFACE_ID as SNIP9_V2_INTERFACE_ID, constants_SN_VERSION_IMPLEMENTING_BLAKE_FOR_COMPILED_CLASS as SN_VERSION_IMPLEMENTING_BLAKE_FOR_COMPILED_CLASS, constants_SYSTEM_MESSAGES as SYSTEM_MESSAGES, _StarknetChainId as StarknetChainId, type constants_SupportedCairoVersion as SupportedCairoVersion, _SupportedRpcVersion as SupportedRpcVersion, type constants_SupportedRpcVersion0_10 as SupportedRpcVersion0_10, type constants_SupportedTransactionVersion as SupportedTransactionVersion, constants_TEXT_TO_FELT_MAX_LEN as TEXT_TO_FELT_MAX_LEN, _TransactionHashPrefix as TransactionHashPrefix, constants_UDC as UDC, constants_ZERO as ZERO };
+  export { constants_ADDR_BOUND as ADDR_BOUND, constants_API_VERSION as API_VERSION, type constants_ChannelDefaultOptions as ChannelDefaultOptions, type constants_ChannelDefaults as ChannelDefaults, type constants_ChannelMethodOptions as ChannelMethodOptions, constants_DEFAULT_GLOBAL_CONFIG as DEFAULT_GLOBAL_CONFIG, constants_HARDENING_4BYTES as HARDENING_4BYTES, constants_HARDENING_BYTE as HARDENING_BYTE, constants_IS_BROWSER as IS_BROWSER, constants_LegacyUDC as LegacyUDC, constants_MASK_250 as MASK_250, constants_MASK_31 as MASK_31, constants_MAX_STORAGE_ITEM_SIZE as MAX_STORAGE_ITEM_SIZE, _NetworkName as NetworkName, constants_OutsideExecutionCallerAny as OutsideExecutionCallerAny, constants_PAYMASTER_RPC_NODES as PAYMASTER_RPC_NODES, constants_PRIME as PRIME, constants_RANGE_CLASS_HASH as RANGE_CLASS_HASH, constants_RANGE_CONTRACT_ADDRESS as RANGE_CONTRACT_ADDRESS, constants_RANGE_ETH_ADDRESS as RANGE_ETH_ADDRESS, constants_RANGE_FELT as RANGE_FELT, constants_RANGE_I128 as RANGE_I128, constants_RANGE_I16 as RANGE_I16, constants_RANGE_I32 as RANGE_I32, constants_RANGE_I64 as RANGE_I64, constants_RANGE_I8 as RANGE_I8, constants_RANGE_U128 as RANGE_U128, constants_RANGE_U16 as RANGE_U16, constants_RANGE_U32 as RANGE_U32, constants_RANGE_U64 as RANGE_U64, constants_RANGE_U8 as RANGE_U8, constants_RANGE_U96 as RANGE_U96, constants_RPC_DEFAULT_NODES as RPC_DEFAULT_NODES, constants_SNIP9_V1_INTERFACE_ID as SNIP9_V1_INTERFACE_ID, constants_SNIP9_V2_INTERFACE_ID as SNIP9_V2_INTERFACE_ID, constants_SN_VERSION_IMPLEMENTING_BLAKE_FOR_COMPILED_CLASS as SN_VERSION_IMPLEMENTING_BLAKE_FOR_COMPILED_CLASS, constants_SYSTEM_MESSAGES as SYSTEM_MESSAGES, _StarknetChainId as StarknetChainId, type constants_SupportedCairoVersion as SupportedCairoVersion, _SupportedRpcVersion as SupportedRpcVersion, type constants_SupportedRpcVersion0_10 as SupportedRpcVersion0_10, type constants_SupportedTransactionVersion as SupportedTransactionVersion, constants_TEXT_TO_FELT_MAX_LEN as TEXT_TO_FELT_MAX_LEN, _TransactionHashPrefix as TransactionHashPrefix, constants_UDC as UDC, constants_ZERO as ZERO };
 }
 
 /** What a {@link SubscriptionChannel} needs: a socket to borrow, and how much to buffer. */
@@ -11306,13 +11420,17 @@ declare const isHexString: typeof isHex;
 /**
  * Convert BigNumberish to bigint
  *
+ * `'0x'`, which holds no digit, is refused with its own message rather than with `BigInt`'s.
  * @param {BigNumberish} value value to convert
  * @returns {BigInt} converted value
+ * @throws {Error} when the value is `'0x'`, or anything else `BigInt` cannot read
  * @example
  * ```typescript
  * const str = '123';
  * const result = toBigInt(str);
  * // result = 123n
+ * toBigInt('0x');
+ * // throws Error("Invalid input: '0x' holds no hexadecimal digit")
  * ```
  */
 declare function toBigInt(value: BigNumberish): bigint;
@@ -11390,22 +11508,22 @@ declare function toHex64(number: BigNumberish): string;
  */
 declare function hexToDecimalString(hex: string): string;
 /**
- * Asserts input is equal to or greater then lowerBound and lower then upperBound.
+ * Asserts input is within [lowerBound, upperBound], both bounds included.
  *
- * The `inputName` parameter is used in the assertion message.
+ * The `inputName` parameter names the input in the assertion message.
  * @param input Value to check
- * @param lowerBound Lower bound value
- * @param upperBound Upper bound value
+ * @param lowerBound Lower bound value, included
+ * @param upperBound Upper bound value, included
  * @param inputName Name of the input for error message
  * @throws Error if input is out of range
  * @example
  * ```typescript
  * const input1:BigNumberish = 10;
- * assertInRange(input1, 5, 20, 'value')
+ * assertInRange(input1, 5, 20, 'amount')
  *
  * const input2: BigNumberish = 25;
- * assertInRange(input2, 5, 20, 'value');
- * // throws Error: Message not signable, invalid value length.
+ * assertInRange(input2, 5, 20, 'amount');
+ * // throws Error: Value is out of amount range [5, 20]
  * ```
  */
 declare function assertInRange(input: BigNumberish, lowerBound: BigNumberish, upperBound: BigNumberish, inputName?: string): void;
@@ -11557,16 +11675,48 @@ declare function addPercent(number: BigNumberish, percent: number): bigint;
  * ```
  */
 declare function stringToSha256ToArrayBuff4(str: string): Uint8Array;
+/**
+ * Test if a value is a `0x` prefix with no digit after it.
+ *
+ * `'0x'` is hexadecimal in form — it is how an EVM tool writes empty data — but it spells no
+ * number : `BigInt('0x')` throws, `isBigNumberish` refuses it, and so does every Cairo type.
+ * @param {unknown} value the value to test
+ * @returns {boolean} true for `'0x'` and `'0X'`, false for anything else
+ * @example
+ * ```typescript
+ * const result = num.isEmptyHex('0x');
+ * // result = true
+ * const result2 = num.isEmptyHex('0x0');
+ * // result2 = false
+ * ```
+ */
+declare function isEmptyHex(value: unknown): boolean;
 /**
  * Checks if a given value is of BigNumberish type.
- * 234, 234n, "234", "0xea" are valid, exclude boolean and string
+ * 234, 234n, "234" and "0xea" are valid ; a boolean is not, nor a string that spells no number —
+ * `'0x'` included, which holds no digit.
+ *
+ * A number or a bigint passes whatever its sign, and a number whatever its decimal part : `-1`,
+ * `-1n` and `1.5` are all accepted here, and it is the Cairo type receiving the value that refuses
+ * what it cannot hold. A string is unsigned : it passes as decimal digits or as `0x` hexadecimal
+ * only, so `'-1'` and `'1.5'` do not — to the library, such a string is text. The signed integer
+ * classes, `CairoInt8` to `CairoInt128`, are the one place where a leading minus sign is read as a
+ * sign.
  * @param {unknown} input a value
  * @returns {boolean} true if type of input is `BigNumberish`
  * @example
  * ```typescript
  * const res = num.isBigNumberish("ZERO");
  * // res = false
- *  ```
+ * const res2 = num.isBigNumberish(-1);
+ * // res2 = true
+ * const res3 = num.isBigNumberish('-1');
+ * // res3 = false     (a string is unsigned : this one is text)
+ * const res4 = num.isBigNumberish(1.5);
+ * // res4 = true      (a number is not checked for a decimal part)
+ * const res5 = num.isBigNumberish('0x');
+ * // res5 = false     (hexadecimal in form, but no digit)
+ * ```
  */
 declare function isBigNumberish(input: unknown): input is BigNumberish;
 /**
@@ -11590,6 +11740,7 @@ declare const num_getNext: typeof getNext;
 declare const num_hexToBytes: typeof hexToBytes;
 declare const num_hexToDecimalString: typeof hexToDecimalString;
 declare const num_isBigNumberish: typeof isBigNumberish;
+declare const num_isEmptyHex: typeof isEmptyHex;
 declare const num_isHex: typeof isHex;
 declare const num_isHexString: typeof isHexString;
 declare const num_isStringWholeNumber: typeof isStringWholeNumber;
@@ -11602,7 +11753,7 @@ declare const num_toHexString: typeof toHexString;
 declare const num_toStorageKey: typeof toStorageKey;
 declare const num_tryToBigInt: typeof tryToBigInt;
 declare namespace num {
-  export { num_addPercent as addPercent, num_assertInRange as assertInRange, num_bigNumberishArrayToDecimalStringArray as bigNumberishArrayToDecimalStringArray, num_bigNumberishArrayToHexadecimalStringArray as bigNumberishArrayToHexadecimalStringArray, num_cleanHex as cleanHex, num_getDecimalString as getDecimalString, num_getHexString as getHexString, num_getHexStringArray as getHexStringArray, num_getNext as getNext, num_hexToBytes as hexToBytes, num_hexToDecimalString as hexToDecimalString, num_isBigNumberish as isBigNumberish, num_isHex as isHex, num_isHexString as isHexString, num_isStringWholeNumber as isStringWholeNumber, num_stringToSha256ToArrayBuff4 as stringToSha256ToArrayBuff4, num_toBigInt as toBigInt, num_toCairoBool as toCairoBool, num_toHex as toHex, num_toHex64 as toHex64, num_toHexString as toHexString, num_toStorageKey as toStorageKey, num_tryToBigInt as tryToBigInt };
+  export { num_addPercent as addPercent, num_assertInRange as assertInRange, num_bigNumberishArrayToDecimalStringArray as bigNumberishArrayToDecimalStringArray, num_bigNumberishArrayToHexadecimalStringArray as bigNumberishArrayToHexadecimalStringArray, num_cleanHex as cleanHex, num_getDecimalString as getDecimalString, num_getHexString as getHexString, num_getHexStringArray as getHexStringArray, num_getNext as getNext, num_hexToBytes as hexToBytes, num_hexToDecimalString as hexToDecimalString, num_isBigNumberish as isBigNumberish, num_isEmptyHex as isEmptyHex, num_isHex as isHex, num_isHexString as isHexString, num_isStringWholeNumber as isStringWholeNumber, num_stringToSha256ToArrayBuff4 as stringToSha256ToArrayBuff4, num_toBigInt as toBigInt, num_toCairoBool as toCairoBool, num_toHex as toHex, num_toHex64 as toHex64, num_toHexString as toHexString, num_toStorageKey as toStorageKey, num_tryToBigInt as tryToBigInt };
 }
 
 /**
@@ -13644,7 +13795,7 @@ declare class CairoUint256 {
      * A `Uint256` object is accepted here too : it already carries `low` and `high`, and both are
      * checked as u128 rather than the whole being cut again.
      * @param {BigNumberish | Uint256} data the value to carry, within [0, 2^256 - 1]
-     * @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 = new CairoUint256(2n ** 130n + 5n).toApiRequest();
@@ -13656,7 +13807,7 @@ declare class CairoUint256 {
      * Build from the two halves as they arrive, already cut (Api response).
      * @param {BigNumberish} low the bottom 128 bits
      * @param {BigNumberish} high the top 128 bits
-     * @throws {Error} when either half is out of 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 = new CairoUint256(5, 4).toBigInt();
@@ -13668,16 +13819,22 @@ declare 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: BigNumberish | unknown): bigint;
@@ -13689,13 +13846,17 @@ declare 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: BigNumberish, high: BigNumberish): {
@@ -14107,11 +14268,19 @@ declare class CairoFixedArray {
  * The bytes are held right-aligned in a fixed 31-byte buffer, so the length of the input is not
  * recoverable from the value — `'0x41'` and `'0x0041'` give the same bytes31. Reach for
  * `CairoByteArray` when the byte count has to survive.
+ *
+ * `'0x'` holds no byte at all, and is the same bytes31 as the empty string `''`. Where a number
+ * type refuses `'0x'`, a type made of bytes reads it as empty bytes, which is how an EVM tool
+ * writes them.
  * @example
  * ```typescript
  * // the same five characters, read two ways
  * new CairoBytes31('12345').toHexString(); //      "0x3039"        the number 12345
  * CairoBytes31.fromText('12345').toHexString(); // "0x3132333435"  the text '12345'
+ *
+ * // no byte at all, written two ways
+ * new CairoBytes31('').toApiRequest(); //   ["0"]
+ * new CairoBytes31('0x').toApiRequest(); // ["0"]
  * ```
  */
 declare class CairoBytes31 {
@@ -14442,16 +14611,18 @@ declare 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")
      * ```
@@ -14509,6 +14680,10 @@ declare class CairoFelt252 {
  * A ByteArray is **not** Cairo's string type. It carries bytes, and text is only one of the things
  * those bytes can mean — which is why the constructor reads a string the way calldata does, and why
  * text has a door of its own, {@link CairoByteArray.fromText}.
+ *
+ * `'0x'` holds no byte at all, and is the same ByteArray as the empty string `''`. Where a number
+ * type refuses `'0x'`, a type made of bytes reads it as empty bytes, which is how an EVM tool
+ * writes them.
  * @example
  * ```typescript
  * // the same four characters, read four ways
@@ -14516,6 +14691,10 @@ declare class CairoFelt252 {
  * new CairoByteArray('12345').toHexString(); //      "0x3039"        the number 12345
  * new CairoByteArray('0x4142').toHexString(); //     "0x4142"        the bytes 0x41 0x42
  * CairoByteArray.fromText('12345').toHexString(); // "0x3132333435"  the text '12345'
+ *
+ * // no byte at all, written two ways
+ * new CairoByteArray('').toApiRequest(); //   ["0", "0", "0"]
+ * new CairoByteArray('0x').toApiRequest(); // ["0", "0", "0"]
  * ```
  */
 declare class CairoByteArray {
@@ -14851,7 +15030,7 @@ declare 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();
@@ -14898,10 +15077,12 @@ declare 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
@@ -14909,6 +15090,8 @@ declare 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: BigNumberish | boolean | unknown): void;
@@ -15070,13 +15253,17 @@ declare 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: BigNumberish | unknown): bigint;
@@ -15087,13 +15274,17 @@ declare 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: BigNumberish, xHigh: BigNumberish, yLow: BigNumberish, yHigh: BigNumberish): {
@@ -15209,9 +15400,9 @@ declare class CairoSecp256k1Point {
  * A Cairo `core::starknet::class_hash::ClassHash` : the hash identifying a declared class.
  *
  * On the wire it is a field element like any other, so what this class adds over
- * {@link CairoFelt252} is the bound the RPC spec sets on it — 252 bits. That is wider than a
- * felt252 is, so the two bounds each refuse values the other allows, and neither stands in for
- * the other.
+ * {@link CairoFelt252} is the bound of the Cairo `ClassHash` type : [0, 2^251), the same range as
+ * the Cairo type of an address, and narrower than the field. The 252-bit bound the RPC spec states
+ * is looser, and never the one that binds.
  *
  * A number, a bigint, a decimal string and a hexadecimal string are all read as the same number.
  * Text is **not** an accepted input : a class hash spelled as words is a mistake, not a value.
@@ -15243,9 +15434,9 @@ declare class CairoClassHash {
      */
     static abiSelector: "core::starknet::class_hash::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();
@@ -15291,16 +15482,21 @@ declare 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: BigNumberish | boolean | unknown): void;
@@ -15387,7 +15583,7 @@ declare 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();
@@ -15433,11 +15629,12 @@ declare 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
@@ -15445,6 +15642,8 @@ declare 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: BigNumberish | boolean | unknown): void;
@@ -17066,12 +17265,14 @@ declare function addAddressPadding(address: BigNumberish): string;
 /**
  * Check the validity of a Starknet address, and format it as a hex number: '0x' and 64 characters, adding leading zeros if necessary.
  *
+ * A string is read as hexadecimal, with or without its `0x` prefix — so `'31'` is 0x31 — and one
+ * holding anything but hexadecimal digits, `'0x'` included, is refused as a malformed address.
  * @param {BigNumberish} address
  * @returns {string} Hex string: 0x followed by 64 characters. No upper case characters in the response.
  * @throws address argument must be a valid address inside the address range bound
  * @example
  * ```typescript
- * const result = [31, 0x1f, '31', '0x1f', '0x90591d9fa3efc87067d95a643f8455e0b8190eb8cb7bfd39e4fb7571fdf'].map(addAddressPadding);
+ * const result = [31, 0x1f, '31', '0x1f', '0x90591d9fa3efc87067d95a643f8455e0b8190eb8cb7bfd39e4fb7571fdf'].map(validateAndParseAddress);
  * // result = [
  * //   '0x000000000000000000000000000000000000000000000000000000000000001f',
  * //   '0x000000000000000000000000000000000000000000000000000000000000001f',
@@ -17079,6 +17280,8 @@ declare function addAddressPadding(address: BigNumberish): string;
  * //   '0x000000000000000000000000000000000000000000000000000000000000001f',
  * //   '0x0000090591d9fa3efc87067d95a643f8455e0b8190eb8cb7bfd39e4fb7571fdf'
  * // ]
+ * validateAndParseAddress('test');
+ * // throws Error("Invalid Address Format")
  * ```
  */
 declare function validateAndParseAddress(address: BigNumberish): string;