starknet 5.22.0 → 5.23.0

package/dist/index.global.js

@@ -83,6 +83,9 @@ var starknet = (() => {
       }, this);
     } else if (Array.isArray(headers)) {
       headers.forEach(function(header) {
+        if (header.length != 2) {
+          throw new TypeError("Headers constructor: expected name/value pair to be length 2, found" + header.length);
+        }
         this.append(header[0], header[1]);
       }, this);
     } else if (headers) {
@@ -92,6 +95,8 @@ var starknet = (() => {
     }
   }
   function consumed(body) {
+    if (body._noBody)
+      return;
     if (body.bodyUsed) {
       return Promise.reject(new TypeError("Already read"));
     }
@@ -116,7 +121,9 @@ var starknet = (() => {
   function readBlobAsText(blob) {
     var reader = new FileReader();
     var promise = fileReaderReady(reader);
-    reader.readAsText(blob);
+    var match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type);
+    var encoding = match ? match[1] : "utf-8";
+    reader.readAsText(blob, encoding);
     return promise;
   }
   function readArrayBufferAsText(buf) {
@@ -142,6 +149,7 @@ var starknet = (() => {
       this.bodyUsed = this.bodyUsed;
       this._bodyInit = body;
       if (!body) {
+        this._noBody = true;
         this._bodyText = "";
       } else if (typeof body === "string") {
         this._bodyText = body;
@@ -185,27 +193,28 @@ var starknet = (() => {
           return Promise.resolve(new Blob([this._bodyText]));
         }
       };
-      this.arrayBuffer = function() {
-        if (this._bodyArrayBuffer) {
-          var isConsumed = consumed(this);
-          if (isConsumed) {
-            return isConsumed;
-          }
-          if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
-            return Promise.resolve(
-              this._bodyArrayBuffer.buffer.slice(
-                this._bodyArrayBuffer.byteOffset,
-                this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
-              )
-            );
-          } else {
-            return Promise.resolve(this._bodyArrayBuffer);
-          }
+    }
+    this.arrayBuffer = function() {
+      if (this._bodyArrayBuffer) {
+        var isConsumed = consumed(this);
+        if (isConsumed) {
+          return isConsumed;
+        } else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+          return Promise.resolve(
+            this._bodyArrayBuffer.buffer.slice(
+              this._bodyArrayBuffer.byteOffset,
+              this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
+            )
+          );
         } else {
-          return this.blob().then(readBlobAsArrayBuffer);
+          return Promise.resolve(this._bodyArrayBuffer);
         }
-      };
-    }
+      } else if (support.blob) {
+        return this.blob().then(readBlobAsArrayBuffer);
+      } else {
+        throw new Error("could not read as ArrayBuffer");
+      }
+    };
     this.text = function() {
       var rejected = consumed(this);
       if (rejected) {
@@ -266,7 +275,12 @@ var starknet = (() => {
     }
     this.method = normalizeMethod(options.method || this.method || "GET");
     this.mode = options.mode || this.mode || null;
-    this.signal = options.signal || this.signal;
+    this.signal = options.signal || this.signal || function() {
+      if ("AbortController" in g) {
+        var ctrl = new AbortController();
+        return ctrl.signal;
+      }
+    }();
     this.referrer = null;
     if ((this.method === "GET" || this.method === "HEAD") && body) {
       throw new TypeError("Body not allowed for GET or HEAD requests");
@@ -306,7 +320,11 @@ var starknet = (() => {
       var key = parts.shift().trim();
       if (key) {
         var value = parts.join(":").trim();
-        headers.append(key, value);
+        try {
+          headers.append(key, value);
+        } catch (error) {
+          console.warn("Response " + error.message);
+        }
       }
     });
     return headers;
@@ -320,6 +338,9 @@ var starknet = (() => {
     }
     this.type = "default";
     this.status = options.status === void 0 ? 200 : options.status;
+    if (this.status < 200 || this.status > 599) {
+      throw new RangeError("Failed to construct 'Response': The status provided (0) is outside the range [200, 599].");
+    }
     this.ok = this.status >= 200 && this.status < 300;
     this.statusText = options.statusText === void 0 ? "" : "" + options.statusText;
     this.headers = new Headers(options.headers);
@@ -338,10 +359,14 @@ var starknet = (() => {
       }
       xhr.onload = function() {
         var options = {
-          status: xhr.status,
           statusText: xhr.statusText,
           headers: parseHeaders(xhr.getAllResponseHeaders() || "")
         };
+        if (request.url.startsWith("file://") && (xhr.status < 200 || xhr.status > 599)) {
+          options.status = 200;
+        } else {
+          options.status = xhr.status;
+        }
         options.url = "responseURL" in xhr ? xhr.responseURL : options.headers.get("X-Request-URL");
         var body = "response" in xhr ? xhr.response : xhr.responseText;
         setTimeout(function() {
@@ -355,7 +380,7 @@ var starknet = (() => {
       };
       xhr.ontimeout = function() {
         setTimeout(function() {
-          reject(new TypeError("Network request failed"));
+          reject(new TypeError("Network request timed out"));
         }, 0);
       };
       xhr.onabort = function() {
@@ -365,7 +390,7 @@ var starknet = (() => {
       };
       function fixUrl(url) {
         try {
-          return url === "" && global2.location.href ? global2.location.href : url;
+          return url === "" && g.location.href ? g.location.href : url;
         } catch (e) {
           return url;
         }
@@ -379,14 +404,21 @@ var starknet = (() => {
       if ("responseType" in xhr) {
         if (support.blob) {
           xhr.responseType = "blob";
-        } else if (support.arrayBuffer && request.headers.get("Content-Type") && request.headers.get("Content-Type").indexOf("application/octet-stream") !== -1) {
+        } else if (support.arrayBuffer) {
           xhr.responseType = "arraybuffer";
         }
       }
-      if (init && typeof init.headers === "object" && !(init.headers instanceof Headers)) {
+      if (init && typeof init.headers === "object" && !(init.headers instanceof Headers || g.Headers && init.headers instanceof g.Headers)) {
+        var names = [];
         Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+          names.push(normalizeName(name));
           xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
         });
+        request.headers.forEach(function(value, name) {
+          if (names.indexOf(name) === -1) {
+            xhr.setRequestHeader(name, value);
+          }
+        });
       } else {
         request.headers.forEach(function(value, name) {
           xhr.setRequestHeader(name, value);
@@ -403,14 +435,15 @@ var starknet = (() => {
       xhr.send(typeof request._bodyInit === "undefined" ? null : request._bodyInit);
     });
   }
-  var global2, support, viewClasses, isArrayBufferView, methods, redirectStatuses, DOMException;
+  var g, support, viewClasses, isArrayBufferView, methods, redirectStatuses, DOMException;
   var init_fetch = __esm({
     "node_modules/whatwg-fetch/fetch.js"() {
-      global2 = typeof globalThis !== "undefined" && globalThis || typeof self !== "undefined" && self || typeof global2 !== "undefined" && global2;
+      g = typeof globalThis !== "undefined" && globalThis || typeof self !== "undefined" && self || // eslint-disable-next-line no-undef
+      typeof global !== "undefined" && global || {};
       support = {
-        searchParams: "URLSearchParams" in global2,
-        iterable: "Symbol" in global2 && "iterator" in Symbol,
-        blob: "FileReader" in global2 && "Blob" in global2 && function() {
+        searchParams: "URLSearchParams" in g,
+        iterable: "Symbol" in g && "iterator" in Symbol,
+        blob: "FileReader" in g && "Blob" in g && function() {
           try {
             new Blob();
             return true;
@@ -418,8 +451,8 @@ var starknet = (() => {
             return false;
           }
         }(),
-        formData: "FormData" in global2,
-        arrayBuffer: "ArrayBuffer" in global2
+        formData: "FormData" in g,
+        arrayBuffer: "ArrayBuffer" in g
       };
       if (support.arrayBuffer) {
         viewClasses = [
@@ -487,7 +520,7 @@ var starknet = (() => {
       if (support.iterable) {
         Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
       }
-      methods = ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"];
+      methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
       Request.prototype.clone = function() {
         return new Request(this, { body: this._bodyInit });
       };
@@ -502,7 +535,8 @@ var starknet = (() => {
         });
       };
       Response.error = function() {
-        var response = new Response(null, { status: 0, statusText: "" });
+        var response = new Response(null, { status: 200, statusText: "" });
+        response.status = 0;
         response.type = "error";
         return response;
       };
@@ -513,7 +547,7 @@ var starknet = (() => {
         }
         return new Response(null, { status, headers: { location: url } });
       };
-      DOMException = global2.DOMException;
+      DOMException = g.DOMException;
       try {
         new DOMException();
       } catch (err2) {
@@ -527,11 +561,11 @@ var starknet = (() => {
         DOMException.prototype.constructor = DOMException;
       }
       fetch.polyfill = true;
-      if (!global2.fetch) {
-        global2.fetch = fetch;
-        global2.Headers = Headers;
-        global2.Request = Request;
-        global2.Response = Response;
+      if (!g.fetch) {
+        g.fetch = fetch;
+        g.Headers = Headers;
+        g.Request = Request;
+        g.Response = Response;
       }
     }
   });
@@ -555,7 +589,7 @@ var starknet = (() => {
         else
           context[name] = definition();
       })("urljoin", exports, function() {
-        function normalize(strArray) {
+        function normalize2(strArray) {
           var resultArray = [];
           if (strArray.length === 0) {
             return "";
@@ -603,7 +637,7 @@ var starknet = (() => {
           } else {
             input = [].slice.call(arguments);
           }
-          return normalize(input);
+          return normalize2(input);
         };
       });
     }
@@ -660,6 +694,7 @@ var starknet = (() => {
     fixStack: () => fixStack,
     getCalldata: () => getCalldata,
     getChecksumAddress: () => getChecksumAddress,
+    getDefaultNodeUrl: () => getDefaultNodeUrl,
     hash: () => hash_exports,
     isSierra: () => isSierra,
     isUrl: () => isUrl,
@@ -697,6 +732,8 @@ var starknet = (() => {
     MASK_250: () => MASK_250,
     MASK_251: () => MASK_251,
     NetworkName: () => NetworkName,
+    RPC_GOERLI_NODES: () => RPC_GOERLI_NODES,
+    RPC_MAINNET_NODES: () => RPC_MAINNET_NODES,
     StarknetChainId: () => StarknetChainId,
     TEXT_TO_FELT_MAX_LEN: () => TEXT_TO_FELT_MAX_LEN,
     TransactionHashPrefix: () => TransactionHashPrefix,
@@ -722,6 +759,177 @@ var starknet = (() => {
     stringToArrayBuffer: () => stringToArrayBuffer,
     utf8ToArray: () => utf8ToArray
   });
+
+  // node_modules/@scure/base/lib/esm/index.js
+  function assertNumber(n) {
+    if (!Number.isSafeInteger(n))
+      throw new Error(`Wrong integer: ${n}`);
+  }
+  function chain(...args) {
+    const wrap = (a, b) => (c) => a(b(c));
+    const encode = Array.from(args).reverse().reduce((acc, i) => acc ? wrap(acc, i.encode) : i.encode, void 0);
+    const decode2 = args.reduce((acc, i) => acc ? wrap(acc, i.decode) : i.decode, void 0);
+    return { encode, decode: decode2 };
+  }
+  function alphabet(alphabet2) {
+    return {
+      encode: (digits) => {
+        if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number")
+          throw new Error("alphabet.encode input should be an array of numbers");
+        return digits.map((i) => {
+          assertNumber(i);
+          if (i < 0 || i >= alphabet2.length)
+            throw new Error(`Digit index outside alphabet: ${i} (alphabet: ${alphabet2.length})`);
+          return alphabet2[i];
+        });
+      },
+      decode: (input) => {
+        if (!Array.isArray(input) || input.length && typeof input[0] !== "string")
+          throw new Error("alphabet.decode input should be array of strings");
+        return input.map((letter) => {
+          if (typeof letter !== "string")
+            throw new Error(`alphabet.decode: not string element=${letter}`);
+          const index = alphabet2.indexOf(letter);
+          if (index === -1)
+            throw new Error(`Unknown letter: "${letter}". Allowed: ${alphabet2}`);
+          return index;
+        });
+      }
+    };
+  }
+  function join(separator = "") {
+    if (typeof separator !== "string")
+      throw new Error("join separator should be string");
+    return {
+      encode: (from) => {
+        if (!Array.isArray(from) || from.length && typeof from[0] !== "string")
+          throw new Error("join.encode input should be array of strings");
+        for (let i of from)
+          if (typeof i !== "string")
+            throw new Error(`join.encode: non-string input=${i}`);
+        return from.join(separator);
+      },
+      decode: (to) => {
+        if (typeof to !== "string")
+          throw new Error("join.decode input should be string");
+        return to.split(separator);
+      }
+    };
+  }
+  function padding(bits, chr = "=") {
+    assertNumber(bits);
+    if (typeof chr !== "string")
+      throw new Error("padding chr should be string");
+    return {
+      encode(data) {
+        if (!Array.isArray(data) || data.length && typeof data[0] !== "string")
+          throw new Error("padding.encode input should be array of strings");
+        for (let i of data)
+          if (typeof i !== "string")
+            throw new Error(`padding.encode: non-string input=${i}`);
+        while (data.length * bits % 8)
+          data.push(chr);
+        return data;
+      },
+      decode(input) {
+        if (!Array.isArray(input) || input.length && typeof input[0] !== "string")
+          throw new Error("padding.encode input should be array of strings");
+        for (let i of input)
+          if (typeof i !== "string")
+            throw new Error(`padding.decode: non-string input=${i}`);
+        let end = input.length;
+        if (end * bits % 8)
+          throw new Error("Invalid padding: string should have whole number of bytes");
+        for (; end > 0 && input[end - 1] === chr; end--) {
+          if (!((end - 1) * bits % 8))
+            throw new Error("Invalid padding: string has too much padding");
+        }
+        return input.slice(0, end);
+      }
+    };
+  }
+  function normalize(fn) {
+    if (typeof fn !== "function")
+      throw new Error("normalize fn should be function");
+    return { encode: (from) => from, decode: (to) => fn(to) };
+  }
+  var gcd = (
+    /* @__NO_SIDE_EFFECTS__ */
+    (a, b) => !b ? a : gcd(b, a % b)
+  );
+  var radix2carry = (
+    /*@__NO_SIDE_EFFECTS__ */
+    (from, to) => from + (to - gcd(from, to))
+  );
+  function convertRadix2(data, from, to, padding2) {
+    if (!Array.isArray(data))
+      throw new Error("convertRadix2: data should be array");
+    if (from <= 0 || from > 32)
+      throw new Error(`convertRadix2: wrong from=${from}`);
+    if (to <= 0 || to > 32)
+      throw new Error(`convertRadix2: wrong to=${to}`);
+    if (radix2carry(from, to) > 32) {
+      throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`);
+    }
+    let carry = 0;
+    let pos = 0;
+    const mask = 2 ** to - 1;
+    const res = [];
+    for (const n of data) {
+      assertNumber(n);
+      if (n >= 2 ** from)
+        throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+      carry = carry << from | n;
+      if (pos + from > 32)
+        throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+      pos += from;
+      for (; pos >= to; pos -= to)
+        res.push((carry >> pos - to & mask) >>> 0);
+      carry &= 2 ** pos - 1;
+    }
+    carry = carry << to - pos & mask;
+    if (!padding2 && pos >= from)
+      throw new Error("Excess padding");
+    if (!padding2 && carry)
+      throw new Error(`Non-zero padding: ${carry}`);
+    if (padding2 && pos > 0)
+      res.push(carry >>> 0);
+    return res;
+  }
+  function radix2(bits, revPadding = false) {
+    assertNumber(bits);
+    if (bits <= 0 || bits > 32)
+      throw new Error("radix2: bits should be in (0..32]");
+    if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32)
+      throw new Error("radix2: carry overflow");
+    return {
+      encode: (bytes2) => {
+        if (!(bytes2 instanceof Uint8Array))
+          throw new Error("radix2.encode input should be Uint8Array");
+        return convertRadix2(Array.from(bytes2), 8, bits, !revPadding);
+      },
+      decode: (digits) => {
+        if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number")
+          throw new Error("radix2.decode input should be array of strings");
+        return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+      }
+    };
+  }
+  var base16 = /* @__PURE__ */ chain(radix2(4), alphabet("0123456789ABCDEF"), join(""));
+  var base32 = /* @__PURE__ */ chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding(5), join(""));
+  var base32hex = /* @__PURE__ */ chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding(5), join(""));
+  var base32crockford = /* @__PURE__ */ chain(radix2(5), alphabet("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join(""), normalize((s) => s.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1")));
+  var base64 = /* @__PURE__ */ chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding(6), join(""));
+  var base64url = /* @__PURE__ */ chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding(6), join(""));
+  var base64urlnopad = /* @__PURE__ */ chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), join(""));
+  var BECH_ALPHABET = /* @__PURE__ */ chain(alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), join(""));
+  var hex = /* @__PURE__ */ chain(radix2(4), alphabet("0123456789abcdef"), join(""), normalize((s) => {
+    if (typeof s !== "string" || s.length % 2)
+      throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);
+    return s.toLowerCase();
+  }));
+
+  // src/utils/encode.ts
   var IS_BROWSER = typeof window !== "undefined";
   var STRING_ZERO = "0";
   function arrayBufferToString(array) {
@@ -734,47 +942,47 @@ var starknet = (() => {
     return utf8ToArray(str);
   }
   function atobUniversal(a) {
-    return IS_BROWSER ? utf8ToArray(atob(a)) : Buffer.from(a, "base64");
+    return base64.decode(a);
   }
   function btoaUniversal(b) {
-    return IS_BROWSER ? btoa(arrayBufferToString(b)) : Buffer.from(b).toString("base64");
+    return base64.encode(new Uint8Array(b));
   }
   function buf2hex(buffer) {
     return buffer.reduce((r, x) => r + x.toString(16).padStart(2, "0"), "");
   }
-  function removeHexPrefix(hex) {
-    return hex.replace(/^0x/i, "");
+  function removeHexPrefix(hex2) {
+    return hex2.replace(/^0x/i, "");
   }
-  function addHexPrefix(hex) {
-    return `0x${removeHexPrefix(hex)}`;
+  function addHexPrefix(hex2) {
+    return `0x${removeHexPrefix(hex2)}`;
   }
-  function padString(str, length, left, padding = STRING_ZERO) {
+  function padString(str, length, left, padding2 = STRING_ZERO) {
     const diff = length - str.length;
     let result = str;
     if (diff > 0) {
-      const pad = padding.repeat(diff);
+      const pad = padding2.repeat(diff);
       result = left ? pad + str : str + pad;
     }
     return result;
   }
-  function padLeft(str, length, padding = STRING_ZERO) {
-    return padString(str, length, true, padding);
+  function padLeft(str, length, padding2 = STRING_ZERO) {
+    return padString(str, length, true, padding2);
   }
   function calcByteLength(str, byteSize = 8) {
     const { length } = str;
     const remainder = length % byteSize;
     return remainder ? (length - remainder) / byteSize * byteSize + byteSize : length;
   }
-  function sanitizeBytes(str, byteSize = 8, padding = STRING_ZERO) {
-    return padLeft(str, calcByteLength(str, byteSize), padding);
+  function sanitizeBytes(str, byteSize = 8, padding2 = STRING_ZERO) {
+    return padLeft(str, calcByteLength(str, byteSize), padding2);
   }
-  function sanitizeHex(hex) {
-    hex = removeHexPrefix(hex);
-    hex = sanitizeBytes(hex, 2);
-    if (hex) {
-      hex = addHexPrefix(hex);
+  function sanitizeHex(hex2) {
+    hex2 = removeHexPrefix(hex2);
+    hex2 = sanitizeBytes(hex2, 2);
+    if (hex2) {
+      hex2 = addHexPrefix(hex2);
     }
-    return hex;
+    return hex2;
   }
   var pascalToSnake = (text) => /[a-z]/.test(text) ? text.split(/(?=[A-Z])/).join("_").toUpperCase() : text;
 
@@ -817,6 +1025,14 @@ var starknet = (() => {
     ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf",
     ENTRYPOINT: "deployContract"
   };
+  var RPC_GOERLI_NODES = [
+    "https://starknet-testnet.public.blastapi.io/rpc/v0.5",
+    "https://limited-rpc.nethermind.io/goerli-juno/v0_5"
+  ];
+  var RPC_MAINNET_NODES = [
+    "https://starknet-mainnet.public.blastapi.io/rpc/v0.5",
+    "https://limited-rpc.nethermind.io/mainnet-juno/v0_5"
+  ];
 
   // src/types/index.ts
   var types_exports = {};
@@ -837,10 +1053,10 @@ var starknet = (() => {
   });
 
   // src/types/account.ts
-  var SIMULATION_FLAG = /* @__PURE__ */ ((SIMULATION_FLAG3) => {
-    SIMULATION_FLAG3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-    SIMULATION_FLAG3["SKIP_EXECUTE"] = "SKIP_EXECUTE";
-    return SIMULATION_FLAG3;
+  var SIMULATION_FLAG = /* @__PURE__ */ ((SIMULATION_FLAG2) => {
+    SIMULATION_FLAG2["SKIP_VALIDATE"] = "SKIP_VALIDATE";
+    SIMULATION_FLAG2["SKIP_EXECUTE"] = "SKIP_EXECUTE";
+    return SIMULATION_FLAG2;
   })(SIMULATION_FLAG || {});
 
   // src/types/calldata.ts
@@ -874,12 +1090,12 @@ var starknet = (() => {
   })(EntryPointType || {});
 
   // src/types/lib/index.ts
-  var TransactionType = /* @__PURE__ */ ((TransactionType3) => {
-    TransactionType3["DECLARE"] = "DECLARE";
-    TransactionType3["DEPLOY"] = "DEPLOY";
-    TransactionType3["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-    TransactionType3["INVOKE"] = "INVOKE_FUNCTION";
-    return TransactionType3;
+  var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
+    TransactionType2["DECLARE"] = "DECLARE";
+    TransactionType2["DEPLOY"] = "DEPLOY";
+    TransactionType2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
+    TransactionType2["INVOKE"] = "INVOKE_FUNCTION";
+    return TransactionType2;
   })(TransactionType || {});
   var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
     TransactionStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
@@ -890,18 +1106,18 @@ var starknet = (() => {
     TransactionStatus2["REVERTED"] = "REVERTED";
     return TransactionStatus2;
   })(TransactionStatus || {});
-  var TransactionFinalityStatus = /* @__PURE__ */ ((TransactionFinalityStatus3) => {
-    TransactionFinalityStatus3["NOT_RECEIVED"] = "NOT_RECEIVED";
-    TransactionFinalityStatus3["RECEIVED"] = "RECEIVED";
-    TransactionFinalityStatus3["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    TransactionFinalityStatus3["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    return TransactionFinalityStatus3;
+  var TransactionFinalityStatus = /* @__PURE__ */ ((TransactionFinalityStatus2) => {
+    TransactionFinalityStatus2["NOT_RECEIVED"] = "NOT_RECEIVED";
+    TransactionFinalityStatus2["RECEIVED"] = "RECEIVED";
+    TransactionFinalityStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+    TransactionFinalityStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+    return TransactionFinalityStatus2;
   })(TransactionFinalityStatus || {});
-  var TransactionExecutionStatus = /* @__PURE__ */ ((TransactionExecutionStatus3) => {
-    TransactionExecutionStatus3["REJECTED"] = "REJECTED";
-    TransactionExecutionStatus3["REVERTED"] = "REVERTED";
-    TransactionExecutionStatus3["SUCCEEDED"] = "SUCCEEDED";
-    return TransactionExecutionStatus3;
+  var TransactionExecutionStatus = /* @__PURE__ */ ((TransactionExecutionStatus2) => {
+    TransactionExecutionStatus2["REJECTED"] = "REJECTED";
+    TransactionExecutionStatus2["REVERTED"] = "REVERTED";
+    TransactionExecutionStatus2["SUCCEEDED"] = "SUCCEEDED";
+    return TransactionExecutionStatus2;
   })(TransactionExecutionStatus || {});
   var BlockStatus = /* @__PURE__ */ ((BlockStatus2) => {
     BlockStatus2["PENDING"] = "PENDING";
@@ -919,42 +1135,68 @@ var starknet = (() => {
   // src/types/api/rpc.ts
   var rpc_exports = {};
   __export(rpc_exports, {
-    SimulationFlag: () => SimulationFlag,
-    TransactionExecutionStatus: () => TransactionExecutionStatus2,
-    TransactionFinalityStatus: () => TransactionFinalityStatus2,
-    TransactionType: () => TransactionType2
+    EBlockTag: () => EBlockTag,
+    EDataAvailabilityMode: () => EDataAvailabilityMode,
+    ESimulationFlag: () => ESimulationFlag,
+    ETransactionExecutionStatus: () => ETransactionExecutionStatus,
+    ETransactionFinalityStatus: () => ETransactionFinalityStatus,
+    ETransactionStatus: () => ETransactionStatus,
+    ETransactionType: () => ETransactionType,
+    Errors: () => errors_exports,
+    JRPC: () => jsonrpc_exports,
+    SPEC: () => components_exports
   });
 
-  // src/types/api/openrpc.ts
-  var TXN_TYPE = /* @__PURE__ */ ((TXN_TYPE2) => {
-    TXN_TYPE2["DECLARE"] = "DECLARE";
-    TXN_TYPE2["DEPLOY"] = "DEPLOY";
-    TXN_TYPE2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
-    TXN_TYPE2["INVOKE"] = "INVOKE";
-    TXN_TYPE2["L1_HANDLER"] = "L1_HANDLER";
-    return TXN_TYPE2;
-  })(TXN_TYPE || {});
-  var TXN_FINALITY_STATUS = /* @__PURE__ */ ((TXN_FINALITY_STATUS2) => {
-    TXN_FINALITY_STATUS2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
-    TXN_FINALITY_STATUS2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
-    return TXN_FINALITY_STATUS2;
-  })(TXN_FINALITY_STATUS || {});
-  var TXN_EXECUTION_STATUS = /* @__PURE__ */ ((TXN_EXECUTION_STATUS2) => {
-    TXN_EXECUTION_STATUS2["SUCCEEDED"] = "SUCCEEDED";
-    TXN_EXECUTION_STATUS2["REVERTED"] = "REVERTED";
-    return TXN_EXECUTION_STATUS2;
-  })(TXN_EXECUTION_STATUS || {});
-  var SIMULATION_FLAG2 = /* @__PURE__ */ ((SIMULATION_FLAG3) => {
-    SIMULATION_FLAG3["SKIP_VALIDATE"] = "SKIP_VALIDATE";
-    SIMULATION_FLAG3["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
-    return SIMULATION_FLAG3;
-  })(SIMULATION_FLAG2 || {});
+  // src/types/api/jsonrpc/index.ts
+  var jsonrpc_exports = {};
 
-  // src/types/api/rpc.ts
-  var TransactionType2 = TXN_TYPE;
-  var SimulationFlag = SIMULATION_FLAG2;
-  var TransactionFinalityStatus2 = TXN_FINALITY_STATUS;
-  var TransactionExecutionStatus2 = TXN_EXECUTION_STATUS;
+  // src/types/api/rpcspec/errors.ts
+  var errors_exports = {};
+
+  // src/types/api/rpcspec/components.ts
+  var components_exports = {};
+
+  // src/types/api/rpcspec/nonspec.ts
+  var ETransactionType = /* @__PURE__ */ ((ETransactionType2) => {
+    ETransactionType2["DECLARE"] = "DECLARE";
+    ETransactionType2["DEPLOY"] = "DEPLOY";
+    ETransactionType2["DEPLOY_ACCOUNT"] = "DEPLOY_ACCOUNT";
+    ETransactionType2["INVOKE"] = "INVOKE";
+    ETransactionType2["L1_HANDLER"] = "L1_HANDLER";
+    return ETransactionType2;
+  })(ETransactionType || {});
+  var ESimulationFlag = /* @__PURE__ */ ((ESimulationFlag2) => {
+    ESimulationFlag2["SKIP_VALIDATE"] = "SKIP_VALIDATE";
+    ESimulationFlag2["SKIP_FEE_CHARGE"] = "SKIP_FEE_CHARGE";
+    return ESimulationFlag2;
+  })(ESimulationFlag || {});
+  var ETransactionStatus = /* @__PURE__ */ ((ETransactionStatus2) => {
+    ETransactionStatus2["RECEIVED"] = "RECEIVED";
+    ETransactionStatus2["REJECTED"] = "REJECTED";
+    ETransactionStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+    ETransactionStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+    return ETransactionStatus2;
+  })(ETransactionStatus || {});
+  var ETransactionFinalityStatus = /* @__PURE__ */ ((ETransactionFinalityStatus2) => {
+    ETransactionFinalityStatus2["ACCEPTED_ON_L2"] = "ACCEPTED_ON_L2";
+    ETransactionFinalityStatus2["ACCEPTED_ON_L1"] = "ACCEPTED_ON_L1";
+    return ETransactionFinalityStatus2;
+  })(ETransactionFinalityStatus || {});
+  var ETransactionExecutionStatus = /* @__PURE__ */ ((ETransactionExecutionStatus2) => {
+    ETransactionExecutionStatus2["SUCCEEDED"] = "SUCCEEDED";
+    ETransactionExecutionStatus2["REVERTED"] = "REVERTED";
+    return ETransactionExecutionStatus2;
+  })(ETransactionExecutionStatus || {});
+  var EBlockTag = /* @__PURE__ */ ((EBlockTag2) => {
+    EBlockTag2["LATEST"] = "latest";
+    EBlockTag2["PENDING"] = "pending";
+    return EBlockTag2;
+  })(EBlockTag || {});
+  var EDataAvailabilityMode = /* @__PURE__ */ ((EDataAvailabilityMode2) => {
+    EDataAvailabilityMode2["L1"] = "L1";
+    EDataAvailabilityMode2["L2"] = "L2";
+    return EDataAvailabilityMode2;
+  })(EDataAvailabilityMode || {});
 
   // src/types/api/sequencer.ts
   var sequencer_exports = {};
@@ -1019,31 +1261,31 @@ var starknet = (() => {
   function bytesToHex(bytes2) {
     if (!u8a(bytes2))
       throw new Error("Uint8Array expected");
-    let hex = "";
+    let hex2 = "";
     for (let i = 0; i < bytes2.length; i++) {
-      hex += hexes[bytes2[i]];
+      hex2 += hexes[bytes2[i]];
     }
-    return hex;
+    return hex2;
   }
   function numberToHexUnpadded(num) {
-    const hex = num.toString(16);
-    return hex.length & 1 ? `0${hex}` : hex;
-  }
-  function hexToNumber(hex) {
-    if (typeof hex !== "string")
-      throw new Error("hex string expected, got " + typeof hex);
-    return BigInt(hex === "" ? "0" : `0x${hex}`);
-  }
-  function hexToBytes(hex) {
-    if (typeof hex !== "string")
-      throw new Error("hex string expected, got " + typeof hex);
-    const len = hex.length;
+    const hex2 = num.toString(16);
+    return hex2.length & 1 ? `0${hex2}` : hex2;
+  }
+  function hexToNumber(hex2) {
+    if (typeof hex2 !== "string")
+      throw new Error("hex string expected, got " + typeof hex2);
+    return BigInt(hex2 === "" ? "0" : `0x${hex2}`);
+  }
+  function hexToBytes(hex2) {
+    if (typeof hex2 !== "string")
+      throw new Error("hex string expected, got " + typeof hex2);
+    const len = hex2.length;
     if (len % 2)
       throw new Error("padded hex string expected, got unpadded hex of length " + len);
     const array = new Uint8Array(len / 2);
     for (let i = 0; i < array.length; i++) {
       const j = i * 2;
-      const hexByte = hex.slice(j, j + 2);
+      const hexByte = hex2.slice(j, j + 2);
       const byte = Number.parseInt(hexByte, 16);
       if (Number.isNaN(byte) || byte < 0)
         throw new Error("Invalid byte sequence");
@@ -1068,16 +1310,16 @@ var starknet = (() => {
   function numberToVarBytesBE(n) {
     return hexToBytes(numberToHexUnpadded(n));
   }
-  function ensureBytes(title, hex, expectedLength) {
+  function ensureBytes(title, hex2, expectedLength) {
     let res;
-    if (typeof hex === "string") {
+    if (typeof hex2 === "string") {
       try {
-        res = hexToBytes(hex);
+        res = hexToBytes(hex2);
       } catch (e) {
-        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
+        throw new Error(`${title} must be valid hex string, got "${hex2}". Cause: ${e}`);
       }
-    } else if (u8a(hex)) {
-      res = Uint8Array.from(hex);
+    } else if (u8a(hex2)) {
+      res = Uint8Array.from(hex2);
     } else {
       throw new Error(`${title} must be hex string or Uint8Array`);
     }
@@ -1204,8 +1446,8 @@ var starknet = (() => {
   }
 
   // src/utils/num.ts
-  function isHex(hex) {
-    return /^0x[0-9a-f]*$/i.test(hex);
+  function isHex(hex2) {
+    return /^0x[0-9a-f]*$/i.test(hex2);
   }
   function toBigInt(value) {
     return BigInt(value);
@@ -1221,10 +1463,10 @@ var starknet = (() => {
     const res = addHexPrefix(toBigInt(number3).toString(16).padStart(64, "0"));
     return res;
   }
-  function hexToDecimalString(hex) {
-    return BigInt(addHexPrefix(hex)).toString(10);
+  function hexToDecimalString(hex2) {
+    return BigInt(addHexPrefix(hex2)).toString(10);
   }
-  var cleanHex = (hex) => hex.toLowerCase().replace(/^(0x)0+/, "$1");
+  var cleanHex = (hex2) => hex2.toLowerCase().replace(/^(0x)0+/, "$1");
   function assertInRange(input, lowerBound, upperBound, inputName = "") {
     const messageSuffix = inputName === "" ? "invalid length" : `invalid ${inputName} length`;
     const inputBigInt = BigInt(input);
@@ -1905,8 +2147,8 @@ var starknet = (() => {
       const n = y - v * q;
       b = a, a = r, x = u, y = v, u = m, v = n;
     }
-    const gcd = b;
-    if (gcd !== _1n3)
+    const gcd2 = b;
+    if (gcd2 !== _1n3)
       throw new Error("invert: does not exist");
     return mod(x, modulo);
   }
@@ -1931,7 +2173,7 @@ var starknet = (() => {
       if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))
         throw new Error("Cannot find square root");
       let r = S;
-      let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q);
+      let g2 = Fp.pow(Fp.mul(Fp.ONE, Z), Q);
       let x = Fp.pow(n, Q1div2);
       let b = Fp.pow(n, Q);
       while (!Fp.eql(b, Fp.ONE)) {
@@ -1943,10 +2185,10 @@ var starknet = (() => {
             break;
           t2 = Fp.sqr(t2);
         }
-        const ge = Fp.pow(g, _1n3 << BigInt(r - m - 1));
-        g = Fp.sqr(ge);
+        const ge = Fp.pow(g2, _1n3 << BigInt(r - m - 1));
+        g2 = Fp.sqr(ge);
         x = Fp.mul(x, ge);
-        b = Fp.mul(b, g);
+        b = Fp.mul(b, g2);
         r = m;
       }
       return x;
@@ -2402,9 +2644,9 @@ var starknet = (() => {
         throw new E("Invalid signature integer: unnecessary leading zero");
       return { d: b2n(res), l: data.subarray(len + 2) };
     },
-    toSig(hex) {
+    toSig(hex2) {
       const { Err: E } = DER;
-      const data = typeof hex === "string" ? h2b(hex) : hex;
+      const data = typeof hex2 === "string" ? h2b(hex2) : hex2;
       if (!(data instanceof Uint8Array))
         throw new Error("ui8a expected");
       let l = data.length;
@@ -2421,8 +2663,8 @@ var starknet = (() => {
     hexFromSig(sig) {
       const slice = (s2) => Number.parseInt(s2[0], 16) & 8 ? "00" + s2 : s2;
       const h = (num) => {
-        const hex = num.toString(16);
-        return hex.length & 1 ? `0${hex}` : hex;
+        const hex2 = num.toString(16);
+        return hex2.length & 1 ? `0${hex2}` : hex2;
       };
       const s = slice(h(sig.s));
       const r = slice(h(sig.r));
@@ -2536,8 +2778,8 @@ var starknet = (() => {
        * Converts hash string or Uint8Array to Point.
        * @param hex short/long ECDSA hex
        */
-      static fromHex(hex) {
-        const P = Point.fromAffine(fromBytes(ensureBytes("pointHex", hex)));
+      static fromHex(hex2) {
+        const P = Point.fromAffine(fromBytes(ensureBytes("pointHex", hex2)));
         P.assertValidity();
         return P;
       }
@@ -2907,15 +3149,15 @@ var starknet = (() => {
         this.assertValidity();
       }
       // pair (bytes of r, bytes of s)
-      static fromCompact(hex) {
+      static fromCompact(hex2) {
         const l = CURVE2.nByteLength;
-        hex = ensureBytes("compactSignature", hex, l * 2);
-        return new Signature3(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
+        hex2 = ensureBytes("compactSignature", hex2, l * 2);
+        return new Signature3(slcNum(hex2, 0, l), slcNum(hex2, l, 2 * l));
       }
       // DER encoded ECDSA signature
       // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
-      static fromDER(hex) {
-        const { r, s } = DER.toSig(ensureBytes("DER", hex));
+      static fromDER(hex2) {
+        const { r, s } = DER.toSig(ensureBytes("DER", hex2));
         return new Signature3(r, s);
       }
       assertValidity() {
@@ -3330,13 +3572,13 @@ var starknet = (() => {
     const num = bytesToNumberBE(bytes2);
     return delta > 0 ? num >> BigInt(delta) : num;
   }
-  function hex0xToBytes(hex) {
-    if (typeof hex === "string") {
-      hex = strip0x(hex);
-      if (hex.length & 1)
-        hex = "0" + hex;
+  function hex0xToBytes(hex2) {
+    if (typeof hex2 === "string") {
+      hex2 = strip0x(hex2);
+      if (hex2.length & 1)
+        hex2 = "0" + hex2;
     }
-    return hexToBytes(hex);
+    return hexToBytes(hex2);
   }
   var curve = weierstrass({
     a: BigInt(1),
@@ -3351,15 +3593,15 @@ var starknet = (() => {
     ...getHash(sha256),
     bits2int,
     bits2int_modN: (bytes2) => {
-      const hex = bytesToNumberBE(bytes2).toString(16);
-      if (hex.length === 63)
-        bytes2 = hex0xToBytes(hex + "0");
+      const hex2 = bytesToNumberBE(bytes2).toString(16);
+      if (hex2.length === 63)
+        bytes2 = hex0xToBytes(hex2 + "0");
       return mod(bits2int(bytes2), CURVE_ORDER);
     }
   });
   var _starkCurve = curve;
-  function ensureBytes2(hex) {
-    return ensureBytes("", typeof hex === "string" ? hex0xToBytes(hex) : hex);
+  function ensureBytes2(hex2) {
+    return ensureBytes("", typeof hex2 === "string" ? hex0xToBytes(hex2) : hex2);
   }
   function normPrivKey(privKey) {
     return bytesToHex(ensureBytes2(privKey)).padStart(64, "0");
@@ -3406,12 +3648,12 @@ var starknet = (() => {
   }
   var { CURVE, ProjectivePoint, Signature, utils } = curve;
   function extractX(bytes2) {
-    const hex = bytesToHex(bytes2.subarray(1));
-    const stripped = hex.replace(/^0+/gm, "");
+    const hex2 = bytesToHex(bytes2.subarray(1));
+    const stripped = hex2.replace(/^0+/gm, "");
     return `0x${stripped}`;
   }
-  function strip0x(hex) {
-    return hex.replace(/^0x/i, "");
+  function strip0x(hex2) {
+    return hex2.replace(/^0x/i, "");
   }
   function grindKey(seed) {
     const _seed = ensureBytes2(seed);
@@ -3650,7 +3892,7 @@ var starknet = (() => {
     if (!isASCII(str))
       throw new Error(`${str} is not an ASCII string`);
     if (isHex(str)) {
-      return removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
+      return removeHexPrefix(str).replace(/.{2}/g, (hex2) => String.fromCharCode(parseInt(hex2, 16)));
     }
     if (isDecimalString(str)) {
       return decodeShortString("0X".concat(BigInt(str).toString(16)));
@@ -10156,10 +10398,10 @@ var starknet = (() => {
     const compressedProgram = gzip_1(stringified);
     return btoaUniversal(compressedProgram);
   }
-  function decompressProgram(base64) {
-    if (Array.isArray(base64))
-      return base64;
-    const decompressed = arrayBufferToString(ungzip_1(atobUniversal(base64)));
+  function decompressProgram(base642) {
+    if (Array.isArray(base642))
+      return base642;
+    const decompressed = arrayBufferToString(ungzip_1(atobUniversal(base642)));
     return parse2(decompressed);
   }
   function randomAddress() {
@@ -10264,22 +10506,22 @@ var starknet = (() => {
     parseGetBlockResponse(res) {
       return {
         timestamp: res.timestamp,
-        block_hash: res.block_hash,
-        block_number: res.block_number,
-        new_root: res.new_root,
+        block_hash: "block_hash" in res ? res.block_hash : "",
+        block_number: "block_number" in res ? res.block_number : -1,
+        new_root: "new_root" in res ? res.new_root : "",
         parent_hash: res.parent_hash,
-        status: res.status,
+        status: "status" in res ? res.status : "PENDING" /* PENDING */,
         transactions: res.transactions
       };
     }
     parseGetTransactionResponse(res) {
       return {
-        calldata: res.calldata || [],
-        contract_address: res.contract_address,
-        sender_address: res.contract_address,
-        max_fee: res.max_fee,
-        nonce: res.nonce,
-        signature: res.signature || [],
+        calldata: "calldata" in res ? res.calldata : [],
+        contract_address: "contract_address" in res ? res.contract_address : "",
+        sender_address: "sender_address" in res ? res.sender_address : "",
+        max_fee: "max_fee" in res ? res.max_fee : "",
+        nonce: "nonce" in res ? res.nonce : "",
+        signature: "signature" in res ? res.signature : [],
         transaction_hash: res.transaction_hash,
         version: res.version
       };
@@ -10555,6 +10797,13 @@ var starknet = (() => {
   };
 
   // src/provider/rpc.ts
+  var getDefaultNodeUrl = (networkName, mute = false) => {
+    if (!mute)
+      console.warn("Using default public node url, please provide nodeUrl in provider options!");
+    const nodes = networkName === "SN_MAIN" /* SN_MAIN */ ? RPC_MAINNET_NODES : RPC_GOERLI_NODES;
+    const randIdx = Math.floor(Math.random() * nodes.length);
+    return nodes[randIdx];
+  };
   var defaultOptions = {
     headers: { "Content-Type": "application/json" },
     blockIdentifier: "pending" /* pending */,
@@ -10563,52 +10812,127 @@ var starknet = (() => {
   var RpcProvider = class {
     constructor(optionsOrProvider) {
       this.responseParser = new RPCResponseParser();
-      const { nodeUrl, retries, headers, blockIdentifier, chainId } = optionsOrProvider;
-      this.nodeUrl = nodeUrl;
+      /**
+       * @deprecated renamed to getBlockLatestAccepted(); (will be removed in next minor version)
+       */
+      this.getBlockHashAndNumber = this.getBlockLatestAccepted;
+      /**
+       * @deprecated renamed to getBlockStateUpdate();
+       */
+      this.getStateUpdate = this.getBlockStateUpdate;
+      /**
+       * Returns the execution traces of all transactions included in the given block
+       * @deprecated renamed to getBlockTransactionsTraces()
+       */
+      this.traceBlockTransactions = this.getBlockTransactionsTraces;
+      /**
+       * Get the number of transactions in a block given a block id
+       * @deprecated renamed to getBlockTransactionCount()
+       * @returns Number of transactions
+       */
+      this.getTransactionCount = this.getBlockTransactionCount;
+      /**
+       * @deprecated renamed to getTransactionTrace();
+       * For a given executed transaction, return the trace of its execution, including internal calls
+       */
+      this.traceTransaction = this.getTransactionTrace;
+      /**
+       * @deprecated renamed to simulateTransaction();
+       */
+      this.getSimulateTransaction = this.simulateTransaction;
+      const { nodeUrl, retries, headers, blockIdentifier, chainId } = optionsOrProvider || {};
+      if (Object.values(NetworkName).includes(nodeUrl)) {
+        this.nodeUrl = getDefaultNodeUrl(nodeUrl, optionsOrProvider?.default);
+      } else if (nodeUrl) {
+        this.nodeUrl = nodeUrl;
+      } else {
+        this.nodeUrl = getDefaultNodeUrl(void 0, optionsOrProvider?.default);
+      }
       this.retries = retries || defaultOptions.retries;
       this.headers = { ...defaultOptions.headers, ...headers };
       this.blockIdentifier = blockIdentifier || defaultOptions.blockIdentifier;
       this.chainId = chainId;
       this.getChainId();
     }
-    fetch(method, params) {
-      const body = stringify2({ method, jsonrpc: "2.0", params, id: 0 });
+    fetch(method, params, id = 0) {
+      const rpcRequestBody = {
+        id,
+        jsonrpc: "2.0",
+        method,
+        ...params && { params }
+      };
       return fetchPonyfill_default(this.nodeUrl, {
         method: "POST",
-        body,
+        body: stringify2(rpcRequestBody),
         headers: this.headers
       });
     }
-    errorHandler(error) {
-      if (error) {
-        const { code, message } = error;
-        throw new LibraryError(`${code}: ${message}`);
+    errorHandler(method, params, rpcError, otherError) {
+      if (rpcError) {
+        const { code, message, data } = rpcError;
+        throw new LibraryError(
+          `RPC: ${method} with params ${JSON.stringify(params)}
+ ${code}: ${message}: ${data}`
+        );
+      }
+      if (otherError instanceof LibraryError) {
+        throw otherError;
+      }
+      if (otherError) {
+        throw Error(otherError.message);
       }
     }
     async fetchEndpoint(method, params) {
       try {
         const rawResult = await this.fetch(method, params);
         const { error, result } = await rawResult.json();
-        this.errorHandler(error);
+        this.errorHandler(method, params, error);
         return result;
       } catch (error) {
-        this.errorHandler(error?.response?.data);
+        this.errorHandler(method, params, error?.response?.data, error);
         throw error;
       }
     }
-    // Methods from Interface
     async getChainId() {
       this.chainId ?? (this.chainId = await this.fetchEndpoint("starknet_chainId"));
       return this.chainId;
     }
+    /**
+     * NEW: Returns the version of the Starknet JSON-RPC specification being used
+     */
+    async getSpecVersion() {
+      return this.fetchEndpoint("starknet_specVersion");
+    }
+    async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
+      const contract_address = toHex(contractAddress);
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getNonce", {
+        contract_address,
+        block_id
+      });
+    }
+    /**
+     * @deprecated use getBlockWithTxHashes or getBlockWithTxs (will be removed on sequencer deprecation)
+     */
     async getBlock(blockIdentifier = this.blockIdentifier) {
       return this.getBlockWithTxHashes(blockIdentifier).then(
         this.responseParser.parseGetBlockResponse
       );
     }
-    async getBlockHashAndNumber() {
+    /**
+     * Get the most recent accepted block hash and number
+     */
+    async getBlockLatestAccepted() {
       return this.fetchEndpoint("starknet_blockHashAndNumber");
     }
+    /**
+     * @deprecated redundant use getBlockLatestAccepted();
+     * Get the most recent accepted block number
+     * @returns Number of the latest block
+     */
+    async getBlockNumber() {
+      return this.fetchEndpoint("starknet_blockNumber");
+    }
     async getBlockWithTxHashes(blockIdentifier = this.blockIdentifier) {
       const block_id = new Block(blockIdentifier).identifier;
       return this.fetchEndpoint("starknet_getBlockWithTxHashes", { block_id });
@@ -10617,68 +10941,176 @@ var starknet = (() => {
       const block_id = new Block(blockIdentifier).identifier;
       return this.fetchEndpoint("starknet_getBlockWithTxs", { block_id });
     }
-    async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+    async getBlockStateUpdate(blockIdentifier = this.blockIdentifier) {
       const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getClassHashAt", {
-        block_id,
-        contract_address: contractAddress
-      });
+      return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
     }
-    async getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
+    async getBlockTransactionsTraces(blockIdentifier = this.blockIdentifier) {
       const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getNonce", {
-        contract_address: contractAddress,
-        block_id
-      });
+      return this.fetchEndpoint("starknet_traceBlockTransactions", { block_id });
     }
+    async getBlockTransactionCount(blockIdentifier = this.blockIdentifier) {
+      const block_id = new Block(blockIdentifier).identifier;
+      return this.fetchEndpoint("starknet_getBlockTransactionCount", { block_id });
+    }
+    /**
+     * Return transactions from pending block
+     * @deprecated Instead use getBlock(BlockTag.pending); (will be removed in next minor version)
+     */
     async getPendingTransactions() {
-      return this.fetchEndpoint("starknet_pendingTransactions");
+      const { transactions } = await this.getBlock("pending" /* pending */);
+      return Promise.all(transactions.map((it) => this.getTransactionByHash(it)));
+    }
+    /**
+     * @deprecated use getTransactionByHash or getTransactionByBlockIdAndIndex (will be removed on sequencer deprecation)
+     */
+    async getTransaction(txHash) {
+      return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
     }
-    async getProtocolVersion() {
-      throw new Error("Pathfinder does not implement this rpc 0.1.0 method");
+    async getTransactionByHash(txHash) {
+      const transaction_hash = toHex(txHash);
+      return this.fetchEndpoint("starknet_getTransactionByHash", {
+        transaction_hash
+      });
     }
-    async getStateUpdate(blockIdentifier = this.blockIdentifier) {
+    async getTransactionByBlockIdAndIndex(blockIdentifier, index) {
       const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getStateUpdate", { block_id });
+      return this.fetchEndpoint("starknet_getTransactionByBlockIdAndIndex", { block_id, index });
+    }
+    async getTransactionReceipt(txHash) {
+      const transaction_hash = toHex(txHash);
+      return this.fetchEndpoint("starknet_getTransactionReceipt", { transaction_hash });
+    }
+    async getTransactionTrace(txHash) {
+      const transaction_hash = toHex(txHash);
+      return this.fetchEndpoint("starknet_traceTransaction", { transaction_hash });
+    }
+    // TODO: implement in waitforTransaction, add add tests, when RPC 0.5 become standard /
+    /**
+     * NEW: Get the status of a transaction
+     */
+    async getTransactionStatus(transactionHash) {
+      const transaction_hash = toHex(transactionHash);
+      return this.fetchEndpoint("starknet_getTransactionStatus", { transaction_hash });
+    }
+    /**
+     * @param invocations AccountInvocations
+     * @param simulateTransactionOptions blockIdentifier and flags to skip validation and fee charge<br/>
+     * - blockIdentifier<br/>
+     * - skipValidate (default false)<br/>
+     * - skipFeeCharge (default true)<br/>
+     */
+    async simulateTransaction(invocations, {
+      blockIdentifier = this.blockIdentifier,
+      skipValidate = false,
+      skipFeeCharge = true
+    }) {
+      const block_id = new Block(blockIdentifier).identifier;
+      const simulationFlags = [];
+      if (skipValidate)
+        simulationFlags.push(rpc_exports.ESimulationFlag.SKIP_VALIDATE);
+      if (skipFeeCharge)
+        simulationFlags.push(rpc_exports.ESimulationFlag.SKIP_FEE_CHARGE);
+      return this.fetchEndpoint("starknet_simulateTransactions", {
+        block_id,
+        transactions: invocations.map((it) => this.buildTransaction(it)),
+        simulation_flags: simulationFlags
+      }).then(this.responseParser.parseSimulateTransactionResponse);
+    }
+    async waitForTransaction(txHash, options) {
+      const transactionHash = toHex(txHash);
+      let { retries } = this;
+      let onchain = false;
+      let isErrorState = false;
+      const retryInterval = options?.retryInterval ?? 5e3;
+      const errorStates = options?.errorStates ?? [
+        rpc_exports.ETransactionStatus.REJECTED,
+        rpc_exports.ETransactionExecutionStatus.REVERTED
+      ];
+      const successStates = options?.successStates ?? [
+        rpc_exports.ETransactionExecutionStatus.SUCCEEDED,
+        rpc_exports.ETransactionStatus.ACCEPTED_ON_L2,
+        rpc_exports.ETransactionStatus.ACCEPTED_ON_L1
+      ];
+      let txStatus;
+      while (!onchain) {
+        await wait(retryInterval);
+        try {
+          txStatus = await this.getTransactionStatus(transactionHash);
+          const executionStatus = txStatus.execution_status;
+          const finalityStatus = txStatus.finality_status;
+          if (!finalityStatus) {
+            const error = new Error("waiting for transaction status");
+            throw error;
+          }
+          if (successStates.includes(executionStatus) || successStates.includes(finalityStatus)) {
+            onchain = true;
+          } else if (errorStates.includes(executionStatus) || errorStates.includes(finalityStatus)) {
+            const message = `${executionStatus}: ${finalityStatus}`;
+            const error = new Error(message);
+            error.response = txStatus;
+            isErrorState = true;
+            throw error;
+          }
+        } catch (error) {
+          if (error instanceof Error && isErrorState) {
+            throw error;
+          }
+          if (retries <= 0) {
+            throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
+          }
+        }
+        retries -= 1;
+      }
+      let txReceipt = null;
+      while (txReceipt === null) {
+        try {
+          txReceipt = await this.getTransactionReceipt(transactionHash);
+        } catch (error) {
+          if (retries <= 0) {
+            throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
+          }
+        }
+        retries -= 1;
+        await wait(retryInterval);
+      }
+      return txReceipt;
     }
     async getStorageAt(contractAddress, key, blockIdentifier = this.blockIdentifier) {
+      const contract_address = toHex(contractAddress);
       const parsedKey = toStorageKey(key);
       const block_id = new Block(blockIdentifier).identifier;
       return this.fetchEndpoint("starknet_getStorageAt", {
-        contract_address: contractAddress,
+        contract_address,
         key: parsedKey,
         block_id
       });
     }
-    // Methods from Interface
-    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) {
+    async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+      const contract_address = toHex(contractAddress);
       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 });
+      return this.fetchEndpoint("starknet_getClassHashAt", {
+        block_id,
+        contract_address
+      });
     }
     async getClassByHash(classHash) {
       return this.getClass(classHash);
     }
     async getClass(classHash, blockIdentifier = this.blockIdentifier) {
+      const class_hash = toHex(classHash);
       const block_id = new Block(blockIdentifier).identifier;
       return this.fetchEndpoint("starknet_getClass", {
-        class_hash: classHash,
+        class_hash,
         block_id
       }).then(this.responseParser.parseContractClassResponse);
     }
     async getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+      const contract_address = toHex(contractAddress);
       const block_id = new Block(blockIdentifier).identifier;
       return this.fetchEndpoint("starknet_getClassAt", {
         block_id,
-        contract_address: contractAddress
+        contract_address
       }).then(this.responseParser.parseContractClassResponse);
     }
     async getCode(_contractAddress, _blockIdentifier) {
@@ -10702,6 +11134,9 @@ var starknet = (() => {
       }
       return { cairo: "0", compiler: "0" };
     }
+    /**
+     * @deprecated use get*type*EstimateFee (will be refactored based on type after sequencer deprecation)
+     */
     async getEstimateFee(invocation, invocationDetails, blockIdentifier = this.blockIdentifier) {
       return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier);
     }
@@ -10760,11 +11195,24 @@ var starknet = (() => {
         block_id
       }).then(this.responseParser.parseFeeEstimateBulkResponse);
     }
+    async invokeFunction(functionInvocation, details) {
+      return this.fetchEndpoint("starknet_addInvokeTransaction", {
+        invoke_transaction: {
+          sender_address: functionInvocation.contractAddress,
+          calldata: CallData.toHex(functionInvocation.calldata),
+          type: rpc_exports.ETransactionType.INVOKE,
+          max_fee: toHex(details.maxFee || 0),
+          version: "0x1",
+          signature: signatureToHexArray(functionInvocation.signature),
+          nonce: toHex(details.nonce)
+        }
+      });
+    }
     async declareContract({ contract, signature, senderAddress, compiledClassHash }, details) {
       if (!isSierra(contract)) {
         return this.fetchEndpoint("starknet_addDeclareTransaction", {
           declare_transaction: {
-            type: rpc_exports.TransactionType.DECLARE,
+            type: rpc_exports.ETransactionType.DECLARE,
             contract_class: {
               program: contract.program,
               entry_points_by_type: contract.entry_points_by_type,
@@ -10780,7 +11228,7 @@ var starknet = (() => {
       }
       return this.fetchEndpoint("starknet_addDeclareTransaction", {
         declare_transaction: {
-          type: rpc_exports.TransactionType.DECLARE,
+          type: rpc_exports.ETransactionType.DECLARE,
           contract_class: {
             sierra_program: decompressProgram(contract.sierra_program),
             contract_class_version: contract.contract_class_version,
@@ -10802,7 +11250,7 @@ var starknet = (() => {
           constructor_calldata: CallData.toHex(constructorCalldata || []),
           class_hash: toHex(classHash),
           contract_address_salt: toHex(addressSalt || 0),
-          type: rpc_exports.TransactionType.DEPLOY_ACCOUNT,
+          type: rpc_exports.ETransactionType.DEPLOY_ACCOUNT,
           max_fee: toHex(details.maxFee || 0),
           version: toHex(details.version || 0),
           signature: signatureToHexArray(signature),
@@ -10810,20 +11258,6 @@ var starknet = (() => {
         }
       });
     }
-    async invokeFunction(functionInvocation, details) {
-      return this.fetchEndpoint("starknet_addInvokeTransaction", {
-        invoke_transaction: {
-          sender_address: functionInvocation.contractAddress,
-          calldata: CallData.toHex(functionInvocation.calldata),
-          type: rpc_exports.TransactionType.INVOKE,
-          max_fee: toHex(details.maxFee || 0),
-          version: "0x1",
-          signature: signatureToHexArray(functionInvocation.signature),
-          nonce: toHex(details.nonce)
-        }
-      });
-    }
-    // Methods from Interface
     async callContract(call, blockIdentifier = this.blockIdentifier) {
       const block_id = new Block(blockIdentifier).identifier;
       const result = await this.fetchEndpoint("starknet_call", {
@@ -10836,117 +11270,47 @@ var starknet = (() => {
       });
       return this.responseParser.parseCallContractResponse(result);
     }
-    async traceTransaction(transactionHash) {
-      return this.fetchEndpoint("starknet_traceTransaction", { transaction_hash: transactionHash });
-    }
-    async traceBlockTransactions(blockHash) {
-      return this.fetchEndpoint("starknet_traceBlockTransactions", { block_hash: blockHash });
-    }
-    async waitForTransaction(txHash, options) {
-      let { retries } = this;
-      let onchain = false;
-      let isErrorState = false;
-      let txReceipt = {};
-      const retryInterval = options?.retryInterval ?? 5e3;
-      const errorStates = options?.errorStates ?? [TransactionExecutionStatus2.REVERTED];
-      const successStates = options?.successStates ?? [
-        TransactionExecutionStatus2.SUCCEEDED,
-        TransactionFinalityStatus2.ACCEPTED_ON_L1,
-        TransactionFinalityStatus2.ACCEPTED_ON_L2
-      ];
-      while (!onchain) {
-        await wait(retryInterval);
-        try {
-          txReceipt = await this.getTransactionReceipt(txHash);
-          const executionStatus = pascalToSnake(txReceipt.execution_status);
-          const finalityStatus = pascalToSnake(txReceipt.finality_status);
-          if (!executionStatus || !finalityStatus) {
-            const error = new Error("waiting for transaction status");
-            throw error;
-          }
-          if (successStates.includes(executionStatus) || successStates.includes(finalityStatus)) {
-            onchain = true;
-          } else if (errorStates.includes(executionStatus) || errorStates.includes(finalityStatus)) {
-            const message = `${executionStatus}: ${finalityStatus}: ${txReceipt.revert_reason}`;
-            const error = new Error(message);
-            error.response = txReceipt;
-            isErrorState = true;
-            throw error;
-          }
-        } catch (error) {
-          if (error instanceof Error && isErrorState) {
-            throw error;
-          }
-          if (retries === 0) {
-            throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
-          }
-        }
-        retries -= 1;
-      }
-      await wait(retryInterval);
-      return txReceipt;
-    }
     /**
-     * Gets the transaction count from a block.
-     *
-     *
-     * @param blockIdentifier
-     * @returns Number of transactions
+     * NEW: Estimate the fee for a message from L1
+     * @param message Message From L1
      */
-    async getTransactionCount(blockIdentifier = this.blockIdentifier) {
+    async estimateMessageFee(message, blockIdentifier = this.blockIdentifier) {
+      const { from_address, to_address, entry_point_selector, payload } = message;
+      const formattedMessage = {
+        from_address: toHex(from_address),
+        to_address: toHex(to_address),
+        entry_point_selector: getSelector(entry_point_selector),
+        payload: getHexStringArray(payload)
+      };
       const block_id = new Block(blockIdentifier).identifier;
-      return this.fetchEndpoint("starknet_getBlockTransactionCount", { block_id });
-    }
-    /**
-     * Gets the latest block number
-     *
-     *
-     * @returns Number of the latest block
-     */
-    async getBlockNumber() {
-      return this.fetchEndpoint("starknet_blockNumber");
+      return this.fetchEndpoint("starknet_estimateMessageFee", {
+        message: formattedMessage,
+        block_id
+      });
     }
     /**
-     * Gets syncing status of the node
-     *
-     *
+     * Returns an object about the sync status, or false if the node is not synching
      * @returns Object with the stats data
      */
     async getSyncingStats() {
       return this.fetchEndpoint("starknet_syncing");
     }
     /**
-     * Gets all the events filtered
-     *
-     *
+     * Returns all events matching the given filter
      * @returns events and the pagination of the events
      */
     async getEvents(eventFilter) {
       return this.fetchEndpoint("starknet_getEvents", { filter: eventFilter });
     }
-    async getSimulateTransaction(invocations, {
-      blockIdentifier = this.blockIdentifier,
-      skipValidate = false,
-      skipExecute = false,
-      // @deprecated
-      skipFeeCharge = true
-      // Pathfinder currently does not support `starknet_simulateTransactions` without `SKIP_FEE_CHARGE` simulation flag being set. This will become supported in a future release
-    }) {
-      const block_id = new Block(blockIdentifier).identifier;
-      const simulationFlags = [];
-      if (skipValidate)
-        simulationFlags.push(SimulationFlag.SKIP_VALIDATE);
-      if (skipExecute || skipFeeCharge)
-        simulationFlags.push(SimulationFlag.SKIP_FEE_CHARGE);
-      return this.fetchEndpoint("starknet_simulateTransactions", {
-        block_id,
-        transactions: invocations.map((it) => this.buildTransaction(it)),
-        simulation_flags: simulationFlags
-      }).then(this.responseParser.parseSimulateTransactionResponse);
-    }
+    /**
+     * StarknetId Endpoint (get name from address)
+     */
     async getStarkName(address, StarknetIdContract2) {
       return getStarkName(this, address, StarknetIdContract2);
     }
+    /**
+     * StarknetId Endpoint (get address from name)
+     */
     async getAddressFromStarkName(name, StarknetIdContract2) {
       return getAddressFromStarkName(this, name, StarknetIdContract2);
     }
@@ -10959,12 +11323,11 @@ var starknet = (() => {
       };
       if (invocation.type === "INVOKE_FUNCTION" /* INVOKE */) {
         return {
-          type: rpc_exports.TransactionType.INVOKE,
+          type: rpc_exports.ETransactionType.INVOKE,
           // Diff between sequencer and rpc invoke type
           sender_address: invocation.contractAddress,
           calldata: CallData.toHex(invocation.calldata),
           version: toHex(invocation.version || defaultVersions.v1),
-          // HEX_STR_TRANSACTION_VERSION_1, // as any HOTFIX TODO: Resolve spec version
           ...details
         };
       }
@@ -10975,7 +11338,6 @@ var starknet = (() => {
             contract_class: invocation.contract,
             sender_address: invocation.senderAddress,
             version: toHex(invocation.version || defaultVersions.v1),
-            // HEX_STR_TRANSACTION_VERSION_1, // as any HOTFIX TODO: Resolve spec version
             ...details
           };
         }
@@ -10989,7 +11351,6 @@ var starknet = (() => {
           compiled_class_hash: invocation.compiledClassHash || "",
           sender_address: invocation.senderAddress,
           version: toHex(invocation.version || defaultVersions.v2),
-          // HEX_STR_TRANSACTION_VERSION_2, // as any HOTFIX TODO: Resolve spec version
           ...details
         };
       }
@@ -11673,7 +12034,7 @@ ${res.tx_failure_reason.error_message}`;
       } else if (providerOrOptions && "sequencer" in providerOrOptions) {
         this.provider = new SequencerProvider(providerOrOptions.sequencer);
       } else {
-        this.provider = new SequencerProvider();
+        this.provider = new RpcProvider();
       }
     }
     async getChainId() {
@@ -12123,7 +12484,7 @@ ${res.tx_failure_reason.error_message}`;
   // src/utils/events.ts
   function parseUDCEvent(txReceipt) {
     if (!txReceipt.events) {
-      throw new Error("UDC emited event is empty");
+      throw new Error("UDC emitted event is empty");
     }
     const event = txReceipt.events.find(
       (it) => cleanHex(it.from_address) === cleanHex(UDC.ADDRESS)
@@ -12662,7 +13023,7 @@ ${res.tx_failure_reason.error_message}`;
   };
 
   // src/provider/index.ts
-  var defaultProvider = new Provider();
+  var defaultProvider = new Provider({ rpc: { default: true } });
 
   // src/account/interface.ts
   var AccountInterface = class extends ProviderInterface {
@@ -13051,8 +13412,8 @@ ${res.tx_failure_reason.error_message}`;
   }
   function getChecksumAddress(address) {
     const chars = removeHexPrefix(validateAndParseAddress(address)).toLowerCase().split("");
-    const hex = removeHexPrefix(keccakBn(address));
-    const hashed = hexToBytes(hex.padStart(64, "0"));
+    const hex2 = removeHexPrefix(keccakBn(address));
+    const hashed = hexToBytes(hex2.padStart(64, "0"));
     for (let i = 0; i < chars.length; i += 2) {
       if (hashed[i >> 1] >> 4 >= 8) {
         chars[i] = chars[i].toUpperCase();
@@ -13073,6 +13434,9 @@ ${res.tx_failure_reason.error_message}`;
 })();
 /*! Bundled license information:
 
+@scure/base/lib/esm/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
 @noble/curves/esm/abstract/utils.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)