starknet 5.7.0 → 5.9.0

package/dist/index.js

@@ -55,6 +55,7 @@ __export(src_exports, {
   encode: () => encode_exports,
   fixProto: () => fixProto,
   fixStack: () => fixStack,
+  getCalldata: () => getCalldata,
   getChecksumAddress: () => getChecksumAddress,
   hash: () => hash_exports,
   isUrl: () => isUrl,
@@ -63,6 +64,7 @@ __export(src_exports, {
   num: () => num_exports,
   number: () => number,
   shortString: () => shortString_exports,
+  splitArgsAndOptions: () => splitArgsAndOptions,
   stark: () => stark_exports,
   starknetId: () => starknetId_exports,
   transaction: () => transaction_exports,
@@ -112,9 +114,12 @@ var RPC;
   })(TransactionType2 = RPC2.TransactionType || (RPC2.TransactionType = {}));
 })(RPC || (RPC = {}));
 
-// src/utils/fetchPonyfill.ts
-var import_isomorphic_fetch = __toESM(require("isomorphic-fetch"));
-var fetchPonyfill_default = typeof window !== "undefined" && window.fetch || typeof global !== "undefined" && global.fetch || import_isomorphic_fetch.default;
+// src/utils/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "Assertion failure");
+  }
+}
 
 // src/utils/hash.ts
 var hash_exports = {};
@@ -2340,15 +2345,6 @@ __export(num_exports, {
   toHexString: () => toHexString
 });
 var import_utils = require("@noble/curves/abstract/utils");
-
-// src/utils/assert.ts
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message || "Assertion failure");
-  }
-}
-
-// src/utils/num.ts
 function isHex(hex) {
   return /^0x[0-9a-f]*$/i.test(hex);
 }
@@ -2548,6 +2544,9 @@ function felt(it) {
   if (typeof it === "string" && isStringWholeNumber(it)) {
     return it;
   }
+  if (typeof it === "boolean") {
+    return `${+it}`;
+  }
   throw new Error(`${it} can't be computed by felt()`);
 }
 
@@ -2809,584 +2808,1087 @@ function computeContractClassHash(contract) {
   return computeLegacyContractClassHash(compiledContract);
 }
 
