starknet 6.6.0 → 6.7.0

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 || {});
 
@@ -517,11 +528,9 @@ var BlockTag = /* @__PURE__ */ ((BlockTag2) => {
 })(BlockTag || {});
 
 // src/types/typedData.ts
-var TypedDataRevision = /* @__PURE__ */ ((TypedDataRevision2) => {
-  TypedDataRevision2["Active"] = "1";
-  TypedDataRevision2["Legacy"] = "0";
-  return TypedDataRevision2;
-})(TypedDataRevision || {});
+import {
+  TypedDataRevision
+} from "starknet-types";
 
 // src/utils/assert.ts
 function assert(condition, message) {
@@ -544,7 +553,9 @@ __export(num_exports, {
   hexToBytes: () => hexToBytes,
   hexToDecimalString: () => hexToDecimalString,
   isBigInt: () => isBigInt,
+  isBoolean: () => isBoolean,
   isHex: () => isHex,
+  isNumber: () => isNumber,
   isStringWholeNumber: () => isStringWholeNumber,
   toBigInt: () => toBigInt,
   toCairoBool: () => toCairoBool,
@@ -626,6 +637,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 +688,7 @@ __export(shortString_exports, {
   isLongText: () => isLongText,
   isShortString: () => isShortString,
   isShortText: () => isShortText,
+  isString: () => isString,
   isText: () => isText,
   splitLongString: () => splitLongString
 });
@@ -683,8 +701,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 +778,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 +920,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 +1062,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 +1096,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 +1503,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 +1526,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 +1539,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 +1573,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 +1664,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 +1725,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 +1748,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 +1843,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 +1874,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 +1907,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 +2037,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 +2050,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 +2118,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 +2135,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 +2234,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 +2914,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 +3010,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 +3038,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 +3078,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 +3146,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) {
@@ -2943,6 +3173,23 @@ function contractClassResponseToLegacyCompiledContract(ccr) {
   return { ...contract, program: decompressProgram(contract.program) };
 }
 
+// src/utils/eth.ts
+var eth_exports = {};
+__export(eth_exports, {
+  ethRandomPrivateKey: () => ethRandomPrivateKey,
+  validateAndParseEthAddress: () => validateAndParseEthAddress
+});
+import { secp256k1 } from "@noble/curves/secp256k1";
+function ethRandomPrivateKey() {
+  return sanitizeHex(buf2hex(secp256k1.utils.randomPrivateKey()));
+}
+function validateAndParseEthAddress(address) {
+  assertInRange(address, ZERO, 2n ** 160n - 1n, "Ethereum Address ");
+  const result = addHexPrefix(removeHexPrefix(toHex(address)).padStart(40, "0"));
+  assert(result.match(/^(0x)?[0-9a-f]{40}$/), "Invalid Ethereum Address Format");
+  return result;
+}
+
 // src/utils/fetchPonyfill.ts
 import makeFetchCookie from "fetch-cookie";
 import isomorphicFetch from "isomorphic-fetch";
@@ -2981,7 +3228,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 +3245,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 +3262,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 */;
     }
@@ -3619,7 +3868,7 @@ var RpcChannel = class {
   estimateMessageFee(message, blockIdentifier = this.blockIdentifier) {
     const { from_address, to_address, entry_point_selector, payload } = message;
     const formattedMessage = {
-      from_address: toHex(from_address),
+      from_address: validateAndParseEthAddress(from_address),
       to_address: toHex(to_address),
       entry_point_selector: getSelector(entry_point_selector),
       payload: getHexStringArray(payload)
@@ -3731,11 +3980,11 @@ var RpcChannel2 = class {
   requestId;
   blockIdentifier;
   chainId;
-  speckVersion;
+  specVersion;
   waitMode;
   // behave like web2 rpc and return when tx is processed
   constructor(optionsOrProvider) {
-    const { nodeUrl, retries, headers, blockIdentifier, chainId, waitMode } = optionsOrProvider || {};
+    const { nodeUrl, retries, headers, blockIdentifier, chainId, specVersion, waitMode } = optionsOrProvider || {};
     if (Object.values(NetworkName).includes(nodeUrl)) {
       this.nodeUrl = getDefaultNodeUrl(nodeUrl, optionsOrProvider?.default);
     } else if (nodeUrl) {
@@ -3747,6 +3996,7 @@ var RpcChannel2 = class {
     this.headers = { ...defaultOptions2.headers, ...headers };
     this.blockIdentifier = blockIdentifier || defaultOptions2.blockIdentifier;
     this.chainId = chainId;
+    this.specVersion = specVersion;
     this.waitMode = waitMode || false;
     this.requestId = 0;
   }
@@ -3798,8 +4048,8 @@ var RpcChannel2 = class {
     return this.chainId;
   }
   async getSpecVersion() {
-    this.speckVersion ??= await this.fetchEndpoint("starknet_specVersion");
-    return this.speckVersion;
+    this.specVersion ??= await this.fetchEndpoint("starknet_specVersion");
+    return this.specVersion;
   }
   getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
     const contract_address = toHex(contractAddress);
@@ -4156,7 +4406,7 @@ var RpcChannel2 = class {
   estimateMessageFee(message, blockIdentifier = this.blockIdentifier) {
     const { from_address, to_address, entry_point_selector, payload } = message;
     const formattedMessage = {
-      from_address: toHex(from_address),
+      from_address: validateAndParseEthAddress(from_address),
       to_address: toHex(to_address),
       entry_point_selector: getSelector(entry_point_selector),
       payload: getHexStringArray(payload)
@@ -4271,7 +4521,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: {
@@ -4290,7 +4540,9 @@ var RPCResponseParser = class {
       gas_price: toBigInt(val.gas_price),
       unit: val.unit,
       suggestedMaxFee: this.estimatedFeeToMaxFee(val.overall_fee),
-      resourceBounds: this.estimateFeeToBounds(val)
+      resourceBounds: this.estimateFeeToBounds(val),
+      data_gas_consumed: val.data_gas_consumed ? toBigInt(val.data_gas_consumed) : 0n,
+      data_gas_price: val.data_gas_price ? toBigInt(val.data_gas_price) : 0n
     };
   }
   parseFeeEstimateBulkResponse(res) {
@@ -4300,7 +4552,9 @@ var RPCResponseParser = class {
       gas_price: toBigInt(val.gas_price),
       unit: val.unit,
       suggestedMaxFee: this.estimatedFeeToMaxFee(val.overall_fee),
-      resourceBounds: this.estimateFeeToBounds(val)
+      resourceBounds: this.estimateFeeToBounds(val),
+      data_gas_consumed: val.data_gas_consumed ? toBigInt(val.data_gas_consumed) : 0n,
+      data_gas_price: val.data_gas_price ? toBigInt(val.data_gas_price) : 0n
     }));
   }
   parseSimulateTransactionResponse(res) {
@@ -4315,11 +4569,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 +4706,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 +4730,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);
@@ -5116,14 +5424,14 @@ var presetTypes = {
   )
 };
 var revisionConfiguration = {
-  ["1" /* Active */]: {
+  [TypedDataRevision.Active]: {
     domain: "StarknetDomain",
     hashMethod: computePoseidonHashOnElements,
     hashMerkleMethod: computePoseidonHash,
     escapeTypeString: (s) => `"${s}"`,
     presetTypes
   },
-  ["0" /* Legacy */]: {
+  [TypedDataRevision.Legacy]: {
     domain: "StarkNetDomain",
     hashMethod: computePedersenHashOnElements,
     hashMerkleMethod: computePedersenHash,
@@ -5131,18 +5439,22 @@ 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 */;
-  if (revisionConfiguration["0" /* Legacy */].domain in types && (domain.revision ?? "0" /* Legacy */) === "0" /* Legacy */)
-    return "0" /* Legacy */;
+  if (revisionConfiguration[TypedDataRevision.Active].domain in types && domain.revision === TypedDataRevision.Active)
+    return TypedDataRevision.Active;
+  if (revisionConfiguration[TypedDataRevision.Legacy].domain in types && (domain.revision ?? TypedDataRevision.Legacy) === TypedDataRevision.Legacy)
+    return TypedDataRevision.Legacy;
   return void 0;
 }
 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}`);
@@ -5160,10 +5472,10 @@ function prepareSelector(selector) {
 function isMerkleTreeType(type) {
   return type.type === "merkletree";
 }
-function getDependencies(types, type, dependencies = [], contains = "", revision = "0" /* Legacy */) {
+function getDependencies(types, type, dependencies = [], contains = "", revision = TypedDataRevision.Legacy) {
   if (type[type.length - 1] === "*") {
     type = type.slice(0, -1);
-  } else if (revision === "1" /* Active */) {
+  } else if (revision === TypedDataRevision.Active) {
     if (type === "enum") {
       type = contains;
     } else if (type.match(/^\(.*\)$/)) {
@@ -5201,8 +5513,8 @@ function getMerkleTreeType(types, ctx) {
   }
   return "raw";
 }
-function encodeType(types, type, revision = "0" /* Legacy */) {
-  const allTypes = revision === "1" /* Active */ ? { ...types, ...revisionConfiguration[revision].presetTypes } : types;
+function encodeType(types, type, revision = TypedDataRevision.Legacy) {
+  const allTypes = revision === TypedDataRevision.Active ? { ...types, ...revisionConfiguration[revision].presetTypes } : types;
   const [primary, ...dependencies] = getDependencies(
     allTypes,
     type,
@@ -5214,17 +5526,17 @@ function encodeType(types, type, revision = "0" /* Legacy */) {
   const esc = revisionConfiguration[revision].escapeTypeString;
   return newTypes.map((dependency) => {
     const dependencyElements = allTypes[dependency].map((t) => {
-      const targetType = t.type === "enum" && revision === "1" /* Active */ ? t.contains : t.type;
+      const targetType = t.type === "enum" && revision === TypedDataRevision.Active ? t.contains : t.type;
       const typeString = targetType.match(/^\(.*\)$/) ? `(${targetType.slice(1, -1).split(",").map((e) => e ? esc(e) : e).join(",")})` : esc(targetType);
       return `${esc(t.name)}:${typeString}`;
     });
     return `${esc(dependency)}(${dependencyElements})`;
   }).join("");
 }
-function getTypeHash(types, type, revision = "0" /* Legacy */) {
+function getTypeHash(types, type, revision = TypedDataRevision.Legacy) {
   return getSelectorFromName(encodeType(types, type, revision));
 }
-function encodeValue(types, type, data, ctx = {}, revision = "0" /* Legacy */) {
+function encodeValue(types, type, data, ctx = {}, revision = TypedDataRevision.Legacy) {
   if (types[type]) {
     return [type, getStructHash(types, type, data, revision)];
   }
@@ -5247,7 +5559,7 @@ function encodeValue(types, type, data, ctx = {}, revision = "0" /* Legacy */) {
   }
   switch (type) {
     case "enum": {
-      if (revision === "1" /* Active */) {
+      if (revision === TypedDataRevision.Active) {
         const [variantKey, variantData] = Object.entries(data)[0];
         const parentType = types[ctx.parent][0];
         const enumType = types[parentType.contains];
@@ -5281,7 +5593,7 @@ function encodeValue(types, type, data, ctx = {}, revision = "0" /* Legacy */) {
       return ["felt", prepareSelector(data)];
     }
     case "string": {
-      if (revision === "1" /* Active */) {
+      if (revision === TypedDataRevision.Active) {
         const byteArray = byteArrayFromString(data);
         const elements = [
           byteArray.data.length,
@@ -5293,24 +5605,50 @@ function encodeValue(types, type, data, ctx = {}, revision = "0" /* Legacy */) {
       }
       return [type, getHex(data)];
     }
+    case "i128": {
+      if (revision === TypedDataRevision.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 === TypedDataRevision.Active) {
+        assertRange(data, type, RANGE_U128);
+      }
+      return [type, getHex(data)];
+    }
     case "felt":
-    case "bool":
-    case "u128":
-    case "i128":
-    case "ContractAddress":
+    case "shortstring": {
+      if (revision === TypedDataRevision.Active) {
+        assertRange(getHex(data), type, RANGE_FELT);
+      }
+      return [type, getHex(data)];
+    }
     case "ClassHash":
-    case "timestamp":
-    case "shortstring":
+    case "ContractAddress": {
+      if (revision === TypedDataRevision.Active) {
+        assertRange(data, type, RANGE_FELT);
+      }
       return [type, getHex(data)];
+    }
+    case "bool": {
+      if (revision === TypedDataRevision.Active) {
+        assert(typeof data === "boolean", `Type mismatch for ${type} ${data}`);
+      }
+      return [type, getHex(data)];
+    }
     default: {
-      if (revision === "1" /* Active */) {
+      if (revision === TypedDataRevision.Active) {
         throw new Error(`Unsupported type: ${type}`);
       }
       return [type, getHex(data)];
     }
   }
 }
-function encodeData(types, type, data, revision = "0" /* Legacy */) {
+function encodeData(types, type, data, revision = TypedDataRevision.Legacy) {
   const targetType = types[type] ?? revisionConfiguration[revision].presetTypes[type];
   const [returnTypes, values] = targetType.reduce(
     ([ts, vs], field) => {
@@ -5329,7 +5667,7 @@ function encodeData(types, type, data, revision = "0" /* Legacy */) {
   );
   return [returnTypes, values];
 }
-function getStructHash(types, type, data, revision = "0" /* Legacy */) {
+function getStructHash(types, type, data, revision = TypedDataRevision.Legacy) {
   return revisionConfiguration[revision].hashMethod(encodeData(types, type, data, revision)[1]);
 }
 function getMessageHash(typedData, account) {
@@ -5441,29 +5779,48 @@ var Signer = class {
 // src/signer/ethSigner.ts
 import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
 
-// src/utils/eth.ts
-var eth_exports = {};
-__export(eth_exports, {
-  ethRandomPrivateKey: () => ethRandomPrivateKey
+// 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
 });
-import { secp256k1 } from "@noble/curves/secp256k1";
-function ethRandomPrivateKey() {
-  return sanitizeHex(buf2hex(secp256k1.utils.randomPrivateKey()));
+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 +5846,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 +5876,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 +5901,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 +5957,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 +6098,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 +6111,12 @@ var Account = class extends RpcProvider2 {
         // sierra
       ],
       nonce,
-      blockIdentifier
+      blockIdentifier,
+      skipValidate
     });
     return super.getEstimateFeeBulk(accountInvocations, {
       blockIdentifier,
-      skipValidate: details.skipValidate
+      skipValidate
     });
   }
   async simulateTransaction(invocations, details = {}) {
@@ -5755,8 +6141,9 @@ var Account = class extends RpcProvider2 {
       skipExecute
     });
   }
-  async execute(calls, abis = void 0, details = {}) {
-    const transactions = Array.isArray(calls) ? calls : [calls];
+  async execute(transactions, arg2, transactionsDetail = {}) {
+    const details = arg2 === void 0 || Array.isArray(arg2) ? transactionsDetail : arg2;
+    const calls = Array.isArray(transactions) ? transactions : [transactions];
     const nonce = toBigInt(details.nonce ?? await this.getNonce());
     const version = toTransactionVersion(
       this.getPreferredVersion("0x1" /* V1 */, "0x3" /* V3 */),
@@ -5765,7 +6152,7 @@ var Account = class extends RpcProvider2 {
     );
     const estimate = await this.getUniversalSuggestedFee(
       version,
-      { type: "INVOKE_FUNCTION" /* INVOKE */, payload: calls },
+      { type: "INVOKE_FUNCTION" /* INVOKE */, payload: transactions },
       {
         ...details,
         version
@@ -5782,8 +6169,8 @@ var Account = class extends RpcProvider2 {
       chainId,
       cairoVersion: await this.getCairoVersion()
     };
-    const signature = await this.signer.signTransaction(transactions, signerDetails, abis);
-    const calldata = getExecuteCalldata(transactions, await this.getCairoVersion());
+    const signature = await this.signer.signTransaction(calls, signerDetails);
+    const calldata = getExecuteCalldata(calls, await this.getCairoVersion());
     return this.invokeFunction(
       { contractAddress: this.address, calldata, signature },
       {
@@ -5995,7 +6382,9 @@ var Account = class extends RpcProvider2 {
           overall_fee: ZERO,
           unit: "FRI",
           suggestedMaxFee: ZERO,
-          resourceBounds: estimateFeeToBounds(ZERO)
+          resourceBounds: estimateFeeToBounds(ZERO),
+          data_gas_consumed: 0n,
+          data_gas_price: 0n
         };
         break;
     }
@@ -6164,6 +6553,23 @@ var AccountInterface = class extends ProviderInterface {
 };
 
 // src/wallet/connect.ts
+var connect_exports = {};
+__export(connect_exports, {
+  addDeclareTransaction: () => addDeclareTransaction,
+  addDeployAccountTransaction: () => addDeployAccountTransaction,
+  addInvokeTransaction: () => addInvokeTransaction,
+  addStarknetChain: () => addStarknetChain,
+  deploymentData: () => deploymentData,
+  getPermissions: () => getPermissions,
+  onAccountChange: () => onAccountChange,
+  onNetworkChanged: () => onNetworkChanged,
+  requestAccounts: () => requestAccounts,
+  requestChainId: () => requestChainId,
+  signMessage: () => signMessage,
+  supportedSpecs: () => supportedSpecs,
+  switchStarknetChain: () => switchStarknetChain,
+  watchAsset: () => watchAsset
+});
 function requestAccounts(swo, silentMode = false) {
   return swo.request({
     type: "wallet_requestAccounts",
@@ -6734,25 +7140,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 +7212,8 @@ export {
   CairoOptionVariant,
   CairoResult,
   CairoResultVariant,
+  CairoUint256,
+  CairoUint512,
   CallData,
   Contract,
   ContractFactory,
@@ -6841,6 +7230,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,21 +7241,26 @@ 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,
   addAddressPadding,
-  addDeclareTransaction,
-  addDeployAccountTransaction,
-  addInvokeTransaction,
-  addStarknetChain,
   buildUrl,
   byteArray_exports as byteArray,
   cairo_exports as cairo,
   constants_exports as constants,
   contractClassResponseToLegacyCompiledContract,
   defaultProvider,
-  deploymentData,
   ec_exports as ec,
   encode_exports as encode,
   eth_exports as eth,
@@ -6875,7 +7270,6 @@ export {
   fixStack,
   getCalldata,
   getChecksumAddress,
-  getPermissions,
   hash_exports as hash,
   isSierra,
   isUrl,
@@ -6883,20 +7277,13 @@ export {
   merkle_exports as merkle,
   num_exports as num,
   number,
-  onAccountChange,
-  onNetworkChanged,
   parseUDCEvent,
   provider_exports as provider,
-  requestAccounts,
-  requestChainId,
   selector_exports as selector,
   shortString_exports as shortString,
-  signMessage,
   splitArgsAndOptions,
   stark_exports as stark,
   starknetId_exports as starknetId,
-  supportedSpecs,
-  switchStarknetChain,
   transaction_exports as transaction,
   typedData_exports as typedData,
   types_exports as types,
@@ -6905,6 +7292,6 @@ export {
   v3_exports as v3hash,
   validateAndParseAddress,
   validateChecksumAddress,
-  watchAsset
+  connect_exports as wallet
 };
 //# sourceMappingURL=index.mjs.map