starknet 6.6.0 → 6.6.6

package/dist/index.mjs

@@ -14,6 +14,10 @@ __export(constants_exports, {
   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,
@@ -321,8 +325,13 @@ var TEXT_TO_FELT_MAX_LEN = 31;
 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";
@@ -457,11 +466,13 @@ var Uint = /* @__PURE__ */ ((Uint2) => {
   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 || {});
 
@@ -544,7 +555,9 @@ __export(num_exports, {
   hexToBytes: () => hexToBytes,
   hexToDecimalString: () => hexToDecimalString,
   isBigInt: () => isBigInt,
+  isBoolean: () => isBoolean,
   isHex: () => isHex,
+  isNumber: () => isNumber,
   isStringWholeNumber: () => isStringWholeNumber,
   toBigInt: () => toBigInt,
   toCairoBool: () => toCairoBool,
@@ -626,6 +639,12 @@ function addPercent(number2, percent) {
   const bigIntNum = BigInt(number2);
   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 = {};
@@ -671,6 +690,7 @@ __export(shortString_exports, {
   isLongText: () => isLongText,
   isShortString: () => isShortString,
   isShortText: () => isShortText,
+  isString: () => isString,
   isText: () => isText,
   splitLongString: () => splitLongString
 });
@@ -683,8 +703,11 @@ function isShortString(str) {
 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);
@@ -757,34 +780,38 @@ __export(cairo_exports, {
   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()`);
@@ -895,6 +922,130 @@ var CairoUint256 = class _CairoUint256 {
   }
 };
 
+// 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 (error) {
+      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";
@@ -913,6 +1064,7 @@ var isTypeContractAddress = (type) => type === "core::starknet::contract_address
 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)) {
@@ -946,6 +1098,9 @@ function getAbiContractVersion(abi) {
 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);
@@ -1350,6 +1505,11 @@ function errorU256(key) {
     `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)) {
@@ -1368,6 +1528,9 @@ function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
     if (isTypeByteArray(abiType)) {
       return unorderedItem;
     }
+    if (isTypeSecp256k1Point(abiType)) {
+      return unorderedItem;
+    }
     if (CairoUint256.isAbiType(abiType)) {
       const u256 = unorderedItem;
       if (typeof u256 !== "object") {
@@ -1378,6 +1541,16 @@ function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
       }
       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);
@@ -1402,7 +1575,7 @@ function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
   };
   function orderArray(myArray, abiParam) {
     const typeInArray = getArrayType(abiParam);
-    if (typeof myArray === "string") {
+    if (isString(myArray)) {
       return myArray;
     }
     return myArray.map((myElem) => orderInput(myElem, typeInArray));
@@ -1493,8 +1666,21 @@ function parseBaseTypes(type, val) {
   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);
   }
@@ -1541,6 +1727,9 @@ function parseCalldataValue(element, type, structs, enums) {
     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")
@@ -1561,6 +1750,9 @@ function parseCalldataValue(element, type, structs, enums) {
   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)) {
@@ -1653,13 +1845,13 @@ function parseCalldataField(argsIterator, input, structs, enums) {
       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(
@@ -1684,12 +1876,25 @@ function parseBaseTypes2(type, it) {
       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);
@@ -1704,6 +1909,13 @@ function parseResponseValue(responseIterator, element, structs, enums) {
     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);
@@ -1827,10 +2039,10 @@ function responseParser(responseIterator, output, structs, enums, parsedResult)
 // 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(
@@ -1840,27 +2052,37 @@ var validateFelt = (parameter, input) => {
   );
 };
 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(
@@ -1898,6 +2120,9 @@ var validateUint = (parameter, input) => {
         `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
@@ -1912,18 +2137,25 @@ var validateUint = (parameter, input) => {
         `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;
   }
@@ -2004,7 +2236,7 @@ var validateArray = (parameter, input, structs, enums) => {
       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));
@@ -2684,7 +2916,7 @@ function computeHintedClassHash(compiledContract) {
   return addHexPrefix(starkCurve.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 = computeHashOnElements2(
     compiledContract.entry_points_by_type.EXTERNAL.flatMap((e) => [e.selector, e.offset])
@@ -2780,7 +3012,7 @@ function computeSierraContractClassHash(sierra) {
   );
 }
 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);
   }
@@ -2808,7 +3040,7 @@ __export(stark_exports, {
 import { getStarkKey, utils } from "@scure/starknet";
 import { gzip, ungzip } from "pako";
 function compressProgram(jsonProgram) {
-  const stringified = typeof jsonProgram === "string" ? jsonProgram : stringify2(jsonProgram);
+  const stringified = isString(jsonProgram) ? jsonProgram : stringify2(jsonProgram);
   const compressedProgram = gzip(stringified);
   return btoaUniversal(compressedProgram);
 }
@@ -2848,7 +3080,7 @@ function estimatedFeeToMaxFee(estimatedFee, overhead = 50 /* MAX_FEE */) {
   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" }
@@ -2916,7 +3148,7 @@ function reduceV2(providedVersion) {
 
 // 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) {
@@ -2981,7 +3213,7 @@ function createSierraContractClass(contract) {
   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,
@@ -2998,7 +3230,7 @@ var getDefaultNodeUrl = (networkName, mute = false) => {
   return nodes[randIdx];
 };
 function formatHash(hashValue) {
-  if (typeof hashValue === "string")
+  if (isString(hashValue))
     return hashValue;
   return toHex(hashValue);
 }
@@ -3015,14 +3247,16 @@ var Block = class {
   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 */;
     }
@@ -4271,7 +4505,7 @@ var RPCResponseParser = class {
     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: {
@@ -4315,11 +4549,59 @@ var RPCResponseParser = class {
   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;
@@ -4404,7 +4686,9 @@ var RpcProvider = class {
     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);
@@ -4426,7 +4710,11 @@ var RpcProvider = class {
     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);
@@ -5131,6 +5419,10 @@ var revisionConfiguration = {
     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 */;
@@ -5142,7 +5434,7 @@ function getHex(value) {
   try {
     return toHex(value);
   } catch (e) {
-    if (typeof value === "string") {
+    if (isString(value)) {
       return toHex(encodeShortString(value));
     }
     throw new Error(`Invalid BigNumberish: ${value}`);
@@ -5293,15 +5585,41 @@ function encodeValue(types, type, data, ctx = {}, revision = "0" /* Legacy */) {
       }
       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}`);
@@ -5451,19 +5769,48 @@ function ethRandomPrivateKey() {
   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(secp256k12.getPublicKey(this.pk)));
+    return addHexPrefix(
+      buf2hex(secp256k12.getPublicKey(this.pk, false)).padStart(130, "0").slice(2)
+    );
   }
   async signMessage(typedData, accountAddress) {
     const msgHash = getMessageHash(typedData, accountAddress);
-    return secp256k12.sign(removeHexPrefix(sanitizeHex(msgHash)), this.pk);
+    const signature = secp256k12.sign(
+      removeHexPrefix(sanitizeHex(msgHash)),
+      this.pk
+    );
+    return this.formatEthSignature(signature);
   }
   async signTransaction(transactions, details) {
     const compiledCalldata = getExecuteCalldata(transactions, details.cairoVersion);
@@ -5489,7 +5836,11 @@ var EthSigner = class {
     } else {
       throw Error("unsupported signTransaction version");
     }
-    return secp256k12.sign(removeHexPrefix(sanitizeHex(msgHash)), this.pk);
+    const signature = secp256k12.sign(
+      removeHexPrefix(sanitizeHex(msgHash)),
+      this.pk
+    );
+    return this.formatEthSignature(signature);
   }
   async signDeployAccountTransaction(details) {
     const compiledConstructorCalldata = CallData.compile(details.constructorCalldata);
@@ -5515,7 +5866,11 @@ var EthSigner = class {
     } else {
       throw Error("unsupported signDeployAccountTransaction version");
     }
-    return secp256k12.sign(removeHexPrefix(sanitizeHex(msgHash)), this.pk);
+    const signature = secp256k12.sign(
+      removeHexPrefix(sanitizeHex(msgHash)),
+      this.pk
+    );
+    return this.formatEthSignature(signature);
   }
   async signDeclareTransaction(details) {
     let msgHash;
@@ -5536,7 +5891,27 @@ var EthSigner = class {
     } else {
       throw Error("unsupported signDeclareTransaction version");
     }
-    return secp256k12.sign(removeHexPrefix(sanitizeHex(msgHash)), this.pk);
+    const signature = secp256k12.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)
+    ];
   }
 };
 
@@ -5572,7 +5947,7 @@ var Account = class extends RpcProvider2 {
   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();
     }
@@ -5713,7 +6088,7 @@ var Account = class extends RpcProvider2 {
     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: [
@@ -5726,11 +6101,12 @@ var Account = class extends RpcProvider2 {
         // sierra
       ],
       nonce,
-      blockIdentifier
+      blockIdentifier,
+      skipValidate
     });
     return super.getEstimateFeeBulk(accountInvocations, {
       blockIdentifier,
-      skipValidate: details.skipValidate
+      skipValidate
     });
   }
   async simulateTransaction(invocations, details = {}) {
@@ -6734,25 +7110,6 @@ var ContractFactory = class {
   // 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
 import { hexToBytes as hexToBytes2 } from "@noble/curves/abstract/utils";
 function addAddressPadding(address) {
@@ -6825,6 +7182,8 @@ export {
   CairoOptionVariant,
   CairoResult,
   CairoResultVariant,
+  CairoUint256,
+  CairoUint512,
   CallData,
   Contract,
   ContractFactory,
@@ -6841,6 +7200,7 @@ export {
   api_exports as RPC,
   rpc_0_6_exports as RPC06,
   rpc_0_7_exports as RPC07,
+  ReceiptTx,
   RpcChannel2 as RpcChannel,
   RpcProvider2 as RpcProvider,
   SIMULATION_FLAG,
@@ -6851,6 +7211,16 @@ export {
   TransactionStatus,
   TransactionType,
   TypedDataRevision,
+  UINT_128_MAX,
+  UINT_128_MIN,
+  UINT_256_HIGH_MAX,
+  UINT_256_HIGH_MIN,
+  UINT_256_LOW_MAX,
+  UINT_256_LOW_MIN,
+  UINT_256_MAX,
+  UINT_256_MIN,
+  UINT_512_MAX,
+  UINT_512_MIN,
   Uint,
   ValidateType,
   WalletAccount,