starknet 5.7.0 → 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,1055 +2922,964 @@ var HttpError = class extends LibraryError {
   }
 };
 
-// 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;
+// 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
+  };
 }
-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");
+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, 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");
-  }
+function extractCairo1Tuple(type) {
+  const cleanType = type.replace(/\s/g, "").slice(1, -1);
+  return cleanType.split(",");
 }
-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");
+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";
-    }
-  }
-  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
+// 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}`
     );
   }
-  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 });
+  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}`);
   }
-  async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getClassHashAt", {
-      block_id,
-      contract_address: contractAddress
-    });
+  if (Array.isArray(element)) {
+    throw Error(`Array inside array (nD) are not supported by cairo. Element: ${element} ${type}`);
   }
-  async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getNonce", {
-      contract_address: contractAddress,
-      block_id
-    });
+  if (isTypeUint256(type)) {
+    const el_uint256 = uint256(element);
+    return [felt(el_uint256.low), felt(el_uint256.high)];
   }
-  async getPendingTransactions() {
-    return this.fetchEndpoint("starknet_pendingTransactions");
+  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));
+    }, []);
   }
-  async getProtocolVersion() {
-    throw new Error("Pathfinder does not implement this rpc 0.1.0 method");
+  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);
+    }, []);
   }
-  async getStateUpdate(blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
+  if (typeof element === "object") {
+    throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
   }
-  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
-    });
+  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 getTransaction(txHash) {
-    return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
+}
+
+// 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 getTransactionByHash(txHash) {
-    return this.fetchEndpoint("starknet_getTransactionByHash", { transaction_hash: txHash });
+  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 getTransactionByBlockIdAndIndex(blockIdentifier, index) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getTransactionByBlockIdAndIndex", { block_id, index });
+  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 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: 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);
-  }
-  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,
-            entry_points_by_type: contractDefinition.entry_points_by_type,
-            abi: contractDefinition.abi
-          },
-          type: RPC.TransactionType.DECLARE,
-          version: "0x1",
-          max_fee: toHex(details.maxFee || 0),
-          signature: signatureToHexArray(signature),
-          sender_address: senderAddress,
-          nonce: toHex(details.nonce)
-        }
-      });
-    }
-    throw new Error("RPC do not support Sierra Contracts yet");
-  }
-  async deployAccountContract({ classHash, constructorCalldata, addressSalt, signature }, details) {
-    return this.fetchEndpoint("starknet_addDeployAccountTransaction", {
-      deploy_account_transaction: {
-        constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata || []),
-        class_hash: toHex(classHash),
-        contract_address_salt: toHex(addressSalt || 0),
-        type: RPC.TransactionType.DEPLOY_ACCOUNT,
-        max_fee: toHex(details.maxFee || 0),
-        version: toHex(details.version || 0),
-        signature: signatureToHexArray(signature),
-        nonce: toHex(details.nonce)
-      }
-    });
-  }
-  async invokeFunction(functionInvocation, details) {
-    return this.fetchEndpoint("starknet_addInvokeTransaction", {
-      invoke_transaction: {
-        sender_address: functionInvocation.contractAddress,
-        calldata: parseCalldata(functionInvocation.calldata),
-        type: RPC.TransactionType.INVOKE,
-        max_fee: toHex(details.maxFee || 0),
-        version: "0x1",
-        signature: signatureToHexArray(functionInvocation.signature),
-        nonce: toHex(details.nonce)
-      }
-    });
-  }
-  async callContract(call, blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    const result = await this.fetchEndpoint("starknet_call", {
-      request: {
-        contract_address: call.contractAddress,
-        entry_point_selector: getSelectorFromName(call.entrypoint),
-        calldata: parseCalldata(call.calldata)
-      },
-      block_id
-    });
-    return this.responseParser.parseCallContractResponse(result);
-  }
-  async traceTransaction(transactionHash) {
-    return this.fetchEndpoint("starknet_traceTransaction", { transaction_hash: transactionHash });
-  }
-  async traceBlockTransactions(blockHash) {
-    return this.fetchEndpoint("starknet_traceBlockTransactions", { block_hash: blockHash });
-  }
-  async waitForTransaction(txHash, options) {
-    const errorStates = ["REJECTED" /* REJECTED */, "NOT_RECEIVED" /* NOT_RECEIVED */];
-    let { retries } = this;
-    let onchain = false;
-    let txReceipt = {};
-    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);
-      try {
-        txReceipt = await this.getTransactionReceipt(txHash);
-        if (!("status" in txReceipt)) {
-          const error = new Error("pending transaction");
-          throw error;
-        }
-        if (txReceipt.status && successStates.includes(txReceipt.status)) {
-          onchain = true;
-        } else if (txReceipt.status && errorStates.includes(txReceipt.status)) {
-          const message = txReceipt.status;
-          const error = new Error(message);
-          error.response = txReceipt;
-          throw error;
-        }
-      } catch (error) {
-        if (error instanceof Error && errorStates.includes(error.message)) {
-          throw error;
-        }
-        if (retries === 0) {
-          throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
-        }
-      }
-      retries -= 1;
-    }
-    await wait(retryInterval);
-    return txReceipt;
-  }
-  async getTransactionCount(blockIdentifier = this.blockIdentifier) {
-    const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint("starknet_getBlockTransactionCount", { block_id });
-  }
-  async getBlockNumber() {
-    return this.fetchEndpoint("starknet_blockNumber");
-  }
-  async getSyncingStats() {
-    return this.fetchEndpoint("starknet_syncing");
-  }
-  async getEvents(eventFilter) {
-    return this.fetchEndpoint("starknet_getEvents", { filter: eventFilter });
-  }
-  async getSimulateTransaction(_invocation, _invocationDetails, _blockIdentifier) {
-    throw new Error("RPC does not implement simulateTransaction function");
+}
+
+// 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 getStarkName(address, StarknetIdContract2) {
-    return getStarkName(this, address, StarknetIdContract2);
+  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 getAddressFromStarkName(name, StarknetIdContract2) {
-    return getAddressFromStarkName(this, name, StarknetIdContract2);
+};
+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/provider/sequencer.ts
-import urljoin2 from "url-join";
-
-// src/utils/responseParser/index.ts
-var ResponseParser = class {
-};
-
-// src/utils/responseParser/sequencer.ts
-var SequencerAPIResponseParser = class extends ResponseParser {
-  parseGetBlockResponse(res) {
-    return {
-      ...res,
-      new_root: res.state_root,
-      parent_hash: res.parent_block_hash,
-      transactions: Object.values(res.transactions).map((value) => "transaction_hash" in value && value.transaction_hash).filter(Boolean)
-    };
-  }
-  parseGetTransactionResponse(res) {
-    return {
-      ...res,
-      calldata: "calldata" in res.transaction ? res.transaction.calldata : [],
-      contract_class: "contract_class" in res.transaction ? res.transaction.contract_class : void 0,
-      entry_point_selector: "entry_point_selector" in res.transaction ? res.transaction.entry_point_selector : void 0,
-      max_fee: "max_fee" in res.transaction ? res.transaction.max_fee : void 0,
-      nonce: res.transaction.nonce,
-      sender_address: "sender_address" in res.transaction ? res.transaction.sender_address : void 0,
-      signature: "signature" in res.transaction ? res.transaction.signature : void 0,
-      transaction_hash: "transaction_hash" in res.transaction ? res.transaction.transaction_hash : void 0,
-      version: "version" in res.transaction ? res.transaction.version : void 0
-    };
-  }
-  parseGetTransactionReceiptResponse(res) {
-    return {
-      transaction_hash: res.transaction_hash,
-      status: res.status,
-      messages_sent: res.l2_to_l1_messages,
-      events: res.events,
-      ..."block_hash" in res && { block_hash: res.block_hash },
-      ..."block_number" in res && { block_number: res.block_number },
-      ..."actual_fee" in res && { actual_fee: res.actual_fee },
-      ..."transaction_index" in res && { transaction_index: res.transaction_index },
-      ..."execution_resources" in res && { execution_resources: res.execution_resources },
-      ..."l1_to_l2_consumed_message" in res && {
-        l1_to_l2_consumed_message: res["l1_to_l2_consumed_message"]
-      },
-      ..."transaction_failure_reason" in res && {
-        transaction_failure_reason: res.transaction_failure_reason
-      }
-    };
+// src/utils/calldata/index.ts
+var CallData = class {
+  constructor(abi) {
+    this.abi = abi;
+    this.structs = CallData.getAbiStruct(abi);
   }
-  parseFeeEstimateResponse(res) {
-    if ("overall_fee" in res) {
-      let gasInfo = {};
-      try {
-        gasInfo = {
-          gas_consumed: toBigInt(res.gas_usage),
-          gas_price: toBigInt(res.gas_price)
-        };
-      } catch {
-      }
-      return {
-        overall_fee: toBigInt(res.overall_fee),
-        ...gasInfo
-      };
+  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`
+      );
     }
