starknet 6.6.0 → 6.6.6

package/dist/index.global.js

@@ -10644,7 +10644,7 @@ var starknet = (() => {
         return typeof data === "function";
       }
       function isNonEmptyString(data) {
-        return isString(data) && data !== "";
+        return isString2(data) && data !== "";
       }
       function isDate(data) {
         return isInstanceStrict(data, Date) && isInteger2(data.getTime());
@@ -10652,7 +10652,7 @@ var starknet = (() => {
       function isEmptyString(data) {
         return data === "" || data instanceof String && data.toString() === "";
       }
-      function isString(data) {
+      function isString2(data) {
         return typeof data === "string" || data instanceof String;
       }
       function isObject2(data) {
@@ -10693,7 +10693,7 @@ var starknet = (() => {
       exports.isNonEmptyString = isNonEmptyString;
       exports.isDate = isDate;
       exports.isEmptyString = isEmptyString;
-      exports.isString = isString;
+      exports.isString = isString2;
       exports.isObject = isObject2;
       exports.validate = validate;
     }
@@ -12681,6 +12681,8 @@ var starknet = (() => {
     CairoOptionVariant: () => CairoOptionVariant,
     CairoResult: () => CairoResult,
     CairoResultVariant: () => CairoResultVariant,
+    CairoUint256: () => CairoUint256,
+    CairoUint512: () => CairoUint512,
     CallData: () => CallData,
     Contract: () => Contract,
     ContractFactory: () => ContractFactory,
@@ -12697,6 +12699,7 @@ var starknet = (() => {
     RPC: () => api_exports,
     RPC06: () => rpc_0_6_exports,
     RPC07: () => rpc_0_7_exports,
+    ReceiptTx: () => ReceiptTx,
     RpcChannel: () => RpcChannel2,
     RpcProvider: () => RpcProvider2,
     SIMULATION_FLAG: () => SIMULATION_FLAG,
@@ -12707,6 +12710,16 @@ var starknet = (() => {
     TransactionStatus: () => TransactionStatus,
     TransactionType: () => TransactionType,
     TypedDataRevision: () => TypedDataRevision,
+    UINT_128_MAX: () => UINT_128_MAX,
+    UINT_128_MIN: () => UINT_128_MIN,
+    UINT_256_HIGH_MAX: () => UINT_256_HIGH_MAX,
+    UINT_256_HIGH_MIN: () => UINT_256_HIGH_MIN,
+    UINT_256_LOW_MAX: () => UINT_256_LOW_MAX,
+    UINT_256_LOW_MIN: () => UINT_256_LOW_MIN,
+    UINT_256_MAX: () => UINT_256_MAX,
+    UINT_256_MIN: () => UINT_256_MIN,
+    UINT_512_MAX: () => UINT_512_MAX,
+    UINT_512_MIN: () => UINT_512_MIN,
     Uint: () => Uint,
     ValidateType: () => ValidateType,
     WalletAccount: () => WalletAccount,
@@ -12774,6 +12787,10 @@ var starknet = (() => {
     MASK_250: () => MASK_250,
     MAX_STORAGE_ITEM_SIZE: () => MAX_STORAGE_ITEM_SIZE,
     NetworkName: () => NetworkName,
+    PRIME: () => PRIME,
+    RANGE_FELT: () => RANGE_FELT,
+    RANGE_I128: () => RANGE_I128,
+    RANGE_U128: () => RANGE_U128,
     RPC_DEFAULT_VERSION: () => RPC_DEFAULT_VERSION,
     RPC_NODES: () => RPC_NODES,
     StarknetChainId: () => StarknetChainId,
@@ -13239,8 +13256,13 @@ var starknet = (() => {
   var ZERO = 0n;
   var MASK_250 = 2n ** 250n - 1n;
   var API_VERSION = ZERO;
+  var PRIME = 2n ** 251n + 17n * 2n ** 192n + 1n;
   var MAX_STORAGE_ITEM_SIZE = 256n;
   var ADDR_BOUND = 2n ** 251n - MAX_STORAGE_ITEM_SIZE;
+  var range = (min, max) => ({ min, max });
+  var RANGE_FELT = range(ZERO, PRIME - 1n);
+  var RANGE_I128 = range(-(2n ** 127n), 2n ** 127n - 1n);
+  var RANGE_U128 = range(ZERO, 2n ** 128n - 1n);
   var BaseUrl = /* @__PURE__ */ ((BaseUrl2) => {
     BaseUrl2["SN_MAIN"] = "https://alpha-mainnet.starknet.io";
     BaseUrl2["SN_GOERLI"] = "https://alpha4.starknet.io";
@@ -13375,11 +13397,13 @@ var starknet = (() => {
     Uint2["u64"] = "core::integer::u64";
     Uint2["u128"] = "core::integer::u128";
     Uint2["u256"] = "core::integer::u256";
+    Uint2["u512"] = "core::integer::u512";
     return Uint2;
   })(Uint || {});
   var Literal = /* @__PURE__ */ ((Literal2) => {
     Literal2["ClassHash"] = "core::starknet::class_hash::ClassHash";
     Literal2["ContractAddress"] = "core::starknet::contract_address::ContractAddress";
+    Literal2["Secp256k1Point"] = "core::starknet::secp256k1::Secp256k1Point";
     return Literal2;
   })(Literal || {});
 
@@ -13462,7 +13486,9 @@ var starknet = (() => {
     hexToBytes: () => hexToBytes2,
     hexToDecimalString: () => hexToDecimalString,
     isBigInt: () => isBigInt,
+    isBoolean: () => isBoolean,
     isHex: () => isHex,
+    isNumber: () => isNumber,
     isStringWholeNumber: () => isStringWholeNumber,
     toBigInt: () => toBigInt,
     toCairoBool: () => toCairoBool,
@@ -13781,6 +13807,12 @@ var starknet = (() => {
     const bigIntNum = BigInt(number3);
     return bigIntNum + bigIntNum * BigInt(percent) / 100n;
   }
+  function isNumber(value) {
+    return typeof value === "number";
+  }
+  function isBoolean(value) {
+    return typeof value === "boolean";
+  }
 
   // src/utils/selector.ts
   var selector_exports = {};
@@ -16148,6 +16180,7 @@ var starknet = (() => {
     isLongText: () => isLongText,
     isShortString: () => isShortString,
     isShortText: () => isShortText,
+    isString: () => isString,
     isText: () => isText,
     splitLongString: () => splitLongString
   });
@@ -16160,8 +16193,11 @@ var starknet = (() => {
   function isDecimalString(str) {
     return /^[0-9]*$/i.test(str);
   }
+  function isString(value) {
+    return typeof value === "string";
+  }
   function isText(val) {
-    return typeof val === "string" && !isHex(val) && !isStringWholeNumber(val);
+    return isString(val) && !isHex(val) && !isStringWholeNumber(val);
   }
   var isShortText = (val) => isText(val) && isShortString(val);
   var isLongText = (val) => isText(val) && !isShortString(val);
@@ -16234,34 +16270,38 @@ var starknet = (() => {
     isTypeNamedTuple: () => isTypeNamedTuple,
     isTypeOption: () => isTypeOption,
     isTypeResult: () => isTypeResult,
+    isTypeSecp256k1Point: () => isTypeSecp256k1Point,
     isTypeStruct: () => isTypeStruct,
     isTypeTuple: () => isTypeTuple,
     isTypeUint: () => isTypeUint,
     isTypeUint256: () => isTypeUint256,
     tuple: () => tuple,
-    uint256: () => uint256
+    uint256: () => uint256,
+    uint512: () => uint512
   });
 
   // src/utils/cairoDataTypes/felt.ts
   function CairoFelt(it) {
-    if (isBigInt(it) || typeof it === "number" && Number.isInteger(it)) {
+    if (isBigInt(it) || Number.isInteger(it)) {
       return it.toString();
     }
-    if (isText(it)) {
-      if (!isShortString(it))
-        throw new Error(
-          `${it} is a long string > 31 chars, felt can store short strings, split it to array of short strings`
-        );
-      const encoded = encodeShortString(it);
-      return BigInt(encoded).toString();
-    }
-    if (typeof it === "string" && isHex(it)) {
-      return BigInt(it).toString();
-    }
-    if (typeof it === "string" && isStringWholeNumber(it)) {
-      return it;
+    if (isString(it)) {
+      if (isHex(it)) {
+        return BigInt(it).toString();
+      }
+      if (isText(it)) {
+        if (!isShortString(it)) {
+          throw new Error(
+            `${it} is a long string > 31 chars. Please split it into an array of short strings.`
+          );
+        }
+        return BigInt(encodeShortString(it)).toString();
+      }
+      if (isStringWholeNumber(it)) {
+        return it;
+      }
     }
-    if (typeof it === "boolean") {
+    if (isBoolean(it)) {
       return `${+it}`;
     }
     throw new Error(`${it} can't be computed by felt()`);
@@ -16372,6 +16412,130 @@ var starknet = (() => {
     }
   };
 
+  // src/utils/cairoDataTypes/uint512.ts
+  var UINT_512_MAX = (1n << 512n) - 1n;
+  var UINT_512_MIN = 0n;
+  var UINT_128_MIN = 0n;
+  var CairoUint512 = class _CairoUint512 {
+    limb0;
+    limb1;
+    limb2;
+    limb3;
+    static abiSelector = "core::integer::u512";
+    constructor(...arr) {
+      if (typeof arr[0] === "object" && arr.length === 1 && "limb0" in arr[0] && "limb1" in arr[0] && "limb2" in arr[0] && "limb3" in arr[0]) {
+        const props = _CairoUint512.validateProps(
+          arr[0].limb0,
+          arr[0].limb1,
+          arr[0].limb2,
+          arr[0].limb3
+        );
+        this.limb0 = props.limb0;
+        this.limb1 = props.limb1;
+        this.limb2 = props.limb2;
+        this.limb3 = props.limb3;
+      } else if (arr.length === 1) {
+        const bigInt = _CairoUint512.validate(arr[0]);
+        this.limb0 = bigInt & UINT_128_MAX;
+        this.limb1 = (bigInt & UINT_128_MAX << 128n) >> 128n;
+        this.limb2 = (bigInt & UINT_128_MAX << 256n) >> 256n;
+        this.limb3 = bigInt >> 384n;
+      } else if (arr.length === 4) {
+        const props = _CairoUint512.validateProps(arr[0], arr[1], arr[2], arr[3]);
+        this.limb0 = props.limb0;
+        this.limb1 = props.limb1;
+        this.limb2 = props.limb2;
+        this.limb3 = props.limb3;
+      } else {
+        throw Error("Incorrect Uint512 constructor parameters");
+      }
+    }
+    /**
+     * Validate if BigNumberish can be represented as Uint512
+     */
+    static validate(bigNumberish) {
+      const bigInt = BigInt(bigNumberish);
+      if (bigInt < UINT_512_MIN)
+        throw Error("bigNumberish is smaller than UINT_512_MIN.");
+      if (bigInt > UINT_512_MAX)
+        throw Error("bigNumberish is bigger than UINT_512_MAX.");
+      return bigInt;
+    }
+    /**
+     * Validate if limbs can be represented as Uint512
+     */
+    static validateProps(limb0, limb1, limb2, limb3) {
+      const l0 = BigInt(limb0);
+      const l1 = BigInt(limb1);
+      const l2 = BigInt(limb2);
+      const l3 = BigInt(limb3);
+      [l0, l1, l2, l3].forEach((value, index) => {
+        if (value < UINT_128_MIN || value > UINT_128_MAX) {
+          throw Error(`limb${index} is not in the range of a u128 number`);
+        }
+      });
+      return { limb0: l0, limb1: l1, limb2: l2, limb3: l3 };
+    }
+    /**
+     * Check if BigNumberish can be represented as Uint512
+     */
+    static is(bigNumberish) {
+      try {
+        _CairoUint512.validate(bigNumberish);
+      } catch (error2) {
+        return false;
+      }
+      return true;
+    }
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType) {
+      return abiType === _CairoUint512.abiSelector;
+    }
+    /**
+     * Return bigint representation
+     */
+    toBigInt() {
+      return (this.limb3 << 384n) + (this.limb2 << 256n) + (this.limb1 << 128n) + this.limb0;
+    }
+    /**
+     * Return Uint512 structure with HexString props
+     * limbx: HexString
+     */
+    toUint512HexString() {
+      return {
+        limb0: addHexPrefix(this.limb0.toString(16)),
+        limb1: addHexPrefix(this.limb1.toString(16)),
+        limb2: addHexPrefix(this.limb2.toString(16)),
+        limb3: addHexPrefix(this.limb3.toString(16))
+      };
+    }
+    /**
+     * Return Uint512 structure with DecimalString props
+     * limbx DecString
+     */
+    toUint512DecimalString() {
+      return {
+        limb0: this.limb0.toString(10),
+        limb1: this.limb1.toString(10),
+        limb2: this.limb2.toString(10),
+        limb3: this.limb3.toString(10)
+      };
+    }
+    /**
+     * Return api requests representation witch is felt array
+     */
+    toApiRequest() {
+      return [
+        CairoFelt(this.limb0),
+        CairoFelt(this.limb1),
+        CairoFelt(this.limb2),
+        CairoFelt(this.limb3)
+      ];
+    }
+  };
+
   // src/utils/calldata/cairo.ts
   var isLen = (name) => /_len$/.test(name);
   var isTypeFelt = (type) => type === "felt" || type === "core::felt252";
@@ -16390,6 +16554,7 @@ var starknet = (() => {
   var isTypeEthAddress = (type) => type === "core::starknet::eth_address::EthAddress";
   var isTypeBytes31 = (type) => type === "core::bytes_31::bytes31";
   var isTypeByteArray = (type) => type === "core::byte_array::ByteArray";
+  var isTypeSecp256k1Point = (type) => type === "core::starknet::secp256k1::Secp256k1Point";
   var isCairo1Type = (type) => type.includes("::");
   var getArrayType = (type) => {
     if (isCairo1Type(type)) {
@@ -16423,6 +16588,9 @@ var starknet = (() => {
   var uint256 = (it) => {
     return new CairoUint256(it).toUint256DecimalString();
   };
+  var uint512 = (it) => {
+    return new CairoUint512(it).toUint512DecimalString();
+  };
   var tuple = (...args) => ({ ...args });
   function felt(it) {
     return CairoFelt(it);
@@ -16827,6 +16995,11 @@ var starknet = (() => {
       `Your object includes the property : ${key}, containing an Uint256 object without the 'low' and 'high' keys.`
     );
   }
+  function errorU512(key) {
+    return Error(
+      `Your object includes the property : ${key}, containing an Uint512 object without the 'limb0' to 'limb3' keys.`
+    );
+  }
   function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
     const orderInput = (unorderedItem, abiType) => {
       if (isTypeArray(abiType)) {
@@ -16845,6 +17018,9 @@ var starknet = (() => {
       if (isTypeByteArray(abiType)) {
         return unorderedItem;
       }
+      if (isTypeSecp256k1Point(abiType)) {
+        return unorderedItem;
+      }
       if (CairoUint256.isAbiType(abiType)) {
         const u256 = unorderedItem;
         if (typeof u256 !== "object") {
@@ -16855,6 +17031,16 @@ var starknet = (() => {
         }
         return { low: u256.low, high: u256.high };
       }
+      if (CairoUint512.isAbiType(abiType)) {
+        const u512 = unorderedItem;
+        if (typeof u512 !== "object") {
+          return u512;
+        }
+        if (!["limb0", "limb1", "limb2", "limb3"].every((key) => key in u512)) {
+          throw errorU512(abiType);
+        }
+        return { limb0: u512.limb0, limb1: u512.limb1, limb2: u512.limb2, limb3: u512.limb3 };
+      }
       if (isTypeStruct(abiType, structs)) {
         const abiOfStruct = structs[abiType].members;
         return orderStruct(unorderedItem, abiOfStruct);
@@ -16879,7 +17065,7 @@ var starknet = (() => {
     };
     function orderArray(myArray, abiParam) {
       const typeInArray = getArrayType(abiParam);
-      if (typeof myArray === "string") {
+      if (isString(myArray)) {
         return myArray;
       }
       return myArray.map((myElem) => orderInput(myElem, typeInArray));
@@ -16970,8 +17156,21 @@ var starknet = (() => {
     switch (true) {
       case CairoUint256.isAbiType(type):
         return new CairoUint256(val).toApiRequest();
+      case CairoUint512.isAbiType(type):
+        return new CairoUint512(val).toApiRequest();
       case isTypeBytes31(type):
         return encodeShortString(val.toString());
+      case isTypeSecp256k1Point(type): {
+        const pubKeyETH = removeHexPrefix(toHex(val)).padStart(128, "0");
+        const pubKeyETHy = uint256(addHexPrefix(pubKeyETH.slice(-64)));
+        const pubKeyETHx = uint256(addHexPrefix(pubKeyETH.slice(0, -64)));
+        return [
+          felt(pubKeyETHx.low),
+          felt(pubKeyETHx.high),
+          felt(pubKeyETHy.low),
+          felt(pubKeyETHy.high)
+        ];
+      }
       default:
         return felt(val);
     }
@@ -17018,6 +17217,9 @@ var starknet = (() => {
       if (CairoUint256.isAbiType(type)) {
         return new CairoUint256(element).toApiRequest();
       }
+      if (CairoUint512.isAbiType(type)) {
+        return new CairoUint512(element).toApiRequest();
+      }
       if (type === "core::starknet::eth_address::EthAddress")
         return parseBaseTypes(type, element);
       if (type === "core::byte_array::ByteArray")
@@ -17038,6 +17240,9 @@ var starknet = (() => {
     if (CairoUint256.isAbiType(type)) {
       return new CairoUint256(element).toApiRequest();
     }
+    if (CairoUint512.isAbiType(type)) {
+      return new CairoUint512(element).toApiRequest();
+    }
     if (isTypeEnum(type, enums)) {
       const { variants } = enums[type];
       if (isTypeOption(type)) {
@@ -17130,13 +17335,13 @@ var starknet = (() => {
         if (!Array.isArray(value) && !isText(value)) {
           throw Error(`ABI expected parameter ${name} to be array or long string, got ${value}`);
         }
-        if (typeof value === "string") {
+        if (isString(value)) {
           value = splitLongString(value);
         }
         return parseCalldataValue(value, input.type, structs, enums);
       case type === "core::starknet::eth_address::EthAddress":
         return parseBaseTypes(type, value);
-      case (isTypeStruct(type, structs) || isTypeTuple(type) || CairoUint256.isAbiType(type)):
+      case (isTypeStruct(type, structs) || isTypeTuple(type) || CairoUint256.isAbiType(type) || CairoUint256.isAbiType(type)):
         return parseCalldataValue(value, type, structs, enums);
       case isTypeEnum(type, enums):
         return parseCalldataValue(
@@ -17161,12 +17366,25 @@ var starknet = (() => {
         const low = it.next().value;
         const high = it.next().value;
         return new CairoUint256(low, high).toBigInt();
+      case CairoUint512.isAbiType(type):
+        const limb0 = it.next().value;
+        const limb1 = it.next().value;
+        const limb2 = it.next().value;
+        const limb3 = it.next().value;
+        return new CairoUint512(limb0, limb1, limb2, limb3).toBigInt();
       case type === "core::starknet::eth_address::EthAddress":
         temp = it.next().value;
         return BigInt(temp);
       case type === "core::bytes_31::bytes31":
         temp = it.next().value;
         return decodeShortString(temp);
+      case isTypeSecp256k1Point(type):
+        const xLow = removeHexPrefix(it.next().value).padStart(32, "0");
+        const xHigh = removeHexPrefix(it.next().value).padStart(32, "0");
+        const yLow = removeHexPrefix(it.next().value).padStart(32, "0");
+        const yHigh = removeHexPrefix(it.next().value).padStart(32, "0");
+        const pubK = BigInt(addHexPrefix(xHigh + xLow + yHigh + yLow));
+        return pubK;
       default:
         temp = it.next().value;
         return BigInt(temp);
@@ -17181,6 +17399,13 @@ var starknet = (() => {
       const high = responseIterator.next().value;
       return new CairoUint256(low, high).toBigInt();
     }
+    if (CairoUint512.isAbiType(element.type)) {
+      const limb0 = responseIterator.next().value;
+      const limb1 = responseIterator.next().value;
+      const limb2 = responseIterator.next().value;
+      const limb3 = responseIterator.next().value;
+      return new CairoUint512(limb0, limb1, limb2, limb3).toBigInt();
+    }
     if (isTypeByteArray(element.type)) {
       const parsedBytes31Arr = [];
       const bytes31ArrLen = BigInt(responseIterator.next().value);
@@ -17304,10 +17529,10 @@ var starknet = (() => {
   // src/utils/calldata/validate.ts
   var validateFelt = (parameter, input) => {
     assert(
-      typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
+      isString(parameter) || isNumber(parameter) || isBigInt(parameter),
       `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`
     );
-    if (typeof parameter === "string" && !isHex(parameter))
+    if (isString(parameter) && !isHex(parameter))
       return;
     const param = BigInt(parameter.toString(10));
     assert(
@@ -17317,27 +17542,37 @@ var starknet = (() => {
     );
   };
   var validateBytes31 = (parameter, input) => {
-    assert(typeof parameter === "string", `Validate: arg ${input.name} should be a string.`);
+    assert(isString(parameter), `Validate: arg ${input.name} should be a string.`);
     assert(
       parameter.length < 32,
       `Validate: arg ${input.name} cairo typed ${input.type} should be a string of less than 32 characters.`
     );
   };
   var validateByteArray = (parameter, input) => {
-    assert(typeof parameter === "string", `Validate: arg ${input.name} should be a string.`);
+    assert(isString(parameter), `Validate: arg ${input.name} should be a string.`);
   };
   var validateUint = (parameter, input) => {
-    if (typeof parameter === "number") {
+    if (isNumber(parameter)) {
       assert(
         parameter <= Number.MAX_SAFE_INTEGER,
         `Validation: Parameter is to large to be typed as Number use (BigInt or String)`
       );
     }
     assert(
-      typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint" || typeof parameter === "object" && "low" in parameter && "high" in parameter,
+      isString(parameter) || isNumber(parameter) || isBigInt(parameter) || typeof parameter === "object" && "low" in parameter && "high" in parameter || typeof parameter === "object" && ["limb0", "limb1", "limb2", "limb3"].every((key) => key in parameter),
       `Validate: arg ${input.name} of cairo type ${input.type} should be type (String, Number or BigInt), but is ${typeof parameter} ${parameter}.`
     );
-    const param = typeof parameter === "object" ? new CairoUint256(parameter).toBigInt() : toBigInt(parameter);
+    let param;
+    switch (input.type) {
+      case "core::integer::u256" /* u256 */:
+        param = new CairoUint256(parameter).toBigInt();
+        break;
+      case "core::integer::u512" /* u512 */:
+        param = new CairoUint512(parameter).toBigInt();
+        break;
+      default:
+        param = toBigInt(parameter);
+    }
     switch (input.type) {
       case "core::integer::u8" /* u8 */:
         assert(
@@ -17375,6 +17610,9 @@ var starknet = (() => {
           `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
         );
         break;
+      case "core::integer::u512" /* u512 */:
+        assert(CairoUint512.is(param), `Validate: arg ${input.name} is ${input.type} 0 - 2^512-1`);
+        break;
       case "core::starknet::class_hash::ClassHash" /* ClassHash */:
         assert(
           // from : https://github.com/starkware-libs/starknet-specs/blob/29bab650be6b1847c92d4461d4c33008b5e50b1a/api/starknet_api_openrpc.json#L1670
@@ -17389,18 +17627,25 @@ var starknet = (() => {
           `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^252-1]`
         );
         break;
+      case "core::starknet::secp256k1::Secp256k1Point" /* Secp256k1Point */: {
+        assert(
+          param >= 0n && param <= 2n ** 512n - 1n,
+          `Validate: arg ${input.name} must be ${input.type} : a 512 bits number.`
+        );
+        break;
+      }
       default:
         break;
     }
   };
   var validateBool = (parameter, input) => {
     assert(
-      typeof parameter === "boolean",
+      isBoolean(parameter),
       `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`
     );
   };
   var validateStruct = (parameter, input, structs) => {
-    if (input.type === "core::integer::u256" /* u256 */) {
+    if (input.type === "core::integer::u256" /* u256 */ || input.type === "core::integer::u512" /* u512 */) {
       validateUint(parameter, input);
       return;
     }
@@ -17481,7 +17726,7 @@ var starknet = (() => {
         parameter.forEach((it) => validateEnum(it, { name: input.name, type: baseType }));
         break;
       case (isTypeUint(baseType) || isTypeLiteral(baseType)):
-        parameter.forEach((param) => validateUint(param, input));
+        parameter.forEach((param) => validateUint(param, { name: "", type: baseType }));
         break;
       case isTypeBool(baseType):
         parameter.forEach((param) => validateBool(param, input));
@@ -18090,7 +18335,7 @@ var starknet = (() => {
     return INTEGER_REGEX.test(value);
   }
   var INTEGER_REGEX = /^-?[0-9]+$/;
-  function isNumber(value) {
+  function isNumber2(value) {
     return NUMBER_REGEX.test(value);
   }
   var NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
@@ -18149,7 +18394,7 @@ var starknet = (() => {
     // type information
     isLosslessNumber = true;
     constructor(value) {
-      if (!isNumber(value)) {
+      if (!isNumber2(value)) {
         throw new Error('Invalid number (value: "' + value + '")');
       }
       this.value = value;
@@ -18539,7 +18784,7 @@ var starknet = (() => {
         const stringifier = numberStringifiers.find((item) => item.test(value2));
         if (stringifier) {
           const str = stringifier.stringify(value2);
-          if (typeof str !== "string" || !isNumber(str)) {
+          if (typeof str !== "string" || !isNumber2(str)) {
             throw new Error(`Invalid JSON number: output of a number stringifier must be a string containing a JSON number (output: ${str})`);
           }
           return str;
@@ -18696,7 +18941,7 @@ var starknet = (() => {
     return addHexPrefix(esm_exports.keccak(utf8ToArray(serializedJson)).toString(16));
   }
   function computeLegacyContractClassHash(contract) {
-    const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
+    const compiledContract = isString(contract) ? parse2(contract) : contract;
     const apiVersion = toHex(API_VERSION);
     const externalEntryPointsHash = computeHashOnElements3(
       compiledContract.entry_points_by_type.EXTERNAL.flatMap((e) => [e.selector, e.offset])
@@ -18792,7 +19037,7 @@ var starknet = (() => {
     );
   }
   function computeContractClassHash(contract) {
-    const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
+    const compiledContract = isString(contract) ? parse2(contract) : contract;
     if ("sierra_program" in compiledContract) {
       return computeSierraContractClassHash(compiledContract);
     }
@@ -22983,7 +23228,7 @@ var starknet = (() => {
 
   // src/utils/stark.ts
   function compressProgram(jsonProgram) {
-    const stringified = typeof jsonProgram === "string" ? jsonProgram : stringify2(jsonProgram);
+    const stringified = isString(jsonProgram) ? jsonProgram : stringify2(jsonProgram);
     const compressedProgram = gzip_1(stringified);
     return btoaUniversal(compressedProgram);
   }
@@ -23023,7 +23268,7 @@ var starknet = (() => {
     return addPercent(estimatedFee, overhead);
   }
   function estimateFeeToBounds(estimate, amountOverhead = 50 /* L1_BOUND_MAX_AMOUNT */, priceOverhead = 50 /* L1_BOUND_MAX_PRICE_PER_UNIT */) {
-    if (typeof estimate === "bigint") {
+    if (isBigInt(estimate)) {
       return {
         l2_gas: { max_amount: "0x0", max_price_per_unit: "0x0" },
         l1_gas: { max_amount: "0x0", max_price_per_unit: "0x0" }
@@ -23091,7 +23336,7 @@ var starknet = (() => {
 
   // src/utils/contract.ts
   function isSierra(contract) {
-    const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
+    const compiledContract = isString(contract) ? parse2(contract) : contract;
     return "sierra_program" in compiledContract;
   }
   function extractContractHashes(payload) {
@@ -23315,7 +23560,7 @@ var starknet = (() => {
     return result;
   }
   function parseContract(contract) {
-    const parsedContract = typeof contract === "string" ? parse2(contract) : contract;
+    const parsedContract = isString(contract) ? parse2(contract) : contract;
     if (!isSierra(contract)) {
       return {
         ...parsedContract,
@@ -23332,7 +23577,7 @@ var starknet = (() => {
     return nodes[randIdx];
   };
   function formatHash(hashValue) {
-    if (typeof hashValue === "string")
+    if (isString(hashValue))
       return hashValue;
     return toHex(hashValue);
   }
@@ -23349,14 +23594,16 @@ var starknet = (() => {
     number = null;
     tag = null;
     setIdentifier(__identifier) {
-      if (typeof __identifier === "string" && isHex(__identifier)) {
-        this.hash = __identifier;
-      } else if (typeof __identifier === "bigint") {
+      if (isString(__identifier)) {
+        if (isHex(__identifier)) {
+          this.hash = __identifier;
+        } else if (validBlockTags.includes(__identifier)) {
+          this.tag = __identifier;
+        }
+      } else if (isBigInt(__identifier)) {
         this.hash = toHex(__identifier);
-      } else if (typeof __identifier === "number") {
+      } else if (isNumber(__identifier)) {
         this.number = __identifier;
-      } else if (typeof __identifier === "string" && validBlockTags.includes(__identifier)) {
-        this.tag = __identifier;
       } else {
         this.tag = "pending" /* pending */;
       }
@@ -24605,7 +24852,7 @@ var starknet = (() => {
       return { status: "PENDING", ...res };
     }
     parseTransactionReceipt(res) {
-      if ("actual_fee" in res && typeof res.actual_fee === "string") {
+      if ("actual_fee" in res && isString(res.actual_fee)) {
         return {
           ...res,
           actual_fee: {
@@ -24649,11 +24896,59 @@ var starknet = (() => {
     parseContractClassResponse(res) {
       return {
         ...res,
-        abi: typeof res.abi === "string" ? JSON.parse(res.abi) : res.abi
+        abi: isString(res.abi) ? JSON.parse(res.abi) : res.abi
       };
     }
   };
 
+  // src/utils/transactionReceipt.ts
+  var ReceiptTx = class _ReceiptTx {
+    statusReceipt;
+    value;
+    constructor(receipt) {
+      [this.statusReceipt, this.value] = _ReceiptTx.isSuccess(receipt) ? ["success", receipt] : _ReceiptTx.isReverted(receipt) ? ["reverted", receipt] : _ReceiptTx.isRejected(receipt) ? ["rejected", receipt] : ["error", new Error("Unknown response type")];
+      for (const [key] of Object.entries(this)) {
+        Object.defineProperty(this, key, {
+          enumerable: false
+        });
+      }
+      for (const [key, value] of Object.entries(receipt)) {
+        Object.defineProperty(this, key, {
+          enumerable: true,
+          writable: false,
+          value
+        });
+      }
+    }
+    match(callbacks) {
+      if (this.statusReceipt in callbacks) {
+        return callbacks[this.statusReceipt](this.value);
+      }
+      return callbacks._();
+    }
+    isSuccess() {
+      return this.statusReceipt === "success";
+    }
+    isReverted() {
+      return this.statusReceipt === "reverted";
+    }
+    isRejected() {
+      return this.statusReceipt === "rejected";
+    }
+    isError() {
+      return this.statusReceipt === "error";
+    }
+    static isSuccess(transactionReceipt) {
+      return transactionReceipt.execution_status === "SUCCEEDED" /* SUCCEEDED */;
+    }
+    static isReverted(transactionReceipt) {
+      return transactionReceipt.execution_status === "REVERTED" /* REVERTED */;
+    }
+    static isRejected(transactionReceipt) {
+      return transactionReceipt.status === "REJECTED" /* REJECTED */;
+    }
+  };
+
   // src/provider/rpc.ts
   var RpcProvider = class {
     responseParser;
@@ -24738,7 +25033,9 @@ var starknet = (() => {
       return this.channel.getTransactionByBlockIdAndIndex(blockIdentifier, index);
     }
     async getTransactionReceipt(txHash) {
-      return this.channel.getTransactionReceipt(txHash).then(this.responseParser.parseTransactionReceipt);
+      const txReceiptWoHelper = await this.channel.getTransactionReceipt(txHash);
+      const txReceiptWoHelperModified = this.responseParser.parseTransactionReceipt(txReceiptWoHelper);
+      return new ReceiptTx(txReceiptWoHelperModified);
     }
     async getTransactionTrace(txHash) {
       return this.channel.getTransactionTrace(txHash);
@@ -24760,7 +25057,11 @@ var starknet = (() => {
       return this.channel.simulateTransaction(invocations, options).then((r) => this.responseParser.parseSimulateTransactionResponse(r));
     }
     async waitForTransaction(txHash, options) {
-      return this.channel.waitForTransaction(txHash, options);
+      const receiptWoHelper = await this.channel.waitForTransaction(
+        txHash,
+        options
+      );
+      return new ReceiptTx(receiptWoHelper);
     }
     async getStorageAt(contractAddress, key, blockIdentifier) {
       return this.channel.getStorageAt(contractAddress, key, blockIdentifier);
@@ -25686,6 +25987,10 @@ var starknet = (() => {
       presetTypes: {}
     }
   };
+  function assertRange(data, type, { min, max }) {
+    const value = BigInt(data);
+    assert(value >= min && value <= max, `${value} (${type}) is out of bounds [${min}, ${max}]`);
+  }
   function identifyRevision({ types, domain }) {
     if (revisionConfiguration["1" /* Active */].domain in types && domain.revision === "1" /* Active */)
       return "1" /* Active */;
@@ -25697,7 +26002,7 @@ var starknet = (() => {
     try {
       return toHex(value);
     } catch (e) {
-      if (typeof value === "string") {
+      if (isString(value)) {
         return toHex(encodeShortString(value));
       }
       throw new Error(`Invalid BigNumberish: ${value}`);
@@ -25848,15 +26153,41 @@ var starknet = (() => {
         }
         return [type, getHex(data)];
       }
+      case "i128": {
+        if (revision === "1" /* Active */) {
+          const value = BigInt(data);
+          assertRange(value, type, RANGE_I128);
+          return [type, getHex(value < 0n ? PRIME + value : value)];
+        }
+        return [type, getHex(data)];
+      }
+      case "timestamp":
+      case "u128": {
+        if (revision === "1" /* Active */) {
+          assertRange(data, type, RANGE_U128);
+        }
+        return [type, getHex(data)];
+      }
       case "felt":
-      case "bool":
-      case "u128":
-      case "i128":
-      case "ContractAddress":
+      case "shortstring": {
+        if (revision === "1" /* Active */) {
+          assertRange(getHex(data), type, RANGE_FELT);
+        }
+        return [type, getHex(data)];
+      }
       case "ClassHash":
-      case "timestamp":
-      case "shortstring":
+      case "ContractAddress": {
+        if (revision === "1" /* Active */) {
+          assertRange(data, type, RANGE_FELT);
+        }
+        return [type, getHex(data)];
+      }
+      case "bool": {
+        if (revision === "1" /* Active */) {
+          assert(typeof data === "boolean", `Type mismatch for ${type} ${data}`);
+        }
         return [type, getHex(data)];
+      }
       default: {
         if (revision === "1" /* Active */) {
           throw new Error(`Unsupported type: ${type}`);
@@ -26082,19 +26413,48 @@ var starknet = (() => {
     return sanitizeHex(buf2hex(secp256k1.utils.randomPrivateKey()));
   }
 
+  // src/utils/uint256.ts
+  var uint256_exports = {};
+  __export(uint256_exports, {
+    UINT_128_MAX: () => UINT_128_MAX,
+    UINT_256_MAX: () => UINT_256_MAX,
+    bnToUint256: () => bnToUint256,
+    isUint256: () => isUint256,
+    uint256ToBN: () => uint256ToBN
+  });
+  function uint256ToBN(uint2562) {
+    return new CairoUint256(uint2562).toBigInt();
+  }
+  function isUint256(bn) {
+    return CairoUint256.is(bn);
+  }
+  function bnToUint256(bn) {
+    return new CairoUint256(bn).toUint256HexString();
+  }
+
   // src/signer/ethSigner.ts
   var EthSigner = class {
     pk;
-    // hex string without 0x and odd number of characters
+    // hex string without 0x and with an odd number of characters
     constructor(pk = ethRandomPrivateKey()) {
-      this.pk = pk instanceof Uint8Array ? removeHexPrefix(sanitizeHex(buf2hex(pk))) : removeHexPrefix(sanitizeHex(toHex(pk)));
+      this.pk = pk instanceof Uint8Array ? buf2hex(pk).padStart(64, "0") : removeHexPrefix(toHex(pk)).padStart(64, "0");
     }
+    /**
+     * provides the Ethereum full public key (without parity prefix)
+     * @returns an hex string : 64 first characters are Point X coordinate. 64 last characters are Point Y coordinate.
+     */
     async getPubKey() {
-      return addHexPrefix(buf2hex(secp256k1.getPublicKey(this.pk)));
+      return addHexPrefix(
+        buf2hex(secp256k1.getPublicKey(this.pk, false)).padStart(130, "0").slice(2)
+      );
     }
     async signMessage(typedData, accountAddress) {
       const msgHash = getMessageHash(typedData, accountAddress);
-      return secp256k1.sign(removeHexPrefix(sanitizeHex(msgHash)), this.pk);
+      const signature = secp256k1.sign(
+        removeHexPrefix(sanitizeHex(msgHash)),
+        this.pk
+      );
+      return this.formatEthSignature(signature);
     }
     async signTransaction(transactions, details) {
       const compiledCalldata = getExecuteCalldata(transactions, details.cairoVersion);
@@ -26120,7 +26480,11 @@ var starknet = (() => {
       } else {
         throw Error("unsupported signTransaction version");
       }
-      return secp256k1.sign(removeHexPrefix(sanitizeHex(msgHash)), this.pk);
+      const signature = secp256k1.sign(
+        removeHexPrefix(sanitizeHex(msgHash)),
+        this.pk
+      );
+      return this.formatEthSignature(signature);
     }
     async signDeployAccountTransaction(details) {
       const compiledConstructorCalldata = CallData.compile(details.constructorCalldata);
@@ -26146,7 +26510,11 @@ var starknet = (() => {
       } else {
         throw Error("unsupported signDeployAccountTransaction version");
       }
-      return secp256k1.sign(removeHexPrefix(sanitizeHex(msgHash)), this.pk);
+      const signature = secp256k1.sign(
+        removeHexPrefix(sanitizeHex(msgHash)),
+        this.pk
+      );
+      return this.formatEthSignature(signature);
     }
     async signDeclareTransaction(details) {
       let msgHash;
@@ -26167,7 +26535,27 @@ var starknet = (() => {
       } else {
         throw Error("unsupported signDeclareTransaction version");
       }
-      return secp256k1.sign(removeHexPrefix(sanitizeHex(msgHash)), this.pk);
+      const signature = secp256k1.sign(
+        removeHexPrefix(sanitizeHex(msgHash)),
+        this.pk
+      );
+      return this.formatEthSignature(signature);
+    }
+    /**
+     * Serialize the signature in conformity with starknet::eth_signature::Signature
+     * @param ethSignature secp256k1 signature from Noble curves library
+     * @return an array of felts, representing a Cairo Eth Signature.
+     */
+    formatEthSignature(ethSignature) {
+      const r = bnToUint256(ethSignature.r);
+      const s = bnToUint256(ethSignature.s);
+      return [
+        toHex(r.low),
+        toHex(r.high),
+        toHex(s.low),
+        toHex(s.high),
+        toHex(ethSignature.recovery)
+      ];
     }
   };
 
@@ -26203,7 +26591,7 @@ var starknet = (() => {
     constructor(providerOrOptions, address, pkOrSigner, cairoVersion, transactionVersion = "0x2" /* V2 */) {
       super(providerOrOptions);
       this.address = address.toLowerCase();
-      this.signer = typeof pkOrSigner === "string" || pkOrSigner instanceof Uint8Array ? new Signer(pkOrSigner) : pkOrSigner;
+      this.signer = isString(pkOrSigner) || pkOrSigner instanceof Uint8Array ? new Signer(pkOrSigner) : pkOrSigner;
       if (cairoVersion) {
         this.cairoVersion = cairoVersion.toString();
       }
@@ -26344,7 +26732,7 @@ var starknet = (() => {
       return this.estimateInvokeFee(calls, details);
     }
     async estimateFeeBulk(invocations, details = {}) {
-      const { nonce, blockIdentifier, version } = details;
+      const { nonce, blockIdentifier, version, skipValidate } = details;
       const accountInvocations = await this.accountInvocationsFactory(invocations, {
         ...v3Details(details),
         versions: [
@@ -26357,11 +26745,12 @@ var starknet = (() => {
           // sierra
         ],
         nonce,
-        blockIdentifier
+        blockIdentifier,
+        skipValidate
       });
       return super.getEstimateFeeBulk(accountInvocations, {
         blockIdentifier,
-        skipValidate: details.skipValidate
+        skipValidate
       });
     }
     async simulateTransaction(invocations, details = {}) {
@@ -27365,25 +27754,6 @@ var starknet = (() => {
     // ethers.js' getDeployTransaction can't be supported as it requires the account or signer to return a signed transaction which is not possible with the current implementation
   };
 
-  // src/utils/uint256.ts
-  var uint256_exports = {};
-  __export(uint256_exports, {
-    UINT_128_MAX: () => UINT_128_MAX,
-    UINT_256_MAX: () => UINT_256_MAX,
-    bnToUint256: () => bnToUint256,
-    isUint256: () => isUint256,
-    uint256ToBN: () => uint256ToBN
-  });
-  function uint256ToBN(uint2562) {
-    return new CairoUint256(uint2562).toBigInt();
-  }
-  function isUint256(bn) {
-    return CairoUint256.is(bn);
-  }
-  function bnToUint256(bn) {
-    return new CairoUint256(bn).toUint256HexString();
-  }
-
   // src/utils/address.ts
   function addAddressPadding(address) {
     return addHexPrefix(removeHexPrefix(toHex(address)).padStart(64, "0"));