starknet 5.6.1 → 5.8.0

package/dist/index.mjs

@@ -2479,6 +2479,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()`);
 }
 
@@ -2765,7 +2768,6 @@ function extractContractHashes(payload) {
 // src/utils/stark.ts
 var stark_exports = {};
 __export(stark_exports, {
-  compileCalldata: () => compileCalldata,
   compressProgram: () => compressProgram,
   estimatedFeeToMaxFee: () => estimatedFeeToMaxFee,
   formatSignature: () => formatSignature,
@@ -2807,21 +2809,6 @@ function signatureToDecimalArray(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;
@@ -2935,308 +2922,826 @@ var HttpError = class extends LibraryError {
   }
 };
 
-// src/utils/starknetId.ts
-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;
+// 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]}`);
   }
-  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)];
+};
+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;
     }
-    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 decoded.concat("stark");
+    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;
+  }, {});
 }
-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));
-  }
-  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;
+
+// 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++;
       }
-    } 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;
+      subTuple.push(s.substring(lBracket, i));
+      result += " ";
+      i--;
+    } else {
+      result += s[i];
     }
+    i++;
   }
-  return encoded;
+  return {
+    subTuple,
+    result
+  };
 }
-function getStarknetIdContract(chainId) {
-  const starknetIdMainnetContract = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678";
-  const starknetIdTestnetContract = "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce";
-  switch (chainId) {
-    case "0x534e5f4d41494e" /* SN_MAIN */:
-      return starknetIdMainnetContract;
-    case "0x534e5f474f45524c49" /* SN_GOERLI */:
-      return starknetIdTestnetContract;
-    default:
-      throw new Error("Starknet.id is not yet deployed on this network");
+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;
 }
-
-// src/provider/starknetId.ts
-async function getStarkName(provider, address, StarknetIdContract) {
-  const chainId = await provider.getChainId();
-  const contract = StarknetIdContract ?? 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");
-  }
+function extractCairo1Tuple(type) {
+  const cleanType = type.replace(/\s/g, "").slice(1, -1);
+  return cleanType.split(",");
 }
-async function getAddressFromStarkName(provider, name, StarknetIdContract) {
-  const chainId = await provider.getChainId();
-  const contract = StarknetIdContract ?? 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");
+function extractTupleMemberTypes(type) {
+  if (isCairo1Type(type)) {
+    return extractCairo1Tuple(type);
   }
+  return extractCairo0Tuple(type);
 }
 
-// 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);
-  }
-  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";
-    }
+// 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}`
+    );
   }
-  get queryIdentifier() {
-    if (this.number !== null) {
-      return `blockNumber=${this.number}`;
-    }
-    if (this.hash !== null) {
-      return `blockHash=${this.hash}`;
-    }
-    return `blockNumber=${this.tag}`;
-  }
-  get identifier() {
-    if (this.number !== null) {
-      return { block_number: this.number };
-    }
-    if (this.hash !== null) {
-      return { block_hash: this.hash };
-    }
-    return this.tag;
+  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}`);
   }
-  set identifier(_identifier) {
-    this.setIdentifier(_identifier);
+  if (Array.isArray(element)) {
+    throw Error(`Array inside array (nD) are not supported by cairo. Element: ${element} ${type}`);
   }
-  get sequencerIdentifier() {
-    return this.hash !== null ? { blockHash: this.hash } : { blockNumber: this.number ?? this.tag };
+  if (isTypeUint256(type)) {
+    const el_uint256 = uint256(element);
+    return [felt(el_uint256.low), felt(el_uint256.high)];
   }
-};
-
-// 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();
+  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));
+    }, []);
   }
-  fetch(method, params) {
-    return fetchPonyfill_default(this.nodeUrl, {
-      method: "POST",
-      body: stringify2({ method, jsonrpc: "2.0", params, id: 0 }),
-      headers: this.headers
-    });
+  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);
+    }, []);
   }
-  errorHandler(error) {
-    if (error) {
-      const { code, message } = error;
-      throw new LibraryError(`${code}: ${message}`);
-    }
+  if (typeof element === "object") {
+    throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
   }
-  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;
-    }
+  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);
   }
-  async getChainId() {
-    this.chainId ?? (this.chainId = await this.fetchEndpoint("starknet_chainId"));
-    return this.chainId;
+}
+
+// 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;
+    }, {});
   }
-  async getBlock(blockIdentifier = this.blockIdentifier) {
-    return this.getBlockWithTxHashes(blockIdentifier).then(
-      this.responseParser.parseGetBlockResponse
-    );
+  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;
+    }, {});
   }
-  async getBlockHashAndNumber() {
-    return this.fetchEndpoint("starknet_blockHashAndNumber");
+  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);
   }
-  async getBlockWithTxHashes(blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getBlockWithTxHashes", { block_id });
+}
+
+// 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 getBlockWithTxs(blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getBlockWithTxs", { block_id });
+  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;
   }
-  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
-    });
+};
+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 getPendingTransactions() {
-    return this.fetchEndpoint("starknet_pendingTransactions");
+};
+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);
   }
-  async getProtocolVersion() {
-    throw new Error("Pathfinder does not implement this rpc 0.1.0 method");
+  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}`
+      );
+    }
+    validateFields(abiMethod, args, this.structs);
   }
