starknet 5.7.0 → 5.8.0

package/dist/index.global.js

@@ -637,6 +637,7 @@ var starknet = (() => {
     encode: () => encode_exports,
     fixProto: () => fixProto,
     fixStack: () => fixStack,
+    getCalldata: () => getCalldata,
     getChecksumAddress: () => getChecksumAddress,
     hash: () => hash_exports,
     isUrl: () => isUrl,
@@ -645,6 +646,7 @@ var starknet = (() => {
     num: () => num_exports,
     number: () => number2,
     shortString: () => shortString_exports,
+    splitArgsAndOptions: () => splitArgsAndOptions,
     stark: () => stark_exports,
     starknetId: () => starknetId_exports,
     transaction: () => transaction_exports,
@@ -5560,6 +5562,9 @@ var starknet = (() => {
     if (typeof it === "string" && isStringWholeNumber(it)) {
       return it;
     }
+    if (typeof it === "boolean") {
+      return `${+it}`;
+    }
     throw new Error(`${it} can't be computed by felt()`);
   }
 
@@ -6490,7 +6495,6 @@ var starknet = (() => {
   // src/utils/stark.ts
   var stark_exports = {};
   __export(stark_exports, {
-    compileCalldata: () => compileCalldata,
     compressProgram: () => compressProgram,
     estimatedFeeToMaxFee: () => estimatedFeeToMaxFee,
     formatSignature: () => formatSignature,
@@ -10606,21 +10610,6 @@ var starknet = (() => {
   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;
@@ -10734,1055 +10723,964 @@ var starknet = (() => {
     }
   };
 
-  // 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, output2, structs, parsedResult) {
+    const { name, type } = output2;
+    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, output2.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);
+  }
+
+  // src/utils/calldata/validate.ts
+  var validateFelt = (parameter, input) => {
+    assert2(
+      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") {
+      assert2(
+        parameter <= Number.MAX_SAFE_INTEGER,
+        `Validation: Parameter is to large to be typed as Number use (BigInt or String)`
+      );
     }
-    async getClass(classHash, blockIdentifier = this.blockIdentifier) {
-      const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getClass", { class_hash: classHash, block_id });
+    assert2(
+      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 */:
+        assert2(
+          param >= 0n && param <= 255n,
+          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
+        );
+        break;
+      case "core::integer::u16" /* u16 */:
+        assert2(
+          param >= 0n && param <= 65535n,
+          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
+        );
+        break;
+      case "core::integer::u32" /* u32 */:
+        assert2(
+          param >= 0n && param <= 4294967295n,
+          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
+        );
+        break;
+      case "core::integer::u64" /* u64 */:
+        assert2(
+          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 */:
+        assert2(
+          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 */:
+        assert2(
+          param >= 0n && param <= 2n ** 256n - 1n,
+          `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
+        );
+        break;
+      default:
+        break;
     }
-    async getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
-      const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getClassAt", {
-        block_id,
-        contract_address: contractAddress
-      });
+  };
+  var validateBool = (parameter, input) => {
+    assert2(
+      typeof parameter === "boolean",
+      `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`
+    );
+  };
+  var validateStruct = (parameter, input, structs) => {
+    assert2(
+      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 }) => {
+      assert2(
+        Object.keys(parameter).includes(name),
+        `Validate: arg ${input.name} should have a property ${name}`
+      );
+    });
+  };
+  var validateTuple = (parameter, input) => {
+    assert2(
+      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;
+    assert2(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 getCode(_contractAddress, _blockIdentifier) {
-      throw new Error("RPC does not implement getCode function");
+  };
+  function validateFields(abiMethod, args, structs) {
+    abiMethod.inputs.reduce((acc, input) => {
+      const parameter = args[acc];
+      switch (true) {
+        case isLen(input.name):
+          return acc;
+        case isTypeFelt(input.type):
+          validateFelt(parameter, input);
+          break;
+        case isTypeUint(input.type):
+          validateUint(parameter, input);
+          break;
+        case isTypeBool(input.type):
+          validateBool(parameter, input);
+          break;
+        case isTypeContractAddress(input.type):
+          break;
+        case isTypeStruct(input.type, structs):
+          validateStruct(parameter, input, structs);
+          break;
+        case isTypeTuple(input.type):
+          validateTuple(parameter, input);
+          break;
+        case isTypeArray(input.type):
+          validateArray(parameter, input, structs);
+          break;
+        default:
+          throw new Error(
+            `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
+          );
+      }
+      return acc + 1;
+    }, 0);
+  }
+
+  // src/utils/calldata/index.ts
+  var CallData = class {
+    constructor(abi) {
+      this.abi = abi;
+      this.structs = CallData.getAbiStruct(abi);
     }
-    async getEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier) {
-      return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier);
+    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);
+        assert2(
+          invocableFunctionNames.includes(method),
+          `${type === "INVOKE" ? "invocable" : "viewable"} method not found in abi`
+        );
+      }
+      const abiMethod = this.abi.find(
+        (abi) => type === "DEPLOY" ? abi.name === method && abi.type === method : abi.name === method && abi.type === "function"
+      );
+      const inputsLength = CallData.abiInputsLength(abiMethod.inputs);
+      if (args.length !== inputsLength) {
+        throw Error(
+          `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
+        );
+      }
+      validateFields(abiMethod, args, this.structs);
     }
-    async 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);
+    compile(method, args) {
+      const argsIterator = args[Symbol.iterator]();
+      const { inputs } = this.abi.find((abi) => abi.name === method);
+      return inputs.reduce(
+        (acc, input) => isLen(input.name) ? acc : acc.concat(parseCalldataField(argsIterator, input, this.structs)),
+        []
+      );
     }
-    async 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);
+    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);
       }
-      throw new Error("RPC do not support Sierra Contracts yet");
+      Object.defineProperty(callTreeArray, "__compiled__", {
+        enumerable: false,
+        writable: false,
+        value: true
+      });
+      return callTreeArray;
     }
-    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)
+    parse(method, response) {
+      const { outputs } = this.abi.find((abi) => abi.name === method);
+      const responseIterator = response.flat()[Symbol.iterator]();
+      const parsed = outputs.flat().reduce((acc, output2, idx) => {
+        const propName = output2.name ?? idx;
+        acc[propName] = responseParser(responseIterator, output2, 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 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)
-        }
-      });
+    format(method, response, format) {
+      const parsed = this.parse(method, response);
+      return formatter(parsed, format);
     }
-    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);
+    static abiInputsLength(inputs) {
+      return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
     }
-    async traceTransaction(transactionHash) {
-      return this.fetchEndpoint("starknet_traceTransaction", { transaction_hash: transactionHash });
+    static getAbiStruct(abi) {
+      return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
+        (acc, abiEntry) => ({
+          ...acc,
+          [abiEntry.name]: abiEntry
+        }),
+        {}
+      );
     }
-    async traceBlockTransactions(blockHash) {
-      return this.fetchEndpoint("starknet_traceBlockTransactions", { block_hash: blockHash });
+  };
+
+  // src/utils/starknetId.ts
+  var starknetId_exports = {};
+  __export(starknetId_exports, {
+    StarknetIdContract: () => StarknetIdContract,
+    getStarknetIdContract: () => getStarknetIdContract,
+    useDecoded: () => useDecoded,
+    useEncoded: () => useEncoded
+  });
+  var basicAlphabet = "abcdefghijklmnopqrstuvwxyz0123456789-";
+  var basicSizePlusOne = BigInt(basicAlphabet.length + 1);
+  var bigAlphabet = "\u8FD9\u6765";
+  var basicAlphabetSize = BigInt(basicAlphabet.length);
+  var bigAlphabetSize = BigInt(bigAlphabet.length);
+  var bigAlphabetSizePlusOne = BigInt(bigAlphabet.length + 1);
+  function extractStars(str) {
+    let k = 0;
+    while (str.endsWith(bigAlphabet[bigAlphabet.length - 1])) {
+      str = str.substring(0, str.length - 1);
+      k += 1;
     }
-    async 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}`);
+    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;
           }
-        }
-        retries -= 1;
+        } else
+          decoded += basicAlphabet[Number(code)];
       }
-      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 });
+      const [str, k] = extractStars(decoded);
+      if (k)
+        decoded = str + (k % 2 === 0 ? bigAlphabet[bigAlphabet.length - 1].repeat(k / 2 - 1) + bigAlphabet[0] + basicAlphabet[1] : bigAlphabet[bigAlphabet.length - 1].repeat((k - 1) / 2 + 1));
+      decoded += ".";
+    });
+    if (!decoded) {
+      return decoded;
     }
-    async getSimulateTransaction(_invocation, _invocationDetails, _blockIdentifier) {
-      throw new Error("RPC does not implement simulateTransaction function");
+    return decoded.concat("stark");
+  }
+  function useEncoded(decoded) {
+    let encoded = BigInt(0);
+    let multiplier = BigInt(1);
+    if (decoded.endsWith(bigAlphabet[0] + basicAlphabet[1])) {
+      const [str, k] = extractStars(decoded.substring(0, decoded.length - 2));
+      decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(2 * (k + 1));
+    } else {
+      const [str, k] = extractStars(decoded);
+      if (k)
+        decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(1 + 2 * (k - 1));
     }
-    async getStarkName(address, StarknetIdContract2) {
-      return getStarkName(this, address, StarknetIdContract2);
+    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;
+      }
     }
-    async getAddressFromStarkName(name, StarknetIdContract2) {
-      return getAddressFromStarkName(this, name, StarknetIdContract2);
+    return encoded;
+  }
+  var StarknetIdContract = /* @__PURE__ */ ((StarknetIdContract2) => {
+    StarknetIdContract2["MAINNET"] = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678";
+    StarknetIdContract2["TESTNET"] = "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce";
+    return StarknetIdContract2;
+  })(StarknetIdContract || {});
+  function getStarknetIdContract(chainId) {
+    switch (chainId) {
+      case "0x534e5f4d41494e" /* SN_MAIN */:
+        return "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678" /* MAINNET */;
+      case "0x534e5f474f45524c49" /* SN_GOERLI */:
+        return "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce" /* TESTNET */;
+      default:
+        throw new Error("Starknet.id is not yet deployed on this network");
     }
-  };
-
-  // src/provider/sequencer.ts
-  var import_url_join2 = __toESM(require_url_join());
+  }
 
