starknet 5.6.1 → 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,7 +646,9 @@ var starknet = (() => {
     num: () => num_exports,
     number: () => number2,
     shortString: () => shortString_exports,
+    splitArgsAndOptions: () => splitArgsAndOptions,
     stark: () => stark_exports,
+    starknetId: () => starknetId_exports,
     transaction: () => transaction_exports,
     typedData: () => typedData_exports,
     uint256: () => uint256_exports,
@@ -5559,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()`);
   }
 
@@ -6489,7 +6495,6 @@ var starknet = (() => {
   // src/utils/stark.ts
   var stark_exports = {};
   __export(stark_exports, {
-    compileCalldata: () => compileCalldata,
     compressProgram: () => compressProgram,
     estimatedFeeToMaxFee: () => estimatedFeeToMaxFee,
     formatSignature: () => formatSignature,
@@ -10605,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;
@@ -10733,308 +10723,826 @@ var starknet = (() => {
     }
   };
 
-  // src/utils/starknetId.ts
-  var basicAlphabet = "abcdefghijklmnopqrstuvwxyz0123456789-";
-  var basicSizePlusOne = BigInt(basicAlphabet.length + 1);
-  var bigAlphabet = "\u8FD9\u6765";
-  var basicAlphabetSize = BigInt(basicAlphabet.length);
-  var bigAlphabetSize = BigInt(bigAlphabet.length);
-  var bigAlphabetSizePlusOne = BigInt(bigAlphabet.length + 1);
-  function extractStars(str) {
-    let k = 0;
-    while (str.endsWith(bigAlphabet[bigAlphabet.length - 1])) {
-      str = str.substring(0, str.length - 1);
-      k += 1;
+  // src/utils/calldata/formatter.ts
+  var guard = {
+    isBN: (data, type, key) => {
+      if (!isBigInt(data[key]))
+        throw new Error(
+          `Data and formatter mismatch on ${key}:${type[key]}, expected response data ${key}:${data[key]} to be BN instead it is ${typeof data[key]}`
+        );
+    },
+    unknown: (data, type, key) => {
+      throw new Error(`Unhandled formatter type on ${key}:${type[key]} for data ${key}:${data[key]}`);
     }
-    return [str, k];
-  }
-  function useDecoded(encoded) {
-    let decoded = "";
-    encoded.forEach((subdomain) => {
-      while (subdomain !== ZERO) {
-        const code = subdomain % basicSizePlusOne;
-        subdomain /= basicSizePlusOne;
-        if (code === BigInt(basicAlphabet.length)) {
-          const nextSubdomain = subdomain / bigAlphabetSizePlusOne;
-          if (nextSubdomain === ZERO) {
-            const code2 = subdomain % bigAlphabetSizePlusOne;
-            subdomain = nextSubdomain;
-            if (code2 === ZERO)
-              decoded += basicAlphabet[0];
-            else
-              decoded += bigAlphabet[Number(code2) - 1];
-          } else {
-            const code2 = subdomain % bigAlphabetSize;
-            decoded += bigAlphabet[Number(code2)];
-            subdomain /= bigAlphabetSize;
-          }
-        } else
-          decoded += basicAlphabet[Number(code)];
+  };
+  function formatter(data, type, sameType) {
+    return Object.entries(data).reduce((acc, [key, value]) => {
+      const elType = sameType ?? type[key];
+      if (!(key in type) && !sameType) {
+        acc[key] = value;
+        return acc;
       }
-      const [str, k] = extractStars(decoded);
-      if (k)
-        decoded = str + (k % 2 === 0 ? bigAlphabet[bigAlphabet.length - 1].repeat(k / 2 - 1) + bigAlphabet[0] + basicAlphabet[1] : bigAlphabet[bigAlphabet.length - 1].repeat((k - 1) / 2 + 1));
-      decoded += ".";
-    });
-    if (!decoded) {
-      return decoded;
-    }
-    return decoded.concat("stark");
+      if (elType === "string") {
+        if (Array.isArray(data[key])) {
+          const arrayStr = formatter(
+            data[key],
+            data[key].map((_) => elType)
+          );
+          acc[key] = Object.values(arrayStr).join("");
+          return acc;
+        }
+        guard.isBN(data, type, key);
+        acc[key] = decodeShortString(value);
+        return acc;
+      }
+      if (elType === "number") {
+        guard.isBN(data, type, key);
+        acc[key] = Number(value);
+        return acc;
+      }
+      if (typeof elType === "function") {
+        acc[key] = elType(value);
+        return acc;
+      }
+      if (Array.isArray(elType)) {
+        const arrayObj = formatter(data[key], elType, elType[0]);
+        acc[key] = Object.values(arrayObj);
+        return acc;
+      }
+      if (typeof elType === "object") {
+        acc[key] = formatter(data[key], elType);
+        return acc;
+      }
+      guard.unknown(data, type, key);
+      return acc;
+    }, {});
   }
-  function useEncoded(decoded) {
-    let encoded = BigInt(0);
-    let multiplier = BigInt(1);
-    if (decoded.endsWith(bigAlphabet[0] + basicAlphabet[1])) {
-      const [str, k] = extractStars(decoded.substring(0, decoded.length - 2));
-      decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(2 * (k + 1));
-    } else {
-      const [str, k] = extractStars(decoded);
-      if (k)
-        decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(1 + 2 * (k - 1));
-    }
-    for (let i = 0; i < decoded.length; i += 1) {
-      const char = decoded[i];
-      const index = basicAlphabet.indexOf(char);
-      const bnIndex = BigInt(basicAlphabet.indexOf(char));
-      if (index !== -1) {
-        if (i === decoded.length - 1 && decoded[i] === basicAlphabet[0]) {
-          encoded += multiplier * basicAlphabetSize;
-          multiplier *= basicSizePlusOne;
-          multiplier *= basicSizePlusOne;
-        } else {
-          encoded += multiplier * bnIndex;
-          multiplier *= basicSizePlusOne;
+
+  // src/utils/calldata/tuple.ts
+  function parseNamedTuple(namedTuple) {
+    const name = namedTuple.substring(0, namedTuple.indexOf(":"));
+    const type = namedTuple.substring(name.length + ":".length);
+    return { name, type };
+  }
+  function parseSubTuple(s) {
+    if (!s.includes("("))
+      return { subTuple: [], result: s };
+    const subTuple = [];
+    let result = "";
+    let i = 0;
+    while (i < s.length) {
+      if (s[i] === "(") {
+        let counter = 1;
+        const lBracket = i;
+        i++;
+        while (counter) {
+          if (s[i] === ")")
+            counter--;
+          if (s[i] === "(")
+            counter++;
+          i++;
         }
-      } else if (bigAlphabet.indexOf(char) !== -1) {
-        encoded += multiplier * basicAlphabetSize;
-        multiplier *= basicSizePlusOne;
-        const newid = (i === decoded.length - 1 ? 1 : 0) + bigAlphabet.indexOf(char);
-        encoded += multiplier * BigInt(newid);
-        multiplier *= bigAlphabetSize;
+        subTuple.push(s.substring(lBracket, i));
+        result += " ";
+        i--;
+      } else {
+        result += s[i];
       }
+      i++;
     }
-    return encoded;
+    return {
+      subTuple,
+      result
+    };
   }
-  function getStarknetIdContract(chainId) {
-    const starknetIdMainnetContract = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678";
-    const starknetIdTestnetContract = "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce";
-    switch (chainId) {
-      case "0x534e5f4d41494e" /* SN_MAIN */:
-        return starknetIdMainnetContract;
-      case "0x534e5f474f45524c49" /* SN_GOERLI */:
-        return starknetIdTestnetContract;
-      default:
-        throw new Error("Starknet.id is not yet deployed on this network");
+  function extractCairo0Tuple(type) {
+    const cleanType = type.replace(/\s/g, "").slice(1, -1);
+    const { subTuple, result } = parseSubTuple(cleanType);
+    let recomposed = result.split(",").map((it) => {
+      return subTuple.length ? it.replace(" ", subTuple.shift()) : it;
+    });
+    if (isTypeNamedTuple(type)) {
+      recomposed = recomposed.reduce((acc, it) => {
+        return acc.concat(parseNamedTuple(it));
+      }, []);
     }
+    return recomposed;
   }
-
-  // src/provider/starknetId.ts
-  async function getStarkName(provider, address, StarknetIdContract) {
-    const chainId = await provider.getChainId();
-    const contract = StarknetIdContract ?? getStarknetIdContract(chainId);
-    try {
-      const hexDomain = await provider.callContract({
-        contractAddress: contract,
-        entrypoint: "address_to_domain",
-        calldata: compileCalldata({
-          address
-        })
-      });
-      const decimalDomain = hexDomain.result.map((element) => BigInt(element)).slice(1);
-      const stringDomain = useDecoded(decimalDomain);
-      if (!stringDomain) {
-        throw Error("Starkname not found");
-      }
-      return stringDomain;
-    } catch (e) {
-      if (e instanceof Error && e.message === "Starkname not found") {
-        throw e;
-      }
-      throw Error("Could not get stark name");
-    }
+  function extractCairo1Tuple(type) {
+    const cleanType = type.replace(/\s/g, "").slice(1, -1);
+    return cleanType.split(",");
   }
-  async function getAddressFromStarkName(provider, name, StarknetIdContract) {
-    const chainId = await provider.getChainId();
-    const contract = StarknetIdContract ?? getStarknetIdContract(chainId);
-    try {
-      const addressData = await provider.callContract({
-        contractAddress: contract,
-        entrypoint: "domain_to_address",
-        calldata: compileCalldata({
-          domain: [useEncoded(name.replace(".stark", "")).toString(10)]
-        })
-      });
-      return addressData.result[0];
-    } catch {
-      throw Error("Could not get address from stark name");
+  function extractTupleMemberTypes(type) {
+    if (isCairo1Type(type)) {
+      return extractCairo1Tuple(type);
     }
+    return extractCairo0Tuple(type);
   }
 
-  // src/provider/utils.ts
-  var validBlockTags = ["latest", "pending"];
-  var Block = class {
-    constructor(_identifier) {
-      this.hash = null;
-      this.number = null;
-      this.tag = null;
-      this.valueOf = () => this.number;
-      this.toString = () => this.hash;
-      this.setIdentifier(_identifier);
-    }
-    setIdentifier(__identifier) {
-      if (typeof __identifier === "string" && isHex(__identifier)) {
-        this.hash = __identifier;
-      } else if (typeof __identifier === "bigint") {
-        this.hash = toHex(__identifier);
-      } else if (typeof __identifier === "number") {
-        this.number = __identifier;
-      } else if (typeof __identifier === "string" && validBlockTags.includes(__identifier)) {
-        this.tag = __identifier;
-      } else {
-        this.tag = "pending";
-      }
+  // src/utils/calldata/requestParser.ts
+  function parseTuple(element, typeStr) {
+    const memberTypes = extractTupleMemberTypes(typeStr);
+    const elements = Object.values(element);
+    if (elements.length !== memberTypes.length) {
+      throw Error(
+        `ParseTuple: provided and expected abi tuple size do not match.
+      provided: ${elements} 
+      expected: ${memberTypes}`
+      );
     }
-    get queryIdentifier() {
-      if (this.number !== null) {
-        return `blockNumber=${this.number}`;
-      }
-      if (this.hash !== null) {
-        return `blockHash=${this.hash}`;
-      }
-      return `blockNumber=${this.tag}`;
-    }
-    get identifier() {
-      if (this.number !== null) {
-        return { block_number: this.number };
-      }
-      if (this.hash !== null) {
-        return { block_hash: this.hash };
-      }
-      return this.tag;
+    return memberTypes.map((it, dx) => {
+      return {
+        element: elements[dx],
+        type: it.type ?? it
+      };
+    });
+  }
+  function parseCalldataValue(element, type, structs) {
+    if (element === void 0) {
+      throw Error(`Missing parameter for type ${type}`);
     }
-    set identifier(_identifier) {
-      this.setIdentifier(_identifier);
+    if (Array.isArray(element)) {
+      throw Error(`Array inside array (nD) are not supported by cairo. Element: ${element} ${type}`);
     }
-    get sequencerIdentifier() {
-      return this.hash !== null ? { blockHash: this.hash } : { blockNumber: this.number ?? this.tag };
+    if (isTypeUint256(type)) {
+      const el_uint256 = uint256(element);
+      return [felt(el_uint256.low), felt(el_uint256.high)];
     }
-  };
-
-  // src/provider/rpc.ts
-  var defaultOptions = {
-    headers: { "Content-Type": "application/json" },
-    blockIdentifier: "latest",
-    retries: 200
-  };
-  var RpcProvider = class {
-    constructor(optionsOrProvider) {
-      this.responseParser = new RPCResponseParser();
-      const { nodeUrl, retries, headers, blockIdentifier } = optionsOrProvider;
-      this.nodeUrl = nodeUrl;
-      this.retries = retries || defaultOptions.retries;
-      this.headers = { ...defaultOptions.headers, ...headers };
-      this.blockIdentifier = blockIdentifier || defaultOptions.blockIdentifier;
-      this.getChainId();
+    if (structs[type] && structs[type].members.length) {
+      const { members } = structs[type];
+      const subElement = element;
+      return members.reduce((acc, it) => {
+        return acc.concat(parseCalldataValue(subElement[it.name], it.type, structs));
+      }, []);
     }
-    fetch(method, params) {
-      return fetchPonyfill_default(this.nodeUrl, {
-        method: "POST",
-        body: stringify2({ method, jsonrpc: "2.0", params, id: 0 }),
-        headers: this.headers
-      });
+    if (isTypeTuple(type)) {
+      const tupled = parseTuple(element, type);
+      return tupled.reduce((acc, it) => {
+        const parsedData = parseCalldataValue(it.element, it.type, structs);
+        return acc.concat(parsedData);
+      }, []);
     }
-    errorHandler(error) {
-      if (error) {
-        const { code, message } = error;
-        throw new LibraryError(`${code}: ${message}`);
-      }
+    if (typeof element === "object") {
+      throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
     }
-    async fetchEndpoint(method, params) {
-      var _a;
-      try {
-        const rawResult = await this.fetch(method, params);
-        const { error, result } = await rawResult.json();
-        this.errorHandler(error);
-        return result;
-      } catch (error) {
-        this.errorHandler((_a = error == null ? void 0 : error.response) == null ? void 0 : _a.data);
-        throw error;
-      }
+    return felt(element);
+  }
+  function parseCalldataField(argsIterator, input, structs) {
+    const { name, type } = input;
+    let { value } = argsIterator.next();
+    switch (true) {
+      case isTypeArray(type):
+        if (!Array.isArray(value) && !isText(value)) {
+          throw Error(`ABI expected parameter ${name} to be array or long string, got ${value}`);
+        }
+        if (typeof value === "string") {
+          value = splitLongString(value);
+        }
+        const result = [];
+        result.push(felt(value.length));
+        const arrayType = getArrayType(input.type);
+        return value.reduce((acc, el) => {
+          if (isTypeFelt(arrayType) || isTypeUint(arrayType) || isTypeContractAddress(arrayType)) {
+            acc.push(felt(el));
+          } else if (isTypeBool(arrayType) && typeof el === "boolean") {
+            acc.push(el.toString());
+          } else {
+            acc.push(...parseCalldataValue(el, arrayType, structs));
+          }
+          return acc;
+        }, result);
+      case (isTypeStruct(type, structs) || isTypeTuple(type) || isTypeUint256(type)):
+        return parseCalldataValue(value, type, structs);
+      case isTypeBool(type):
+        return `${+value}`;
+      default:
+        return felt(value);
     }
-    async getChainId() {
-      this.chainId ?? (this.chainId = await this.fetchEndpoint("starknet_chainId"));
-      return this.chainId;
+  }
+
+  // src/utils/calldata/responseParser.ts
+  function parseResponseStruct(responseIterator, type, structs) {
+    if (type in structs && structs[type]) {
+      return structs[type].members.reduce((acc, el) => {
+        acc[el.name] = parseResponseStruct(responseIterator, el.type, structs);
+        return acc;
+      }, {});
     }
-    async getBlock(blockIdentifier = this.blockIdentifier) {
-      return this.getBlockWithTxHashes(blockIdentifier).then(
-        this.responseParser.parseGetBlockResponse
-      );
+    if (isTypeTuple(type)) {
+      const memberTypes = extractTupleMemberTypes(type);
+      return memberTypes.reduce((acc, it, idx) => {
+        const tName = (it == null ? void 0 : it.name) ? it.name : idx;
+        const tType = (it == null ? void 0 : it.type) ? it.type : it;
+        acc[tName] = parseResponseStruct(responseIterator, tType, structs);
+        return acc;
+      }, {});
     }
-    async getBlockHashAndNumber() {
-      return this.fetchEndpoint("starknet_blockHashAndNumber");
+    const temp = responseIterator.next().value;
+    return BigInt(temp);
+  }
+  function responseParser(responseIterator, 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 getBlockWithTxHashes(blockIdentifier = this.blockIdentifier) {
-      const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getBlockWithTxHashes", { block_id });
+  }
+
+  // src/utils/calldata/validate.ts
+  var validateFelt = (parameter, input) => {
+    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 getBlockWithTxs(blockIdentifier = this.blockIdentifier) {
-      const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getBlockWithTxs", { 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 getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
-      const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getClassHashAt", {
-        block_id,
-        contract_address: contractAddress
-      });
-    }
-    async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
-      const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getNonce", {
-        contract_address: contractAddress,
-        block_id
-      });
+  };
+  var validateBool = (parameter, input) => {
+    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 getPendingTransactions() {
-      return this.fetchEndpoint("starknet_pendingTransactions");
+  };
+  function validateFields(abiMethod, args, structs) {
+    abiMethod.inputs.reduce((acc, input) => {
+      const parameter = args[acc];
+      switch (true) {
+        case isLen(input.name):
+          return acc;
+        case isTypeFelt(input.type):
+          validateFelt(parameter, input);
+          break;
+        case isTypeUint(input.type):
+          validateUint(parameter, input);
+          break;
+        case isTypeBool(input.type):
+          validateBool(parameter, input);
+          break;
+        case isTypeContractAddress(input.type):
+          break;
+        case isTypeStruct(input.type, structs):
+          validateStruct(parameter, input, structs);
+          break;
+        case isTypeTuple(input.type):
+          validateTuple(parameter, input);
+          break;
+        case isTypeArray(input.type):
+          validateArray(parameter, input, structs);
+          break;
+        default:
+          throw new Error(
+            `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
+          );
+      }
+      return acc + 1;
+    }, 0);
+  }
+
+  // src/utils/calldata/index.ts
+  var CallData = class {
+    constructor(abi) {
+      this.abi = abi;
+      this.structs = CallData.getAbiStruct(abi);
     }
-    async getProtocolVersion() {
-      throw new Error("Pathfinder does not implement this rpc 0.1.0 method");
+    validate(type, method, args = []) {
+      if (type !== "DEPLOY") {
+        const invocableFunctionNames = this.abi.filter((abi) => {
+          if (abi.type !== "function")
+            return false;
+          const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
+          return type === "INVOKE" ? !isView : isView;
+        }).map((abi) => abi.name);
+        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 getStateUpdate(blockIdentifier = this.blockIdentifier) {
-      const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
+    compile(method, args) {
+      const argsIterator = args[Symbol.iterator]();
+      const { inputs } = this.abi.find((abi) => abi.name === method);
+      return inputs.reduce(
+        (acc, input) => isLen(input.name) ? acc : acc.concat(parseCalldataField(argsIterator, input, this.structs)),
+        []
+      );
     }
-    async getStorageAt(contractAddress, key, blockIdentifier = this.blockIdentifier) {
-      const parsedKey = toHex(key);
-      const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getStorageAt", {
-        contract_address: contractAddress,
-        key: parsedKey,
-        block_id
+    static compile(rawArgs) {
+      const createTree = (obj) => {
+        const getEntries = (o, prefix = "") => {
+          const oe = Array.isArray(o) ? [o.length.toString(), ...o] : o;
+          return Object.entries(oe).flatMap(([k, v]) => {
+            let value = v;
+            if (isLongText(value))
+              value = splitLongString(value);
+            const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
+            if (isBigInt(value))
+              return [[`${prefix}${kk}`, felt(value)]];
+            return Object(value) === value ? getEntries(value, `${prefix}${kk}.`) : [[`${prefix}${kk}`, felt(value)]];
+          });
+        };
+        return Object.fromEntries(getEntries(obj));
+      };
+      let callTreeArray;
+      if (!Array.isArray(rawArgs)) {
+        const callTree = createTree(rawArgs);
+        callTreeArray = Object.values(callTree);
+      } else {
+        const callObj = { ...rawArgs };
+        const callTree = createTree(callObj);
+        callTreeArray = Object.values(callTree);
+      }
+      Object.defineProperty(callTreeArray, "__compiled__", {
+        enumerable: false,
+        writable: false,
+        value: true
       });
+      return callTreeArray;
     }
-    async getTransaction(txHash) {
-      return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
+    parse(method, response) {
+      const { outputs } = this.abi.find((abi) => abi.name === method);
+      const responseIterator = response.flat()[Symbol.iterator]();
+      const parsed = outputs.flat().reduce((acc, 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 getTransactionByHash(txHash) {
-      return this.fetchEndpoint("starknet_getTransactionByHash", { transaction_hash: txHash });
+    format(method, response, format) {
+      const parsed = this.parse(method, response);
+      return formatter(parsed, format);
     }
-    async getTransactionByBlockIdAndIndex(blockIdentifier, index) {
-      const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getTransactionByBlockIdAndIndex", { block_id, index });
+    static abiInputsLength(inputs) {
+      return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
     }
-    async getTransactionReceipt(txHash) {
-      return this.fetchEndpoint("starknet_getTransactionReceipt", { transaction_hash: txHash });
+    static getAbiStruct(abi) {
+      return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
+        (acc, abiEntry) => ({
+          ...acc,
+          [abiEntry.name]: abiEntry
+        }),
+        {}
+      );
     }
-    async getClassByHash(classHash) {
-      return this.getClass(classHash);
+  };
+
+  // src/utils/starknetId.ts
+  var starknetId_exports = {};
+  __export(starknetId_exports, {
+    StarknetIdContract: () => StarknetIdContract,
+    getStarknetIdContract: () => getStarknetIdContract,
+    useDecoded: () => useDecoded,
+    useEncoded: () => useEncoded
+  });
+  var basicAlphabet = "abcdefghijklmnopqrstuvwxyz0123456789-";
+  var basicSizePlusOne = BigInt(basicAlphabet.length + 1);
+  var bigAlphabet = "\u8FD9\u6765";
+  var basicAlphabetSize = BigInt(basicAlphabet.length);
+  var bigAlphabetSize = BigInt(bigAlphabet.length);
+  var bigAlphabetSizePlusOne = BigInt(bigAlphabet.length + 1);
+  function extractStars(str) {
+    let k = 0;
+    while (str.endsWith(bigAlphabet[bigAlphabet.length - 1])) {
+      str = str.substring(0, str.length - 1);
+      k += 1;
     }
-    async getClass(classHash, blockIdentifier = this.blockIdentifier) {
-      const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getClass", { class_hash: classHash, block_id });
+    return [str, k];
+  }
+  function useDecoded(encoded) {
+    let decoded = "";
+    encoded.forEach((subdomain) => {
+      while (subdomain !== ZERO) {
+        const code = subdomain % basicSizePlusOne;
+        subdomain /= basicSizePlusOne;
+        if (code === BigInt(basicAlphabet.length)) {
+          const nextSubdomain = subdomain / bigAlphabetSizePlusOne;
+          if (nextSubdomain === ZERO) {
+            const code2 = subdomain % bigAlphabetSizePlusOne;
+            subdomain = nextSubdomain;
+            if (code2 === ZERO)
+              decoded += basicAlphabet[0];
+            else
+              decoded += bigAlphabet[Number(code2) - 1];
+          } else {
+            const code2 = subdomain % bigAlphabetSize;
+            decoded += bigAlphabet[Number(code2)];
+            subdomain /= bigAlphabetSize;
+          }
+        } else
+          decoded += basicAlphabet[Number(code)];
+      }
+      const [str, k] = extractStars(decoded);
+      if (k)
+        decoded = str + (k % 2 === 0 ? bigAlphabet[bigAlphabet.length - 1].repeat(k / 2 - 1) + bigAlphabet[0] + basicAlphabet[1] : bigAlphabet[bigAlphabet.length - 1].repeat((k - 1) / 2 + 1));
+      decoded += ".";
+    });
+    if (!decoded) {
+      return decoded;
     }
-    async getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+    return decoded.concat("stark");
+  }
+  function useEncoded(decoded) {
+    let encoded = BigInt(0);
+    let multiplier = BigInt(1);
+    if (decoded.endsWith(bigAlphabet[0] + basicAlphabet[1])) {
+      const [str, k] = extractStars(decoded.substring(0, decoded.length - 2));
+      decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(2 * (k + 1));
+    } else {
+      const [str, k] = extractStars(decoded);
+      if (k)
+        decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(1 + 2 * (k - 1));
+    }
+    for (let i = 0; i < decoded.length; i += 1) {
+      const char = decoded[i];
+      const index = basicAlphabet.indexOf(char);
+      const bnIndex = BigInt(basicAlphabet.indexOf(char));
+      if (index !== -1) {
+        if (i === decoded.length - 1 && decoded[i] === basicAlphabet[0]) {
+          encoded += multiplier * basicAlphabetSize;
+          multiplier *= basicSizePlusOne;
+          multiplier *= basicSizePlusOne;
+        } else {
+          encoded += multiplier * bnIndex;
+          multiplier *= basicSizePlusOne;
+        }
+      } else if (bigAlphabet.indexOf(char) !== -1) {
+        encoded += multiplier * basicAlphabetSize;
+        multiplier *= basicSizePlusOne;
+        const newid = (i === decoded.length - 1 ? 1 : 0) + bigAlphabet.indexOf(char);
+        encoded += multiplier * BigInt(newid);
+        multiplier *= bigAlphabetSize;
+      }
+    }
+    return encoded;
+  }
+  var StarknetIdContract = /* @__PURE__ */ ((StarknetIdContract2) => {
+    StarknetIdContract2["MAINNET"] = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678";
+    StarknetIdContract2["TESTNET"] = "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce";
+    return StarknetIdContract2;
+  })(StarknetIdContract || {});
+  function getStarknetIdContract(chainId) {
+    switch (chainId) {
+      case "0x534e5f4d41494e" /* SN_MAIN */:
+        return "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678" /* MAINNET */;
+      case "0x534e5f474f45524c49" /* SN_GOERLI */:
+        return "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce" /* TESTNET */;
+      default:
+        throw new Error("Starknet.id is not yet deployed on this network");
+    }
+  }
+
+  // src/provider/starknetId.ts
+  async function getStarkName(provider, address, StarknetIdContract2) {
+    const chainId = await provider.getChainId();
+    const contract = StarknetIdContract2 ?? getStarknetIdContract(chainId);
+    try {
+      const hexDomain = await provider.callContract({
+        contractAddress: contract,
+        entrypoint: "address_to_domain",
+        calldata: CallData.compile({
+          address
+        })
+      });
+      const decimalDomain = hexDomain.result.map((element) => BigInt(element)).slice(1);
+      const stringDomain = useDecoded(decimalDomain);
+      if (!stringDomain) {
+        throw Error("Starkname not found");
+      }
+      return stringDomain;
+    } catch (e) {
+      if (e instanceof Error && e.message === "Starkname not found") {
+        throw e;
+      }
+      throw Error("Could not get stark name");
+    }
+  }
+  async function getAddressFromStarkName(provider, name, StarknetIdContract2) {
+    const chainId = await provider.getChainId();
+    const contract = StarknetIdContract2 ?? getStarknetIdContract(chainId);
+    try {
+      const addressData = await provider.callContract({
+        contractAddress: contract,
+        entrypoint: "domain_to_address",
+        calldata: CallData.compile({
+          domain: [useEncoded(name.replace(".stark", "")).toString(10)]
+        })
+      });
+      return addressData.result[0];
+    } catch {
+      throw Error("Could not get address from stark name");
+    }
+  }
+
+  // src/provider/utils.ts
+  var validBlockTags = ["latest", "pending"];
+  var Block = class {
+    constructor(_identifier) {
+      this.hash = null;
+      this.number = null;
+      this.tag = null;
+      this.valueOf = () => this.number;
+      this.toString = () => this.hash;
+      this.setIdentifier(_identifier);
+    }
+    setIdentifier(__identifier) {
+      if (typeof __identifier === "string" && isHex(__identifier)) {
+        this.hash = __identifier;
+      } else if (typeof __identifier === "bigint") {
+        this.hash = toHex(__identifier);
+      } else if (typeof __identifier === "number") {
+        this.number = __identifier;
+      } else if (typeof __identifier === "string" && validBlockTags.includes(__identifier)) {
+        this.tag = __identifier;
+      } else {
+        this.tag = "pending";
+      }
+    }
+    get queryIdentifier() {
+      if (this.number !== null) {
+        return `blockNumber=${this.number}`;
+      }
+      if (this.hash !== null) {
+        return `blockHash=${this.hash}`;
+      }
+      return `blockNumber=${this.tag}`;
+    }
+    get identifier() {
+      if (this.number !== null) {
+        return { block_number: this.number };
+      }
+      if (this.hash !== null) {
+        return { block_hash: this.hash };
+      }
+      return this.tag;
+    }
+    set identifier(_identifier) {
+      this.setIdentifier(_identifier);
+    }
+    get sequencerIdentifier() {
+      return this.hash !== null ? { blockHash: this.hash } : { blockNumber: this.number ?? this.tag };
+    }
+  };
+
+  // src/provider/rpc.ts
+  var defaultOptions = {
+    headers: { "Content-Type": "application/json" },
+    blockIdentifier: "latest",
+    retries: 200
+  };
+  var RpcProvider = class {
+    constructor(optionsOrProvider) {
+      this.responseParser = new RPCResponseParser();
+      const { nodeUrl, retries, headers, blockIdentifier } = optionsOrProvider;
+      this.nodeUrl = nodeUrl;
+      this.retries = retries || defaultOptions.retries;
+      this.headers = { ...defaultOptions.headers, ...headers };
+      this.blockIdentifier = blockIdentifier || defaultOptions.blockIdentifier;
+      this.getChainId();
+    }
+    fetch(method, params) {
+      return fetchPonyfill_default(this.nodeUrl, {
+        method: "POST",
+        body: stringify2({ method, jsonrpc: "2.0", params, id: 0 }),
+        headers: this.headers
+      });
+    }
+    errorHandler(error) {
+      if (error) {
+        const { code, message } = error;
+        throw new LibraryError(`${code}: ${message}`);
+      }
+    }
+    async fetchEndpoint(method, params) {
+      var _a;
+      try {
+        const rawResult = await this.fetch(method, params);
+        const { error, result } = await rawResult.json();
+        this.errorHandler(error);
+        return result;
+      } catch (error) {
+        this.errorHandler((_a = error == null ? void 0 : error.response) == null ? void 0 : _a.data);
+        throw error;
+      }
+    }
+    async getChainId() {
+      this.chainId ?? (this.chainId = await this.fetchEndpoint("starknet_chainId"));
+      return this.chainId;
+    }
+    async getBlock(blockIdentifier = this.blockIdentifier) {
+      return this.getBlockWithTxHashes(blockIdentifier).then(
+        this.responseParser.parseGetBlockResponse
+      );
+    }
+    async getBlockHashAndNumber() {
+      return this.fetchEndpoint("starknet_blockHashAndNumber");
+    }
+    async getBlockWithTxHashes(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getBlockWithTxHashes", { block_id });
+    }
+    async getBlockWithTxs(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getBlockWithTxs", { block_id });
+    }
+    async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getClassHashAt", {
+        block_id,
+        contract_address: contractAddress
+      });
+    }
+    async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getNonce", {
+        contract_address: contractAddress,
+        block_id
+      });
+    }
+    async getPendingTransactions() {
+      return this.fetchEndpoint("starknet_pendingTransactions");
+    }
+    async getProtocolVersion() {
+      throw new Error("Pathfinder does not implement this rpc 0.1.0 method");
+    }
+    async getStateUpdate(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
+    }
+    async getStorageAt(contractAddress, key, blockIdentifier = this.blockIdentifier) {
+      const parsedKey = toHex(key);
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getStorageAt", {
+        contract_address: contractAddress,
+        key: parsedKey,
+        block_id
+      });
+    }
+    async getTransaction(txHash) {
+      return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
+    }
+    async getTransactionByHash(txHash) {
+      return this.fetchEndpoint("starknet_getTransactionByHash", { transaction_hash: txHash });
+    }
+    async getTransactionByBlockIdAndIndex(blockIdentifier, index) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getTransactionByBlockIdAndIndex", { block_id, index });
+    }
+    async getTransactionReceipt(txHash) {
+      return this.fetchEndpoint("starknet_getTransactionReceipt", { transaction_hash: txHash });
+    }
+    async getClassByHash(classHash) {
+      return this.getClass(classHash);
+    }
+    async getClass(classHash, blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getClass", { class_hash: classHash, block_id });
+    }
+    async getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
       const block_id = new Block(blockIdentifier).identifier;
       return this.fetchEndpoint("starknet_getClassAt", {
         block_id,
@@ -11224,11 +11732,11 @@ var starknet = (() => {
     async getSimulateTransaction(_invocation, _invocationDetails, _blockIdentifier) {
       throw new Error("RPC does not implement simulateTransaction function");
     }
-    async getStarkName(address, StarknetIdContract) {
-      return getStarkName(this, address, StarknetIdContract);
+    async getStarkName(address, StarknetIdContract2) {
+      return getStarkName(this, address, StarknetIdContract2);
     }
-    async getAddressFromStarkName(name, StarknetIdContract) {
-      return getAddressFromStarkName(this, name, StarknetIdContract);
+    async getAddressFromStarkName(name, StarknetIdContract2) {
+      return getAddressFromStarkName(this, name, StarknetIdContract2);
     }
   };
 
@@ -11759,710 +12267,205 @@ var starknet = (() => {
           signature: bigNumberishArrayToDecimalStringArray(formatSignature(invocation.signature)),
           version: toHex(toBigInt((invocation == null ? void 0 : invocation.version) || 1)),
           nonce: toHex(toBigInt(invocation.nonce))
-        };
-      });
-      return this.fetchEndpoint("estimate_fee_bulk", { blockIdentifier }, params).then(
-        this.responseParser.parseFeeEstimateBulkResponse
-      );
-    }
-    async getCode(contractAddress, blockIdentifier = this.blockIdentifier) {
-      return this.fetchEndpoint("get_code", { contractAddress, blockIdentifier });
-    }
-    async waitForTransaction(txHash, options) {
-      const errorStates = ["REJECTED" /* REJECTED */, "NOT_RECEIVED" /* NOT_RECEIVED */];
-      let onchain = false;
-      let res;
-      const retryInterval = (options == null ? void 0 : options.retryInterval) ?? 8e3;
-      const successStates = (options == null ? void 0 : options.successStates) ?? [
-        "ACCEPTED_ON_L1" /* ACCEPTED_ON_L1 */,
-        "ACCEPTED_ON_L2" /* ACCEPTED_ON_L2 */,
-        "PENDING" /* PENDING */
-      ];
-      while (!onchain) {
-        await wait(retryInterval);
-        res = await this.getTransactionStatus(txHash);
-        if (successStates.includes(res.tx_status)) {
-          onchain = true;
-        } else if (errorStates.includes(res.tx_status)) {
-          const message = res.tx_failure_reason ? `${res.tx_status}: ${res.tx_failure_reason.code}
-${res.tx_failure_reason.error_message}` : res.tx_status;
-          const error = new Error(message);
-          error.response = res;
-          throw error;
-        }
-      }
-      const txReceipt = await this.getTransactionReceipt(txHash);
-      return txReceipt;
-    }
-    async getTransactionStatus(txHash) {
-      const txHashHex = toHex(txHash);
-      return this.fetchEndpoint("get_transaction_status", { transactionHash: txHashHex });
-    }
-    async getContractAddresses() {
-      return this.fetchEndpoint("get_contract_addresses");
-    }
-    async getTransactionTrace(txHash) {
-      const txHashHex = toHex(txHash);
-      return this.fetchEndpoint("get_transaction_trace", { transactionHash: txHashHex });
-    }
-    async estimateMessageFee({ from_address, to_address, entry_point_selector, payload }, blockIdentifier = this.blockIdentifier) {
-      const validCallL1Handler = {
-        from_address: getDecimalString(from_address),
-        to_address: getHexString(to_address),
-        entry_point_selector: getSelector(entry_point_selector),
-        payload: getHexStringArray(payload)
-      };
-      return this.fetchEndpoint("estimate_message_fee", { blockIdentifier }, validCallL1Handler);
-    }
-    async getSimulateTransaction(invocation, invocationDetails, blockIdentifier = this.blockIdentifier, skipValidate = false) {
-      return this.fetchEndpoint(
-        "simulate_transaction",
-        { blockIdentifier, skipValidate },
-        {
-          type: "INVOKE_FUNCTION",
-          sender_address: invocation.contractAddress,
-          calldata: invocation.calldata ?? [],
-          signature: signatureToDecimalArray(invocation.signature),
-          version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
-          nonce: toHex(invocationDetails.nonce),
-          max_fee: toHex((invocationDetails == null ? void 0 : invocationDetails.maxFee) || 0)
-        }
-      ).then(this.responseParser.parseFeeSimulateTransactionResponse);
-    }
-    async getStateUpdate(blockIdentifier = this.blockIdentifier) {
-      const args = new Block(blockIdentifier).sequencerIdentifier;
-      return this.fetchEndpoint("get_state_update", { ...args }).then(
-        this.responseParser.parseGetStateUpdateResponse
-      );
-    }
-    async getBlockTraces(blockIdentifier = this.blockIdentifier) {
-      const args = new Block(blockIdentifier).sequencerIdentifier;
-      return this.fetchEndpoint("get_block_traces", { ...args });
-    }
-    async getStarkName(address, StarknetIdContract) {
-      return getStarkName(this, address, StarknetIdContract);
-    }
-    async getAddressFromStarkName(name, StarknetIdContract) {
-      return getAddressFromStarkName(this, name, StarknetIdContract);
-    }
-  };
-
-  // src/provider/default.ts
-  var Provider = class {
-    constructor(providerOrOptions) {
-      if (providerOrOptions instanceof Provider) {
-        this.provider = providerOrOptions.provider;
-      } else if (providerOrOptions instanceof RpcProvider || providerOrOptions instanceof SequencerProvider) {
-        this.provider = providerOrOptions;
-      } else if (providerOrOptions && "rpc" in providerOrOptions) {
-        this.provider = new RpcProvider(providerOrOptions.rpc);
-      } else if (providerOrOptions && "sequencer" in providerOrOptions) {
-        this.provider = new SequencerProvider(providerOrOptions.sequencer);
-      } else {
-        this.provider = new SequencerProvider();
-      }
-    }
-    async getChainId() {
-      return this.provider.getChainId();
-    }
-    async getBlock(blockIdentifier) {
-      return this.provider.getBlock(blockIdentifier);
-    }
-    async getClassAt(contractAddress, blockIdentifier) {
-      return this.provider.getClassAt(contractAddress, blockIdentifier);
-    }
-    async getClassHashAt(contractAddress, blockIdentifier) {
-      return this.provider.getClassHashAt(contractAddress, blockIdentifier);
-    }
-    getClassByHash(classHash) {
-      return this.provider.getClassByHash(classHash);
-    }
-    async getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier) {
-      return this.provider.getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier);
-    }
-    async getInvokeEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier, skipValidate) {
-      return this.provider.getInvokeEstimateFee(
-        invocationWithTxType,
-        invocationDetails,
-        blockIdentifier,
-        skipValidate
-      );
-    }
-    async getEstimateFeeBulk(invocations, blockIdentifier) {
-      return this.provider.getEstimateFeeBulk(invocations, blockIdentifier);
-    }
-    async getNonceForAddress(contractAddress, blockIdentifier) {
-      return this.provider.getNonceForAddress(contractAddress, blockIdentifier);
-    }
-    async getStorageAt(contractAddress, key, blockIdentifier) {
-      return this.provider.getStorageAt(contractAddress, key, blockIdentifier);
-    }
-    async getTransaction(txHash) {
-      return this.provider.getTransaction(txHash);
-    }
-    async getTransactionReceipt(txHash) {
-      return this.provider.getTransactionReceipt(txHash);
-    }
-    async callContract(request, blockIdentifier) {
-      return this.provider.callContract(request, blockIdentifier);
-    }
-    async invokeFunction(functionInvocation, details) {
-      return this.provider.invokeFunction(functionInvocation, details);
-    }
-    async deployAccountContract(payload, details) {
-      return this.provider.deployAccountContract(payload, details);
-    }
-    async declareContract(transaction, details) {
-      return this.provider.declareContract(transaction, details);
-    }
-    async getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate) {
-      return this.provider.getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate);
-    }
-    getDeployAccountEstimateFee(transaction, details, blockIdentifier, skipValidate) {
-      return this.provider.getDeployAccountEstimateFee(
-        transaction,
-        details,
-        blockIdentifier,
-        skipValidate
-      );
-    }
-    async getCode(contractAddress, blockIdentifier) {
-      return this.provider.getCode(contractAddress, blockIdentifier);
-    }
-    async waitForTransaction(txHash, options) {
-      return this.provider.waitForTransaction(txHash, options);
-    }
-    async getSimulateTransaction(invocation, invocationDetails, blockIdentifier, skipValidate) {
-      return this.provider.getSimulateTransaction(
-        invocation,
-        invocationDetails,
-        blockIdentifier,
-        skipValidate
-      );
-    }
-    async getStateUpdate(blockIdentifier) {
-      return this.provider.getStateUpdate(blockIdentifier);
-    }
-    async getStarkName(address, StarknetIdContract) {
-      return getStarkName(this, address, StarknetIdContract);
-    }
-    async getAddressFromStarkName(name, StarknetIdContract) {
-      return getAddressFromStarkName(this, name, StarknetIdContract);
-    }
-  };
-
-  // src/provider/interface.ts
-  var ProviderInterface = class {
-  };
-
-  // src/provider/index.ts
-  var defaultProvider = new Provider();
-
-  // src/utils/calldata/formatter.ts
-  var guard = {
-    isBN: (data, type, key) => {
-      if (!isBigInt(data[key]))
-        throw new Error(
-          `Data and formatter mismatch on ${key}:${type[key]}, expected response data ${key}:${data[key]} to be BN instead it is ${typeof data[key]}`
-        );
-    },
-    unknown: (data, type, key) => {
-      throw new Error(`Unhandled formatter type on ${key}:${type[key]} for data ${key}:${data[key]}`);
-    }
-  };
-  function formatter(data, type, sameType) {
-    return Object.entries(data).reduce((acc, [key, value]) => {
-      const elType = sameType ?? type[key];
-      if (!(key in type) && !sameType) {
-        acc[key] = value;
-        return acc;
-      }
-      if (elType === "string") {
-        if (Array.isArray(data[key])) {
-          const arrayStr = formatter(
-            data[key],
-            data[key].map((_) => elType)
-          );
-          acc[key] = Object.values(arrayStr).join("");
-          return acc;
-        }
-        guard.isBN(data, type, key);
-        acc[key] = decodeShortString(value);
-        return acc;
-      }
-      if (elType === "number") {
-        guard.isBN(data, type, key);
-        acc[key] = Number(value);
-        return acc;
-      }
-      if (typeof elType === "function") {
-        acc[key] = elType(value);
-        return acc;
-      }
-      if (Array.isArray(elType)) {
-        const arrayObj = formatter(data[key], elType, elType[0]);
-        acc[key] = Object.values(arrayObj);
-        return acc;
-      }
-      if (typeof elType === "object") {
-        acc[key] = formatter(data[key], elType);
-        return acc;
-      }
-      guard.unknown(data, type, key);
-      return acc;
-    }, {});
-  }
-
-  // src/utils/calldata/tuple.ts
-  function parseNamedTuple(namedTuple) {
-    const name = namedTuple.substring(0, namedTuple.indexOf(":"));
-    const type = namedTuple.substring(name.length + ":".length);
-    return { name, type };
-  }
-  function parseSubTuple(s) {
-    if (!s.includes("("))
-      return { subTuple: [], result: s };
-    const subTuple = [];
-    let result = "";
-    let i = 0;
-    while (i < s.length) {
-      if (s[i] === "(") {
-        let counter = 1;
-        const lBracket = i;
-        i++;
-        while (counter) {
-          if (s[i] === ")")
-            counter--;
-          if (s[i] === "(")
-            counter++;
-          i++;
-        }
-        subTuple.push(s.substring(lBracket, i));
-        result += " ";
-        i--;
-      } else {
-        result += s[i];
-      }
-      i++;
-    }
-    return {
-      subTuple,
-      result
-    };
-  }
-  function extractCairo0Tuple(type) {
-    const cleanType = type.replace(/\s/g, "").slice(1, -1);
-    const { subTuple, result } = parseSubTuple(cleanType);
-    let recomposed = result.split(",").map((it) => {
-      return subTuple.length ? it.replace(" ", subTuple.shift()) : it;
-    });
-    if (isTypeNamedTuple(type)) {
-      recomposed = recomposed.reduce((acc, it) => {
-        return acc.concat(parseNamedTuple(it));
-      }, []);
-    }
-    return recomposed;
-  }
-  function extractCairo1Tuple(type) {
-    const cleanType = type.replace(/\s/g, "").slice(1, -1);
-    return cleanType.split(",");
-  }
-  function extractTupleMemberTypes(type) {
-    if (isCairo1Type(type)) {
-      return extractCairo1Tuple(type);
-    }
-    return extractCairo0Tuple(type);
-  }
-
-  // src/utils/calldata/requestParser.ts
-  function parseTuple(element, typeStr) {
-    const memberTypes = extractTupleMemberTypes(typeStr);
-    const elements = Object.values(element);
-    if (elements.length !== memberTypes.length) {
-      throw Error(
-        `ParseTuple: provided and expected abi tuple size do not match.
-      provided: ${elements} 
-      expected: ${memberTypes}`
-      );
-    }
-    return memberTypes.map((it, dx) => {
-      return {
-        element: elements[dx],
-        type: it.type ?? it
-      };
-    });
-  }
-  function parseCalldataValue(element, type, structs) {
-    if (element === void 0) {
-      throw Error(`Missing parameter for type ${type}`);
-    }
-    if (Array.isArray(element)) {
-      throw Error(`Array inside array (nD) are not supported by cairo. Element: ${element} ${type}`);
-    }
-    if (isTypeUint256(type)) {
-      const el_uint256 = uint256(element);
-      return [felt(el_uint256.low), felt(el_uint256.high)];
-    }
-    if (structs[type] && structs[type].members.length) {
-      const { members } = structs[type];
-      const subElement = element;
-      return members.reduce((acc, it) => {
-        return acc.concat(parseCalldataValue(subElement[it.name], it.type, structs));
-      }, []);
-    }
-    if (isTypeTuple(type)) {
-      const tupled = parseTuple(element, type);
-      return tupled.reduce((acc, it) => {
-        const parsedData = parseCalldataValue(it.element, it.type, structs);
-        return acc.concat(parsedData);
-      }, []);
-    }
-    if (typeof element === "object") {
-      throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
-    }
-    return felt(element);
-  }
-  function parseCalldataField(argsIterator, input, structs) {
-    const { name, type } = input;
-    let { value } = argsIterator.next();
-    switch (true) {
-      case isTypeArray(type):
-        if (!Array.isArray(value) && !isText(value)) {
-          throw Error(`ABI expected parameter ${name} to be array or long string, got ${value}`);
-        }
-        if (typeof value === "string") {
-          value = splitLongString(value);
-        }
-        const result = [];
-        result.push(felt(value.length));
-        const arrayType = getArrayType(input.type);
-        return value.reduce((acc, el) => {
-          if (isTypeFelt(arrayType) || isTypeUint(arrayType) || isTypeContractAddress(arrayType)) {
-            acc.push(felt(el));
-          } else if (isTypeBool(arrayType) && typeof el === "boolean") {
-            acc.push(el.toString());
-          } else {
-            acc.push(...parseCalldataValue(el, arrayType, structs));
-          }
-          return acc;
-        }, result);
-      case (isTypeStruct(type, structs) || isTypeTuple(type) || isTypeUint256(type)):
-        return parseCalldataValue(value, type, structs);
-      case isTypeBool(type):
-        return `${+value}`;
-      default:
-        return felt(value);
-    }
-  }
-
-  // src/utils/calldata/responseParser.ts
-  function parseResponseStruct(responseIterator, type, structs) {
-    if (type in structs && structs[type]) {
-      return structs[type].members.reduce((acc, el) => {
-        acc[el.name] = parseResponseStruct(responseIterator, el.type, structs);
-        return acc;
-      }, {});
-    }
-    if (isTypeTuple(type)) {
-      const memberTypes = extractTupleMemberTypes(type);
-      return memberTypes.reduce((acc, it, idx) => {
-        const tName = (it == null ? void 0 : it.name) ? it.name : idx;
-        const tType = (it == null ? void 0 : it.type) ? it.type : it;
-        acc[tName] = parseResponseStruct(responseIterator, tType, structs);
-        return acc;
-      }, {});
-    }
-    const temp = responseIterator.next().value;
-    return BigInt(temp);
-  }
-  function responseParser(responseIterator, 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);
-    }
-  }
-
-  // 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)`
-      );
-    }
-    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;
-    }
-  };
-  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}`
-        );
-    }
-  };
-  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"
+        };
+      });
+      return this.fetchEndpoint("estimate_fee_bulk", { blockIdentifier }, params).then(
+        this.responseParser.parseFeeEstimateBulkResponse
       );
-      const inputsLength = CallData.abiInputsLength(abiMethod.inputs);
-      if (args.length !== inputsLength) {
-        throw Error(
-          `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
-        );
+    }
+    async getCode(contractAddress, blockIdentifier = this.blockIdentifier) {
+      return this.fetchEndpoint("get_code", { contractAddress, blockIdentifier });
+    }
+    async waitForTransaction(txHash, options) {
+      const errorStates = ["REJECTED" /* REJECTED */, "NOT_RECEIVED" /* NOT_RECEIVED */];
+      let onchain = false;
+      let res;
+      const retryInterval = (options == null ? void 0 : options.retryInterval) ?? 8e3;
+      const successStates = (options == null ? void 0 : options.successStates) ?? [
+        "ACCEPTED_ON_L1" /* ACCEPTED_ON_L1 */,
+        "ACCEPTED_ON_L2" /* ACCEPTED_ON_L2 */,
+        "PENDING" /* PENDING */
+      ];
+      while (!onchain) {
+        await wait(retryInterval);
+        res = await this.getTransactionStatus(txHash);
+        if (successStates.includes(res.tx_status)) {
+          onchain = true;
+        } else if (errorStates.includes(res.tx_status)) {
+          const message = res.tx_failure_reason ? `${res.tx_status}: ${res.tx_failure_reason.code}
+${res.tx_failure_reason.error_message}` : res.tx_status;
+          const error = new Error(message);
+          error.response = res;
+          throw error;
+        }
       }
-      validateFields(abiMethod, args, this.structs);
+      const txReceipt = await this.getTransactionReceipt(txHash);
+      return txReceipt;
     }