-  async getStateUpdate(blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
+  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)),
+      []
+    );
   }
-  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
+  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);
+          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);
+    }
+    Object.defineProperty(callTreeArray, "__compiled__", {
+      enumerable: false,
+      writable: false,
+      value: true
     });
+    return callTreeArray;
   }
-  async getTransaction(txHash) {
-    return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
+  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 getTransactionByHash(txHash) {
-    return this.fetchEndpoint("starknet_getTransactionByHash", { transaction_hash: txHash });
+  format(method, response, format) {
+    const parsed = this.parse(method, response);
+    return formatter(parsed, format);
   }
-  async getTransactionByBlockIdAndIndex(blockIdentifier, index) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getTransactionByBlockIdAndIndex", { block_id, index });
+  static abiInputsLength(inputs) {
+    return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
   }
-  async getTransactionReceipt(txHash) {
-    return this.fetchEndpoint("starknet_getTransactionReceipt", { transaction_hash: txHash });
+  static getAbiStruct(abi) {
+    return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
+      (acc, abiEntry) => ({
+        ...acc,
+        [abiEntry.name]: abiEntry
+      }),
+      {}
+    );
   }
-  async getClassByHash(classHash) {
-    return this.getClass(classHash);
+};
+
+// 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 getClass(classHash, blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getClass", { class_hash: classHash, block_id });
+  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 getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+  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));
+  }
+  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 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");
+  }
+}
+
+// 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);
+  }
+  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";
+    }
+  }
+  get queryIdentifier() {
+    if (this.number !== null) {
+      return `blockNumber=${this.number}`;
+    }
+    if (this.hash !== null) {
+      return `blockHash=${this.hash}`;
+    }
+    return `blockNumber=${this.tag}`;
+  }
+  get identifier() {
+    if (this.number !== null) {
+      return { block_number: this.number };
+    }
+    if (this.hash !== null) {
+      return { block_hash: this.hash };
+    }
+    return this.tag;
+  }
+  set identifier(_identifier) {
+    this.setIdentifier(_identifier);
+  }
+  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,
@@ -3426,11 +3931,11 @@ var RpcProvider = class {
   async getSimulateTransaction(_invocation, _invocationDetails, _blockIdentifier) {
     throw new Error("RPC does not implement simulateTransaction function");
   }
-  async getStarkName(address, StarknetIdContract) {
-    return getStarkName(this, address, StarknetIdContract);
+  async getStarkName(address, StarknetIdContract2) {
+    return getStarkName(this, address, StarknetIdContract2);
   }
-  async getAddressFromStarkName(name, StarknetIdContract) {
-    return getAddressFromStarkName(this, name, StarknetIdContract);
+  async getAddressFromStarkName(name, StarknetIdContract2) {
+    return getAddressFromStarkName(this, name, StarknetIdContract2);
   }
 };
 
@@ -3960,711 +4465,206 @@ var SequencerProvider = class {
         ...res,
         signature: bigNumberishArrayToDecimalStringArray(formatSignature(invocation.signature)),
         version: toHex(toBigInt((invocation == null ? void 0 : invocation.version) || 1)),
-        nonce: toHex(toBigInt(invocation.nonce))
-      };
-    });
-    return this.fetchEndpoint("estimate_fee_bulk", { blockIdentifier }, params).then(
-      this.responseParser.parseFeeEstimateBulkResponse
-    );
-  }
-  async getCode(contractAddress, blockIdentifier = this.blockIdentifier) {
-    return this.fetchEndpoint("get_code", { contractAddress, blockIdentifier });
-  }
-  async waitForTransaction(txHash, options) {
-    const errorStates = ["REJECTED" /* REJECTED */, "NOT_RECEIVED" /* NOT_RECEIVED */];
-    let onchain = false;
-    let res;
-    const retryInterval = (options == null ? void 0 : options.retryInterval) ?? 8e3;
-    const successStates = (options == null ? void 0 : options.successStates) ?? [
-      "ACCEPTED_ON_L1" /* ACCEPTED_ON_L1 */,
-      "ACCEPTED_ON_L2" /* ACCEPTED_ON_L2 */,
-      "PENDING" /* PENDING */
-    ];
-    while (!onchain) {
-      await wait(retryInterval);
-      res = await this.getTransactionStatus(txHash);
-      if (successStates.includes(res.tx_status)) {
-        onchain = true;
-      } else if (errorStates.includes(res.tx_status)) {
-        const message = res.tx_failure_reason ? `${res.tx_status}: ${res.tx_failure_reason.code}
-${res.tx_failure_reason.error_message}` : res.tx_status;
-        const error = new Error(message);
-        error.response = res;
-        throw error;
-      }
-    }
-    const txReceipt = await this.getTransactionReceipt(txHash);
-    return txReceipt;
-  }
-  async getTransactionStatus(txHash) {
-    const txHashHex = toHex(txHash);
-    return this.fetchEndpoint("get_transaction_status", { transactionHash: txHashHex });
-  }
-  async getContractAddresses() {
-    return this.fetchEndpoint("get_contract_addresses");
-  }
-  async getTransactionTrace(txHash) {
-    const txHashHex = toHex(txHash);
-    return this.fetchEndpoint("get_transaction_trace", { transactionHash: txHashHex });
-  }
-  async estimateMessageFee({ from_address, to_address, entry_point_selector, payload }, blockIdentifier = this.blockIdentifier) {
-    const validCallL1Handler = {
-      from_address: getDecimalString(from_address),
-      to_address: getHexString(to_address),
-      entry_point_selector: getSelector(entry_point_selector),
-      payload: getHexStringArray(payload)
-    };
-    return this.fetchEndpoint("estimate_message_fee", { blockIdentifier }, validCallL1Handler);
-  }
-  async getSimulateTransaction(invocation, invocationDetails, blockIdentifier = this.blockIdentifier, skipValidate = false) {
-    return this.fetchEndpoint(
-      "simulate_transaction",
-      { blockIdentifier, skipValidate },
-      {
-        type: "INVOKE_FUNCTION",
-        sender_address: invocation.contractAddress,
-        calldata: invocation.calldata ?? [],
-        signature: signatureToDecimalArray(invocation.signature),
-        version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
-        nonce: toHex(invocationDetails.nonce),
-        max_fee: toHex((invocationDetails == null ? void 0 : invocationDetails.maxFee) || 0)
-      }
-    ).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, StarknetIdContract) {
-    return getStarkName(this, address, StarknetIdContract);
-  }
-  async getAddressFromStarkName(name, StarknetIdContract) {
-    return getAddressFromStarkName(this, name, StarknetIdContract);
-  }
-};
-
-// 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, StarknetIdContract) {
-    return getStarkName(this, address, StarknetIdContract);
-  }
-  async getAddressFromStarkName(name, StarknetIdContract) {
-    return getAddressFromStarkName(this, name, StarknetIdContract);
-  }
-};
-
-// 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}`
-      );
-  }
-};
-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"
+        nonce: toHex(toBigInt(invocation.nonce))
+      };
+    });
+    return this.fetchEndpoint("estimate_fee_bulk", { blockIdentifier }, params).then(
+      this.responseParser.parseFeeEstimateBulkResponse
     );