-  // src/utils/responseParser/index.ts
-  var ResponseParser = class {
-  };
+  // src/provider/starknetId.ts
+  async function getStarkName(provider, address, StarknetIdContract2) {
+    const chainId = await provider.getChainId();
+    const contract = StarknetIdContract2 ?? getStarknetIdContract(chainId);
+    try {
+      const hexDomain = await provider.callContract({
+        contractAddress: contract,
+        entrypoint: "address_to_domain",
+        calldata: CallData.compile({
+          address
+        })
+      });
+      const decimalDomain = hexDomain.result.map((element) => BigInt(element)).slice(1);
+      const stringDomain = useDecoded(decimalDomain);
+      if (!stringDomain) {
+        throw Error("Starkname not found");
+      }
+      return stringDomain;
+    } catch (e) {
+      if (e instanceof Error && e.message === "Starkname not found") {
+        throw e;
+      }
+      throw Error("Could not get stark name");
+    }
+  }
+  async function getAddressFromStarkName(provider, name, StarknetIdContract2) {
+    const chainId = await provider.getChainId();
+    const contract = StarknetIdContract2 ?? getStarknetIdContract(chainId);
+    try {
+      const addressData = await provider.callContract({
+        contractAddress: contract,
+        entrypoint: "domain_to_address",
+        calldata: CallData.compile({
+          domain: [useEncoded(name.replace(".stark", "")).toString(10)]
+        })
+      });
+      return addressData.result[0];
+    } catch {
+      throw Error("Could not get address from stark name");
+    }
+  }
 