-    return {
-      overall_fee: toBigInt(res.amount)
-    };
-  }
-  parseFeeEstimateBulkResponse(res) {
-    return [].concat(res).map((item) => {
-      if ("overall_fee" in item) {
-        let gasInfo = {};
-        try {
-          gasInfo = {
-            gas_consumed: toBigInt(item.gas_usage),
-            gas_price: toBigInt(item.gas_price)
-          };
-        } catch {
-        }
-        return {
-          overall_fee: toBigInt(item.overall_fee),
-          ...gasInfo
-        };
-      }
-      return {
-        overall_fee: toBigInt(item.amount)
-      };
-    });
-  }
-  parseFeeSimulateTransactionResponse(res) {
-    if ("overall_fee" in res.fee_estimation) {
-      let gasInfo = {};
-      try {
-        gasInfo = {
-          gas_consumed: toBigInt(res.fee_estimation.gas_usage),
-          gas_price: toBigInt(res.fee_estimation.gas_price)
-        };
-      } catch {
-      }
-      return {
-        trace: res.trace,
-        fee_estimation: {
-          ...gasInfo,
-          overall_fee: toBigInt(res.fee_estimation.overall_fee)
-        }
-      };
+    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 {
-      trace: res.trace,
-      fee_estimation: {
-        overall_fee: toBigInt(res.fee_estimation.amount)
-      }
-    };
-  }
-  parseCallContractResponse(res) {
-    return {
-      result: res.result
-    };
-  }
-  parseInvokeFunctionResponse(res) {
-    return {
-      transaction_hash: res.transaction_hash
-    };
+    validateFields(abiMethod, args, this.structs);
   }
-  parseDeployContractResponse(res) {
-    return {
-      transaction_hash: res.transaction_hash,
-      contract_address: res.address
-    };
+  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)),
+      []
+    );
   }