-    const inputsLength = CallData.abiInputsLength(abiMethod.inputs);
-    if (args.length !== inputsLength) {
-      throw Error(
-        `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
-      );
+  }
+  async getCode(contractAddress, blockIdentifier = this.blockIdentifier) {
+    return this.fetchEndpoint("get_code", { contractAddress, blockIdentifier });
+  }
+  async waitForTransaction(txHash, options) {
+    const errorStates = ["REJECTED" /* REJECTED */, "NOT_RECEIVED" /* NOT_RECEIVED */];
+    let onchain = false;
+    let res;
+    const retryInterval = (options == null ? void 0 : options.retryInterval) ?? 8e3;
+    const successStates = (options == null ? void 0 : options.successStates) ?? [
+      "ACCEPTED_ON_L1" /* ACCEPTED_ON_L1 */,
+      "ACCEPTED_ON_L2" /* ACCEPTED_ON_L2 */,
+      "PENDING" /* PENDING */
+    ];
+    while (!onchain) {
+      await wait(retryInterval);
+      res = await this.getTransactionStatus(txHash);
+      if (successStates.includes(res.tx_status)) {
+        onchain = true;
+      } else if (errorStates.includes(res.tx_status)) {
+        const message = res.tx_failure_reason ? `${res.tx_status}: ${res.tx_failure_reason.code}
+${res.tx_failure_reason.error_message}` : res.tx_status;
+        const error = new Error(message);
+        error.response = res;
+        throw error;
+      }
     }
-    validateFields(abiMethod, args, this.structs);
+    const txReceipt = await this.getTransactionReceipt(txHash);
+    return txReceipt;
   }
-  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 getTransactionStatus(txHash) {
+    const txHashHex = toHex(txHash);
+    return this.fetchEndpoint("get_transaction_status", { transactionHash: txHashHex });
   }
-  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));
+  async getContractAddresses() {
+    return this.fetchEndpoint("get_contract_addresses");
+  }
+  async getTransactionTrace(txHash) {
+    const txHashHex = toHex(txHash);
+    return this.fetchEndpoint("get_transaction_trace", { transactionHash: txHashHex });
+  }
+  async estimateMessageFee({ from_address, to_address, entry_point_selector, payload }, blockIdentifier = this.blockIdentifier) {
+    const validCallL1Handler = {
+      from_address: getDecimalString(from_address),
+      to_address: getHexString(to_address),
+      entry_point_selector: getSelector(entry_point_selector),
+      payload: getHexStringArray(payload)
     };
-    let callTreeArray;
-    if (!Array.isArray(data)) {
-      const callTree = createTree(data);
-      callTreeArray = Object.values(callTree);
+    return this.fetchEndpoint("estimate_message_fee", { blockIdentifier }, validCallL1Handler);
+  }
+  async getSimulateTransaction(invocation, invocationDetails, blockIdentifier = this.blockIdentifier, skipValidate = false) {
+    return this.fetchEndpoint(
+      "simulate_transaction",
+      { blockIdentifier, skipValidate },
+      {
+        type: "INVOKE_FUNCTION",
+        sender_address: invocation.contractAddress,
+        calldata: invocation.calldata ?? [],
+        signature: signatureToDecimalArray(invocation.signature),
+        version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
+        nonce: toHex(invocationDetails.nonce),
+        max_fee: toHex((invocationDetails == null ? void 0 : invocationDetails.maxFee) || 0)
+      }
+    ).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 {
-      callTreeArray = data;
+      this.provider = new SequencerProvider();
     }
-    Object.defineProperty(callTreeArray, "compiled", {
-      enumerable: false,
-      writable: false,
-      value: true
-    });
-    return callTreeArray;
   }
-  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 getChainId() {
+    return this.provider.getChainId();
   }
-  format(method, response, format) {
-    const parsed = this.parse(method, response);
-    return formatter(parsed, format);
+  async getBlock(blockIdentifier) {
+    return this.provider.getBlock(blockIdentifier);
   }
-  static abiInputsLength(inputs) {
-    return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
+  async getClassAt(contractAddress, blockIdentifier) {
+    return this.provider.getClassAt(contractAddress, blockIdentifier);
   }
-  static getAbiStruct(abi) {
-    return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
-      (acc, abiEntry) => ({
-        ...acc,
-        [abiEntry.name]: abiEntry
-      }),
-      {}
+  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/contract/default.ts
 var splitArgsAndOptions = (args) => {
   const options = [
@@ -4674,13 +4674,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) {
@@ -4717,20 +4718,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 },
@@ -4787,15 +4788,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,
@@ -4804,25 +4811,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,
@@ -4830,40 +4837,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,
@@ -4883,36 +4886,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(
@@ -5540,7 +5531,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: {
@@ -5564,7 +5555,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
@@ -5636,7 +5630,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)
         })
@@ -5722,7 +5716,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,
@@ -5766,8 +5760,8 @@ var Account = class extends Provider {
       }
     };
   }
-  async getStarkName(address = this.address, StarknetIdContract) {
-    return super.getStarkName(address, StarknetIdContract);
+  async getStarkName(address = this.address, StarknetIdContract2) {
+    return super.getStarkName(address, StarknetIdContract2);
   }
 };
 
@@ -5838,6 +5832,7 @@ export {
   encode_exports as encode,
   fixProto,
   fixStack,
+  getCalldata,
   getChecksumAddress,
   hash_exports as hash,
   isUrl,
@@ -5846,7 +5841,9 @@ export {
   num_exports as num,
   number,
   shortString_exports as shortString,
+  splitArgsAndOptions,
   stark_exports as stark,
+  starknetId_exports as starknetId,
   transaction_exports as transaction,
   typedData_exports as typedData,
   uint256_exports as uint256,