-  // src/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)
-      };
+  // 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);
     }
-    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
-      };
+    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";
+      }
     }
-    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
-        }
-      };
+    get queryIdentifier() {
+      if (this.number !== null) {
+        return `blockNumber=${this.number}`;
+      }
+      if (this.hash !== null) {
+        return `blockHash=${this.hash}`;
+      }
+      return `blockNumber=${this.tag}`;
     }
-    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
-        };
+    get identifier() {
+      if (this.number !== null) {
+        return { block_number: this.number };
       }
-      return {
-        overall_fee: toBigInt(res.amount)
-      };
+      if (this.hash !== null) {
+        return { block_hash: this.hash };
+      }
+      return this.tag;
     }
-    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)
-        };
+    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
       });
     }
-    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)
-          }
-        };
+    errorHandler(error) {
+      if (error) {
+        const { code, message } = error;
+        throw new LibraryError(`${code}: ${message}`);
       }
-      return {
-        trace: res.trace,
-        fee_estimation: {
-          overall_fee: toBigInt(res.fee_estimation.amount)
-        }
-      };
     }
-    parseCallContractResponse(res) {
-      return {
-        result: res.result
-      };
+    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;
+      }
     }
-    parseInvokeFunctionResponse(res) {
-      return {
-        transaction_hash: res.transaction_hash
-      };
+    async getChainId() {
+      this.chainId ?? (this.chainId = await this.fetchEndpoint("starknet_chainId"));
+      return this.chainId;
     }
-    parseDeployContractResponse(res) {
-      return {
-        transaction_hash: res.transaction_hash,
-        contract_address: res.address
-      };
+    async getBlock(blockIdentifier = this.blockIdentifier) {
+      return this.getBlockWithTxHashes(blockIdentifier).then(
+        this.responseParser.parseGetBlockResponse
+      );
     }
-    parseDeclareContractResponse(res) {
-      return {
-        transaction_hash: res.transaction_hash,
-        class_hash: res.class_hash
-      };
+    async getBlockHashAndNumber() {
+      return this.fetchEndpoint("starknet_blockHashAndNumber");
     }
-    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 getBlockWithTxHashes(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getBlockWithTxHashes", { block_id });
     }
-    parseSierraContractClassResponse(res) {
-      return {
-        ...res,
-        abi: JSON.parse(res.abi)
-      };
+    async getBlockWithTxs(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getBlockWithTxs", { block_id });
     }
-  };
-
-  // src/utils/url.ts
-  var import_url_join = __toESM(require_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 getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getClassHashAt", {
+        block_id,
+        contract_address: contractAddress
+      });
     }
-    if (typeof s !== "string") {
-      return false;
+    async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getNonce", {
+        contract_address: contractAddress,
+        block_id
+      });
     }