-  parseDeclareContractResponse(res) {
-    return {
-      transaction_hash: res.transaction_hash,
-      class_hash: res.class_hash
+  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;
   }
-  parseGetStateUpdateResponse(res) {
-    const nonces = Object.entries(res.state_diff.nonces).map(([contract_address, nonce]) => ({
-      contract_address,
-      nonce
-    }));
-    const storage_diffs = Object.entries(res.state_diff.storage_diffs).map(
-      ([address, storage_entries]) => ({ address, storage_entries })
-    );
-    return {
-      ...res,
-      state_diff: {
-        ...res.state_diff,
-        storage_diffs,
-        nonces
+  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;
   }
-  parseSierraContractClassResponse(res) {
-    return {
-      ...res,
-      abi: JSON.parse(res.abi)
-    };
+  format(method, response, format) {
+    const parsed = this.parse(method, response);
+    return formatter(parsed, format);
+  }
+  static abiInputsLength(inputs) {
+    return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
+  }
+  static getAbiStruct(abi) {
+    return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
+      (acc, abiEntry) => ({
+        ...acc,
+        [abiEntry.name]: abiEntry
+      }),
+      {}
+    );
   }
 };
 
-// src/utils/url.ts
-import urljoin from "url-join";
-var protocolAndDomainRE = /^(?:\w+:)?\/\/(\S+)$/;
-var localhostDomainRE = /^localhost[:?\d]*(?:[^:?\d]\S*)?$/;
-var nonLocalhostDomainRE = /^[^\s.]+\.\S{2,}$/;
-function isUrl(s) {
-  if (!s) {
-    return false;
-  }
-  if (typeof s !== "string") {
-    return false;
+// 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;
   }
-  const match = s.match(protocolAndDomainRE);
-  if (!match) {
-    return false;
+  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;
   }
-  const everythingAfterProtocol = match[1];
-  if (!everythingAfterProtocol) {
-    return false;
+  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));
   }
-  if (localhostDomainRE.test(everythingAfterProtocol) || nonLocalhostDomainRE.test(everythingAfterProtocol)) {
-    return true;
+  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 false;
+  return encoded;
 }
-function buildUrl(baseUrl, defaultPath, urlOrPath) {
-  return isUrl(urlOrPath) ? urlOrPath : urljoin(baseUrl, urlOrPath ?? defaultPath);
+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/sequencer.ts
-function isEmptyQueryObject(obj) {
-  return obj === void 0 || Object.keys(obj).length === 0 || Object.keys(obj).length === 1 && Object.entries(obj).every(([k, v]) => k === "blockIdentifier" && v === null);
-}
-var defaultOptions2 = {
-  network: "SN_GOERLI2" /* SN_GOERLI2 */,
-  blockIdentifier: "pending"
-};
-var SequencerProvider = class {
-  constructor(optionsOrProvider = defaultOptions2) {
-    this.responseParser = new SequencerAPIResponseParser();
-    if ("network" in optionsOrProvider) {
-      this.baseUrl = SequencerProvider.getNetworkFromName(optionsOrProvider.network);
-      this.feederGatewayUrl = buildUrl(this.baseUrl, "feeder_gateway");
-      this.gatewayUrl = buildUrl(this.baseUrl, "gateway");
-    } else {
-      this.baseUrl = optionsOrProvider.baseUrl;
-      this.feederGatewayUrl = buildUrl(
-        this.baseUrl,
-        "feeder_gateway",
-        optionsOrProvider.feederGatewayUrl
-      );
-      this.gatewayUrl = buildUrl(this.baseUrl, "gateway", optionsOrProvider.gatewayUrl);
+// 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");
     }
-    this.chainId = (optionsOrProvider == null ? void 0 : optionsOrProvider.chainId) ?? SequencerProvider.getChainIdFromBaseUrl(this.baseUrl);
-    this.headers = optionsOrProvider.headers;
-    this.blockIdentifier = (optionsOrProvider == null ? void 0 : optionsOrProvider.blockIdentifier) || defaultOptions2.blockIdentifier;
-  }
-  static getNetworkFromName(name) {
-    switch (name) {
-      case ("SN_MAIN" /* SN_MAIN */ || "0x534e5f4d41494e" /* SN_MAIN */):
-        return "https://alpha-mainnet.starknet.io" /* SN_MAIN */;
-      case ("SN_GOERLI" /* SN_GOERLI */ || "0x534e5f474f45524c49" /* SN_GOERLI */):
-        return "https://alpha4.starknet.io" /* SN_GOERLI */;
-      case ("SN_GOERLI2" /* SN_GOERLI2 */ || "0x534e5f474f45524c4932" /* SN_GOERLI2 */):
-        return "https://alpha4-2.starknet.io" /* SN_GOERLI2 */;
-      default:
-        throw new Error("Could not detect base url from NetworkName");
+    return stringDomain;
+  } catch (e) {
+    if (e instanceof Error && e.message === "Starkname not found") {
+      throw e;
     }
+    throw Error("Could not get stark name");
   }
-  static getChainIdFromBaseUrl(baseUrl) {
-    try {
-      const url = new URL(baseUrl);
-      if (url.host.includes("mainnet.starknet.io")) {
-        return "0x534e5f4d41494e" /* SN_MAIN */;
-      }
-      if (url.host.includes("alpha4-2.starknet.io")) {
-        return "0x534e5f474f45524c4932" /* SN_GOERLI2 */;
-      }
-      return "0x534e5f474f45524c49" /* SN_GOERLI */;
-    } catch {
-      console.error(`Could not parse baseUrl: ${baseUrl}`);
-      return "0x534e5f474f45524c49" /* SN_GOERLI */;
+}
+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";
     }
   }
-  getFetchUrl(endpoint) {
-    const gatewayUrlEndpoints = ["add_transaction"];
-    return gatewayUrlEndpoints.includes(endpoint) ? this.gatewayUrl : this.feederGatewayUrl;
-  }
-  getFetchMethod(endpoint) {
-    const postMethodEndpoints = [
-      "add_transaction",
-      "call_contract",
-      "estimate_fee",
-      "estimate_message_fee",
-      "estimate_fee_bulk",
-      "simulate_transaction"
-    ];
-    return postMethodEndpoints.includes(endpoint) ? "POST" : "GET";
-  }
-  getQueryString(query) {
-    if (isEmptyQueryObject(query)) {
-      return "";
+  get queryIdentifier() {
+    if (this.number !== null) {
+      return `blockNumber=${this.number}`;
     }
-    const queryString = Object.entries(query).map(([key, value]) => {
-      if (key === "blockIdentifier") {
-        const block = new Block(value);
-        return `${block.queryIdentifier}`;
-      }
-      return `${key}=${value}`;
-    }).join("&");
-    return `?${queryString}`;
+    if (this.hash !== null) {
+      return `blockHash=${this.hash}`;
+    }
+    return `blockNumber=${this.tag}`;
   }
-  getHeaders(method) {
-    if (method === "POST") {
-      return {
-        "Content-Type": "application/json",
-        ...this.headers
-      };
+  get identifier() {
+    if (this.number !== null) {
+      return { block_number: this.number };
     }
-    return this.headers;
+    if (this.hash !== null) {
+      return { block_hash: this.hash };
+    }
+    return this.tag;
   }
-  async fetchEndpoint(endpoint, ...[query, request]) {
-    const baseUrl = this.getFetchUrl(endpoint);
-    const method = this.getFetchMethod(endpoint);
-    const queryString = this.getQueryString(query);
-    const url = urljoin2(baseUrl, endpoint, queryString);
-    return this.fetch(url, {
-      method,
-      body: request
+  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
     });
   }
-  async fetch(endpoint, options) {
-    const url = buildUrl(this.baseUrl, "", endpoint);
-    const method = (options == null ? void 0 : options.method) ?? "GET";
-    const headers = this.getHeaders(method);
-    const body = stringify2(options == null ? void 0 : options.body);
+  errorHandler(error) {
+    if (error) {
+      const { code, message } = error;
+      throw new LibraryError(`${code}: ${message}`);
+    }
+  }
+  async fetchEndpoint(method, params) {
+    var _a;
     try {
-      const response = await fetchPonyfill_default(url, {
-        method,
-        body,
-        headers
-      });
-      const textResponse = await response.text();
-      if (!response.ok) {
-        let responseBody;
-        try {
-          responseBody = parse2(textResponse);
-        } catch {
-          throw new HttpError(response.statusText, response.status);
-        }
-        throw new GatewayError(responseBody.message, responseBody.code);
-      }
-      const parseChoice = (options == null ? void 0 : options.parseAlwaysAsBigInt) ? parseAlwaysAsBig : parse2;
-      return parseChoice(textResponse);
+      const rawResult = await this.fetch(method, params);
+      const { error, result } = await rawResult.json();
+      this.errorHandler(error);
+      return result;
     } catch (error) {
-      if (error instanceof Error && !(error instanceof LibraryError))
-        throw Error(`Could not ${method} from endpoint \`${url}\`: ${error.message}`);
+      this.errorHandler((_a = error == null ? void 0 : error.response) == null ? void 0 : _a.data);
       throw error;
     }
   }
   async getChainId() {
-    return Promise.resolve(this.chainId);
-  }
-  async callContract({ contractAddress, entrypoint: entryPointSelector, calldata = [] }, blockIdentifier = this.blockIdentifier) {
-    return this.fetchEndpoint(
-      "call_contract",
-      { blockIdentifier },
-      {
-        contract_address: contractAddress,
-        entry_point_selector: getSelectorFromName(entryPointSelector),
-        calldata
-      }
-    ).then(this.responseParser.parseCallContractResponse);
+    this.chainId ?? (this.chainId = await this.fetchEndpoint("starknet_chainId"));
+    return this.chainId;
   }
   async getBlock(blockIdentifier = this.blockIdentifier) {
-    return this.fetchEndpoint("get_block", { blockIdentifier }).then(
+    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) {
-    return this.fetchEndpoint("get_nonce", { contractAddress, 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 = toBigInt(key).toString(10);
-    return this.fetchEndpoint("get_storage_at", {
-      blockIdentifier,
-      contractAddress,
-      key: parsedKey
+    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) {
-    const txHashHex = toHex(txHash);
-    return this.fetchEndpoint("get_transaction", { transactionHash: txHashHex }).then((result) => {
-      if (Object.values(result).length === 1)
-        throw new LibraryError(result.status);
-      return this.responseParser.parseGetTransactionResponse(result);
-    });
+    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) {
-    const txHashHex = toHex(txHash);
-    return this.fetchEndpoint("get_transaction_receipt", { transactionHash: txHashHex }).then(
-      this.responseParser.parseGetTransactionReceiptResponse
-    );
+    return this.fetchEndpoint("starknet_getTransactionReceipt", { transaction_hash: txHash });
   }
-  async getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
-    return this.fetchEndpoint("get_full_contract", { blockIdentifier, contractAddress }).then(
-      (res) => {
-        if (isSierra(res)) {
-          return this.responseParser.parseSierraContractClassResponse(res);
-        }
-        return parseContract(res);
-      }
-    );
+  async getClassByHash(classHash) {
+    return this.getClass(classHash);
   }
-  async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
-    return this.fetchEndpoint("get_class_hash_at", { blockIdentifier, contractAddress });
+  async getClass(classHash, blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getClass", { class_hash: classHash, block_id });
   }
-  async getClassByHash(classHash, blockIdentifier = this.blockIdentifier) {
-    return this.fetchEndpoint("get_class_by_hash", { classHash, blockIdentifier }).then((res) => {
-      if (isSierra(res)) {
-        return this.responseParser.parseSierraContractClassResponse(res);
-      }
-      return parseContract(res);
+  async getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getClassAt", {
+      block_id,
+      contract_address: contractAddress
     });
   }
-  async getCompiledClassByClassHash(classHash, blockIdentifier = this.blockIdentifier) {
-    return this.fetchEndpoint("get_compiled_class_by_class_hash", { classHash, blockIdentifier });
-  }
-  async invokeFunction(functionInvocation, details) {
-    return this.fetchEndpoint("add_transaction", void 0, {
-      type: "INVOKE_FUNCTION" /* INVOKE */,
-      sender_address: functionInvocation.contractAddress,
-      calldata: bigNumberishArrayToDecimalStringArray(functionInvocation.calldata ?? []),
-      signature: signatureToDecimalArray(functionInvocation.signature),
-      nonce: toHex(details.nonce),
-      max_fee: toHex(details.maxFee || 0),
-      version: "0x1"
-    }).then(this.responseParser.parseInvokeFunctionResponse);
+  async getCode(_contractAddress, _blockIdentifier) {
+    throw new Error("RPC does not implement getCode function");
   }
-  async deployAccountContract({ classHash, constructorCalldata, addressSalt, signature }, details) {
-    return this.fetchEndpoint("add_transaction", void 0, {
-      type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
-      contract_address_salt: addressSalt ?? randomAddress(),
-      constructor_calldata: bigNumberishArrayToDecimalStringArray(constructorCalldata ?? []),
-      class_hash: toHex(classHash),
-      max_fee: toHex(details.maxFee || 0),
-      version: toHex(details.version || 0),
-      nonce: toHex(details.nonce),
-      signature: signatureToDecimalArray(signature)
-    }).then(this.responseParser.parseDeployContractResponse);
+  async getEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier) {
+    return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier);
   }
-  async declareContract({ senderAddress, contractDefinition, signature, compiledClassHash }, details) {
-    if (!isSierra(contractDefinition)) {
-      return this.fetchEndpoint("add_transaction", void 0, {
-        type: "DECLARE" /* DECLARE */,
-        contract_class: contractDefinition,
-        nonce: toHex(details.nonce),
-        signature: signatureToDecimalArray(signature),
-        sender_address: senderAddress,
-        max_fee: toHex(details.maxFee || 0),
-        version: "0x1"
-      }).then(this.responseParser.parseDeclareContractResponse);
+  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);
+  }
+  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);
     }
-    return this.fetchEndpoint("add_transaction", void 0, {
-      type: "DECLARE" /* DECLARE */,
-      sender_address: senderAddress,
-      compiled_class_hash: compiledClassHash,
-      contract_class: contractDefinition,
-      nonce: toHex(details.nonce),
-      signature: signatureToDecimalArray(signature),
-      max_fee: toHex(details.maxFee || 0),
-      version: "0x2"
-    }).then(this.responseParser.parseDeclareContractResponse);
+    throw new Error("RPC do not support Sierra Contracts yet");
   }
-  async getEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier, skipValidate = false) {
-    return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier, skipValidate);
+  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 getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier, skipValidate = false) {
-    return this.fetchEndpoint(
-      "estimate_fee",
-      { blockIdentifier, skipValidate },
-      {
-        type: "INVOKE_FUNCTION" /* INVOKE */,
-        sender_address: invocation.contractAddress,
-        calldata: invocation.calldata ?? [],
-        signature: signatureToDecimalArray(invocation.signature),
-        version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
-        nonce: toHex(invocationDetails.nonce)
-      }
-    ).then(this.responseParser.parseFeeEstimateResponse);
+  async getEstimateFeeBulk(_invocations, _blockIdentifier = this.blockIdentifier) {
+    throw new Error("RPC does not implement getInvokeEstimateFeeBulk function");
   }
-  async getDeclareEstimateFee({ senderAddress, contractDefinition, signature, compiledClassHash }, details, blockIdentifier = this.blockIdentifier, skipValidate = false) {
-    if (!isSierra(contractDefinition)) {
-      return this.fetchEndpoint(
-        "estimate_fee",
-        { blockIdentifier, skipValidate },
-        {
-          type: "DECLARE" /* DECLARE */,
+  async declareContract({ contractDefinition, signature, senderAddress }, details) {
+    if ("program" in contractDefinition) {
+      return this.fetchEndpoint("starknet_addDeclareTransaction", {
+        declare_transaction: {
+          contract_class: {
+            program: contractDefinition.program,
+            entry_points_by_type: contractDefinition.entry_points_by_type,
+            abi: contractDefinition.abi
+          },
+          type: RPC.TransactionType.DECLARE,
+          version: "0x1",
+          max_fee: toHex(details.maxFee || 0),
+          signature: signatureToHexArray(signature),
           sender_address: senderAddress,
-          contract_class: contractDefinition,
-          signature: signatureToDecimalArray(signature),
-          version: toHex((details == null ? void 0 : details.version) || toBigInt(feeTransactionVersion)),
           nonce: toHex(details.nonce)
         }
-      ).then(this.responseParser.parseFeeEstimateResponse);
+      });
     }
-    return this.fetchEndpoint(
-      "estimate_fee",
-      { blockIdentifier, skipValidate },
-      {
-        type: "DECLARE" /* DECLARE */,
-        sender_address: senderAddress,
-        compiled_class_hash: compiledClassHash,
-        contract_class: contractDefinition,
-        nonce: toHex(details.nonce),
-        signature: signatureToDecimalArray(signature),
-        version: "0x2"
-      }
-    ).then(this.responseParser.parseFeeEstimateResponse);
+    throw new Error("RPC do not support Sierra Contracts yet");
   }
-  async getDeployAccountEstimateFee({ classHash, addressSalt, constructorCalldata, signature }, details, blockIdentifier = this.blockIdentifier, skipValidate = false) {
-    return this.fetchEndpoint(
-      "estimate_fee",
-      { blockIdentifier, skipValidate },
-      {
-        type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
+  async deployAccountContract({ classHash, constructorCalldata, addressSalt, signature }, details) {
+    return this.fetchEndpoint("starknet_addDeployAccountTransaction", {
+      deploy_account_transaction: {
+        constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata || []),
         class_hash: toHex(classHash),
-        constructor_calldata: bigNumberishArrayToDecimalStringArray(constructorCalldata || []),
         contract_address_salt: toHex(addressSalt || 0),
-        signature: signatureToDecimalArray(signature),
-        version: toHex((details == null ? void 0 : details.version) || 0),
+        type: RPC.TransactionType.DEPLOY_ACCOUNT,
+        max_fee: toHex(details.maxFee || 0),
+        version: toHex(details.version || 0),
+        signature: signatureToHexArray(signature),
         nonce: toHex(details.nonce)
       }
-    ).then(this.responseParser.parseFeeEstimateResponse);
+    });
   }
-  async getEstimateFeeBulk(invocations, blockIdentifier = this.blockIdentifier) {
-    const params = invocations.map((invocation) => {
-      let res;
-      if (invocation.type === "INVOKE_FUNCTION") {
-        res = {
-          type: invocation.type,
-          sender_address: invocation.contractAddress,
-          calldata: invocation.calldata ?? []
-        };
-      } else if (invocation.type === "DECLARE") {
-        res = {
-          type: invocation.type,
-          sender_address: invocation.senderAddress,
-          contract_class: invocation.contractDefinition
-        };
-      } else {
-        res = {
-          type: invocation.type,
-          class_hash: toHex(toBigInt(invocation.classHash)),
-          constructor_calldata: bigNumberishArrayToDecimalStringArray(
-            invocation.constructorCalldata || []
-          ),
-          contract_address_salt: toHex(toBigInt(invocation.addressSalt || 0))
-        };
+  async invokeFunction(functionInvocation, details) {
+    return this.fetchEndpoint("starknet_addInvokeTransaction", {
+      invoke_transaction: {
+        sender_address: functionInvocation.contractAddress,
+        calldata: parseCalldata(functionInvocation.calldata),
+        type: RPC.TransactionType.INVOKE,
+        max_fee: toHex(details.maxFee || 0),
+        version: "0x1",
+        signature: signatureToHexArray(functionInvocation.signature),
+        nonce: toHex(details.nonce)
       }
-      return {
-        ...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 callContract(call, blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    const result = await this.fetchEndpoint("starknet_call", {
+      request: {
+        contract_address: call.contractAddress,
+        entry_point_selector: getSelectorFromName(call.entrypoint),
+        calldata: parseCalldata(call.calldata)
+      },
+      block_id
+    });
+    return this.responseParser.parseCallContractResponse(result);
+  }
+  async traceTransaction(transactionHash) {
+    return this.fetchEndpoint("starknet_traceTransaction", { transaction_hash: transactionHash });
+  }
+  async traceBlockTransactions(blockHash) {
+    return this.fetchEndpoint("starknet_traceBlockTransactions", { block_hash: blockHash });
   }
   async waitForTransaction(txHash, options) {
     const errorStates = ["REJECTED" /* REJECTED */, "NOT_RECEIVED" /* NOT_RECEIVED */];
+    let { retries } = this;
     let onchain = false;
-    let res;
+    let txReceipt = {};
     const retryInterval = (options == null ? void 0 : options.retryInterval) ?? 8e3;
     const successStates = (options == null ? void 0 : options.successStates) ?? [
       "ACCEPTED_ON_L1" /* ACCEPTED_ON_L1 */,
@@ -3992,64 +3888,48 @@ var SequencerProvider = class {
     ];
     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;
+      try {
+        txReceipt = await this.getTransactionReceipt(txHash);
+        if (!("status" in txReceipt)) {
+          const error = new Error("pending transaction");
+          throw error;
+        }
+        if (txReceipt.status && successStates.includes(txReceipt.status)) {
+          onchain = true;
+        } else if (txReceipt.status && errorStates.includes(txReceipt.status)) {
+          const message = txReceipt.status;
+          const error = new Error(message);
+          error.response = txReceipt;
+          throw error;
+        }
+      } catch (error) {
+        if (error instanceof Error && errorStates.includes(error.message)) {
+          throw error;
+        }
+        if (retries === 0) {
+          throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
+        }
       }
+      retries -= 1;
     }
-    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 });
+    await wait(retryInterval);
+    return txReceipt;
   }
-  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 getTransactionCount(blockIdentifier = this.blockIdentifier) {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getBlockTransactionCount", { block_id });
   }
-  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 getBlockNumber() {
+    return this.fetchEndpoint("starknet_blockNumber");
   }
-  async getStateUpdate(blockIdentifier = this.blockIdentifier) {
-    const args = new Block(blockIdentifier).sequencerIdentifier;
-    return this.fetchEndpoint("get_state_update", { ...args }).then(
-      this.responseParser.parseGetStateUpdateResponse
-    );
+  async getSyncingStats() {
+    return this.fetchEndpoint("starknet_syncing");
   }
-  async getBlockTraces(blockIdentifier = this.blockIdentifier) {
-    const args = new Block(blockIdentifier).sequencerIdentifier;
-    return this.fetchEndpoint("get_block_traces", { ...args });
+  async getEvents(eventFilter) {
+    return this.fetchEndpoint("starknet_getEvents", { filter: eventFilter });
+  }
+  async getSimulateTransaction(_invocation, _invocationDetails, _blockIdentifier) {
+    throw new Error("RPC does not implement simulateTransaction function");
   }
   async getStarkName(address, StarknetIdContract2) {
     return getStarkName(this, address, StarknetIdContract2);
@@ -4059,622 +3939,732 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
   }
 };
 
-// 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);
+// src/provider/sequencer.ts
+import urljoin2 from "url-join";
+
+// src/utils/responseParser/index.ts
+var ResponseParser = class {
+};
+
+// src/utils/responseParser/sequencer.ts
+var SequencerAPIResponseParser = class extends ResponseParser {
+  parseGetBlockResponse(res) {
+    return {
+      ...res,
+      new_root: res.state_root,
+      parent_hash: res.parent_block_hash,
+      transactions: Object.values(res.transactions).map((value) => "transaction_hash" in value && value.transaction_hash).filter(Boolean)
+    };
   }
-  async getNonceForAddress(contractAddress, blockIdentifier) {
-    return this.provider.getNonceForAddress(contractAddress, blockIdentifier);
+  parseGetTransactionResponse(res) {
+    return {
+      ...res,
+      calldata: "calldata" in res.transaction ? res.transaction.calldata : [],
+      contract_class: "contract_class" in res.transaction ? res.transaction.contract_class : void 0,
+      entry_point_selector: "entry_point_selector" in res.transaction ? res.transaction.entry_point_selector : void 0,
+      max_fee: "max_fee" in res.transaction ? res.transaction.max_fee : void 0,
+      nonce: res.transaction.nonce,
+      sender_address: "sender_address" in res.transaction ? res.transaction.sender_address : void 0,
+      signature: "signature" in res.transaction ? res.transaction.signature : void 0,
+      transaction_hash: "transaction_hash" in res.transaction ? res.transaction.transaction_hash : void 0,
+      version: "version" in res.transaction ? res.transaction.version : void 0
+    };
   }
-  async getStorageAt(contractAddress, key, blockIdentifier) {
-    return this.provider.getStorageAt(contractAddress, key, blockIdentifier);
+  parseGetTransactionReceiptResponse(res) {
+    return {
+      transaction_hash: res.transaction_hash,
+      status: res.status,
+      messages_sent: res.l2_to_l1_messages,
+      events: res.events,
+      ..."block_hash" in res && { block_hash: res.block_hash },
+      ..."block_number" in res && { block_number: res.block_number },
+      ..."actual_fee" in res && { actual_fee: res.actual_fee },
+      ..."transaction_index" in res && { transaction_index: res.transaction_index },
+      ..."execution_resources" in res && { execution_resources: res.execution_resources },
+      ..."l1_to_l2_consumed_message" in res && {
+        l1_to_l2_consumed_message: res["l1_to_l2_consumed_message"]
+      },
+      ..."transaction_failure_reason" in res && {
+        transaction_failure_reason: res.transaction_failure_reason
+      }
+    };
   }
-  async getTransaction(txHash) {
-    return this.provider.getTransaction(txHash);
+  parseFeeEstimateResponse(res) {
+    if ("overall_fee" in res) {
+      let gasInfo = {};
+      try {
+        gasInfo = {
+          gas_consumed: toBigInt(res.gas_usage),
+          gas_price: toBigInt(res.gas_price)
+        };
+      } catch {
+      }
+      return {
+        overall_fee: toBigInt(res.overall_fee),
+        ...gasInfo
+      };
+    }
+    return {
+      overall_fee: toBigInt(res.amount)
+    };
   }
-  async getTransactionReceipt(txHash) {
-    return this.provider.getTransactionReceipt(txHash);
+  parseFeeEstimateBulkResponse(res) {
+    return [].concat(res).map((item) => {
+      if ("overall_fee" in item) {
+        let gasInfo = {};
+        try {
+          gasInfo = {
+            gas_consumed: toBigInt(item.gas_usage),
+            gas_price: toBigInt(item.gas_price)
+          };
+        } catch {
+        }
+        return {
+          overall_fee: toBigInt(item.overall_fee),
+          ...gasInfo
+        };
+      }
+      return {
+        overall_fee: toBigInt(item.amount)
+      };
+    });
   }
-  async callContract(request, blockIdentifier) {
-    return this.provider.callContract(request, blockIdentifier);
+  parseFeeSimulateTransactionResponse(res) {
+    if ("overall_fee" in res.fee_estimation) {
+      let gasInfo = {};
+      try {
+        gasInfo = {
+          gas_consumed: toBigInt(res.fee_estimation.gas_usage),
+          gas_price: toBigInt(res.fee_estimation.gas_price)
+        };
+      } catch {
+      }
+      return {
+        trace: res.trace,
+        fee_estimation: {
+          ...gasInfo,
+          overall_fee: toBigInt(res.fee_estimation.overall_fee)
+        }
+      };
+    }
+    return {
+      trace: res.trace,
+      fee_estimation: {
+        overall_fee: toBigInt(res.fee_estimation.amount)
+      }
+    };
   }
-  async invokeFunction(functionInvocation, details) {
-    return this.provider.invokeFunction(functionInvocation, details);
+  parseCallContractResponse(res) {
+    return {
+      result: res.result
+    };
   }
-  async deployAccountContract(payload, details) {
-    return this.provider.deployAccountContract(payload, details);
+  parseInvokeFunctionResponse(res) {
+    return {
+      transaction_hash: res.transaction_hash
+    };
   }
-  async declareContract(transaction, details) {
-    return this.provider.declareContract(transaction, details);
+  parseDeployContractResponse(res) {
+    return {
+      transaction_hash: res.transaction_hash,
+      contract_address: res.address
+    };
   }
-  async getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate) {
-    return this.provider.getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate);
+  parseDeclareContractResponse(res) {
+    return {
+      transaction_hash: res.transaction_hash,
+      class_hash: res.class_hash
+    };
   }
-  getDeployAccountEstimateFee(transaction, details, blockIdentifier, skipValidate) {
-    return this.provider.getDeployAccountEstimateFee(
-      transaction,
-      details,
-      blockIdentifier,
-      skipValidate
+  parseGetStateUpdateResponse(res) {
+    const nonces = Object.entries(res.state_diff.nonces).map(([contract_address, nonce]) => ({
+      contract_address,
+      nonce
+    }));
+    const storage_diffs = Object.entries(res.state_diff.storage_diffs).map(
+      ([address, storage_entries]) => ({ address, storage_entries })
     );
+    return {
+      ...res,
+      state_diff: {
+        ...res.state_diff,
+        storage_diffs,
+        nonces
+      }
+    };
   }
-  async getCode(contractAddress, blockIdentifier) {
-    return this.provider.getCode(contractAddress, blockIdentifier);
+  parseSierraContractClassResponse(res) {
+    return {
+      ...res,
+      abi: JSON.parse(res.abi)
+    };
   }
-  async waitForTransaction(txHash, options) {
-    return this.provider.waitForTransaction(txHash, options);
+};
+
+// src/utils/url.ts
+import urljoin from "url-join";
+var protocolAndDomainRE = /^(?:\w+:)?\/\/(\S+)$/;
+var localhostDomainRE = /^localhost[:?\d]*(?:[^:?\d]\S*)?$/;
+var nonLocalhostDomainRE = /^[^\s.]+\.\S{2,}$/;
+function isUrl(s) {
+  if (!s) {
+    return false;
   }
-  async getSimulateTransaction(invocation, invocationDetails, blockIdentifier, skipValidate) {
-    return this.provider.getSimulateTransaction(
-      invocation,
-      invocationDetails,
-      blockIdentifier,
-      skipValidate
-    );
+  if (typeof s !== "string") {
+    return false;
   }
-  async getStateUpdate(blockIdentifier) {
-    return this.provider.getStateUpdate(blockIdentifier);
+  const match = s.match(protocolAndDomainRE);
+  if (!match) {
+    return false;
   }
-  async getStarkName(address, StarknetIdContract2) {
-    return getStarkName(this, address, StarknetIdContract2);
+  const everythingAfterProtocol = match[1];
+  if (!everythingAfterProtocol) {
+    return false;
   }
-  async getAddressFromStarkName(name, StarknetIdContract2) {
-    return getAddressFromStarkName(this, name, StarknetIdContract2);
+  if (localhostDomainRE.test(everythingAfterProtocol) || nonLocalhostDomainRE.test(everythingAfterProtocol)) {
+    return true;
   }
-};
+  return false;
+}
+function buildUrl(baseUrl, defaultPath, urlOrPath) {
+  return isUrl(urlOrPath) ? urlOrPath : urljoin(baseUrl, urlOrPath ?? defaultPath);
+}
 
-// src/provider/interface.ts
-var ProviderInterface = class {
+// src/provider/sequencer.ts
+function isEmptyQueryObject(obj) {
+  return obj === void 0 || Object.keys(obj).length === 0 || Object.keys(obj).length === 1 && Object.entries(obj).every(([k, v]) => k === "blockIdentifier" && v === null);
+}
+var defaultOptions2 = {
+  network: "SN_GOERLI2" /* SN_GOERLI2 */,
+  blockIdentifier: "pending"
 };
-
-// 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]}`
+var SequencerProvider = class {
+  constructor(optionsOrProvider = defaultOptions2) {
+    this.responseParser = new SequencerAPIResponseParser();
+    if ("network" in optionsOrProvider) {
+      this.baseUrl = SequencerProvider.getNetworkFromName(optionsOrProvider.network);
+      this.feederGatewayUrl = buildUrl(this.baseUrl, "feeder_gateway");
+      this.gatewayUrl = buildUrl(this.baseUrl, "gateway");
+    } else {
+      this.baseUrl = optionsOrProvider.baseUrl;
+      this.feederGatewayUrl = buildUrl(
+        this.baseUrl,
+        "feeder_gateway",
+        optionsOrProvider.feederGatewayUrl
       );
-  },
-  unknown: (data, type, key) => {
-    throw new Error(`Unhandled formatter type on ${key}:${type[key]} for data ${key}:${data[key]}`);
+      this.gatewayUrl = buildUrl(this.baseUrl, "gateway", optionsOrProvider.gatewayUrl);
+    }
+    this.chainId = (optionsOrProvider == null ? void 0 : optionsOrProvider.chainId) ?? SequencerProvider.getChainIdFromBaseUrl(this.baseUrl);
+    this.headers = optionsOrProvider.headers;
+    this.blockIdentifier = (optionsOrProvider == null ? void 0 : optionsOrProvider.blockIdentifier) || defaultOptions2.blockIdentifier;
   }
-};
-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;
+  static getNetworkFromName(name) {
+    switch (name) {
+      case ("SN_MAIN" /* SN_MAIN */ || "0x534e5f4d41494e" /* SN_MAIN */):
+        return "https://alpha-mainnet.starknet.io" /* SN_MAIN */;
+      case ("SN_GOERLI" /* SN_GOERLI */ || "0x534e5f474f45524c49" /* SN_GOERLI */):
+        return "https://alpha4.starknet.io" /* SN_GOERLI */;
+      case ("SN_GOERLI2" /* SN_GOERLI2 */ || "0x534e5f474f45524c4932" /* SN_GOERLI2 */):
+        return "https://alpha4-2.starknet.io" /* SN_GOERLI2 */;
+      default:
+        throw new Error("Could not detect base url from NetworkName");
     }
-    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;
+  }
+  static getChainIdFromBaseUrl(baseUrl) {
+    try {
+      const url = new URL(baseUrl);
+      if (url.host.includes("mainnet.starknet.io")) {
+        return "0x534e5f4d41494e" /* SN_MAIN */;
       }
-      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 (url.host.includes("alpha4-2.starknet.io")) {
+        return "0x534e5f474f45524c4932" /* SN_GOERLI2 */;
+      }
+      return "0x534e5f474f45524c49" /* SN_GOERLI */;
+    } catch {
+      console.error(`Could not parse baseUrl: ${baseUrl}`);
+      return "0x534e5f474f45524c49" /* SN_GOERLI */;
     }
-    if (Array.isArray(elType)) {
-      const arrayObj = formatter(data[key], elType, elType[0]);
-      acc[key] = Object.values(arrayObj);
-      return acc;
+  }
+  getFetchUrl(endpoint) {
+    const gatewayUrlEndpoints = ["add_transaction"];
+    return gatewayUrlEndpoints.includes(endpoint) ? this.gatewayUrl : this.feederGatewayUrl;
+  }
+  getFetchMethod(endpoint) {
+    const postMethodEndpoints = [
+      "add_transaction",
+      "call_contract",
+      "estimate_fee",
+      "estimate_message_fee",
+      "estimate_fee_bulk",
+      "simulate_transaction"
+    ];
+    return postMethodEndpoints.includes(endpoint) ? "POST" : "GET";
+  }
+  getQueryString(query) {
+    if (isEmptyQueryObject(query)) {
+      return "";
     }
-    if (typeof elType === "object") {
-      acc[key] = formatter(data[key], elType);
-      return acc;
+    const queryString = Object.entries(query).map(([key, value]) => {
+      if (key === "blockIdentifier") {
+        const block = new Block(value);
+        return `${block.queryIdentifier}`;
+      }
+      return `${key}=${value}`;
+    }).join("&");
+    return `?${queryString}`;
+  }
+  getHeaders(method) {
+    if (method === "POST") {
+      return {
+        "Content-Type": "application/json",
+        ...this.headers
+      };
     }
-    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++;
+    return this.headers;
+  }
+  async fetchEndpoint(endpoint, ...[query, request]) {
+    const baseUrl = this.getFetchUrl(endpoint);
+    const method = this.getFetchMethod(endpoint);
+    const queryString = this.getQueryString(query);
+    const url = urljoin2(baseUrl, endpoint, queryString);
+    return this.fetch(url, {
+      method,
+      body: request
+    });
+  }
+  async fetch(endpoint, options) {
+    const url = buildUrl(this.baseUrl, "", endpoint);
+    const method = (options == null ? void 0 : options.method) ?? "GET";
+    const headers = this.getHeaders(method);
+    const body = stringify2(options == null ? void 0 : options.body);
+    try {
+      const response = await fetchPonyfill_default(url, {
+        method,
+        body,
+        headers
+      });
+      const textResponse = await response.text();
+      if (!response.ok) {
+        let responseBody;
+        try {
+          responseBody = parse2(textResponse);
+        } catch {
+          throw new HttpError(response.statusText, response.status);
+        }
+        throw new GatewayError(responseBody.message, responseBody.code);
       }
-      subTuple.push(s.substring(lBracket, i));
-      result += " ";
-      i--;
-    } else {
-      result += s[i];
+      const parseChoice = (options == null ? void 0 : options.parseAlwaysAsBigInt) ? parseAlwaysAsBig : parse2;
+      return parseChoice(textResponse);
+    } catch (error) {
+      if (error instanceof Error && !(error instanceof LibraryError))
+        throw Error(`Could not ${method} from endpoint \`${url}\`: ${error.message}`);
+      throw error;
     }
-    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));
-    }, []);
+  async getChainId() {
+    return Promise.resolve(this.chainId);
+  }
+  async callContract({ contractAddress, entrypoint: entryPointSelector, calldata = [] }, blockIdentifier = this.blockIdentifier) {
+    return this.fetchEndpoint(
+      "call_contract",
+      { blockIdentifier },
+      {
+        contract_address: contractAddress,
+        entry_point_selector: getSelectorFromName(entryPointSelector),
+        calldata
+      }
+    ).then(this.responseParser.parseCallContractResponse);
+  }
+  async getBlock(blockIdentifier = this.blockIdentifier) {
+    return this.fetchEndpoint("get_block", { blockIdentifier }).then(
+      this.responseParser.parseGetBlockResponse
+    );
   }
-  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);
+  async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
+    return this.fetchEndpoint("get_nonce", { contractAddress, blockIdentifier });
   }
-  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}`
+  async getStorageAt(contractAddress, key, blockIdentifier = this.blockIdentifier) {
+    const parsedKey = toBigInt(key).toString(10);
+    return this.fetchEndpoint("get_storage_at", {
+      blockIdentifier,
+      contractAddress,
+      key: parsedKey
+    });
+  }
+  async getTransaction(txHash) {
+    const txHashHex = toHex(txHash);
+    return this.fetchEndpoint("get_transaction", { transactionHash: txHashHex }).then((result) => {
+      if (Object.values(result).length === 1)
+        throw new LibraryError(result.status);
+      return this.responseParser.parseGetTransactionResponse(result);
+    });
+  }
+  async getTransactionReceipt(txHash) {
+    const txHashHex = toHex(txHash);
+    return this.fetchEndpoint("get_transaction_receipt", { transactionHash: txHashHex }).then(
+      this.responseParser.parseGetTransactionReceiptResponse
     );
   }
-  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}`);
+  async getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+    return this.fetchEndpoint("get_full_contract", { blockIdentifier, contractAddress }).then(
+      (res) => {
+        if (isSierra(res)) {
+          return this.responseParser.parseSierraContractClassResponse(res);
+        }
+        return parseContract(res);
+      }
+    );
   }
-  if (Array.isArray(element)) {
-    throw Error(`Array inside array (nD) are not supported by cairo. Element: ${element} ${type}`);
+  async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+    return this.fetchEndpoint("get_class_hash_at", { blockIdentifier, contractAddress });
   }
-  if (isTypeUint256(type)) {
-    const el_uint256 = uint256(element);
-    return [felt(el_uint256.low), felt(el_uint256.high)];
+  async getClassByHash(classHash, blockIdentifier = this.blockIdentifier) {
+    return this.fetchEndpoint("get_class_by_hash", { classHash, blockIdentifier }).then((res) => {
+      if (isSierra(res)) {
+        return this.responseParser.parseSierraContractClassResponse(res);
+      }
+      return parseContract(res);
+    });
   }
-  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));
-    }, []);
+  async getCompiledClassByClassHash(classHash, blockIdentifier = this.blockIdentifier) {
+    return this.fetchEndpoint("get_compiled_class_by_class_hash", { classHash, blockIdentifier });
   }
-  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);
-    }, []);
+  async invokeFunction(functionInvocation, details) {
+    return this.fetchEndpoint("add_transaction", void 0, {
+      type: "INVOKE_FUNCTION" /* INVOKE */,
+      sender_address: functionInvocation.contractAddress,
+      calldata: bigNumberishArrayToDecimalStringArray(functionInvocation.calldata ?? []),
+      signature: signatureToDecimalArray(functionInvocation.signature),
+      nonce: toHex(details.nonce),
+      max_fee: toHex(details.maxFee || 0),
+      version: "0x1"
+    }).then(this.responseParser.parseInvokeFunctionResponse);
+  }
+  async deployAccountContract({ classHash, constructorCalldata, addressSalt, signature }, details) {
+    return this.fetchEndpoint("add_transaction", void 0, {
+      type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
+      contract_address_salt: addressSalt ?? randomAddress(),
+      constructor_calldata: bigNumberishArrayToDecimalStringArray(constructorCalldata ?? []),
+      class_hash: toHex(classHash),
+      max_fee: toHex(details.maxFee || 0),
+      version: toHex(details.version || 0),
+      nonce: toHex(details.nonce),
+      signature: signatureToDecimalArray(signature)
+    }).then(this.responseParser.parseDeployContractResponse);
+  }
+  async declareContract({ senderAddress, contractDefinition, signature, compiledClassHash }, details) {
+    if (!isSierra(contractDefinition)) {
+      return this.fetchEndpoint("add_transaction", void 0, {
+        type: "DECLARE" /* DECLARE */,
+        contract_class: contractDefinition,
+        nonce: toHex(details.nonce),
+        signature: signatureToDecimalArray(signature),
+        sender_address: senderAddress,
+        max_fee: toHex(details.maxFee || 0),
+        version: "0x1"
+      }).then(this.responseParser.parseDeclareContractResponse);
+    }
+    return this.fetchEndpoint("add_transaction", void 0, {
+      type: "DECLARE" /* DECLARE */,
+      sender_address: senderAddress,
+      compiled_class_hash: compiledClassHash,
+      contract_class: contractDefinition,
+      nonce: toHex(details.nonce),
+      signature: signatureToDecimalArray(signature),
+      max_fee: toHex(details.maxFee || 0),
+      version: "0x2"
+    }).then(this.responseParser.parseDeclareContractResponse);
+  }
+  async getEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier, skipValidate = false) {
+    return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier, skipValidate);
+  }
+  async getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier, skipValidate = false) {
+    return this.fetchEndpoint(
+      "estimate_fee",
+      { blockIdentifier, skipValidate },
+      {
+        type: "INVOKE_FUNCTION" /* INVOKE */,
+        sender_address: invocation.contractAddress,
+        calldata: invocation.calldata ?? [],
+        signature: signatureToDecimalArray(invocation.signature),
+        version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
+        nonce: toHex(invocationDetails.nonce)
+      }
+    ).then(this.responseParser.parseFeeEstimateResponse);
+  }
+  async getDeclareEstimateFee({ senderAddress, contractDefinition, signature, compiledClassHash }, details, blockIdentifier = this.blockIdentifier, skipValidate = false) {
+    if (!isSierra(contractDefinition)) {
+      return this.fetchEndpoint(
+        "estimate_fee",
+        { blockIdentifier, skipValidate },
+        {
+          type: "DECLARE" /* DECLARE */,
+          sender_address: senderAddress,
+          contract_class: contractDefinition,
+          signature: signatureToDecimalArray(signature),
+          version: toHex((details == null ? void 0 : details.version) || toBigInt(feeTransactionVersion)),
+          nonce: toHex(details.nonce)
+        }
+      ).then(this.responseParser.parseFeeEstimateResponse);
+    }
+    return this.fetchEndpoint(
+      "estimate_fee",
+      { blockIdentifier, skipValidate },
+      {
+        type: "DECLARE" /* DECLARE */,
+        sender_address: senderAddress,
+        compiled_class_hash: compiledClassHash,
+        contract_class: contractDefinition,
+        nonce: toHex(details.nonce),
+        signature: signatureToDecimalArray(signature),
+        version: "0x2"
+      }
+    ).then(this.responseParser.parseFeeEstimateResponse);
+  }
+  async getDeployAccountEstimateFee({ classHash, addressSalt, constructorCalldata, signature }, details, blockIdentifier = this.blockIdentifier, skipValidate = false) {
+    return this.fetchEndpoint(
+      "estimate_fee",
+      { blockIdentifier, skipValidate },
+      {
+        type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
+        class_hash: toHex(classHash),
+        constructor_calldata: bigNumberishArrayToDecimalStringArray(constructorCalldata || []),
+        contract_address_salt: toHex(addressSalt || 0),
+        signature: signatureToDecimalArray(signature),
+        version: toHex((details == null ? void 0 : details.version) || 0),
+        nonce: toHex(details.nonce)
+      }
+    ).then(this.responseParser.parseFeeEstimateResponse);
+  }
+  async getEstimateFeeBulk(invocations, blockIdentifier = this.blockIdentifier) {
+    const params = invocations.map((invocation) => {
+      let res;
+      if (invocation.type === "INVOKE_FUNCTION") {
+        res = {
+          type: invocation.type,
+          sender_address: invocation.contractAddress,
+          calldata: invocation.calldata ?? []
+        };
+      } else if (invocation.type === "DECLARE") {
+        res = {
+          type: invocation.type,
+          sender_address: invocation.senderAddress,
+          contract_class: invocation.contractDefinition
+        };
+      } else {
+        res = {
+          type: invocation.type,
+          class_hash: toHex(toBigInt(invocation.classHash)),
+          constructor_calldata: bigNumberishArrayToDecimalStringArray(
+            invocation.constructorCalldata || []
+          ),
+          contract_address_salt: toHex(toBigInt(invocation.addressSalt || 0))
+        };
+      }
+      return {
+        ...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
+    );
   }
-  if (typeof element === "object") {
-    throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
+  async getCode(contractAddress, blockIdentifier = this.blockIdentifier) {
+    return this.fetchEndpoint("get_code", { contractAddress, blockIdentifier });
   }
-  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);
+  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 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;
-    }, {});
+    }
+    const txReceipt = await this.getTransactionReceipt(txHash);
+    return txReceipt;
   }
-  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 getTransactionStatus(txHash) {
+    const txHashHex = toHex(txHash);
+    return this.fetchEndpoint("get_transaction_status", { transactionHash: txHashHex });
   }
-  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 getContractAddresses() {
+    return this.fetchEndpoint("get_contract_addresses");
   }
-}
-
-// 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 getTransactionTrace(txHash) {
+    const txHashHex = toHex(txHash);
+    return this.fetchEndpoint("get_transaction_trace", { transactionHash: txHashHex });
   }
-  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 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);
   }
-};
-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 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);
   }
 };
-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 = [
@@ -4684,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) {
@@ -4727,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 },
@@ -4797,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,
@@ -4814,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,
@@ -4840,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,
@@ -4893,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(
@@ -5550,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: {
@@ -5574,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
@@ -5646,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)
         })
@@ -5732,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,
@@ -5848,6 +5832,7 @@ export {
   encode_exports as encode,
   fixProto,
   fixStack,
+  getCalldata,
   getChecksumAddress,
   hash_exports as hash,
   isUrl,
@@ -5856,6 +5841,7 @@ export {
   num_exports as num,
   number,
   shortString_exports as shortString,
+  splitArgsAndOptions,
   stark_exports as stark,
   starknetId_exports as starknetId,
   transaction_exports as transaction,