-    compile(args, inputs) {
-      const argsIterator = args[Symbol.iterator]();
-      return inputs.reduce(
-        (acc, input) => isLen(input.name) ? acc : acc.concat(parseCalldataField(argsIterator, input, this.structs)),
-        []
-      );
+    async getTransactionStatus(txHash) {
+      const txHashHex = toHex(txHash);
+      return this.fetchEndpoint("get_transaction_status", { transactionHash: txHashHex });
     }
-    static compile(data) {
-      const createTree = (obj) => {
-        const getEntries = (o, prefix = "") => {
-          const oe = Array.isArray(o) ? [o.length.toString(), ...o] : o;
-          return Object.entries(oe).flatMap(([k, v]) => {
-            let value = v;
-            if (isLongText(value))
-              value = splitLongString(value);
-            const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
-            if (isBigInt(value))
-              return [[`${prefix}${kk}`, felt(value)]];
-            return Object(value) === value ? getEntries(value, `${prefix}${kk}.`) : [[`${prefix}${kk}`, felt(value)]];
-          });
-        };
-        return Object.fromEntries(getEntries(obj));
+    async getContractAddresses() {
+      return this.fetchEndpoint("get_contract_addresses");
+    }
+    async getTransactionTrace(txHash) {
+      const txHashHex = toHex(txHash);
+      return this.fetchEndpoint("get_transaction_trace", { transactionHash: txHashHex });
+    }
+    async estimateMessageFee({ from_address, to_address, entry_point_selector, payload }, blockIdentifier = this.blockIdentifier) {
+      const validCallL1Handler = {
+        from_address: getDecimalString(from_address),
+        to_address: getHexString(to_address),
+        entry_point_selector: getSelector(entry_point_selector),
+        payload: getHexStringArray(payload)
       };
-      let callTreeArray;
-      if (!Array.isArray(data)) {
-        const callTree = createTree(data);
-        callTreeArray = Object.values(callTree);
+      return this.fetchEndpoint("estimate_message_fee", { blockIdentifier }, validCallL1Handler);
+    }
+    async getSimulateTransaction(invocation, invocationDetails, blockIdentifier = this.blockIdentifier, skipValidate = false) {
+      return this.fetchEndpoint(
+        "simulate_transaction",
+        { blockIdentifier, skipValidate },
+        {
+          type: "INVOKE_FUNCTION",
+          sender_address: invocation.contractAddress,
+          calldata: invocation.calldata ?? [],
+          signature: signatureToDecimalArray(invocation.signature),
+          version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
+          nonce: toHex(invocationDetails.nonce),
+          max_fee: toHex((invocationDetails == null ? void 0 : invocationDetails.maxFee) || 0)
+        }
+      ).then(this.responseParser.parseFeeSimulateTransactionResponse);
+    }
+    async getStateUpdate(blockIdentifier = this.blockIdentifier) {
+      const args = new Block(blockIdentifier).sequencerIdentifier;
+      return this.fetchEndpoint("get_state_update", { ...args }).then(
+        this.responseParser.parseGetStateUpdateResponse
+      );
+    }
+    async getBlockTraces(blockIdentifier = this.blockIdentifier) {
+      const args = new Block(blockIdentifier).sequencerIdentifier;
+      return this.fetchEndpoint("get_block_traces", { ...args });
+    }
+    async getStarkName(address, StarknetIdContract2) {
+      return getStarkName(this, address, StarknetIdContract2);
+    }
+    async getAddressFromStarkName(name, StarknetIdContract2) {
+      return getAddressFromStarkName(this, name, StarknetIdContract2);
+    }
+  };
+
+  // src/provider/default.ts
+  var Provider = class {
+    constructor(providerOrOptions) {
+      if (providerOrOptions instanceof Provider) {
+        this.provider = providerOrOptions.provider;
+      } else if (providerOrOptions instanceof RpcProvider || providerOrOptions instanceof SequencerProvider) {
+        this.provider = providerOrOptions;
+      } else if (providerOrOptions && "rpc" in providerOrOptions) {
+        this.provider = new RpcProvider(providerOrOptions.rpc);
+      } else if (providerOrOptions && "sequencer" in providerOrOptions) {
+        this.provider = new SequencerProvider(providerOrOptions.sequencer);
       } else {
-        callTreeArray = data;
+        this.provider = new SequencerProvider();
       }
-      Object.defineProperty(callTreeArray, "compiled", {
-        enumerable: false,
-        writable: false,
-        value: true
-      });
-      return callTreeArray;
     }
-    parse(method, response) {
-      const { outputs } = this.abi.find((abi) => abi.name === method);
-      const responseIterator = response.flat()[Symbol.iterator]();
-      const parsed = outputs.flat().reduce((acc, 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 getChainId() {
+      return this.provider.getChainId();
     }
-    format(method, response, format) {
-      const parsed = this.parse(method, response);
-      return formatter(parsed, format);
+    async getBlock(blockIdentifier) {
+      return this.provider.getBlock(blockIdentifier);
     }
-    static abiInputsLength(inputs) {
-      return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
+    async getClassAt(contractAddress, blockIdentifier) {
+      return this.provider.getClassAt(contractAddress, blockIdentifier);
     }
-    static getAbiStruct(abi) {
-      return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
-        (acc, abiEntry) => ({
-          ...acc,
-          [abiEntry.name]: abiEntry
-        }),
-        {}
+    async getClassHashAt(contractAddress, blockIdentifier) {
+      return this.provider.getClassHashAt(contractAddress, blockIdentifier);
+    }
+    getClassByHash(classHash) {
+      return this.provider.getClassByHash(classHash);
+    }
+    async getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier) {
+      return this.provider.getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier);
+    }
+    async getInvokeEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier, skipValidate) {
+      return this.provider.getInvokeEstimateFee(
+        invocationWithTxType,
+        invocationDetails,
+        blockIdentifier,
+        skipValidate
+      );
+    }
+    async getEstimateFeeBulk(invocations, blockIdentifier) {
+      return this.provider.getEstimateFeeBulk(invocations, blockIdentifier);
+    }
+    async getNonceForAddress(contractAddress, blockIdentifier) {
+      return this.provider.getNonceForAddress(contractAddress, blockIdentifier);
+    }
+    async getStorageAt(contractAddress, key, blockIdentifier) {
+      return this.provider.getStorageAt(contractAddress, key, blockIdentifier);
+    }
+    async getTransaction(txHash) {
+      return this.provider.getTransaction(txHash);
+    }
+    async getTransactionReceipt(txHash) {
+      return this.provider.getTransactionReceipt(txHash);
+    }
+    async callContract(request, blockIdentifier) {
+      return this.provider.callContract(request, blockIdentifier);
+    }
+    async invokeFunction(functionInvocation, details) {
+      return this.provider.invokeFunction(functionInvocation, details);
+    }
+    async deployAccountContract(payload, details) {
+      return this.provider.deployAccountContract(payload, details);
+    }
+    async declareContract(transaction, details) {
+      return this.provider.declareContract(transaction, details);
+    }
+    async getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate) {
+      return this.provider.getDeclareEstimateFee(transaction, details, blockIdentifier, skipValidate);
+    }
+    getDeployAccountEstimateFee(transaction, details, blockIdentifier, skipValidate) {
+      return this.provider.getDeployAccountEstimateFee(
+        transaction,
+        details,
+        blockIdentifier,
+        skipValidate
+      );
+    }
+    async getCode(contractAddress, blockIdentifier) {
+      return this.provider.getCode(contractAddress, blockIdentifier);
+    }
+    async waitForTransaction(txHash, options) {
+      return this.provider.waitForTransaction(txHash, options);
+    }
+    async getSimulateTransaction(invocation, invocationDetails, blockIdentifier, skipValidate) {
+      return this.provider.getSimulateTransaction(
+        invocation,
+        invocationDetails,
+        blockIdentifier,
+        skipValidate
       );
     }
+    async getStateUpdate(blockIdentifier) {
+      return this.provider.getStateUpdate(blockIdentifier);
+    }
+    async getStarkName(address, StarknetIdContract2) {
+      return getStarkName(this, address, StarknetIdContract2);
+    }
+    async getAddressFromStarkName(name, StarknetIdContract2) {
+      return getAddressFromStarkName(this, name, StarknetIdContract2);
+    }
+  };
+
+  // src/provider/interface.ts
+  var ProviderInterface = class {
   };
 
+  // src/provider/index.ts
+  var defaultProvider = new Provider();
+
   // src/contract/default.ts
   var splitArgsAndOptions = (args) => {
     const options = [
@@ -12472,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) {
@@ -12515,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 },
@@ -12585,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,
@@ -12602,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,
@@ -12628,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,
@@ -12681,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(
@@ -13338,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: {
@@ -13362,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
@@ -13434,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)
           })
@@ -13520,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,
@@ -13564,8 +13561,8 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         }
       };
     }
-    async getStarkName(address = this.address, StarknetIdContract) {
-      return super.getStarkName(address, StarknetIdContract);
+    async getStarkName(address = this.address, StarknetIdContract2) {
+      return super.getStarkName(address, StarknetIdContract2);
     }
   };