-    const match = s.match(protocolAndDomainRE);
-    if (!match) {
-      return false;
+    async getPendingTransactions() {
+      return this.fetchEndpoint("starknet_pendingTransactions");
     }
-    const everythingAfterProtocol = match[1];
-    if (!everythingAfterProtocol) {
-      return false;
+    async getProtocolVersion() {
+      throw new Error("Pathfinder does not implement this rpc 0.1.0 method");
     }
-    if (localhostDomainRE.test(everythingAfterProtocol) || nonLocalhostDomainRE.test(everythingAfterProtocol)) {
-      return true;
+    async getStateUpdate(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
     }
-    return false;
-  }
-  function buildUrl(baseUrl, defaultPath, urlOrPath) {
-    return isUrl(urlOrPath) ? urlOrPath : (0, import_url_join.default)(baseUrl, urlOrPath ?? defaultPath);
-  }
-
-  // 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);
-      }
-      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;
+    async getStorageAt(contractAddress, key, blockIdentifier = this.blockIdentifier) {
+      const parsedKey = toHex(key);
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getStorageAt", {
+        contract_address: contractAddress,
+        key: parsedKey,
+        block_id
+      });
     }
-    static 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");
-      }
+    async getTransaction(txHash) {
+      return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
     }
-    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 getTransactionByHash(txHash) {
+      return this.fetchEndpoint("starknet_getTransactionByHash", { transaction_hash: txHash });
     }
-    getFetchUrl(endpoint) {
-      const gatewayUrlEndpoints = ["add_transaction"];
-      return gatewayUrlEndpoints.includes(endpoint) ? this.gatewayUrl : this.feederGatewayUrl;
+    async getTransactionByBlockIdAndIndex(blockIdentifier, index) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getTransactionByBlockIdAndIndex", { block_id, index });
     }