-// src/utils/contract.ts
-function isSierra(contract) {
-  const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
-  return "sierra_program" in compiledContract;
-}
-function extractContractHashes(payload) {
-  const response = { ...payload };
-  if (isSierra(payload.contract)) {
-    if (!payload.compiledClassHash && payload.casm) {
-      response.compiledClassHash = computeCompiledClassHash(payload.casm);
-    }
-    if (!response.compiledClassHash)
+// src/utils/calldata/formatter.ts
+var guard = {
+  isBN: (data, type, key) => {
+    if (!isBigInt(data[key]))
       throw new Error(
-        "Extract compiledClassHash failed, provide (CairoAssembly).casm file or compiledClassHash"
+        `Data and formatter mismatch on ${key}:${type[key]}, expected response data ${key}:${data[key]} to be BN instead it is ${typeof data[key]}`
       );
+  },
+  unknown: (data, type, key) => {
+    throw new Error(`Unhandled formatter type on ${key}:${type[key]} for data ${key}:${data[key]}`);
   }
-  response.classHash = payload.classHash ?? computeContractClassHash(payload.contract);
-  if (!response.classHash)
-    throw new Error("Extract classHash failed, provide (CompiledContract).json file or classHash");
-  return response;
+};
+function formatter(data, type, sameType) {
+  return Object.entries(data).reduce((acc, [key, value]) => {
+    const elType = sameType ?? type[key];
+    if (!(key in type) && !sameType) {
+      acc[key] = value;
+      return acc;
+    }
+    if (elType === "string") {
+      if (Array.isArray(data[key])) {
+        const arrayStr = formatter(
+          data[key],
+          data[key].map((_) => elType)
+        );
+        acc[key] = Object.values(arrayStr).join("");
+        return acc;
+      }
+      guard.isBN(data, type, key);
+      acc[key] = decodeShortString(value);
+      return acc;
+    }
+    if (elType === "number") {
+      guard.isBN(data, type, key);
+      acc[key] = Number(value);
+      return acc;
+    }
+    if (typeof elType === "function") {
+      acc[key] = elType(value);
+      return acc;
+    }
+    if (Array.isArray(elType)) {
+      const arrayObj = formatter(data[key], elType, elType[0]);
+      acc[key] = Object.values(arrayObj);
+      return acc;
+    }
+    if (typeof elType === "object") {
+      acc[key] = formatter(data[key], elType);
+      return acc;
+    }
+    guard.unknown(data, type, key);
+    return acc;
+  }, {});
 }
 
-// src/utils/stark.ts
-var stark_exports = {};
-__export(stark_exports, {
-  compileCalldata: () => compileCalldata,
-  compressProgram: () => compressProgram,
-  estimatedFeeToMaxFee: () => estimatedFeeToMaxFee,
-  formatSignature: () => formatSignature,
-  makeAddress: () => makeAddress,
-  randomAddress: () => randomAddress,
-  signatureToDecimalArray: () => signatureToDecimalArray,
-  signatureToHexArray: () => signatureToHexArray
-});
-var import_micro_starknet2 = require("micro-starknet");
-var import_pako = require("pako");
-function compressProgram(jsonProgram) {
-  const stringified = typeof jsonProgram === "string" ? jsonProgram : stringify2(jsonProgram);
-  const compressedProgram = (0, import_pako.gzip)(stringified);
-  return btoaUniversal(compressedProgram);
-}
-function randomAddress() {
-  const randomKeyPair = import_micro_starknet2.utils.randomPrivateKey();
-  return (0, import_micro_starknet2.getStarkKey)(randomKeyPair);
-}
-function makeAddress(input) {
-  return addHexPrefix(input).toLowerCase();
+// src/utils/calldata/tuple.ts
+function parseNamedTuple(namedTuple) {
+  const name = namedTuple.substring(0, namedTuple.indexOf(":"));
+  const type = namedTuple.substring(name.length + ":".length);
+  return { name, type };
 }
-function formatSignature(sig) {
-  if (!sig)
-    throw Error("formatSignature: provided signature is undefined");
-  if (Array.isArray(sig)) {
-    return sig.map((it) => toHex(it));
-  }
-  try {
-    const { r, s } = sig;
-    return [toHex(r), toHex(s)];
-  } catch (e) {
-    throw new Error("Signature need to be weierstrass.SignatureType or an array for custom");
+function parseSubTuple(s) {
+  if (!s.includes("("))
+    return { subTuple: [], result: s };
+  const subTuple = [];
+  let result = "";
+  let i = 0;
+  while (i < s.length) {
+    if (s[i] === "(") {
+      let counter = 1;
+      const lBracket = i;
+      i++;
+      while (counter) {
+        if (s[i] === ")")
+          counter--;
+        if (s[i] === "(")
+          counter++;
+        i++;
+      }
+      subTuple.push(s.substring(lBracket, i));
+      result += " ";
+      i--;
+    } else {
+      result += s[i];
+    }
+    i++;
   }
+  return {
+    subTuple,
+    result
+  };
 }
-function signatureToDecimalArray(sig) {
-  return bigNumberishArrayToDecimalStringArray(formatSignature(sig));
-}
-function signatureToHexArray(sig) {
-  return bigNumberishArrayToHexadecimalStringArray(formatSignature(sig));
-}
-function compileCalldata(args) {
-  const compiledData = Object.values(args).flatMap((value) => {
-    if (Array.isArray(value))
-      return [toBigInt(value.length).toString(), ...value.map((x) => toBigInt(x).toString())];
-    if (typeof value === "object" && "type" in value)
-      return Object.entries(value).filter(([k]) => k !== "type").map(([, v]) => toBigInt(v).toString());
-    return toBigInt(value).toString();
-  });
-  Object.defineProperty(compiledData, "compiled", {
-    enumerable: false,
-    writable: false,
-    value: true
-  });
-  return compiledData;
-}
-function estimatedFeeToMaxFee(estimatedFee, overhead = 0.5) {
-  const overHeadPercent = Math.round((1 + overhead) * 100);
-  return toBigInt(estimatedFee) * toBigInt(overHeadPercent) / 100n;
-}
-
-// src/utils/provider.ts
-function wait(delay) {
-  return new Promise((res) => {
-    setTimeout(res, delay);
-  });
-}
-function parseCalldata(calldata = []) {
-  return calldata.map((data) => {
-    if (typeof data === "string" && isHex(data)) {
-      return data;
-    }
-    return toHex(data);
+function extractCairo0Tuple(type) {
+  const cleanType = type.replace(/\s/g, "").slice(1, -1);
+  const { subTuple, result } = parseSubTuple(cleanType);
+  let recomposed = result.split(",").map((it) => {
+    return subTuple.length ? it.replace(" ", subTuple.shift()) : it;
   });
+  if (isTypeNamedTuple(type)) {
+    recomposed = recomposed.reduce((acc, it) => {
+      return acc.concat(parseNamedTuple(it));
+    }, []);
+  }
+  return recomposed;
 }
-function createSierraContractClass(contract) {
-  const result = { ...contract };
-  delete result.sierra_program_debug_info;
-  result.abi = formatSpaces(stringify2(contract.abi));
-  result.sierra_program = formatSpaces(stringify2(contract.sierra_program));
-  result.sierra_program = compressProgram(result.sierra_program);
-  return result;
+function extractCairo1Tuple(type) {
+  const cleanType = type.replace(/\s/g, "").slice(1, -1);
+  return cleanType.split(",");
 }
-function parseContract(contract) {
-  const parsedContract = typeof contract === "string" ? parse2(contract) : contract;
-  if (!isSierra(contract)) {
-    return {
-      ...parsedContract,
-      ..."program" in parsedContract && { program: compressProgram(parsedContract.program) }
-    };
+function extractTupleMemberTypes(type) {
+  if (isCairo1Type(type)) {
+    return extractCairo1Tuple(type);
   }
-  return createSierraContractClass(parsedContract);
+  return extractCairo0Tuple(type);
 }
 
-// src/utils/responseParser/rpc.ts
-var RPCResponseParser = class {
-  parseGetBlockResponse(res) {
-    return {
-      timestamp: res.timestamp,
-      block_hash: res.block_hash,
-      block_number: res.block_number,
-      new_root: res.new_root,
-      parent_hash: res.parent_hash,
-      status: res.status,
-      transactions: res.transactions
-    };
+// src/utils/calldata/requestParser.ts
+function parseBaseTypes(type, val) {
+  switch (true) {
+    case isTypeUint256(type):
+      const el_uint256 = uint256(val);
+      return [felt(el_uint256.low), felt(el_uint256.high)];
+    default:
+      return felt(val);
   }
-  parseGetTransactionResponse(res) {
-    return {
-      calldata: res.calldata || [],
-      contract_address: res.contract_address,
-      sender_address: res.contract_address,
-      max_fee: res.max_fee,
-      nonce: res.nonce,
-      signature: res.signature || [],
-      transaction_hash: res.transaction_hash,
-      version: res.version
-    };
+}
+function parseTuple(element, typeStr) {
+  const memberTypes = extractTupleMemberTypes(typeStr);
+  const elements = Object.values(element);
+  if (elements.length !== memberTypes.length) {
+    throw Error(
+      `ParseTuple: provided and expected abi tuple size do not match.
+      provided: ${elements} 
+      expected: ${memberTypes}`
+    );
   }
-  parseFeeEstimateResponse(res) {
+  return memberTypes.map((it, dx) => {
     return {
-      overall_fee: toBigInt(res.overall_fee),
-      gas_consumed: toBigInt(res.gas_consumed),
-      gas_price: toBigInt(res.gas_price)
+      element: elements[dx],
+      type: it.type ?? it
     };
-  }
-  parseCallContractResponse(res) {
-    return {
-      result: res
-    };
-  }
-};
-
-// src/provider/errors.ts
-function fixStack(target, fn = target.constructor) {
-  const { captureStackTrace } = Error;
-  captureStackTrace && captureStackTrace(target, fn);
-}
-function fixProto(target, prototype) {
-  const { setPrototypeOf } = Object;
-  setPrototypeOf ? setPrototypeOf(target, prototype) : target.__proto__ = prototype;
+  });
 }
-var CustomError = class extends Error {
-  constructor(message) {
-    super(message);
-    Object.defineProperty(this, "name", {
-      value: new.target.name,
-      enumerable: false,
-      configurable: true
-    });
-    fixProto(this, new.target.prototype);
-    fixStack(this);
+function parseCalldataValue(element, type, structs) {
+  if (element === void 0) {
+    throw Error(`Missing parameter for type ${type}`);
   }
-};
-var LibraryError = class extends CustomError {
-};
-var GatewayError = class extends LibraryError {
-  constructor(message, errorCode) {
-    super(message);
-    this.errorCode = errorCode;
+  if (Array.isArray(element)) {
+    throw Error(`Array inside array (nD) are not supported by cairo. Element: ${element} ${type}`);
   }
-};
-var HttpError = class extends LibraryError {
-  constructor(message, errorCode) {
-    super(message);
-    this.errorCode = errorCode;
+  if (structs[type] && structs[type].members.length) {
+    const { members } = structs[type];
+    const subElement = element;
+    return members.reduce((acc, it) => {
+      return acc.concat(parseCalldataValue(subElement[it.name], it.type, structs));
+    }, []);
   }
-};
-
-// src/utils/starknetId.ts
-var starknetId_exports = {};
-__export(starknetId_exports, {
-  StarknetIdContract: () => StarknetIdContract,
-  getStarknetIdContract: () => getStarknetIdContract,
-  useDecoded: () => useDecoded,
-  useEncoded: () => useEncoded
-});
-var basicAlphabet = "abcdefghijklmnopqrstuvwxyz0123456789-";
-var basicSizePlusOne = BigInt(basicAlphabet.length + 1);
-var bigAlphabet = "\u8FD9\u6765";
-var basicAlphabetSize = BigInt(basicAlphabet.length);
-var bigAlphabetSize = BigInt(bigAlphabet.length);
-var bigAlphabetSizePlusOne = BigInt(bigAlphabet.length + 1);
-function extractStars(str) {
-  let k = 0;
-  while (str.endsWith(bigAlphabet[bigAlphabet.length - 1])) {
-    str = str.substring(0, str.length - 1);
-    k += 1;
+  if (isTypeTuple(type)) {
+    const tupled = parseTuple(element, type);
+    return tupled.reduce((acc, it) => {
+      const parsedData = parseCalldataValue(it.element, it.type, structs);
+      return acc.concat(parsedData);
+    }, []);
   }
-  return [str, k];
+  if (typeof element === "object") {
+    throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
+  }
+  return parseBaseTypes(type, element);
 }
-function useDecoded(encoded) {
-  let decoded = "";
-  encoded.forEach((subdomain) => {
-    while (subdomain !== ZERO) {
-      const code = subdomain % basicSizePlusOne;
-      subdomain /= basicSizePlusOne;
-      if (code === BigInt(basicAlphabet.length)) {
-        const nextSubdomain = subdomain / bigAlphabetSizePlusOne;
-        if (nextSubdomain === ZERO) {
-          const code2 = subdomain % bigAlphabetSizePlusOne;
-          subdomain = nextSubdomain;
-          if (code2 === ZERO)
-            decoded += basicAlphabet[0];
-          else
-            decoded += bigAlphabet[Number(code2) - 1];
+function parseCalldataField(argsIterator, input, structs) {
+  const { name, type } = input;
+  let { value } = argsIterator.next();
+  switch (true) {
+    case isTypeArray(type):
+      if (!Array.isArray(value) && !isText(value)) {
+        throw Error(`ABI expected parameter ${name} to be array or long string, got ${value}`);
+      }
+      if (typeof value === "string") {
+        value = splitLongString(value);
+      }
+      const result = [];
+      result.push(felt(value.length));
+      const arrayType = getArrayType(input.type);
+      return value.reduce((acc, el) => {
+        if (isTypeStruct(arrayType, structs) || isTypeTuple(arrayType) || isTypeArray(arrayType)) {
+          acc.push(...parseCalldataValue(el, arrayType, structs));
         } else {
-          const code2 = subdomain % bigAlphabetSize;
-          decoded += bigAlphabet[Number(code2)];
-          subdomain /= bigAlphabetSize;
+          return acc.concat(parseBaseTypes(arrayType, el));
         }
-      } else
-        decoded += basicAlphabet[Number(code)];
-    }
-    const [str, k] = extractStars(decoded);
-    if (k)
-      decoded = str + (k % 2 === 0 ? bigAlphabet[bigAlphabet.length - 1].repeat(k / 2 - 1) + bigAlphabet[0] + basicAlphabet[1] : bigAlphabet[bigAlphabet.length - 1].repeat((k - 1) / 2 + 1));
-    decoded += ".";
-  });
-  if (!decoded) {
-    return decoded;
+        return acc;
+      }, result);
+    case (isTypeStruct(type, structs) || isTypeTuple(type)):
+      return parseCalldataValue(value, type, structs);
+    default:
+      return parseBaseTypes(type, value);
   }
-  return decoded.concat("stark");
 }
-function useEncoded(decoded) {
-  let encoded = BigInt(0);
-  let multiplier = BigInt(1);
-  if (decoded.endsWith(bigAlphabet[0] + basicAlphabet[1])) {
-    const [str, k] = extractStars(decoded.substring(0, decoded.length - 2));
-    decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(2 * (k + 1));
-  } else {
-    const [str, k] = extractStars(decoded);
-    if (k)
-      decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(1 + 2 * (k - 1));
+
+// src/utils/calldata/responseParser.ts
+function parseBaseTypes2(type, it) {
+  let temp;
+  switch (true) {
+    case isTypeBool(type):
+      temp = it.next().value;
+      return Boolean(BigInt(temp));
+    case isTypeUint256(type):
+      const low = it.next().value;
+      const high = it.next().value;
+      return uint256ToBN({ low, high });
+    default:
+      temp = it.next().value;
+      return BigInt(temp);
   }
-  for (let i = 0; i < decoded.length; i += 1) {
-    const char = decoded[i];
-    const index = basicAlphabet.indexOf(char);
-    const bnIndex = BigInt(basicAlphabet.indexOf(char));
-    if (index !== -1) {
-      if (i === decoded.length - 1 && decoded[i] === basicAlphabet[0]) {
-        encoded += multiplier * basicAlphabetSize;
-        multiplier *= basicSizePlusOne;
-        multiplier *= basicSizePlusOne;
-      } else {
-        encoded += multiplier * bnIndex;
-        multiplier *= basicSizePlusOne;
-      }
-    } else if (bigAlphabet.indexOf(char) !== -1) {
-      encoded += multiplier * basicAlphabetSize;
-      multiplier *= basicSizePlusOne;
-      const newid = (i === decoded.length - 1 ? 1 : 0) + bigAlphabet.indexOf(char);
-      encoded += multiplier * BigInt(newid);
-      multiplier *= bigAlphabetSize;
-    }
+}
+function parseResponseStruct(responseIterator, type, structs) {
+  if (type in structs && structs[type]) {
+    return structs[type].members.reduce((acc, el) => {
+      acc[el.name] = parseResponseStruct(responseIterator, el.type, structs);
+      return acc;
+    }, {});
   }
-  return encoded;
+  if (isTypeTuple(type)) {
+    const memberTypes = extractTupleMemberTypes(type);
+    return memberTypes.reduce((acc, it, idx) => {
+      const tName = (it == null ? void 0 : it.name) ? it.name : idx;
+      const tType = (it == null ? void 0 : it.type) ? it.type : it;
+      acc[tName] = parseResponseStruct(responseIterator, tType, structs);
+      return acc;
+    }, {});
+  }
+  return parseBaseTypes2(type, responseIterator);
 }
-var StarknetIdContract = /* @__PURE__ */ ((StarknetIdContract2) => {
-  StarknetIdContract2["MAINNET"] = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678";
-  StarknetIdContract2["TESTNET"] = "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce";
-  return StarknetIdContract2;
-})(StarknetIdContract || {});
-function getStarknetIdContract(chainId) {
-  switch (chainId) {
-    case "0x534e5f4d41494e" /* SN_MAIN */:
-      return "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678" /* MAINNET */;
-    case "0x534e5f474f45524c49" /* SN_GOERLI */:
-      return "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce" /* TESTNET */;
+function responseParser(responseIterator, output, structs, parsedResult) {
+  const { name, type } = output;
+  let temp;
+  switch (true) {
+    case isLen(name):
+      temp = responseIterator.next().value;
+      return BigInt(temp);
+    case isTypeArray(type):
+      const parsedDataArr = [];
+      if (isCairo1Type(type)) {
+        const arrayType = getArrayType(type);
+        const len = BigInt(responseIterator.next().value);
+        while (parsedDataArr.length < len) {
+          parsedDataArr.push(parseResponseStruct(responseIterator, arrayType, structs));
+        }
+        return parsedDataArr;
+      }
+      if (parsedResult && parsedResult[`${name}_len`]) {
+        const arrLen = parsedResult[`${name}_len`];
+        while (parsedDataArr.length < arrLen) {
+          parsedDataArr.push(
+            parseResponseStruct(responseIterator, output.type.replace("*", ""), structs)
+          );
+        }
+      }
+      return parsedDataArr;
+    case (type in structs || isTypeTuple(type)):
+      return parseResponseStruct(responseIterator, type, structs);
     default:
-      throw new Error("Starknet.id is not yet deployed on this network");
+      return parseBaseTypes2(type, responseIterator);
   }
 }
 
-// src/provider/starknetId.ts
-async function getStarkName(provider, address, StarknetIdContract2) {
-  const chainId = await provider.getChainId();
-  const contract = StarknetIdContract2 ?? getStarknetIdContract(chainId);
-  try {
-    const hexDomain = await provider.callContract({
-      contractAddress: contract,
-      entrypoint: "address_to_domain",
-      calldata: compileCalldata({
-        address
-      })
-    });
-    const decimalDomain = hexDomain.result.map((element) => BigInt(element)).slice(1);
-    const stringDomain = useDecoded(decimalDomain);
-    if (!stringDomain) {
-      throw Error("Starkname not found");
-    }
-    return stringDomain;
-  } catch (e) {
-    if (e instanceof Error && e.message === "Starkname not found") {
-      throw e;
-    }
-    throw Error("Could not get stark name");
+// src/utils/calldata/validate.ts
+var validateFelt = (parameter, input) => {
+  assert(
+    typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
+    `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`
+  );
+};
+var validateUint = (parameter, input) => {
+  if (typeof parameter === "number") {
+    assert(
+      parameter <= Number.MAX_SAFE_INTEGER,
+      `Validation: Parameter is to large to be typed as Number use (BigInt or String)`
+    );
   }
-}
-async function getAddressFromStarkName(provider, name, StarknetIdContract2) {
-  const chainId = await provider.getChainId();
-  const contract = StarknetIdContract2 ?? getStarknetIdContract(chainId);
-  try {
-    const addressData = await provider.callContract({
-      contractAddress: contract,
-      entrypoint: "domain_to_address",
-      calldata: compileCalldata({
-        domain: [useEncoded(name.replace(".stark", "")).toString(10)]
-      })
-    });
-    return addressData.result[0];
-  } catch {
-    throw Error("Could not get address from stark name");
+  assert(
+    typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
+    `Validate: arg ${input.name} of cairo type ${input.type} should be type (String, Number or BigInt)`
+  );
+  const param = toBigInt(parameter);
+  switch (input.type) {
+    case "core::integer::u8" /* u8 */:
+      assert(
+        param >= 0n && param <= 255n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
+      );
+      break;
+    case "core::integer::u16" /* u16 */:
+      assert(
+        param >= 0n && param <= 65535n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
+      );
+      break;
+    case "core::integer::u32" /* u32 */:
+      assert(
+        param >= 0n && param <= 4294967295n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
+      );
+      break;
+    case "core::integer::u64" /* u64 */:
+      assert(
+        param >= 0n && param <= 2n ** 64n - 1n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^64-1]`
+      );
+      break;
+    case "core::integer::u128" /* u128 */:
+      assert(
+        param >= 0n && param <= 2n ** 128n - 1n,
+        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^128-1]`
+      );
+      break;
+    case "core::integer::u256" /* u256 */:
+      assert(
+        param >= 0n && param <= 2n ** 256n - 1n,
+        `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
+      );
+      break;
+    default:
+      break;
   }
-}
-
-// src/provider/utils.ts
-var validBlockTags = ["latest", "pending"];
-var Block = class {
-  constructor(_identifier) {
-    this.hash = null;
-    this.number = null;
-    this.tag = null;
-    this.valueOf = () => this.number;
-    this.toString = () => this.hash;
-    this.setIdentifier(_identifier);
+};
+var validateBool = (parameter, input) => {
+  assert(
+    typeof parameter === "boolean",
+    `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`
+  );
+};
+var validateStruct = (parameter, input, structs) => {
+  assert(
+    typeof parameter === "object" && !Array.isArray(parameter),
+    `Validate: arg ${input.name} is cairo type struct (${input.type}), and should be defined as js object (not array)`
+  );
+  structs[input.type].members.forEach(({ name }) => {
+    assert(
+      Object.keys(parameter).includes(name),
+      `Validate: arg ${input.name} should have a property ${name}`
+    );
+  });
+};
+var validateTuple = (parameter, input) => {
+  assert(
+    typeof parameter === "object" && !Array.isArray(parameter),
+    `Validate: arg ${input.name} should be a tuple (defined as object)`
+  );
+};
+var validateArray = (parameter, input, structs) => {
+  const baseType = getArrayType(input.type);
+  if (isTypeFelt(baseType) && isLongText(parameter))
+    return;
+  assert(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
+  switch (true) {
+    case isTypeFelt(baseType):
+      parameter.forEach((param) => validateFelt(param, input));
+      break;
+    case isTypeTuple(baseType):
+      parameter.forEach((it) => validateTuple(it, { name: input.name, type: baseType }));
+      break;
+    case isTypeStruct(baseType, structs):
+      parameter.forEach(
+        (it) => validateStruct(it, { name: input.name, type: baseType }, structs)
+      );
+      break;
+    case isTypeUint(baseType):
+      parameter.forEach((param) => validateUint(param, input));
+      break;
+    case isTypeBool(baseType):
+      parameter.forEach((param) => validateBool(param, input));
+      break;
+    default:
+      throw new Error(
+        `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
+      );
   }
-  setIdentifier(__identifier) {
-    if (typeof __identifier === "string" && isHex(__identifier)) {
-      this.hash = __identifier;
-    } else if (typeof __identifier === "bigint") {
-      this.hash = toHex(__identifier);
-    } else if (typeof __identifier === "number") {
-      this.number = __identifier;
-    } else if (typeof __identifier === "string" && validBlockTags.includes(__identifier)) {
-      this.tag = __identifier;
-    } else {
-      this.tag = "pending";
+};
+function validateFields(abiMethod, args, structs) {
+  abiMethod.inputs.reduce((acc, input) => {
+    const parameter = args[acc];
+    switch (true) {
+      case isLen(input.name):
+        return acc;
+      case isTypeFelt(input.type):
+        validateFelt(parameter, input);
+        break;
+      case isTypeUint(input.type):
+        validateUint(parameter, input);
+        break;
+      case isTypeBool(input.type):
+        validateBool(parameter, input);
+        break;
+      case isTypeContractAddress(input.type):
+        break;
+      case isTypeStruct(input.type, structs):
+        validateStruct(parameter, input, structs);
+        break;
+      case isTypeTuple(input.type):
+        validateTuple(parameter, input);
+        break;
+      case isTypeArray(input.type):
+        validateArray(parameter, input, structs);
+        break;
+      default:
+        throw new Error(
+          `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
+        );
     }
+    return acc + 1;
+  }, 0);
+}
+
+// src/utils/calldata/index.ts
+var CallData = class {
+  constructor(abi) {
+    this.abi = abi;
+    this.structs = CallData.getAbiStruct(abi);
   }
-  get queryIdentifier() {
-    if (this.number !== null) {
-      return `blockNumber=${this.number}`;
+  validate(type, method, args = []) {
+    if (type !== "DEPLOY") {
+      const invocableFunctionNames = this.abi.filter((abi) => {
+        if (abi.type !== "function")
+          return false;
+        const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
+        return type === "INVOKE" ? !isView : isView;
+      }).map((abi) => abi.name);
+      assert(
+        invocableFunctionNames.includes(method),
+        `${type === "INVOKE" ? "invocable" : "viewable"} method not found in abi`
+      );
     }
-    if (this.hash !== null) {
-      return `blockHash=${this.hash}`;
+    const abiMethod = this.abi.find(
+      (abi) => type === "DEPLOY" ? abi.name === method && abi.type === method : abi.name === method && abi.type === "function"
+    );
+    const inputsLength = CallData.abiInputsLength(abiMethod.inputs);
+    if (args.length !== inputsLength) {
+      throw Error(
+        `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
+      );
     }
-    return `blockNumber=${this.tag}`;
+    validateFields(abiMethod, args, this.structs);
   }
-  get identifier() {
-    if (this.number !== null) {
-      return { block_number: this.number };
-    }
-    if (this.hash !== null) {
-      return { block_hash: this.hash };
+  compile(method, args) {
+    const argsIterator = args[Symbol.iterator]();
+    const { inputs } = this.abi.find((abi) => abi.name === method);
+    return inputs.reduce(
+      (acc, input) => isLen(input.name) ? acc : acc.concat(parseCalldataField(argsIterator, input, this.structs)),
+      []
+    );
+  }
+  static compile(rawArgs) {
+    const createTree = (obj) => {
+      const getEntries = (o, prefix = "") => {
+        const oe = Array.isArray(o) ? [o.length.toString(), ...o] : o;
+        return Object.entries(oe).flatMap(([k, v]) => {
+          let value = v;
+          if (isLongText(value))
+            value = splitLongString(value);
+          if (k === "entrypoint")
+            value = getSelectorFromName(value);
+          const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
+          if (isBigInt(value))
+            return [[`${prefix}${kk}`, felt(value)]];
+          return Object(value) === value ? getEntries(value, `${prefix}${kk}.`) : [[`${prefix}${kk}`, felt(value)]];
+        });
+      };
+      return Object.fromEntries(getEntries(obj));
+    };
+    let callTreeArray;
+    if (!Array.isArray(rawArgs)) {
+      const callTree = createTree(rawArgs);
+      callTreeArray = Object.values(callTree);
+    } else {
+      const callObj = { ...rawArgs };
+      const callTree = createTree(callObj);
+      callTreeArray = Object.values(callTree);
     }
-    return this.tag;
+    Object.defineProperty(callTreeArray, "__compiled__", {
+      enumerable: false,
+      writable: false,
+      value: true
+    });
+    return callTreeArray;
   }
-  set identifier(_identifier) {
-    this.setIdentifier(_identifier);
+  parse(method, response) {
+    const { outputs } = this.abi.find((abi) => abi.name === method);
+    const responseIterator = response.flat()[Symbol.iterator]();
+    const parsed = outputs.flat().reduce((acc, output, idx) => {
+      const propName = output.name ?? idx;
+      acc[propName] = responseParser(responseIterator, output, this.structs, acc);
+      if (acc[propName] && acc[`${propName}_len`]) {
+        delete acc[`${propName}_len`];
+      }
+      return acc;
+    }, {});
+    return Object.keys(parsed).length === 1 && 0 in parsed ? parsed[0] : parsed;
   }
-  get sequencerIdentifier() {
-    return this.hash !== null ? { blockHash: this.hash } : { blockNumber: this.number ?? this.tag };
+  format(method, response, format) {
+    const parsed = this.parse(method, response);
+    return formatter(parsed, format);
   }
-};
-
-// src/provider/rpc.ts
-var defaultOptions = {
-  headers: { "Content-Type": "application/json" },
-  blockIdentifier: "latest",
-  retries: 200
-};
-var RpcProvider = class {
-  constructor(optionsOrProvider) {
-    this.responseParser = new RPCResponseParser();
-    const { nodeUrl, retries, headers, blockIdentifier } = optionsOrProvider;
-    this.nodeUrl = nodeUrl;
-    this.retries = retries || defaultOptions.retries;
-    this.headers = { ...defaultOptions.headers, ...headers };
-    this.blockIdentifier = blockIdentifier || defaultOptions.blockIdentifier;
-    this.getChainId();
-  }
-  fetch(method, params) {
-    return fetchPonyfill_default(this.nodeUrl, {
-      method: "POST",
-      body: stringify2({ method, jsonrpc: "2.0", params, id: 0 }),
-      headers: this.headers
-    });
-  }
-  errorHandler(error) {
-    if (error) {
-      const { code, message } = error;
-      throw new LibraryError(`${code}: ${message}`);
-    }
+  static abiInputsLength(inputs) {
+    return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
   }
-  async fetchEndpoint(method, params) {
-    var _a;
-    try {
-      const rawResult = await this.fetch(method, params);
-      const { error, result } = await rawResult.json();
-      this.errorHandler(error);
-      return result;
-    } catch (error) {
-      this.errorHandler((_a = error == null ? void 0 : error.response) == null ? void 0 : _a.data);
-      throw error;
-    }
+  static getAbiStruct(abi) {
+    return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
+      (acc, abiEntry) => ({
+        ...acc,
+        [abiEntry.name]: abiEntry
+      }),
+      {}
+    );
   }
-  async getChainId() {
-    this.chainId ?? (this.chainId = await this.fetchEndpoint("starknet_chainId"));
-    return this.chainId;
+  static toCalldata(rawCalldata = []) {
+    return CallData.compile(rawCalldata);
   }
-  async getBlock(blockIdentifier = this.blockIdentifier) {
-    return this.getBlockWithTxHashes(blockIdentifier).then(
-      this.responseParser.parseGetBlockResponse
-    );
+  static toHex(rawCalldata = []) {
+    const calldata = CallData.compile(rawCalldata);
+    return calldata.map((it) => toHex(it));
   }
-  async getBlockHashAndNumber() {
-    return this.fetchEndpoint("starknet_blockHashAndNumber");
+};
+
+// src/utils/fetchPonyfill.ts
+var import_isomorphic_fetch = __toESM(require("isomorphic-fetch"));
+var fetchPonyfill_default = typeof window !== "undefined" && window.fetch || typeof global !== "undefined" && global.fetch || import_isomorphic_fetch.default;
+
+// src/utils/contract.ts
+function isSierra(contract) {
+  const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
+  return "sierra_program" in compiledContract;
+}
+function extractContractHashes(payload) {
+  const response = { ...payload };
+  if (isSierra(payload.contract)) {
+    if (!payload.compiledClassHash && payload.casm) {
+      response.compiledClassHash = computeCompiledClassHash(payload.casm);
+    }
+    if (!response.compiledClassHash)
+      throw new Error(
+        "Extract compiledClassHash failed, provide (CairoAssembly).casm file or compiledClassHash"
+      );
   }
-  async getBlockWithTxHashes(blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getBlockWithTxHashes", { block_id });
+  response.classHash = payload.classHash ?? computeContractClassHash(payload.contract);
+  if (!response.classHash)
+    throw new Error("Extract classHash failed, provide (CompiledContract).json file or classHash");
+  return response;
+}
+
+// src/utils/stark.ts
+var stark_exports = {};
+__export(stark_exports, {
+  compressProgram: () => compressProgram,
+  estimatedFeeToMaxFee: () => estimatedFeeToMaxFee,
+  formatSignature: () => formatSignature,
+  makeAddress: () => makeAddress,
+  randomAddress: () => randomAddress,
+  signatureToDecimalArray: () => signatureToDecimalArray,
+  signatureToHexArray: () => signatureToHexArray
+});
+var import_micro_starknet2 = require("micro-starknet");
+var import_pako = require("pako");
+function compressProgram(jsonProgram) {
+  const stringified = typeof jsonProgram === "string" ? jsonProgram : stringify2(jsonProgram);
+  const compressedProgram = (0, import_pako.gzip)(stringified);
+  return btoaUniversal(compressedProgram);
+}
+function randomAddress() {
+  const randomKeyPair = import_micro_starknet2.utils.randomPrivateKey();
+  return (0, import_micro_starknet2.getStarkKey)(randomKeyPair);
+}
+function makeAddress(input) {
+  return addHexPrefix(input).toLowerCase();
+}
+function formatSignature(sig) {
+  if (!sig)
+    throw Error("formatSignature: provided signature is undefined");
+  if (Array.isArray(sig)) {
+    return sig.map((it) => toHex(it));
   }
-  async getBlockWithTxs(blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getBlockWithTxs", { block_id });
+  try {
+    const { r, s } = sig;
+    return [toHex(r), toHex(s)];
+  } catch (e) {
+    throw new Error("Signature need to be weierstrass.SignatureType or an array for custom");
   }
-  async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getClassHashAt", {
-      block_id,
-      contract_address: contractAddress
-    });
+}
+function signatureToDecimalArray(sig) {
+  return bigNumberishArrayToDecimalStringArray(formatSignature(sig));
+}
+function signatureToHexArray(sig) {
+  return bigNumberishArrayToHexadecimalStringArray(formatSignature(sig));
+}
+function estimatedFeeToMaxFee(estimatedFee, overhead = 0.5) {
+  const overHeadPercent = Math.round((1 + overhead) * 100);
+  return toBigInt(estimatedFee) * toBigInt(overHeadPercent) / 100n;
+}
+
+// src/utils/provider.ts
+function wait(delay) {
+  return new Promise((res) => {
+    setTimeout(res, delay);
+  });
+}
+function createSierraContractClass(contract) {
+  const result = { ...contract };
+  delete result.sierra_program_debug_info;
+  result.abi = formatSpaces(stringify2(contract.abi));
+  result.sierra_program = formatSpaces(stringify2(contract.sierra_program));
+  result.sierra_program = compressProgram(result.sierra_program);
+  return result;
+}
+function parseContract(contract) {
+  const parsedContract = typeof contract === "string" ? parse2(contract) : contract;
+  if (!isSierra(contract)) {
+    return {
+      ...parsedContract,
+      ..."program" in parsedContract && { program: compressProgram(parsedContract.program) }
+    };
   }
-  async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getNonce", {
-      contract_address: contractAddress,
-      block_id
-    });
+  return createSierraContractClass(parsedContract);
+}
+
+// src/utils/responseParser/rpc.ts
+var RPCResponseParser = class {
+  parseGetBlockResponse(res) {
+    return {
+      timestamp: res.timestamp,
+      block_hash: res.block_hash,
+      block_number: res.block_number,
+      new_root: res.new_root,
+      parent_hash: res.parent_hash,
+      status: res.status,
+      transactions: res.transactions
+    };
   }
-  async getPendingTransactions() {
-    return this.fetchEndpoint("starknet_pendingTransactions");
+  parseGetTransactionResponse(res) {
+    return {
+      calldata: res.calldata || [],
+      contract_address: res.contract_address,
+      sender_address: res.contract_address,
+      max_fee: res.max_fee,
+      nonce: res.nonce,
+      signature: res.signature || [],
+      transaction_hash: res.transaction_hash,
+      version: res.version
+    };
   }
-  async getProtocolVersion() {
-    throw new Error("Pathfinder does not implement this rpc 0.1.0 method");
+  parseFeeEstimateResponse(res) {
+    return {
+      overall_fee: toBigInt(res.overall_fee),
+      gas_consumed: toBigInt(res.gas_consumed),
+      gas_price: toBigInt(res.gas_price)
+    };
   }
-  async getStateUpdate(blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
+  parseCallContractResponse(res) {
+    return {
+      result: res
+    };
   }
-  async getStorageAt(contractAddress, key, blockIdentifier = this.blockIdentifier) {
-    const parsedKey = toHex(key);
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getStorageAt", {
-      contract_address: contractAddress,
-      key: parsedKey,
-      block_id
+};
+
+// src/provider/errors.ts
+function fixStack(target, fn = target.constructor) {
+  const { captureStackTrace } = Error;
+  captureStackTrace && captureStackTrace(target, fn);
+}
+function fixProto(target, prototype) {
+  const { setPrototypeOf } = Object;
+  setPrototypeOf ? setPrototypeOf(target, prototype) : target.__proto__ = prototype;
+}
+var CustomError = class extends Error {
+  constructor(message) {
+    super(message);
+    Object.defineProperty(this, "name", {
+      value: new.target.name,
+      enumerable: false,
+      configurable: true
     });
+    fixProto(this, new.target.prototype);
+    fixStack(this);
   }
-  async getTransaction(txHash) {
-    return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
-  }
-  async getTransactionByHash(txHash) {
-    return this.fetchEndpoint("starknet_getTransactionByHash", { transaction_hash: txHash });
+};
+var LibraryError = class extends CustomError {
+};
+var GatewayError = class extends LibraryError {
+  constructor(message, errorCode) {
+    super(message);
+    this.errorCode = errorCode;
   }
-  async getTransactionByBlockIdAndIndex(blockIdentifier, index) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getTransactionByBlockIdAndIndex", { block_id, index });
+};
+var HttpError = class extends LibraryError {
+  constructor(message, errorCode) {
+    super(message);
+    this.errorCode = errorCode;
   }
-  async getTransactionReceipt(txHash) {
-    return this.fetchEndpoint("starknet_getTransactionReceipt", { transaction_hash: txHash });
+};
+
+// src/utils/starknetId.ts
+var starknetId_exports = {};
+__export(starknetId_exports, {
+  StarknetIdContract: () => StarknetIdContract,
+  getStarknetIdContract: () => getStarknetIdContract,
+  useDecoded: () => useDecoded,
+  useEncoded: () => useEncoded
+});
+var basicAlphabet = "abcdefghijklmnopqrstuvwxyz0123456789-";
+var basicSizePlusOne = BigInt(basicAlphabet.length + 1);
+var bigAlphabet = "\u8FD9\u6765";
+var basicAlphabetSize = BigInt(basicAlphabet.length);
+var bigAlphabetSize = BigInt(bigAlphabet.length);
+var bigAlphabetSizePlusOne = BigInt(bigAlphabet.length + 1);
+function extractStars(str) {
+  let k = 0;
+  while (str.endsWith(bigAlphabet[bigAlphabet.length - 1])) {
+    str = str.substring(0, str.length - 1);
+    k += 1;
   }
-  async getClassByHash(classHash) {
-    return this.getClass(classHash);
+  return [str, k];
+}
+function useDecoded(encoded) {
+  let decoded = "";
+  encoded.forEach((subdomain) => {
+    while (subdomain !== ZERO) {
+      const code = subdomain % basicSizePlusOne;
+      subdomain /= basicSizePlusOne;
+      if (code === BigInt(basicAlphabet.length)) {
+        const nextSubdomain = subdomain / bigAlphabetSizePlusOne;
+        if (nextSubdomain === ZERO) {
+          const code2 = subdomain % bigAlphabetSizePlusOne;
+          subdomain = nextSubdomain;
+          if (code2 === ZERO)
+            decoded += basicAlphabet[0];
+          else
+            decoded += bigAlphabet[Number(code2) - 1];
+        } else {
+          const code2 = subdomain % bigAlphabetSize;
+          decoded += bigAlphabet[Number(code2)];
+          subdomain /= bigAlphabetSize;
+        }
+      } else
+        decoded += basicAlphabet[Number(code)];
+    }
+    const [str, k] = extractStars(decoded);
+    if (k)
+      decoded = str + (k % 2 === 0 ? bigAlphabet[bigAlphabet.length - 1].repeat(k / 2 - 1) + bigAlphabet[0] + basicAlphabet[1] : bigAlphabet[bigAlphabet.length - 1].repeat((k - 1) / 2 + 1));
+    decoded += ".";
+  });
+  if (!decoded) {
+    return decoded;
   }
-  async getClass(classHash, blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getClass", { class_hash: classHash, block_id });
+  return decoded.concat("stark");
+}
+function useEncoded(decoded) {
+  let encoded = BigInt(0);
+  let multiplier = BigInt(1);
+  if (decoded.endsWith(bigAlphabet[0] + basicAlphabet[1])) {
+    const [str, k] = extractStars(decoded.substring(0, decoded.length - 2));
+    decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(2 * (k + 1));
+  } else {
+    const [str, k] = extractStars(decoded);
+    if (k)
+      decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(1 + 2 * (k - 1));
   }
-  async getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getClassAt", {
-      block_id,
-      contract_address: contractAddress
+  for (let i = 0; i < decoded.length; i += 1) {
+    const char = decoded[i];
+    const index = basicAlphabet.indexOf(char);
+    const bnIndex = BigInt(basicAlphabet.indexOf(char));
+    if (index !== -1) {
+      if (i === decoded.length - 1 && decoded[i] === basicAlphabet[0]) {
+        encoded += multiplier * basicAlphabetSize;
+        multiplier *= basicSizePlusOne;
+        multiplier *= basicSizePlusOne;
+      } else {
+        encoded += multiplier * bnIndex;
+        multiplier *= basicSizePlusOne;
+      }
+    } else if (bigAlphabet.indexOf(char) !== -1) {
+      encoded += multiplier * basicAlphabetSize;
+      multiplier *= basicSizePlusOne;
+      const newid = (i === decoded.length - 1 ? 1 : 0) + bigAlphabet.indexOf(char);
+      encoded += multiplier * BigInt(newid);
+      multiplier *= bigAlphabetSize;
+    }
+  }
+  return encoded;
+}
+var StarknetIdContract = /* @__PURE__ */ ((StarknetIdContract2) => {
+  StarknetIdContract2["MAINNET"] = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678";
+  StarknetIdContract2["TESTNET"] = "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce";
+  return StarknetIdContract2;
+})(StarknetIdContract || {});
+function getStarknetIdContract(chainId) {
+  switch (chainId) {
+    case "0x534e5f4d41494e" /* SN_MAIN */:
+      return "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678" /* MAINNET */;
+    case "0x534e5f474f45524c49" /* SN_GOERLI */:
+      return "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce" /* TESTNET */;
+    default:
+      throw new Error("Starknet.id is not yet deployed on this network");
+  }
+}
+
+// src/provider/starknetId.ts
+async function getStarkName(provider, address, StarknetIdContract2) {
+  const chainId = await provider.getChainId();
+  const contract = StarknetIdContract2 ?? getStarknetIdContract(chainId);
+  try {
+    const hexDomain = await provider.callContract({
+      contractAddress: contract,
+      entrypoint: "address_to_domain",
+      calldata: CallData.compile({
+        address
+      })
     });
+    const decimalDomain = hexDomain.result.map((element) => BigInt(element)).slice(1);
+    const stringDomain = useDecoded(decimalDomain);
+    if (!stringDomain) {
+      throw Error("Starkname not found");
+    }
+    return stringDomain;
+  } catch (e) {
+    if (e instanceof Error && e.message === "Starkname not found") {
+      throw e;
+    }
+    throw Error("Could not get stark name");
   }
-  async getCode(_contractAddress, _blockIdentifier) {
-    throw new Error("RPC does not implement getCode function");
+}
+async function getAddressFromStarkName(provider, name, StarknetIdContract2) {
+  const chainId = await provider.getChainId();
+  const contract = StarknetIdContract2 ?? getStarknetIdContract(chainId);
+  try {
+    const addressData = await provider.callContract({
+      contractAddress: contract,
+      entrypoint: "domain_to_address",
+      calldata: CallData.compile({
+        domain: [useEncoded(name.replace(".stark", "")).toString(10)]
+      })
+    });
+    return addressData.result[0];
+  } catch {
+    throw Error("Could not get address from stark name");
   }
-  async getEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier) {
-    return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier);
+}
+
+// src/provider/utils.ts
+var validBlockTags = ["latest", "pending"];
+var Block = class {
+  constructor(_identifier) {
+    this.hash = null;
+    this.number = null;
+    this.tag = null;
+    this.valueOf = () => this.number;
+    this.toString = () => this.hash;
+    this.setIdentifier(_identifier);
   }
-  async getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_estimateFee", {
-      request: {
-        type: RPC.TransactionType.INVOKE,
-        sender_address: invocation.contractAddress,
-        calldata: parseCalldata(invocation.calldata),
-        signature: signatureToHexArray(invocation.signature),
-        version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 0),
-        nonce: toHex(invocationDetails.nonce),
-        max_fee: toHex((invocationDetails == null ? void 0 : invocationDetails.maxFee) || 0)
-      },
-      block_id
-    }).then(this.responseParser.parseFeeEstimateResponse);
+  setIdentifier(__identifier) {
+    if (typeof __identifier === "string" && isHex(__identifier)) {
+      this.hash = __identifier;
+    } else if (typeof __identifier === "bigint") {
+      this.hash = toHex(__identifier);
+    } else if (typeof __identifier === "number") {
+      this.number = __identifier;
+    } else if (typeof __identifier === "string" && validBlockTags.includes(__identifier)) {
+      this.tag = __identifier;
+    } else {
+      this.tag = "pending";
+    }
   }
-  async getDeclareEstimateFee({ senderAddress, contractDefinition, signature }, details, blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    if ("program" in contractDefinition) {
-      return this.fetchEndpoint("starknet_estimateFee", {
-        request: {
-          type: RPC.TransactionType.DECLARE,
-          contract_class: {
-            program: contractDefinition.program,
-            entry_points_by_type: contractDefinition.entry_points_by_type,
-            abi: contractDefinition.abi
-          },
-          sender_address: senderAddress,
-          signature: signatureToHexArray(signature),
-          version: toHex((details == null ? void 0 : details.version) || 0),
-          nonce: toHex(details.nonce),
-          max_fee: toHex((details == null ? void 0 : details.maxFee) || 0)
-        },
-        block_id
-      }).then(this.responseParser.parseFeeEstimateResponse);
+  get queryIdentifier() {
+    if (this.number !== null) {
+      return `blockNumber=${this.number}`;
     }
-    throw new Error("RPC do not support Sierra Contracts yet");
+    if (this.hash !== null) {
+      return `blockHash=${this.hash}`;
+    }
+    return `blockNumber=${this.tag}`;
   }
-  async getDeployAccountEstimateFee({ classHash, constructorCalldata, addressSalt, signature }, details, blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_estimateFee", {
-      request: {
-        type: RPC.TransactionType.DEPLOY_ACCOUNT,
-        constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata || []),
-        class_hash: toHex(classHash),
-        contract_address_salt: toHex(addressSalt || 0),
-        signature: signatureToHexArray(signature),
-        version: toHex((details == null ? void 0 : details.version) || 0),
-        nonce: toHex(details.nonce),
-        max_fee: toHex((details == null ? void 0 : details.maxFee) || 0)
-      },
-      block_id
-    }).then(this.responseParser.parseFeeEstimateResponse);
+  get identifier() {
+    if (this.number !== null) {
+      return { block_number: this.number };
+    }
+    if (this.hash !== null) {
+      return { block_hash: this.hash };
+    }
+    return this.tag;
   }
-  async getEstimateFeeBulk(_invocations, _blockIdentifier = this.blockIdentifier) {
-    throw new Error("RPC does not implement getInvokeEstimateFeeBulk function");
+  set identifier(_identifier) {
+    this.setIdentifier(_identifier);
   }
-  async declareContract({ contractDefinition, signature, senderAddress }, details) {
-    if ("program" in contractDefinition) {
-      return this.fetchEndpoint("starknet_addDeclareTransaction", {
+  get sequencerIdentifier() {
+    return this.hash !== null ? { blockHash: this.hash } : { blockNumber: this.number ?? this.tag };
+  }
+};
+
+// src/provider/rpc.ts
+var defaultOptions = {
+  headers: { "Content-Type": "application/json" },
+  blockIdentifier: "latest",
+  retries: 200
+};
+var RpcProvider = class {
+  constructor(optionsOrProvider) {
+    this.responseParser = new RPCResponseParser();
+    const { nodeUrl, retries, headers, blockIdentifier } = optionsOrProvider;
+    this.nodeUrl = nodeUrl;
+    this.retries = retries || defaultOptions.retries;
+    this.headers = { ...defaultOptions.headers, ...headers };
+    this.blockIdentifier = blockIdentifier || defaultOptions.blockIdentifier;
+    this.getChainId();
+  }
+  fetch(method, params) {
+    return fetchPonyfill_default(this.nodeUrl, {
+      method: "POST",
+      body: stringify2({ method, jsonrpc: "2.0", params, id: 0 }),
+      headers: this.headers
+    });
+  }
+  errorHandler(error) {
+    if (error) {
+      const { code, message } = error;
+      throw new LibraryError(`${code}: ${message}`);
+    }
+  }
+  async fetchEndpoint(method, params) {
+    var _a;
+    try {
+      const rawResult = await this.fetch(method, params);
+      const { error, result } = await rawResult.json();
+      this.errorHandler(error);
+      return result;
+    } catch (error) {
+      this.errorHandler((_a = error == null ? void 0 : error.response) == null ? void 0 : _a.data);
+      throw error;
+    }
+  }
+  async getChainId() {
+    this.chainId ?? (this.chainId = await this.fetchEndpoint("starknet_chainId"));
+    return this.chainId;
+  }
+  async getBlock(blockIdentifier = this.blockIdentifier) {
+    return this.getBlockWithTxHashes(blockIdentifier).then(
+      this.responseParser.parseGetBlockResponse
+    );
+  }
+  async getBlockHashAndNumber() {
+    return this.fetchEndpoint("starknet_blockHashAndNumber");
+  }
+  async getBlockWithTxHashes(blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getBlockWithTxHashes", { block_id });
+  }
+  async getBlockWithTxs(blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getBlockWithTxs", { block_id });
+  }
+  async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getClassHashAt", {
+      block_id,
+      contract_address: contractAddress
+    });
+  }
+  async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getNonce", {
+      contract_address: contractAddress,
+      block_id
+    });
+  }
+  async getPendingTransactions() {
+    return this.fetchEndpoint("starknet_pendingTransactions");
+  }
+  async getProtocolVersion() {
+    throw new Error("Pathfinder does not implement this rpc 0.1.0 method");
+  }
+  async getStateUpdate(blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
+  }
+  async getStorageAt(contractAddress, key, blockIdentifier = this.blockIdentifier) {
+    const parsedKey = toHex(key);
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getStorageAt", {
+      contract_address: contractAddress,
+      key: parsedKey,
+      block_id
+    });
+  }
+  async getTransaction(txHash) {
+    return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
+  }
+  async getTransactionByHash(txHash) {
+    return this.fetchEndpoint("starknet_getTransactionByHash", { transaction_hash: txHash });
+  }
+  async getTransactionByBlockIdAndIndex(blockIdentifier, index) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getTransactionByBlockIdAndIndex", { block_id, index });
+  }
+  async getTransactionReceipt(txHash) {
+    return this.fetchEndpoint("starknet_getTransactionReceipt", { transaction_hash: txHash });
+  }
+  async getClassByHash(classHash) {
+    return this.getClass(classHash);
+  }
+  async getClass(classHash, blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getClass", { class_hash: classHash, block_id });
+  }
+  async getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getClassAt", {
+      block_id,
+      contract_address: contractAddress
+    });
+  }
+  async getCode(_contractAddress, _blockIdentifier) {
+    throw new Error("RPC does not implement getCode function");
+  }
+  async getEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier) {
+    return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier);
+  }
+  async getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_estimateFee", {
+      request: {
+        type: RPC.TransactionType.INVOKE,
+        sender_address: invocation.contractAddress,
+        calldata: CallData.toHex(invocation.calldata),
+        signature: signatureToHexArray(invocation.signature),
+        version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 0),
+        nonce: toHex(invocationDetails.nonce),
+        max_fee: toHex((invocationDetails == null ? void 0 : invocationDetails.maxFee) || 0)
+      },
+      block_id
+    }).then(this.responseParser.parseFeeEstimateResponse);
+  }
+  async getDeclareEstimateFee({ senderAddress, contractDefinition, signature }, details, blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    if ("program" in contractDefinition) {
+      return this.fetchEndpoint("starknet_estimateFee", {
+        request: {
+          type: RPC.TransactionType.DECLARE,
+          contract_class: {
+            program: contractDefinition.program,
+            entry_points_by_type: contractDefinition.entry_points_by_type,
+            abi: contractDefinition.abi
+          },
+          sender_address: senderAddress,
+          signature: signatureToHexArray(signature),
+          version: toHex((details == null ? void 0 : details.version) || 0),
+          nonce: toHex(details.nonce),
+          max_fee: toHex((details == null ? void 0 : details.maxFee) || 0)
+        },
+        block_id
+      }).then(this.responseParser.parseFeeEstimateResponse);
+    }
+    throw new Error("RPC do not support Sierra Contracts yet");
+  }
+  async getDeployAccountEstimateFee({ classHash, constructorCalldata, addressSalt, signature }, details, blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_estimateFee", {
+      request: {
+        type: RPC.TransactionType.DEPLOY_ACCOUNT,
+        constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata || []),
+        class_hash: toHex(classHash),
+        contract_address_salt: toHex(addressSalt || 0),
+        signature: signatureToHexArray(signature),
+        version: toHex((details == null ? void 0 : details.version) || 0),
+        nonce: toHex(details.nonce),
+        max_fee: toHex((details == null ? void 0 : details.maxFee) || 0)
+      },
+      block_id
+    }).then(this.responseParser.parseFeeEstimateResponse);
+  }
+  async getEstimateFeeBulk(_invocations, _blockIdentifier = this.blockIdentifier) {
+    throw new Error("RPC does not implement getInvokeEstimateFeeBulk function");
+  }
+  async declareContract({ contractDefinition, signature, senderAddress }, details) {
+    if ("program" in contractDefinition) {
+      return this.fetchEndpoint("starknet_addDeclareTransaction", {
         declare_transaction: {
           contract_class: {
             program: contractDefinition.program,
@@ -3422,7 +3924,7 @@ var RpcProvider = class {
     return this.fetchEndpoint("starknet_addInvokeTransaction", {
       invoke_transaction: {
         sender_address: functionInvocation.contractAddress,
-        calldata: parseCalldata(functionInvocation.calldata),
+        calldata: CallData.toHex(functionInvocation.calldata),
         type: RPC.TransactionType.INVOKE,
         max_fee: toHex(details.maxFee || 0),
         version: "0x1",
@@ -3437,7 +3939,7 @@ var RpcProvider = class {
       request: {
         contract_address: call.contractAddress,
         entry_point_selector: getSelectorFromName(call.entrypoint),
-        calldata: parseCalldata(call.calldata)
+        calldata: CallData.toHex(call.calldata)
       },
       block_id
     });
@@ -3907,7 +4409,7 @@ var SequencerProvider = class {
     return this.fetchEndpoint("add_transaction", void 0, {
       type: "INVOKE_FUNCTION" /* INVOKE */,
       sender_address: functionInvocation.contractAddress,
-      calldata: bigNumberishArrayToDecimalStringArray(functionInvocation.calldata ?? []),
+      calldata: CallData.compile(functionInvocation.calldata ?? []),
       signature: signatureToDecimalArray(functionInvocation.signature),
       nonce: toHex(details.nonce),
       max_fee: toHex(details.maxFee || 0),
@@ -3918,7 +4420,7 @@ var SequencerProvider = class {
     return this.fetchEndpoint("add_transaction", void 0, {
       type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
       contract_address_salt: addressSalt ?? randomAddress(),
-      constructor_calldata: bigNumberishArrayToDecimalStringArray(constructorCalldata ?? []),
+      constructor_calldata: CallData.compile(constructorCalldata ?? []),
       class_hash: toHex(classHash),
       max_fee: toHex(details.maxFee || 0),
       version: toHex(details.version || 0),
@@ -4002,7 +4504,7 @@ var SequencerProvider = class {
       {
         type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
         class_hash: toHex(classHash),
-        constructor_calldata: bigNumberishArrayToDecimalStringArray(constructorCalldata || []),
+        constructor_calldata: CallData.compile(constructorCalldata || []),
         contract_address_salt: toHex(addressSalt || 0),
         signature: signatureToDecimalArray(signature),
         version: toHex((details == null ? void 0 : details.version) || 0),
@@ -4029,9 +4531,7 @@ var SequencerProvider = class {
         res = {
           type: invocation.type,
           class_hash: toHex(toBigInt(invocation.classHash)),
-          constructor_calldata: bigNumberishArrayToDecimalStringArray(
-            invocation.constructorCalldata || []
-          ),
+          constructor_calldata: CallData.compile(invocation.constructorCalldata || []),
           contract_address_salt: toHex(toBigInt(invocation.addressSalt || 0))
         };
       }
@@ -4110,640 +4610,135 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       }
     ).then(this.responseParser.parseFeeSimulateTransactionResponse);
   }
-  async getStateUpdate(blockIdentifier = this.blockIdentifier) {
-    const args = new Block(blockIdentifier).sequencerIdentifier;
-    return this.fetchEndpoint("get_state_update", { ...args }).then(
-      this.responseParser.parseGetStateUpdateResponse
-    );
-  }
-  async getBlockTraces(blockIdentifier = this.blockIdentifier) {
-    const args = new Block(blockIdentifier).sequencerIdentifier;
-    return this.fetchEndpoint("get_block_traces", { ...args });
-  }
-  async getStarkName(address, StarknetIdContract2) {
-    return getStarkName(this, address, StarknetIdContract2);
-  }
-  async getAddressFromStarkName(name, StarknetIdContract2) {
-    return getAddressFromStarkName(this, name, StarknetIdContract2);
-  }
-};
-
-// src/provider/default.ts
-var Provider = class {
-  constructor(providerOrOptions) {
-    if (providerOrOptions instanceof Provider) {
-      this.provider = providerOrOptions.provider;
-    } else if (providerOrOptions instanceof RpcProvider || providerOrOptions instanceof SequencerProvider) {
-      this.provider = providerOrOptions;
-    } else if (providerOrOptions && "rpc" in providerOrOptions) {
-      this.provider = new RpcProvider(providerOrOptions.rpc);
-    } else if (providerOrOptions && "sequencer" in providerOrOptions) {
-      this.provider = new SequencerProvider(providerOrOptions.sequencer);
-    } else {
-      this.provider = new SequencerProvider();
-    }
-  }
-  async getChainId() {
-    return this.provider.getChainId();
-  }
-  async getBlock(blockIdentifier) {
-    return this.provider.getBlock(blockIdentifier);
-  }
-  async getClassAt(contractAddress, blockIdentifier) {
-    return this.provider.getClassAt(contractAddress, blockIdentifier);
-  }
-  async getClassHashAt(contractAddress, blockIdentifier) {
-    return this.provider.getClassHashAt(contractAddress, blockIdentifier);
-  }
-  getClassByHash(classHash) {
-    return this.provider.getClassByHash(classHash);
-  }
-  async getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier) {
-    return this.provider.getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier);
-  }
-  async getInvokeEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier, skipValidate) {
-    return this.provider.getInvokeEstimateFee(
-      invocationWithTxType,
-      invocationDetails,
-      blockIdentifier,
-      skipValidate
-    );
-  }
-  async getEstimateFeeBulk(invocations, blockIdentifier) {
-    return this.provider.getEstimateFeeBulk(invocations, blockIdentifier);
-  }
-  async getNonceForAddress(contractAddress, blockIdentifier) {
-    return this.provider.getNonceForAddress(contractAddress, blockIdentifier);
-  }
-  async getStorageAt(contractAddress, key, blockIdentifier) {
-    return this.provider.getStorageAt(contractAddress, key, blockIdentifier);
-  }
-  async getTransaction(txHash) {
-    return this.provider.getTransaction(txHash);
-  }
-  async getTransactionReceipt(txHash) {
-    return this.provider.getTransactionReceipt(txHash);
-  }
-  async callContract(request, blockIdentifier) {
-    return this.provider.callContract(request, blockIdentifier);
-  }
-  async invokeFunction(functionInvocation, details) {
-    return this.provider.invokeFunction(functionInvocation, details);
-  }
-  async deployAccountContract(payload, details) {
-    return this.provider.deployAccountContract(payload, details);
-  }
-  async declareContract(transaction, details) {
-    return this.provider.declareContract(transaction, details);
-  }
-  async getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate) {
-    return this.provider.getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate);
-  }
-  getDeployAccountEstimateFee(transaction, details, blockIdentifier, skipValidate) {
-    return this.provider.getDeployAccountEstimateFee(
-      transaction,
-      details,
-      blockIdentifier,
-      skipValidate
-    );
-  }
-  async getCode(contractAddress, blockIdentifier) {
-    return this.provider.getCode(contractAddress, blockIdentifier);
-  }
-  async waitForTransaction(txHash, options) {
-    return this.provider.waitForTransaction(txHash, options);
-  }
-  async getSimulateTransaction(invocation, invocationDetails, blockIdentifier, skipValidate) {
-    return this.provider.getSimulateTransaction(
-      invocation,
-      invocationDetails,
-      blockIdentifier,
-      skipValidate
-    );
-  }
-  async getStateUpdate(blockIdentifier) {
-    return this.provider.getStateUpdate(blockIdentifier);
-  }
-  async getStarkName(address, StarknetIdContract2) {
-    return getStarkName(this, address, StarknetIdContract2);
-  }
-  async getAddressFromStarkName(name, StarknetIdContract2) {
-    return getAddressFromStarkName(this, name, StarknetIdContract2);
-  }
-};
-
-// src/provider/interface.ts
-var ProviderInterface = class {
-};
-
-// src/provider/index.ts
-var defaultProvider = new Provider();
-
-// src/utils/calldata/formatter.ts
-var guard = {
-  isBN: (data, type, key) => {
-    if (!isBigInt(data[key]))
-      throw new Error(
-        `Data and formatter mismatch on ${key}:${type[key]}, expected response data ${key}:${data[key]} to be BN instead it is ${typeof data[key]}`
-      );
-  },
-  unknown: (data, type, key) => {
-    throw new Error(`Unhandled formatter type on ${key}:${type[key]} for data ${key}:${data[key]}`);
-  }
-};
-function formatter(data, type, sameType) {
-  return Object.entries(data).reduce((acc, [key, value]) => {
-    const elType = sameType ?? type[key];
-    if (!(key in type) && !sameType) {
-      acc[key] = value;
-      return acc;
-    }
-    if (elType === "string") {
-      if (Array.isArray(data[key])) {
-        const arrayStr = formatter(
-          data[key],
-          data[key].map((_) => elType)
-        );
-        acc[key] = Object.values(arrayStr).join("");
-        return acc;
-      }
-      guard.isBN(data, type, key);
-      acc[key] = decodeShortString(value);
-      return acc;
-    }
-    if (elType === "number") {
-      guard.isBN(data, type, key);
-      acc[key] = Number(value);
-      return acc;
-    }
-    if (typeof elType === "function") {
-      acc[key] = elType(value);
-      return acc;
-    }
-    if (Array.isArray(elType)) {
-      const arrayObj = formatter(data[key], elType, elType[0]);
-      acc[key] = Object.values(arrayObj);
-      return acc;
-    }
-    if (typeof elType === "object") {
-      acc[key] = formatter(data[key], elType);
-      return acc;
-    }
-    guard.unknown(data, type, key);
-    return acc;
-  }, {});
-}
-
-// src/utils/calldata/tuple.ts
-function parseNamedTuple(namedTuple) {
-  const name = namedTuple.substring(0, namedTuple.indexOf(":"));
-  const type = namedTuple.substring(name.length + ":".length);
-  return { name, type };
-}
-function parseSubTuple(s) {
-  if (!s.includes("("))
-    return { subTuple: [], result: s };
-  const subTuple = [];
-  let result = "";
-  let i = 0;
-  while (i < s.length) {
-    if (s[i] === "(") {
-      let counter = 1;
-      const lBracket = i;
-      i++;
-      while (counter) {
-        if (s[i] === ")")
-          counter--;
-        if (s[i] === "(")
-          counter++;
-        i++;
-      }
-      subTuple.push(s.substring(lBracket, i));
-      result += " ";
-      i--;
-    } else {
-      result += s[i];
-    }
-    i++;
-  }
-  return {
-    subTuple,
-    result
-  };
-}
-function extractCairo0Tuple(type) {
-  const cleanType = type.replace(/\s/g, "").slice(1, -1);
-  const { subTuple, result } = parseSubTuple(cleanType);
-  let recomposed = result.split(",").map((it) => {
-    return subTuple.length ? it.replace(" ", subTuple.shift()) : it;
-  });
-  if (isTypeNamedTuple(type)) {
-    recomposed = recomposed.reduce((acc, it) => {
-      return acc.concat(parseNamedTuple(it));
-    }, []);
-  }
-  return recomposed;
-}
-function extractCairo1Tuple(type) {
-  const cleanType = type.replace(/\s/g, "").slice(1, -1);
-  return cleanType.split(",");
-}
-function extractTupleMemberTypes(type) {
-  if (isCairo1Type(type)) {
-    return extractCairo1Tuple(type);
-  }
-  return extractCairo0Tuple(type);
-}
-
-// src/utils/calldata/requestParser.ts
-function parseTuple(element, typeStr) {
-  const memberTypes = extractTupleMemberTypes(typeStr);
-  const elements = Object.values(element);
-  if (elements.length !== memberTypes.length) {
-    throw Error(
-      `ParseTuple: provided and expected abi tuple size do not match.
-      provided: ${elements} 
-      expected: ${memberTypes}`
-    );
-  }
-  return memberTypes.map((it, dx) => {
-    return {
-      element: elements[dx],
-      type: it.type ?? it
-    };
-  });
-}
-function parseCalldataValue(element, type, structs) {
-  if (element === void 0) {
-    throw Error(`Missing parameter for type ${type}`);
-  }
-  if (Array.isArray(element)) {
-    throw Error(`Array inside array (nD) are not supported by cairo. Element: ${element} ${type}`);
-  }
-  if (isTypeUint256(type)) {
-    const el_uint256 = uint256(element);
-    return [felt(el_uint256.low), felt(el_uint256.high)];
-  }
-  if (structs[type] && structs[type].members.length) {
-    const { members } = structs[type];
-    const subElement = element;
-    return members.reduce((acc, it) => {
-      return acc.concat(parseCalldataValue(subElement[it.name], it.type, structs));
-    }, []);
-  }
-  if (isTypeTuple(type)) {
-    const tupled = parseTuple(element, type);
-    return tupled.reduce((acc, it) => {
-      const parsedData = parseCalldataValue(it.element, it.type, structs);
-      return acc.concat(parsedData);
-    }, []);
-  }
-  if (typeof element === "object") {
-    throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
-  }
-  return felt(element);
-}
-function parseCalldataField(argsIterator, input, structs) {
-  const { name, type } = input;
-  let { value } = argsIterator.next();
-  switch (true) {
-    case isTypeArray(type):
-      if (!Array.isArray(value) && !isText(value)) {
-        throw Error(`ABI expected parameter ${name} to be array or long string, got ${value}`);
-      }
-      if (typeof value === "string") {
-        value = splitLongString(value);
-      }
-      const result = [];
-      result.push(felt(value.length));
-      const arrayType = getArrayType(input.type);
-      return value.reduce((acc, el) => {
-        if (isTypeFelt(arrayType) || isTypeUint(arrayType) || isTypeContractAddress(arrayType)) {
-          acc.push(felt(el));
-        } else if (isTypeBool(arrayType) && typeof el === "boolean") {
-          acc.push(el.toString());
-        } else {
-          acc.push(...parseCalldataValue(el, arrayType, structs));
-        }
-        return acc;
-      }, result);
-    case (isTypeStruct(type, structs) || isTypeTuple(type) || isTypeUint256(type)):
-      return parseCalldataValue(value, type, structs);
-    case isTypeBool(type):
-      return `${+value}`;
-    default:
-      return felt(value);
-  }
-}
-
-// src/utils/calldata/responseParser.ts
-function parseResponseStruct(responseIterator, type, structs) {
-  if (type in structs && structs[type]) {
-    return structs[type].members.reduce((acc, el) => {
-      acc[el.name] = parseResponseStruct(responseIterator, el.type, structs);
-      return acc;
-    }, {});
-  }
-  if (isTypeTuple(type)) {
-    const memberTypes = extractTupleMemberTypes(type);
-    return memberTypes.reduce((acc, it, idx) => {
-      const tName = (it == null ? void 0 : it.name) ? it.name : idx;
-      const tType = (it == null ? void 0 : it.type) ? it.type : it;
-      acc[tName] = parseResponseStruct(responseIterator, tType, structs);
-      return acc;
-    }, {});
-  }
-  const temp = responseIterator.next().value;
-  return BigInt(temp);
-}
-function responseParser(responseIterator, output, structs, parsedResult) {
-  const { name, type } = output;
-  let temp;
-  switch (true) {
-    case isLen(name):
-      temp = responseIterator.next().value;
-      return BigInt(temp);
-    case isTypeBool(type):
-      temp = responseIterator.next().value;
-      return Boolean(BigInt(temp));
-    case isTypeUint256(type):
-      const low = responseIterator.next().value;
-      const high = responseIterator.next().value;
-      return uint256ToBN({ low, high });
-    case isTypeArray(type):
-      const parsedDataArr = [];
-      if (isCairo1Type(type)) {
-        responseIterator.next();
-        let it = responseIterator.next();
-        while (!it.done) {
-          parsedDataArr.push(BigInt(it.value));
-          it = responseIterator.next();
-        }
-        return parsedDataArr;
-      }
-      if (parsedResult && parsedResult[`${name}_len`]) {
-        const arrLen = parsedResult[`${name}_len`];
-        while (parsedDataArr.length < arrLen) {
-          parsedDataArr.push(
-            parseResponseStruct(responseIterator, output.type.replace("*", ""), structs)
-          );
-        }
-      }
-      return parsedDataArr;
-    case (type in structs || isTypeTuple(type)):
-      return parseResponseStruct(responseIterator, type, structs);
-    default:
-      temp = responseIterator.next().value;
-      return BigInt(temp);
-  }
-}
-
-// src/utils/calldata/validate.ts
-var validateFelt = (parameter, input) => {
-  assert(
-    typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
-    `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`
-  );
-};
-var validateUint = (parameter, input) => {
-  if (typeof parameter === "number") {
-    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",
-    `Validate: arg ${input.name} of cairo type ${input.type} should be type (String, Number or BigInt)`
-  );
-  const param = toBigInt(parameter);
-  switch (input.type) {
-    case "core::integer::u8" /* u8 */:
-      assert(
-        param >= 0n && param <= 255n,
-        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
-      );
-      break;
-    case "core::integer::u16" /* u16 */:
-      assert(
-        param >= 0n && param <= 65535n,
-        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
-      );
-      break;
-    case "core::integer::u32" /* u32 */:
-      assert(
-        param >= 0n && param <= 4294967295n,
-        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
-      );
-      break;
-    case "core::integer::u64" /* u64 */:
-      assert(
-        param >= 0n && param <= 2n ** 64n - 1n,
-        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^64-1]`
-      );
-      break;
-    case "core::integer::u128" /* u128 */:
-      assert(
-        param >= 0n && param <= 2n ** 128n - 1n,
-        `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^128-1]`
-      );
-      break;
-    case "core::integer::u256" /* u256 */:
-      assert(
-        param >= 0n && param <= 2n ** 256n - 1n,
-        `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
-      );
-      break;
-    default:
-      break;
-  }
-};
-var validateBool = (parameter, input) => {
-  assert(
-    typeof parameter === "boolean",
-    `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`
-  );
-};
-var validateStruct = (parameter, input, structs) => {
-  assert(
-    typeof parameter === "object" && !Array.isArray(parameter),
-    `Validate: arg ${input.name} is cairo type struct (${input.type}), and should be defined as js object (not array)`
-  );
-  structs[input.type].members.forEach(({ name }) => {
-    assert(
-      Object.keys(parameter).includes(name),
-      `Validate: arg ${input.name} should have a property ${name}`
-    );
-  });
-};
-var validateTuple = (parameter, input) => {
-  assert(
-    typeof parameter === "object" && !Array.isArray(parameter),
-    `Validate: arg ${input.name} should be a tuple (defined as object)`
-  );
-};
-var validateArray = (parameter, input, structs) => {
-  const baseType = getArrayType(input.type);
-  if (isTypeFelt(baseType) && isLongText(parameter))
-    return;
-  assert(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
-  switch (true) {
-    case isTypeFelt(baseType):
-      parameter.forEach((param) => validateFelt(param, input));
-      break;
-    case isTypeTuple(baseType):
-      parameter.forEach((it) => validateTuple(it, { name: input.name, type: baseType }));
-      break;
-    case isTypeStruct(baseType, structs):
-      parameter.forEach(
-        (it) => validateStruct(it, { name: input.name, type: baseType }, structs)
-      );
-      break;
-    case isTypeUint(baseType):
-      parameter.forEach((param) => validateUint(param, input));
-      break;
-    case isTypeBool(baseType):
-      parameter.forEach((param) => validateBool(param, input));
-      break;
-    default:
-      throw new Error(
-        `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
-      );
-  }
+  async getStateUpdate(blockIdentifier = this.blockIdentifier) {
+    const args = new Block(blockIdentifier).sequencerIdentifier;
+    return this.fetchEndpoint("get_state_update", { ...args }).then(
+      this.responseParser.parseGetStateUpdateResponse
+    );
+  }
+  async getBlockTraces(blockIdentifier = this.blockIdentifier) {
+    const args = new Block(blockIdentifier).sequencerIdentifier;
+    return this.fetchEndpoint("get_block_traces", { ...args });
+  }
+  async getStarkName(address, StarknetIdContract2) {
+    return getStarkName(this, address, StarknetIdContract2);
+  }
+  async getAddressFromStarkName(name, StarknetIdContract2) {
+    return getAddressFromStarkName(this, name, StarknetIdContract2);
+  }
 };
-function validateFields(abiMethod, args, structs) {
-  abiMethod.inputs.reduce((acc, input) => {
-    const parameter = args[acc];
-    switch (true) {
-      case isLen(input.name):
-        return acc;
-      case isTypeFelt(input.type):
-        validateFelt(parameter, input);
-        break;
-      case isTypeUint(input.type):
-        validateUint(parameter, input);
-        break;
-      case isTypeBool(input.type):
-        validateBool(parameter, input);
-        break;
-      case isTypeContractAddress(input.type):
-        break;
-      case isTypeStruct(input.type, structs):
-        validateStruct(parameter, input, structs);
-        break;
-      case isTypeTuple(input.type):
-        validateTuple(parameter, input);
-        break;
-      case isTypeArray(input.type):
-        validateArray(parameter, input, structs);
-        break;
-      default:
-        throw new Error(
-          `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
-        );
-    }
-    return acc + 1;
-  }, 0);
-}
 
-// src/utils/calldata/index.ts
-var CallData = class {
-  constructor(abi) {
-    this.abi = abi;
-    this.structs = CallData.getAbiStruct(abi);
-  }
-  validate(type, method, args = []) {
-    if (type !== "DEPLOY") {
-      const invocableFunctionNames = this.abi.filter((abi) => {
-        if (abi.type !== "function")
-          return false;
-        const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
-        return type === "INVOKE" ? !isView : isView;
-      }).map((abi) => abi.name);
-      assert(
-        invocableFunctionNames.includes(method),
-        `${type === "INVOKE" ? "invocable" : "viewable"} method not found in abi`
-      );
-    }
-    const abiMethod = this.abi.find(
-      (abi) => type === "DEPLOY" ? abi.name === method && abi.type === method : abi.name === method && abi.type === "function"
-    );
-    const inputsLength = CallData.abiInputsLength(abiMethod.inputs);
-    if (args.length !== inputsLength) {
-      throw Error(
-        `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
-      );
+// src/provider/default.ts
+var Provider = class {
+  constructor(providerOrOptions) {
+    if (providerOrOptions instanceof Provider) {
+      this.provider = providerOrOptions.provider;
+    } else if (providerOrOptions instanceof RpcProvider || providerOrOptions instanceof SequencerProvider) {
+      this.provider = providerOrOptions;
+    } else if (providerOrOptions && "rpc" in providerOrOptions) {
+      this.provider = new RpcProvider(providerOrOptions.rpc);
+    } else if (providerOrOptions && "sequencer" in providerOrOptions) {
+      this.provider = new SequencerProvider(providerOrOptions.sequencer);
+    } else {
+      this.provider = new SequencerProvider();
     }
-    validateFields(abiMethod, args, this.structs);
   }
-  compile(args, inputs) {
-    const argsIterator = args[Symbol.iterator]();
-    return inputs.reduce(
-      (acc, input) => isLen(input.name) ? acc : acc.concat(parseCalldataField(argsIterator, input, this.structs)),
-      []
+  async getChainId() {
+    return this.provider.getChainId();
+  }
+  async getBlock(blockIdentifier) {
+    return this.provider.getBlock(blockIdentifier);
+  }
+  async getClassAt(contractAddress, blockIdentifier) {
+    return this.provider.getClassAt(contractAddress, blockIdentifier);
+  }
+  async getClassHashAt(contractAddress, blockIdentifier) {
+    return this.provider.getClassHashAt(contractAddress, blockIdentifier);
+  }
+  getClassByHash(classHash) {
+    return this.provider.getClassByHash(classHash);
+  }
+  async getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier) {
+    return this.provider.getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier);
+  }
+  async getInvokeEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier, skipValidate) {
+    return this.provider.getInvokeEstimateFee(
+      invocationWithTxType,
+      invocationDetails,
+      blockIdentifier,
+      skipValidate
     );
   }
-  static compile(data) {
-    const createTree = (obj) => {
-      const getEntries = (o, prefix = "") => {
-        const oe = Array.isArray(o) ? [o.length.toString(), ...o] : o;
-        return Object.entries(oe).flatMap(([k, v]) => {
-          let value = v;
-          if (isLongText(value))
-            value = splitLongString(value);
-          const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
-          if (isBigInt(value))
-            return [[`${prefix}${kk}`, felt(value)]];
-          return Object(value) === value ? getEntries(value, `${prefix}${kk}.`) : [[`${prefix}${kk}`, felt(value)]];
-        });
-      };
-      return Object.fromEntries(getEntries(obj));
-    };
-    let callTreeArray;
-    if (!Array.isArray(data)) {
-      const callTree = createTree(data);
-      callTreeArray = Object.values(callTree);
-    } else {
-      callTreeArray = data;
-    }
-    Object.defineProperty(callTreeArray, "compiled", {
-      enumerable: false,
-      writable: false,
-      value: true
-    });
-    return callTreeArray;
+  async getEstimateFeeBulk(invocations, blockIdentifier) {
+    return this.provider.getEstimateFeeBulk(invocations, blockIdentifier);
   }
-  parse(method, response) {
-    const { outputs } = this.abi.find((abi) => abi.name === method);
-    const responseIterator = response.flat()[Symbol.iterator]();
-    const parsed = outputs.flat().reduce((acc, output, idx) => {
-      const propName = output.name ?? idx;
-      acc[propName] = responseParser(responseIterator, output, this.structs, acc);
-      if (acc[propName] && acc[`${propName}_len`]) {
-        delete acc[`${propName}_len`];
-      }
-      return acc;
-    }, {});
-    return Object.keys(parsed).length === 1 && 0 in parsed ? parsed[0] : parsed;
+  async getNonceForAddress(contractAddress, blockIdentifier) {
+    return this.provider.getNonceForAddress(contractAddress, blockIdentifier);
   }
-  format(method, response, format) {
-    const parsed = this.parse(method, response);
-    return formatter(parsed, format);
+  async getStorageAt(contractAddress, key, blockIdentifier) {
+    return this.provider.getStorageAt(contractAddress, key, blockIdentifier);
   }
-  static abiInputsLength(inputs) {
-    return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
+  async getTransaction(txHash) {
+    return this.provider.getTransaction(txHash);
   }
-  static getAbiStruct(abi) {
-    return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
-      (acc, abiEntry) => ({
-        ...acc,
-        [abiEntry.name]: abiEntry
-      }),
-      {}
+  async getTransactionReceipt(txHash) {
+    return this.provider.getTransactionReceipt(txHash);
+  }
+  async callContract(request, blockIdentifier) {
+    return this.provider.callContract(request, blockIdentifier);
+  }
+  async invokeFunction(functionInvocation, details) {
+    return this.provider.invokeFunction(functionInvocation, details);
+  }
+  async deployAccountContract(payload, details) {
+    return this.provider.deployAccountContract(payload, details);
+  }
+  async declareContract(transaction, details) {
+    return this.provider.declareContract(transaction, details);
+  }
+  async getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate) {
+    return this.provider.getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate);
+  }
+  getDeployAccountEstimateFee(transaction, details, blockIdentifier, skipValidate) {
+    return this.provider.getDeployAccountEstimateFee(
+      transaction,
+      details,
+      blockIdentifier,
+      skipValidate
+    );
+  }
+  async getCode(contractAddress, blockIdentifier) {
+    return this.provider.getCode(contractAddress, blockIdentifier);
+  }
+  async waitForTransaction(txHash, options) {
+    return this.provider.waitForTransaction(txHash, options);
+  }
+  async getSimulateTransaction(invocation, invocationDetails, blockIdentifier, skipValidate) {
+    return this.provider.getSimulateTransaction(
+      invocation,
+      invocationDetails,
+      blockIdentifier,
+      skipValidate
     );
   }
+  async getStateUpdate(blockIdentifier) {
+    return this.provider.getStateUpdate(blockIdentifier);
+  }
+  async getStarkName(address, StarknetIdContract2) {
+    return getStarkName(this, address, StarknetIdContract2);
+  }
+  async getAddressFromStarkName(name, StarknetIdContract2) {
+    return getAddressFromStarkName(this, name, StarknetIdContract2);
+  }
+};
+
+// src/provider/interface.ts
+var ProviderInterface = class {
 };
 
+// src/provider/index.ts
+var defaultProvider = new Provider();
+
 // src/contract/default.ts
 var splitArgsAndOptions = (args) => {
   const options = [
@@ -4753,13 +4748,14 @@ var splitArgsAndOptions = (args) => {
     "formatResponse",
     "maxFee",
     "nonce",
-    "signature"
+    "signature",
+    "addressSalt"
   ];
   const lastArg = args[args.length - 1];
   if (typeof lastArg === "object" && options.some((x) => x in lastArg)) {
     return { args, options: args.pop() };
   }
-  return { args, options: {} };
+  return { args };
 };
 function buildCall(contract, functionAbi) {
   return async function(...args) {
@@ -4796,20 +4792,20 @@ function buildEstimate(contract, functionAbi) {
     return contract.estimate(functionAbi.name, args);
   };
 }
-var detectCairoVersion = (abi) => {
-  if (!abi)
-    return "0";
-  return abi.find((it) => "state_mutability" in it) ? "1" : "0";
-};
+function getCalldata(args, callback) {
+  if ("__compiled__" in args)
+    return args;
+  if (Array.isArray(args[0]) && "__compiled__" in args[0])
+    return args[0];
+  return callback();
+}
 var Contract = class {
-  constructor(abi, address, providerOrAccount = defaultProvider, cairoVersion = detectCairoVersion(abi)) {
-    this.version = "0";
+  constructor(abi, address, providerOrAccount = defaultProvider) {
     this.address = address && address.toLowerCase();
     this.providerOrAccount = providerOrAccount;
     this.callData = new CallData(abi);
     this.structs = CallData.getAbiStruct(abi);
     this.abi = abi;
-    this.version = cairoVersion;
     const options = { enumerable: true, value: {}, writable: false };
     Object.defineProperties(this, {
       functions: { enumerable: true, value: {}, writable: false },
@@ -4866,15 +4862,21 @@ var Contract = class {
     }
     return this;
   }
-  async call(method, args = [], options = { parseRequest: true, parseResponse: true, formatResponse: void 0 }) {
+  async call(method, args = [], {
+    parseRequest = true,
+    parseResponse = true,
+    formatResponse = void 0,
+    blockIdentifier = void 0
+  } = {}) {
     assert(this.address !== null, "contract is not connected to an address");
-    const blockIdentifier = (options == null ? void 0 : options.blockIdentifier) || void 0;
-    let calldata = "compiled" in args ? args : args[0];
-    if (options.parseRequest && !(calldata == null ? void 0 : calldata.compiled)) {
-      const { inputs } = this.abi.find((abi) => abi.name === method);
-      this.callData.validate("CALL", method, args);
-      calldata = this.callData.compile(args, inputs);
-    }
+    const calldata = getCalldata(args, () => {
+      if (parseRequest) {
+        this.callData.validate("CALL", method, args);
+        return this.callData.compile(method, args);
+      }
+      console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
+      return args;
+    });
     return this.providerOrAccount.callContract(
       {
         contractAddress: this.address,
@@ -4883,25 +4885,25 @@ var Contract = class {
       },
       blockIdentifier
     ).then((x) => {
-      if (!options.parseResponse) {
+      if (!parseResponse) {
         return x.result;
       }
-      if (options.formatResponse) {
-        return this.callData.format(method, x.result, options.formatResponse);
+      if (formatResponse) {
+        return this.callData.format(method, x.result, formatResponse);
       }
       return this.callData.parse(method, x.result);
     });
   }
-  invoke(method, args = [], options = {
-    parseRequest: true
-  }) {
+  invoke(method, args = [], { parseRequest = true, maxFee, nonce, signature } = {}) {
     assert(this.address !== null, "contract is not connected to an address");
-    let calldata = "compiled" in args ? args : args[0];
-    if (options.parseRequest && !(calldata == null ? void 0 : calldata.compiled)) {
-      const { inputs } = this.abi.find((abi) => abi.name === method);
-      this.callData.validate("INVOKE", method, args);
-      calldata = this.callData.compile(args, inputs);
-    }
+    const calldata = getCalldata(args, () => {
+      if (parseRequest) {
+        this.callData.validate("INVOKE", method, args);
+        return this.callData.compile(method, args);
+      }
+      console.warn("Invoke skipped parsing but provided rawArgs, possible malfunction request");
+      return args;
+    });
     const invocation = {
       contractAddress: this.address,
       calldata,
@@ -4909,40 +4911,36 @@ var Contract = class {
     };
     if ("execute" in this.providerOrAccount) {
       return this.providerOrAccount.execute(invocation, void 0, {
-        maxFee: options.maxFee,
-        nonce: options.nonce
+        maxFee,
+        nonce
       });
     }
-    if (!options.nonce) {
+    if (!nonce)
       throw new Error(`Nonce is required when invoking a function without an account`);
-    }
     console.warn(`Invoking ${method} without an account. This will not work on a public node.`);
     return this.providerOrAccount.invokeFunction(
       {
         ...invocation,
-        signature: options.signature
+        signature
       },
       {
-        nonce: options.nonce
+        nonce
       }
     );
   }
   async estimate(method, args = []) {
-    var _a;
     assert(this.address !== null, "contract is not connected to an address");
-    if (!((_a = args[0]) == null ? void 0 : _a.compiled)) {
+    if (!getCalldata(args, () => false)) {
       this.callData.validate("INVOKE", method, args);
     }
-    const invocation = this.populateTransaction[method](...args);
+    const invocation = this.populate(method, args);
     if ("estimateInvokeFee" in this.providerOrAccount) {
       return this.providerOrAccount.estimateInvokeFee(invocation);
     }
     throw Error("Contract must be connected to the account contract to estimate");
   }
   populate(method, args = []) {
-    var _a;
-    const { inputs } = this.abi.find((abi) => abi.name === method);
-    const calldata = ((_a = args == null ? void 0 : args[0]) == null ? void 0 : _a.compiled) ? args == null ? void 0 : args[0] : this.callData.compile(args, inputs);
+    const calldata = getCalldata(args, () => this.callData.compile(method, args));
     return {
       contractAddress: this.address,
       entrypoint: method,
@@ -4962,36 +4960,24 @@ var ContractFactory = class {
     this.compiledContract = compiledContract;
     this.account = account;
     this.classHash = classHash;
-    this.callData = new CallData(abi);
+    this.CallData = new CallData(abi);
   }
   async deploy(...args) {
-    var _a;
-    let constructorCalldata;
-    let parseRequest = true;
-    let addressSalt;
-    args.forEach((arg) => {
-      if (typeof arg !== "object")
-        return;
-      if ("addressSalt" in arg) {
-        addressSalt = arg.addressSalt;
-      }
-      if ("parseRequest" in arg) {
-        parseRequest = arg.parseRequest;
+    const { args: param, options = { parseRequest: true } } = splitArgsAndOptions(args);
+    const constructorCalldata = getCalldata(param, () => {
+      if (options.parseRequest) {
+        this.CallData.validate("DEPLOY", "constructor", param);
+        return this.CallData.compile("constructor", param);
       }
+      console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
+      return param;
     });
-    if (!parseRequest || ((_a = args[0]) == null ? void 0 : _a.compiled)) {
-      constructorCalldata = args[0];
-    } else {
-      this.callData.validate("DEPLOY", "constructor", args);
-      const { inputs } = this.abi.find((abi) => abi.type === "constructor");
-      constructorCalldata = this.callData.compile(args, inputs);
-    }
     const {
       deploy: { contract_address, transaction_hash }
     } = await this.account.declareAndDeploy({
       contract: this.compiledContract,
       constructorCalldata,
-      salt: addressSalt
+      salt: options.addressSalt
     });
     assert(Boolean(contract_address), "Deployment of the contract failed");
     const contractInstance = new Contract(
@@ -5040,19 +5026,13 @@ var transformCallsToMulticallArrays = (calls) => {
   });
   return {
     callArray,
-    calldata: bigNumberishArrayToDecimalStringArray(calldata)
+    calldata: CallData.compile({ calldata })
   };
 };
 var fromCallsToExecuteCalldata = (calls) => {
   const { callArray, calldata } = transformCallsToMulticallArrays(calls);
-  return [
-    callArray.length.toString(),
-    ...callArray.map(
-      ({ to, selector, data_offset, data_len }) => [to, selector, data_offset, data_len]
-    ).flat(),
-    calldata.length.toString(),
-    ...calldata
-  ];
+  const compiledCalls = CallData.compile({ callArray });
+  return [...compiledCalls, ...calldata];
 };
 var fromCallsToExecuteCalldataWithNonce = (calls, nonce) => {
   return [...fromCallsToExecuteCalldata(calls), toBigInt(nonce).toString()];
@@ -5061,20 +5041,16 @@ var transformCallsToMulticallArrays_cairo1 = (calls) => {
   const callArray = calls.map((call) => ({
     to: toBigInt(call.contractAddress).toString(10),
     selector: toBigInt(getSelectorFromName(call.entrypoint)).toString(10),
-    calldata: bigNumberishArrayToDecimalStringArray(call.calldata || [])
+    calldata: CallData.compile(call.calldata || [])
   }));
   return callArray;
 };
 var fromCallsToExecuteCalldata_cairo1 = (calls) => {
-  const callArray = transformCallsToMulticallArrays_cairo1(calls);
-  return [
-    callArray.length.toString(),
-    ...callArray.map(({ to, selector, calldata }) => [to, selector, calldata.length.toString(), ...calldata]).flat()
-  ];
+  return CallData.compile({ calls });
 };
 var getExecuteCalldata = (calls, cairoVersion = "0") => {
   if (cairoVersion === "1") {
-    return fromCallsToExecuteCalldata_cairo1(calls);
+    return CallData.compile({ calls });
   }
   return fromCallsToExecuteCalldata(calls);
 };
@@ -5619,7 +5595,7 @@ var Account = class extends Provider {
         unique = true,
         constructorCalldata = []
       } = it;
-      const compiledConstructorCallData = compileCalldata(constructorCalldata);
+      const compiledConstructorCallData = CallData.compile(constructorCalldata);
       const deploySalt = salt ?? randomAddress();
       return {
         call: {
@@ -5643,7 +5619,10 @@ var Account = class extends Provider {
     });
     const calls = params.map((it) => it.call);
     const addresses = params.map((it) => it.address);
-    const invokeResponse = await this.execute(calls, void 0, details);
+    const invokeResponse = await this.execute(calls, void 0, {
+      ...details,
+      cairoVersion: "0"
+    });
     return {
       ...invokeResponse,
       contract_address: addresses
@@ -5677,7 +5656,8 @@ var Account = class extends Provider {
     const version = toBigInt(transactionVersion);
     const nonce = ZERO;
     const chainId = await this.getChainId();
-    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, constructorCalldata, 0);
+    const compiledCalldata = CallData.compile(constructorCalldata);
+    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, compiledCalldata, 0);
     const maxFee = transactionsDetail.maxFee ?? await this.getSuggestedMaxFee(
       {
         type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
@@ -5715,7 +5695,7 @@ var Account = class extends Provider {
       await this.callContract({
         contractAddress: this.address,
         entrypoint: "isValidSignature",
-        calldata: compileCalldata({
+        calldata: CallData.compile({
           hash: toBigInt(hash).toString(),
           signature: formatSignature(signature)
         })
@@ -5775,7 +5755,8 @@ var Account = class extends Provider {
     constructorCalldata = [],
     contractAddress: providedContractAddress
   }, { nonce, chainId, version, maxFee }) {
-    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, constructorCalldata, 0);
+    const compiledCalldata = CallData.compile(constructorCalldata);
+    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, compiledCalldata, 0);
     const signature = await this.signer.signDeployAccountTransaction({
       classHash,
       contractAddress,
@@ -5801,7 +5782,7 @@ var Account = class extends Provider {
         unique = true,
         constructorCalldata = []
       } = it;
-      const compiledConstructorCallData = compileCalldata(constructorCalldata);
+      const compiledConstructorCallData = CallData.compile(constructorCalldata);
       return {
         contractAddress: UDC.ADDRESS,
         entrypoint: UDC.ENTRYPOINT,
@@ -5918,6 +5899,7 @@ var number = num_exports;
   encode,
   fixProto,
   fixStack,
+  getCalldata,
   getChecksumAddress,
   hash,
   isUrl,
@@ -5926,6 +5908,7 @@ var number = num_exports;
   num,
   number,
   shortString,
+  splitArgsAndOptions,
   stark,
   starknetId,
   transaction,