-    getFetchMethod(endpoint) {
-      const postMethodEndpoints = [
-        "add_transaction",
-        "call_contract",
-        "estimate_fee",
-        "estimate_message_fee",
-        "estimate_fee_bulk",
-        "simulate_transaction"
-      ];
-      return postMethodEndpoints.includes(endpoint) ? "POST" : "GET";
+    async getTransactionReceipt(txHash) {
+      return this.fetchEndpoint("starknet_getTransactionReceipt", { transaction_hash: txHash });
     }
-    getQueryString(query) {
-      if (isEmptyQueryObject(query)) {
-        return "";
-      }
-      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}`;
+    async getClassByHash(classHash) {
+      return this.getClass(classHash);
     }
-    getHeaders(method) {
-      if (method === "POST") {
-        return {
-          "Content-Type": "application/json",
-          ...this.headers
-        };
-      }
-      return this.headers;
+    async getClass(classHash, blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getClass", { class_hash: classHash, block_id });
     }
-    async fetchEndpoint(endpoint, ...[query, request]) {
-      const baseUrl = this.getFetchUrl(endpoint);
-      const method = this.getFetchMethod(endpoint);
-      const queryString = this.getQueryString(query);
-      const url = (0, import_url_join2.default)(baseUrl, endpoint, queryString);
-      return this.fetch(url, {
-        method,
-        body: request
+    async getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getClassAt", {
+        block_id,
+        contract_address: contractAddress
       });
     }
-    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);
-        }
-        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;
-      }
-    }
-    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 getCode(_contractAddress, _blockIdentifier) {
+      throw new Error("RPC does not implement getCode function");
     }
-    async getBlock(blockIdentifier = this.blockIdentifier) {
-      return this.fetchEndpoint("get_block", { blockIdentifier }).then(
-        this.responseParser.parseGetBlockResponse
-      );
+    async getEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier) {
+      return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier);
     }
-    async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
-      return this.fetchEndpoint("get_nonce", { contractAddress, 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 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
-      );
-    }
-    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 getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
-      return this.fetchEndpoint("get_class_hash_at", { blockIdentifier, contractAddress });
-    }
-    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 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 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);
+    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 waitForTransaction(txHash, options) {
+    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 */,
@@ -11791,64 +11689,48 @@ var starknet = (() => {
       ];
       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);
+      await wait(retryInterval);
       return txReceipt;
     }
-    async getTransactionStatus(txHash) {
-      const txHashHex = toHex(txHash);
-      return this.fetchEndpoint("get_transaction_status", { transactionHash: txHashHex });
-    }
-    async getContractAddresses() {
-      return this.fetchEndpoint("get_contract_addresses");
-    }
-    async getTransactionTrace(txHash) {
-      const txHashHex = toHex(txHash);
-      return this.fetchEndpoint("get_transaction_trace", { transactionHash: txHashHex });
+    async getTransactionCount(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getBlockTransactionCount", { block_id });
     }
-    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 getBlockNumber() {
+      return this.fetchEndpoint("starknet_blockNumber");
     }
-    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 getSyncingStats() {
+      return this.fetchEndpoint("starknet_syncing");
     }
-    async getStateUpdate(blockIdentifier = this.blockIdentifier) {
-      const args = new Block(blockIdentifier).sequencerIdentifier;
-      return this.fetchEndpoint("get_state_update", { ...args }).then(
-        this.responseParser.parseGetStateUpdateResponse
-      );
+    async getEvents(eventFilter) {
+      return this.fetchEndpoint("starknet_getEvents", { filter: eventFilter });
     }
-    async getBlockTraces(blockIdentifier = this.blockIdentifier) {
-      const args = new Block(blockIdentifier).sequencerIdentifier;
-      return this.fetchEndpoint("get_block_traces", { ...args });
+    async getSimulateTransaction(_invocation, _invocationDetails, _blockIdentifier) {
+      throw new Error("RPC does not implement simulateTransaction function");
     }
     async getStarkName(address, StarknetIdContract2) {
       return getStarkName(this, address, StarknetIdContract2);
@@ -11858,622 +11740,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();
+  // src/provider/sequencer.ts
+  var import_url_join2 = __toESM(require_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 getBlock(blockIdentifier) {
-      return this.provider.getBlock(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 getClassAt(contractAddress, blockIdentifier) {
-      return this.provider.getClassAt(contractAddress, 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 getClassHashAt(contractAddress, blockIdentifier) {
-      return this.provider.getClassHashAt(contractAddress, blockIdentifier);
+    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)
+      };
     }
-    getClassByHash(classHash) {
-      return this.provider.getClassByHash(classHash);
+    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 getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier) {
-      return this.provider.getEstimateFee(invocationWithTxType, invocationDetails, 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 getInvokeEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier, skipValidate) {
-      return this.provider.getInvokeEstimateFee(
-        invocationWithTxType,
-        invocationDetails,
-        blockIdentifier,
-        skipValidate
-      );
+    parseCallContractResponse(res) {
+      return {
+        result: res.result
+      };
     }
-    async getEstimateFeeBulk(invocations, blockIdentifier) {
-      return this.provider.getEstimateFeeBulk(invocations, blockIdentifier);
+    parseInvokeFunctionResponse(res) {
+      return {
+        transaction_hash: res.transaction_hash
+      };
     }
-    async getNonceForAddress(contractAddress, blockIdentifier) {
-      return this.provider.getNonceForAddress(contractAddress, blockIdentifier);
+    parseDeployContractResponse(res) {
+      return {
+        transaction_hash: res.transaction_hash,
+        contract_address: res.address
+      };
     }
-    async getStorageAt(contractAddress, key, blockIdentifier) {
-      return this.provider.getStorageAt(contractAddress, key, blockIdentifier);
-    }
-    async getTransaction(txHash) {
-      return this.provider.getTransaction(txHash);
-    }
-    async getTransactionReceipt(txHash) {
-      return this.provider.getTransactionReceipt(txHash);
-    }
-    async callContract(request, blockIdentifier) {
-      return this.provider.callContract(request, blockIdentifier);
-    }
-    async invokeFunction(functionInvocation, details) {
-      return this.provider.invokeFunction(functionInvocation, details);
-    }
-    async deployAccountContract(payload, details) {
-      return this.provider.deployAccountContract(payload, details);
-    }
-    async declareContract(transaction, details) {
-      return this.provider.declareContract(transaction, details);
-    }
-    async getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate) {
-      return this.provider.getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate);
+    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
+  var import_url_join = __toESM(require_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 : (0, import_url_join.default)(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 (Array.isArray(elType)) {
-        const arrayObj = formatter(data[key], elType, elType[0]);
-        acc[key] = Object.values(arrayObj);
-        return acc;
-      }
-      if (typeof elType === "object") {
-        acc[key] = formatter(data[key], elType);
-        return acc;
-      }
-      guard.unknown(data, type, key);
-      return acc;
-    }, {});
-  }
-
-  // src/utils/calldata/tuple.ts
-  function parseNamedTuple(namedTuple) {
-    const name = namedTuple.substring(0, namedTuple.indexOf(":"));
-    const type = namedTuple.substring(name.length + ":".length);
-    return { name, type };
-  }
-  function parseSubTuple(s) {
-    if (!s.includes("("))
-      return { subTuple: [], result: s };
-    const subTuple = [];
-    let result = "";
-    let i = 0;
-    while (i < s.length) {
-      if (s[i] === "(") {
-        let counter = 1;
-        const lBracket = i;
-        i++;
-        while (counter) {
-          if (s[i] === ")")
-            counter--;
-          if (s[i] === "(")
-            counter++;
-          i++;
+        if (url.host.includes("alpha4-2.starknet.io")) {
+          return "0x534e5f474f45524c4932" /* SN_GOERLI2 */;
         }
-        subTuple.push(s.substring(lBracket, i));
-        result += " ";
-        i--;
-      } else {
-        result += s[i];
+        return "0x534e5f474f45524c49" /* SN_GOERLI */;
+      } catch {
+        console.error(`Could not parse baseUrl: ${baseUrl}`);
+        return "0x534e5f474f45524c49" /* SN_GOERLI */;
       }
-      i++;
-    }
-    return {
-      subTuple,
-      result
-    };
-  }
-  function extractCairo0Tuple(type) {
-    const cleanType = type.replace(/\s/g, "").slice(1, -1);
-    const { subTuple, result } = parseSubTuple(cleanType);
-    let recomposed = result.split(",").map((it) => {
-      return subTuple.length ? it.replace(" ", subTuple.shift()) : it;
-    });
-    if (isTypeNamedTuple(type)) {
-      recomposed = recomposed.reduce((acc, it) => {
-        return acc.concat(parseNamedTuple(it));
-      }, []);
     }
-    return recomposed;
-  }
-  function extractCairo1Tuple(type) {
-    const cleanType = type.replace(/\s/g, "").slice(1, -1);
-    return cleanType.split(",");
-  }
-  function extractTupleMemberTypes(type) {
-    if (isCairo1Type(type)) {
-      return extractCairo1Tuple(type);
+    getFetchUrl(endpoint) {
+      const gatewayUrlEndpoints = ["add_transaction"];
+      return gatewayUrlEndpoints.includes(endpoint) ? this.gatewayUrl : this.feederGatewayUrl;
     }
-    return extractCairo0Tuple(type);
-  }
-
-  // src/utils/calldata/requestParser.ts
-  function parseTuple(element, typeStr) {
-    const memberTypes = extractTupleMemberTypes(typeStr);
-    const elements = Object.values(element);
-    if (elements.length !== memberTypes.length) {
-      throw Error(
-        `ParseTuple: provided and expected abi tuple size do not match.
-      provided: ${elements} 
-      expected: ${memberTypes}`
-      );
-    }
-    return memberTypes.map((it, dx) => {
-      return {
-        element: elements[dx],
-        type: it.type ?? it
-      };
-    });
-  }
-  function parseCalldataValue(element, type, structs) {
-    if (element === void 0) {
-      throw Error(`Missing parameter for type ${type}`);
+    getFetchMethod(endpoint) {
+      const postMethodEndpoints = [
+        "add_transaction",
+        "call_contract",
+        "estimate_fee",
+        "estimate_message_fee",
+        "estimate_fee_bulk",
+        "simulate_transaction"
+      ];
+      return postMethodEndpoints.includes(endpoint) ? "POST" : "GET";
     }
-    if (Array.isArray(element)) {
-      throw Error(`Array inside array (nD) are not supported by cairo. Element: ${element} ${type}`);
+    getQueryString(query) {
+      if (isEmptyQueryObject(query)) {
+        return "";
+      }
+      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 (isTypeUint256(type)) {
-      const el_uint256 = uint256(element);
-      return [felt(el_uint256.low), felt(el_uint256.high)];
+    getHeaders(method) {
+      if (method === "POST") {
+        return {
+          "Content-Type": "application/json",
+          ...this.headers
+        };
+      }
+      return this.headers;
     }
-    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 fetchEndpoint(endpoint, ...[query, request]) {
+      const baseUrl = this.getFetchUrl(endpoint);
+      const method = this.getFetchMethod(endpoint);
+      const queryString = this.getQueryString(query);
+      const url = (0, import_url_join2.default)(baseUrl, endpoint, queryString);
+      return this.fetch(url, {
+        method,
+        body: request
+      });
     }
-    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 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);
+        }
+        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;
+      }
     }
-    if (typeof element === "object") {
-      throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
+    async getChainId() {
+      return Promise.resolve(this.chainId);
     }
-    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 callContract({ contractAddress, entrypoint: entryPointSelector, calldata = [] }, blockIdentifier = this.blockIdentifier) {
+      return this.fetchEndpoint(
+        "call_contract",
+        { blockIdentifier },
+        {
+          contract_address: contractAddress,
+          entry_point_selector: getSelectorFromName(entryPointSelector),
+          calldata
         }
-        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);
+      ).then(this.responseParser.parseCallContractResponse);
     }
-  }
-
-  // src/utils/calldata/responseParser.ts
-  function parseResponseStruct(responseIterator, type, structs) {
-    if (type in structs && structs[type]) {
-      return structs[type].members.reduce((acc, el) => {
-        acc[el.name] = parseResponseStruct(responseIterator, el.type, structs);
-        return acc;
-      }, {});
+    async getBlock(blockIdentifier = this.blockIdentifier) {
+      return this.fetchEndpoint("get_block", { blockIdentifier }).then(
+        this.responseParser.parseGetBlockResponse
+      );
     }
-    if (isTypeTuple(type)) {
-      const memberTypes = extractTupleMemberTypes(type);
-      return memberTypes.reduce((acc, it, idx) => {
-        const tName = (it == null ? void 0 : it.name) ? it.name : idx;
-        const tType = (it == null ? void 0 : it.type) ? it.type : it;
-        acc[tName] = parseResponseStruct(responseIterator, tType, structs);
-        return acc;
-      }, {});
+    async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
+      return this.fetchEndpoint("get_nonce", { contractAddress, blockIdentifier });
     }
-    const temp = responseIterator.next().value;
-    return BigInt(temp);
-  }
-  function responseParser(responseIterator, output2, structs, parsedResult) {
-    const { name, type } = output2;
-    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();
+    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
+      );
+    }
+    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 parsedDataArr;
+          return parseContract(res);
         }
-        if (parsedResult && parsedResult[`${name}_len`]) {
-          const arrLen = parsedResult[`${name}_len`];
-          while (parsedDataArr.length < arrLen) {
-            parsedDataArr.push(
-              parseResponseStruct(responseIterator, output2.type.replace("*", ""), structs)
-            );
-          }
+      );
+    }
+    async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+      return this.fetchEndpoint("get_class_hash_at", { blockIdentifier, contractAddress });
+    }
+    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 parsedDataArr;
-      case (type in structs || isTypeTuple(type)):
-        return parseResponseStruct(responseIterator, type, structs);
-      default:
-        temp = responseIterator.next().value;
-        return BigInt(temp);
+        return parseContract(res);
+      });
     }
-  }
-
-  // src/utils/calldata/validate.ts
-  var validateFelt = (parameter, input) => {
-    assert2(
-      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") {
-      assert2(
-        parameter <= Number.MAX_SAFE_INTEGER,
-        `Validation: Parameter is to large to be typed as Number use (BigInt or String)`
-      );
+    async getCompiledClassByClassHash(classHash, blockIdentifier = this.blockIdentifier) {
+      return this.fetchEndpoint("get_compiled_class_by_class_hash", { classHash, blockIdentifier });
     }
-    assert2(
-      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 */:
-        assert2(
-          param >= 0n && param <= 255n,
-          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
-        );
-        break;
-      case "core::integer::u16" /* u16 */:
-        assert2(
-          param >= 0n && param <= 65535n,
-          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
-        );
-        break;
-      case "core::integer::u32" /* u32 */:
-        assert2(
-          param >= 0n && param <= 4294967295n,
-          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
-        );
-        break;
-      case "core::integer::u64" /* u64 */:
-        assert2(
-          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 */:
-        assert2(
-          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 */:
-        assert2(
-          param >= 0n && param <= 2n ** 256n - 1n,
-          `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
-        );
-        break;
-      default:
-        break;
+    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);
     }
-  };
-  var validateBool = (parameter, input) => {
-    assert2(
-      typeof parameter === "boolean",
-      `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`
-    );
-  };
-  var validateStruct = (parameter, input, structs) => {
-    assert2(
-      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 }) => {
-      assert2(
-        Object.keys(parameter).includes(name),
-        `Validate: arg ${input.name} should have a property ${name}`
+    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
       );
-    });
-  };
-  var validateTuple = (parameter, input) => {
-    assert2(
-      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;
-    assert2(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 getCode(contractAddress, blockIdentifier = this.blockIdentifier) {
+      return this.fetchEndpoint("get_code", { contractAddress, blockIdentifier });
+    }
+    async waitForTransaction(txHash, options) {
+      const errorStates = ["REJECTED" /* REJECTED */, "NOT_RECEIVED" /* NOT_RECEIVED */];
+      let onchain = false;
+      let res;
+      const retryInterval = (options == null ? void 0 : options.retryInterval) ?? 8e3;
+      const successStates = (options == null ? void 0 : options.successStates) ?? [
+        "ACCEPTED_ON_L1" /* ACCEPTED_ON_L1 */,
+        "ACCEPTED_ON_L2" /* ACCEPTED_ON_L2 */,
+        "PENDING" /* PENDING */
+      ];
+      while (!onchain) {
+        await wait(retryInterval);
+        res = await this.getTransactionStatus(txHash);
+        if (successStates.includes(res.tx_status)) {
+          onchain = true;
+        } else if (errorStates.includes(res.tx_status)) {
+          const message = res.tx_failure_reason ? `${res.tx_status}: ${res.tx_failure_reason.code}
+${res.tx_failure_reason.error_message}` : res.tx_status;
+          const error = new Error(message);
+          error.response = res;
+          throw error;
+        }
+      }
+      const txReceipt = await this.getTransactionReceipt(txHash);
+      return txReceipt;
+    }
+    async getTransactionStatus(txHash) {
+      const txHashHex = toHex(txHash);
+      return this.fetchEndpoint("get_transaction_status", { transactionHash: txHashHex });
+    }
+    async getContractAddresses() {
+      return this.fetchEndpoint("get_contract_addresses");
+    }
+    async getTransactionTrace(txHash) {
+      const txHashHex = toHex(txHash);
+      return this.fetchEndpoint("get_transaction_trace", { transactionHash: txHashHex });
+    }
+    async estimateMessageFee({ from_address, to_address, entry_point_selector, payload }, blockIdentifier = this.blockIdentifier) {
+      const validCallL1Handler = {
+        from_address: getDecimalString(from_address),
+        to_address: getHexString(to_address),
+        entry_point_selector: getSelector(entry_point_selector),
+        payload: getHexStringArray(payload)
+      };
+      return this.fetchEndpoint("estimate_message_fee", { blockIdentifier }, validCallL1Handler);
+    }
+    async getSimulateTransaction(invocation, invocationDetails, blockIdentifier = this.blockIdentifier, skipValidate = false) {
+      return this.fetchEndpoint(
+        "simulate_transaction",
+        { blockIdentifier, skipValidate },
+        {
+          type: "INVOKE_FUNCTION",
+          sender_address: invocation.contractAddress,
+          calldata: invocation.calldata ?? [],
+          signature: signatureToDecimalArray(invocation.signature),
+          version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
+          nonce: toHex(invocationDetails.nonce),
+          max_fee: toHex((invocationDetails == null ? void 0 : invocationDetails.maxFee) || 0)
+        }
+      ).then(this.responseParser.parseFeeSimulateTransactionResponse);
+    }
+    async getStateUpdate(blockIdentifier = this.blockIdentifier) {
+      const args = new Block(blockIdentifier).sequencerIdentifier;
+      return this.fetchEndpoint("get_state_update", { ...args }).then(
+        this.responseParser.parseGetStateUpdateResponse
+      );
+    }
+    async getBlockTraces(blockIdentifier = this.blockIdentifier) {
+      const args = new Block(blockIdentifier).sequencerIdentifier;
+      return this.fetchEndpoint("get_block_traces", { ...args });
+    }
+    async getStarkName(address, 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);
-        assert2(
-          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, output2, idx) => {
-        const propName = output2.name ?? idx;
-        acc[propName] = responseParser(responseIterator, output2, 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 = [
@@ -12483,13 +12475,14 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       "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) {
@@ -12526,20 +12519,20 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       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 },
@@ -12596,15 +12589,21 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       }
       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
+    } = {}) {
       assert2(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,
@@ -12613,25 +12612,25 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         },
         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 } = {}) {
       assert2(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,
@@ -12639,40 +12638,36 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       };
       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;
       assert2(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,
@@ -12692,36 +12687,24 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       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
       });
       assert2(Boolean(contract_address), "Deployment of the contract failed");
       const contractInstance = new Contract(
@@ -13349,7 +13332,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
           unique = true,
           constructorCalldata = []
         } = it;
-        const compiledConstructorCallData = compileCalldata(constructorCalldata);
+        const compiledConstructorCallData = CallData.compile(constructorCalldata);
         const deploySalt = salt ?? randomAddress();
         return {
           call: {
@@ -13373,7 +13356,10 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       });
       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
@@ -13445,7 +13431,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         await this.callContract({
           contractAddress: this.address,
           entrypoint: "isValidSignature",
-          calldata: compileCalldata({
+          calldata: CallData.compile({
             hash: toBigInt(hash2).toString(),
             signature: formatSignature(signature)
           })
@@ -13531,7 +13517,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
           unique = true,
           constructorCalldata = []
         } = it;
-        const compiledConstructorCallData = compileCalldata(constructorCalldata);
+        const compiledConstructorCallData = CallData.compile(constructorCalldata);
         return {
           contractAddress: UDC.ADDRESS,
           entrypoint: UDC.ENTRYPOINT,