starknet 8.5.2 → 8.5.4

package/dist/index.global.js

@@ -769,6 +769,12 @@ var starknet = (() => {
   function isBytes(a) {
     return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
   }
+  function abytes(b, ...lengths) {
+    if (!isBytes(b))
+      throw new Error("Uint8Array expected");
+    if (lengths.length > 0 && !lengths.includes(b.length))
+      throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+  }
   function isArrayOf(isString2, arr) {
     if (!Array.isArray(arr))
       return false;
@@ -941,7 +947,24 @@ var starknet = (() => {
       }
     };
   }
-  var base64 = /* @__PURE__ */ chain(/* @__PURE__ */ radix2(6), /* @__PURE__ */ alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ padding(6), /* @__PURE__ */ join(""));
+  var hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === "function" && typeof Uint8Array.fromBase64 === "function")();
+  var decodeBase64Builtin = (s, isUrl) => {
+    astr("base64", s);
+    const re = isUrl ? /^[A-Za-z0-9=_-]+$/ : /^[A-Za-z0-9=+/]+$/;
+    const alphabet2 = isUrl ? "base64url" : "base64";
+    if (s.length > 0 && !re.test(s))
+      throw new Error("invalid base64");
+    return Uint8Array.fromBase64(s, { alphabet: alphabet2, lastChunkHandling: "strict" });
+  };
+  var base64 = hasBase64Builtin ? {
+    encode(b) {
+      abytes(b);
+      return b.toBase64();
+    },
+    decode(s) {
+      return decodeBase64Builtin(s, false);
+    }
+  } : /* @__PURE__ */ chain(/* @__PURE__ */ radix2(6), /* @__PURE__ */ alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ padding(6), /* @__PURE__ */ join(""));
 
   // src/utils/encode.ts
   var IS_BROWSER = typeof window !== "undefined";
@@ -1492,6 +1515,9 @@ ${JSON.stringify(data, null, 2)}`;
   }
   var NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
   function isSafeNumber(value, config3) {
+    if (isInteger(value)) {
+      return Number.isSafeInteger(Number.parseInt(value, 10));
+    }
     const num = Number.parseFloat(value);
     const parsed = String(num);
     if (value === parsed) {
@@ -1510,13 +1536,13 @@ ${JSON.stringify(data, null, 2)}`;
     }
     return false;
   }
-  var UnsafeNumberReason = /* @__PURE__ */ function(UnsafeNumberReason2) {
+  var UnsafeNumberReason = /* @__PURE__ */ (function(UnsafeNumberReason2) {
     UnsafeNumberReason2["underflow"] = "underflow";
     UnsafeNumberReason2["overflow"] = "overflow";
     UnsafeNumberReason2["truncate_integer"] = "truncate_integer";
     UnsafeNumberReason2["truncate_float"] = "truncate_float";
     return UnsafeNumberReason2;
-  }({});
+  })({});
   function getUnsafeNumberReason(value) {
     if (isSafeNumber(value, {
       approx: false
@@ -2190,7 +2216,7 @@ ${indent}}` : "}";
   __export(utils_exports, {
     aInRange: () => aInRange,
     abool: () => abool,
-    abytes: () => abytes,
+    abytes: () => abytes2,
     bitGet: () => bitGet,
     bitLen: () => bitLen,
     bitMask: () => bitMask,
@@ -2221,7 +2247,7 @@ ${indent}}` : "}";
   function isBytes2(a) {
     return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
   }
-  function abytes(item) {
+  function abytes2(item) {
     if (!isBytes2(item))
       throw new Error("Uint8Array expected");
   }
@@ -2231,7 +2257,7 @@ ${indent}}` : "}";
   }
   var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
   function bytesToHex(bytes) {
-    abytes(bytes);
+    abytes2(bytes);
     let hex = "";
     for (let i = 0; i < bytes.length; i++) {
       hex += hexes[bytes[i]];
@@ -2280,7 +2306,7 @@ ${indent}}` : "}";
     return hexToNumber(bytesToHex(bytes));
   }
   function bytesToNumberLE(bytes) {
-    abytes(bytes);
+    abytes2(bytes);
     return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
   }
   function numberToBytesBE(n, len) {
@@ -2314,7 +2340,7 @@ ${indent}}` : "}";
     let sum = 0;
     for (let i = 0; i < arrays.length; i++) {
       const a = arrays[i];
-      abytes(a);
+      abytes2(a);
       sum += a.length;
     }
     const res = new Uint8Array(sum);
@@ -2461,18 +2487,12 @@ ${indent}}` : "}";
   function isBytes3(a) {
     return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
   }
-  function abytes2(b, ...lengths) {
+  function abytes3(b, ...lengths) {
     if (!isBytes3(b))
       throw new Error("Uint8Array expected");
     if (lengths.length > 0 && !lengths.includes(b.length))
       throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
   }
-  function ahash(h) {
-    if (typeof h !== "function" || typeof h.create !== "function")
-      throw new Error("Hash should be wrapped by utils.wrapConstructor");
-    anumber2(h.outputLen);
-    anumber2(h.blockLen);
-  }
   function aexists(instance, checkFinished = true) {
     if (instance.destroyed)
       throw new Error("Hash instance has been destroyed");
@@ -2480,16 +2500,13 @@ ${indent}}` : "}";
       throw new Error("Hash#digest() has already been called");
   }
   function aoutput(out, instance) {
-    abytes2(out);
+    abytes3(out);
     const min = instance.outputLen;
     if (out.length < min) {
       throw new Error("digestInto() expects output buffer of length at least " + min);
     }
   }
 
-  // node_modules/@noble/hashes/esm/crypto.js
-  var crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
-
   // node_modules/@noble/hashes/esm/utils.js
   var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
   var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
@@ -2509,24 +2526,9 @@ ${indent}}` : "}";
   function toBytes(data) {
     if (typeof data === "string")
       data = utf8ToBytes2(data);
-    abytes2(data);
+    abytes3(data);
     return data;
   }
-  function concatBytes2(...arrays) {
-    let sum = 0;
-    for (let i = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      abytes2(a);
-      sum += a.length;
-    }
-    const res = new Uint8Array(sum);
-    for (let i = 0, pad = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      res.set(a, pad);
-      pad += a.length;
-    }
-    return res;
-  }
   var Hash = class {
     // Safe version that clones internal state
     clone() {
@@ -2549,15 +2551,6 @@ ${indent}}` : "}";
     hashC.create = (opts) => hashCons(opts);
     return hashC;
   }
-  function randomBytes(bytesLength = 32) {
-    if (crypto && typeof crypto.getRandomValues === "function") {
-      return crypto.getRandomValues(new Uint8Array(bytesLength));
-    }
-    if (crypto && typeof crypto.randomBytes === "function") {
-      return crypto.randomBytes(bytesLength);
-    }
-    throw new Error("crypto.getRandomValues must be defined");
-  }
 
   // node_modules/@noble/hashes/esm/_md.js
   function setBigUint64(view, byteOffset, value, isLE2) {
@@ -3121,7 +3114,7 @@ ${indent}}` : "}";
     }
     writeInto(out) {
       aexists(this, false);
-      abytes2(out);
+      abytes3(out);
       this.finish();
       const bufferOut = this.state;
       const { blockLen } = this;
@@ -3924,7 +3917,7 @@ ${indent}}` : "}";
     toSig(hex) {
       const { Err: E, _int: int, _tlv: tlv } = DER;
       const data = typeof hex === "string" ? h2b(hex) : hex;
-      abytes(data);
+      abytes2(data);
       const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
       if (seqLeftBytes.length)
         throw new E("invalid signature: left bytes after parsing");
@@ -3951,7 +3944,7 @@ ${indent}}` : "}";
     const CURVE2 = validatePointOpts(opts);
     const { Fp } = CURVE2;
     const Fn = Field(CURVE2.n, CURVE2.nBitLength);
-    const toBytes2 = CURVE2.toBytes || ((_c, point, _isCompressed) => {
+    const toBytes3 = CURVE2.toBytes || ((_c, point, _isCompressed) => {
       const a = point.toAffine();
       return concatBytes(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
     });
@@ -4324,7 +4317,7 @@ ${indent}}` : "}";
       toRawBytes(isCompressed = true) {
         abool("isCompressed", isCompressed);
         this.assertValidity();
-        return toBytes2(Point2, this, isCompressed);
+        return toBytes3(Point2, this, isCompressed);
       }
       toHex(isCompressed = true) {
         abool("isCompressed", isCompressed);
@@ -4771,14 +4764,104 @@ ${indent}}` : "}";
     };
   }
 
-  // node_modules/@noble/hashes/esm/hmac.js
-  var HMAC = class extends Hash {
+  // node_modules/@noble/curves/node_modules/@noble/hashes/esm/_assert.js
+  function anumber3(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+      throw new Error("positive integer expected, got " + n);
+  }
+  function isBytes4(a) {
+    return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+  }
+  function abytes4(b, ...lengths) {
+    if (!isBytes4(b))
+      throw new Error("Uint8Array expected");
+    if (lengths.length > 0 && !lengths.includes(b.length))
+      throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+  }
+  function ahash(h) {
+    if (typeof h !== "function" || typeof h.create !== "function")
+      throw new Error("Hash should be wrapped by utils.wrapConstructor");
+    anumber3(h.outputLen);
+    anumber3(h.blockLen);
+  }
+  function aexists2(instance, checkFinished = true) {
+    if (instance.destroyed)
+      throw new Error("Hash instance has been destroyed");
+    if (checkFinished && instance.finished)
+      throw new Error("Hash#digest() has already been called");
+  }
+  function aoutput2(out, instance) {
+    abytes4(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+      throw new Error("digestInto() expects output buffer of length at least " + min);
+    }
+  }
+
+  // node_modules/@noble/curves/node_modules/@noble/hashes/esm/crypto.js
+  var crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+
+  // node_modules/@noble/curves/node_modules/@noble/hashes/esm/utils.js
+  var createView2 = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+  var rotr2 = (word, shift) => word << 32 - shift | word >>> shift;
+  function utf8ToBytes3(str) {
+    if (typeof str !== "string")
+      throw new Error("utf8ToBytes expected string, got " + typeof str);
+    return new Uint8Array(new TextEncoder().encode(str));
+  }
+  function toBytes2(data) {
+    if (typeof data === "string")
+      data = utf8ToBytes3(data);
+    abytes4(data);
+    return data;
+  }
+  function concatBytes2(...arrays) {
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      abytes4(a);
+      sum += a.length;
+    }
+    const res = new Uint8Array(sum);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      res.set(a, pad);
+      pad += a.length;
+    }
+    return res;
+  }
+  var Hash2 = class {
+    // Safe version that clones internal state
+    clone() {
+      return this._cloneInto();
+    }
+  };
+  function wrapConstructor2(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
+    const tmp = hashCons();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashCons();
+    return hashC;
+  }
+  function randomBytes(bytesLength = 32) {
+    if (crypto && typeof crypto.getRandomValues === "function") {
+      return crypto.getRandomValues(new Uint8Array(bytesLength));
+    }
+    if (crypto && typeof crypto.randomBytes === "function") {
+      return crypto.randomBytes(bytesLength);
+    }
+    throw new Error("crypto.getRandomValues must be defined");
+  }
+
+  // node_modules/@noble/curves/node_modules/@noble/hashes/esm/hmac.js
+  var HMAC = class extends Hash2 {
     constructor(hash, _key) {
       super();
       this.finished = false;
       this.destroyed = false;
       ahash(hash);
-      const key = toBytes(_key);
+      const key = toBytes2(_key);
       this.iHash = hash.create();
       if (typeof this.iHash.update !== "function")
         throw new Error("Expected instance of class which extends utils.Hash");
@@ -4797,13 +4880,13 @@ ${indent}}` : "}";
       pad.fill(0);
     }
     update(buf) {
-      aexists(this);
+      aexists2(this);
       this.iHash.update(buf);
       return this;
     }
     digestInto(out) {
-      aexists(this);
-      abytes2(out, this.outputLen);
+      aexists2(this);
+      abytes4(out, this.outputLen);
       this.finished = true;
       this.iHash.digestInto(out);
       this.oHash.update(out);
@@ -5323,7 +5406,8 @@ ${indent}}` : "}";
     static abiSelector = "core::felt252";
     constructor(data) {
       _CairoFelt252.validate(data);
-      this.data = _CairoFelt252.__processData(data);
+      const processedData = _CairoFelt252.__processData(data);
+      this.data = processedData.subarray(processedData.findIndex((x) => x > 0));
     }
     static __processData(data) {
       if (isString(data)) {
@@ -5926,7 +6010,9 @@ ${indent}}` : "}";
     static abiSelector = "core::bytes_31::bytes31";
     constructor(data) {
       _CairoBytes31.validate(data);
-      this.data = _CairoBytes31.__processData(data);
+      const processedData = _CairoBytes31.__processData(data);
+      this.data = new Uint8Array(_CairoBytes31.MAX_BYTE_SIZE);
+      this.data.set(processedData, _CairoBytes31.MAX_BYTE_SIZE - processedData.length);
     }
     static __processData(data) {
       if (isString(data)) {
@@ -5947,11 +6033,16 @@ ${indent}}` : "}";
       return uint8ArrayToBigInt(this.data);
     }
     decodeUtf8() {
-      return new TextDecoder().decode(this.data);
+      const cutoff = this.data.findIndex((x) => x > 0);
+      const pruned = this.data.subarray(cutoff >= 0 ? cutoff : Infinity);
+      return new TextDecoder().decode(pruned);
     }
-    toHexString() {
-      const hexValue = this.data.length === 0 ? "0" : buf2hex(this.data);
-      return addHexPrefix(hexValue);
+    /**
+     * @param padded flag for including leading zeros
+     */
+    toHexString(padded) {
+      const hex = padded === "padded" ? buf2hex(this.data) : this.toBigInt().toString(16);
+      return addHexPrefix(hex);
     }
     static validate(data) {
       const byteLength = _CairoBytes31.__processData(data).length;
@@ -6009,10 +6100,13 @@ ${indent}}` : "}";
     UNSUPPORTED_TX_VERSION: 61,
     UNSUPPORTED_CONTRACT_CLASS_VERSION: 62,
     UNEXPECTED_ERROR: 63,
+    REPLACEMENT_TRANSACTION_UNDERPRICED: 64,
+    FEE_BELOW_MINIMUM: 65,
     INVALID_SUBSCRIPTION_ID: 66,
     TOO_MANY_ADDRESSES_IN_FILTER: 67,
     TOO_MANY_BLOCKS_BACK: 68,
     COMPILATION_ERROR: 100,
+    //
     INVALID_ADDRESS: 150,
     TOKEN_NOT_SUPPORTED: 151,
     INVALID_SIGNATURE: 153,
@@ -6247,11 +6341,11 @@ ${indent}}` : "}";
       ]);
     }
     decodeUtf8() {
-      const allBytes = this.reconstructBytes();
+      const allBytes = concatenateArrayBuffer(this.toElements());
       return new TextDecoder().decode(allBytes);
     }
     toBigInt() {
-      const allBytes = this.reconstructBytes();
+      const allBytes = concatenateArrayBuffer(this.toElements());
       if (allBytes.length === 0) {
         return 0n;
       }
@@ -6262,15 +6356,39 @@ ${indent}}` : "}";
       return result;
     }
     toHexString() {
-      const allBytes = this.reconstructBytes();
+      const allBytes = concatenateArrayBuffer(this.toElements());
       const hexValue = allBytes.length === 0 ? "0" : buf2hex(allBytes);
       return addHexPrefix(hexValue);
     }
     toBuffer() {
-      this.assertInitialized();
-      const allBytes = this.reconstructBytes();
+      const allBytes = concatenateArrayBuffer(this.toElements());
       return buffer_default.from(allBytes);
     }
+    /**
+     * returns an array of all the data chunks and the pending word
+     * when concatenated, represents the original bytes sequence
+     */
+    toElements() {
+      this.assertInitialized();
+      const allChunks = this.data.flatMap((chunk) => chunk.data);
+      const pendingLen = Number(this.pending_word_len.toBigInt());
+      if (pendingLen) {
+        const pending = new Uint8Array(pendingLen);
+        const paddingDifference = pendingLen - this.pending_word.data.length;
+        pending.set(this.pending_word.data, paddingDifference);
+        allChunks.push(pending);
+      }
+      return allChunks;
+    }
+    /**
+     * Private helper to check if the CairoByteArray is properly initialized
+     */
+    assertInitialized() {
+      assert(
+        this.data && this.pending_word !== void 0 && this.pending_word_len !== void 0,
+        "CairoByteArray is not properly initialized"
+      );
+    }
     static validate(data) {
       assert(data !== null && data !== void 0, "Invalid input: null or undefined");
       assert(
@@ -6318,30 +6436,6 @@ ${indent}}` : "}";
     static isAbiType(abiType) {
       return abiType === _CairoByteArray.abiSelector;
     }
-    /**
-     * Private helper to check if the CairoByteArray is properly initialized
-     */
-    assertInitialized() {
-      assert(
-        this.data && this.pending_word !== void 0 && this.pending_word_len !== void 0,
-        "CairoByteArray is not properly initialized"
-      );
-    }
-    /**
-     * Private helper to reconstruct the full byte sequence from chunks and pending word
-     */
-    reconstructBytes() {
-      this.assertInitialized();
-      const allChunks = this.data.flatMap((chunk) => chunk.data);
-      const pendingLen = Number(this.pending_word_len.toBigInt());
-      if (pendingLen) {
-        const pending = new Uint8Array(pendingLen);
-        const paddingDifference = pendingLen - this.pending_word.data.length;
-        pending.set(this.pending_word.data, paddingDifference);
-        allChunks.push(pending);
-      }
-      return concatenateArrayBuffer(allChunks);
-    }
     static factoryFromApiResponse(responseIterator) {
       const data = Array.from(
         { length: Number(getNext(responseIterator)) },
@@ -13672,6 +13766,258 @@ ${indent}}` : "}";
     validateAndParseEthAddress: () => validateAndParseEthAddress
   });
 
+  // node_modules/@noble/curves/node_modules/@noble/hashes/esm/_md.js
+  function setBigUint642(view, byteOffset, value, isLE2) {
+    if (typeof view.setBigUint64 === "function")
+      return view.setBigUint64(byteOffset, value, isLE2);
+    const _32n2 = BigInt(32);
+    const _u32_max = BigInt(4294967295);
+    const wh = Number(value >> _32n2 & _u32_max);
+    const wl = Number(value & _u32_max);
+    const h = isLE2 ? 4 : 0;
+    const l = isLE2 ? 0 : 4;
+    view.setUint32(byteOffset + h, wh, isLE2);
+    view.setUint32(byteOffset + l, wl, isLE2);
+  }
+  var Chi2 = (a, b, c) => a & b ^ ~a & c;
+  var Maj2 = (a, b, c) => a & b ^ a & c ^ b & c;
+  var HashMD2 = class extends Hash2 {
+    constructor(blockLen, outputLen, padOffset, isLE2) {
+      super();
+      this.blockLen = blockLen;
+      this.outputLen = outputLen;
+      this.padOffset = padOffset;
+      this.isLE = isLE2;
+      this.finished = false;
+      this.length = 0;
+      this.pos = 0;
+      this.destroyed = false;
+      this.buffer = new Uint8Array(blockLen);
+      this.view = createView2(this.buffer);
+    }
+    update(data) {
+      aexists2(this);
+      const { view, buffer, blockLen } = this;
+      data = toBytes2(data);
+      const len = data.length;
+      for (let pos = 0; pos < len; ) {
+        const take = Math.min(blockLen - this.pos, len - pos);
+        if (take === blockLen) {
+          const dataView = createView2(data);
+          for (; blockLen <= len - pos; pos += blockLen)
+            this.process(dataView, pos);
+          continue;
+        }
+        buffer.set(data.subarray(pos, pos + take), this.pos);
+        this.pos += take;
+        pos += take;
+        if (this.pos === blockLen) {
+          this.process(view, 0);
+          this.pos = 0;
+        }
+      }
+      this.length += data.length;
+      this.roundClean();
+      return this;
+    }
+    digestInto(out) {
+      aexists2(this);
+      aoutput2(out, this);
+      this.finished = true;
+      const { buffer, view, blockLen, isLE: isLE2 } = this;
+      let { pos } = this;
+      buffer[pos++] = 128;
+      this.buffer.subarray(pos).fill(0);
+      if (this.padOffset > blockLen - pos) {
+        this.process(view, 0);
+        pos = 0;
+      }
+      for (let i = pos; i < blockLen; i++)
+        buffer[i] = 0;
+      setBigUint642(view, blockLen - 8, BigInt(this.length * 8), isLE2);
+      this.process(view, 0);
+      const oview = createView2(out);
+      const len = this.outputLen;
+      if (len % 4)
+        throw new Error("_sha2: outputLen should be aligned to 32bit");
+      const outLen = len / 4;
+      const state = this.get();
+      if (outLen > state.length)
+        throw new Error("_sha2: outputLen bigger than state");
+      for (let i = 0; i < outLen; i++)
+        oview.setUint32(4 * i, state[i], isLE2);
+    }
+    digest() {
+      const { buffer, outputLen } = this;
+      this.digestInto(buffer);
+      const res = buffer.slice(0, outputLen);
+      this.destroy();
+      return res;
+    }
+    _cloneInto(to) {
+      to || (to = new this.constructor());
+      to.set(...this.get());
+      const { blockLen, buffer, length, finished, destroyed, pos } = this;
+      to.length = length;
+      to.pos = pos;
+      to.finished = finished;
+      to.destroyed = destroyed;
+      if (length % blockLen)
+        to.buffer.set(buffer);
+      return to;
+    }
+  };
+
+  // node_modules/@noble/curves/node_modules/@noble/hashes/esm/sha256.js
+  var SHA256_K2 = /* @__PURE__ */ new Uint32Array([
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+  ]);
+  var SHA256_IV2 = /* @__PURE__ */ new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  var SHA256_W2 = /* @__PURE__ */ new Uint32Array(64);
+  var SHA2562 = class extends HashMD2 {
+    constructor() {
+      super(64, 32, 8, false);
+      this.A = SHA256_IV2[0] | 0;
+      this.B = SHA256_IV2[1] | 0;
+      this.C = SHA256_IV2[2] | 0;
+      this.D = SHA256_IV2[3] | 0;
+      this.E = SHA256_IV2[4] | 0;
+      this.F = SHA256_IV2[5] | 0;
+      this.G = SHA256_IV2[6] | 0;
+      this.H = SHA256_IV2[7] | 0;
+    }
+    get() {
+      const { A, B, C, D, E, F, G, H } = this;
+      return [A, B, C, D, E, F, G, H];
+    }
+    // prettier-ignore
+    set(A, B, C, D, E, F, G, H) {
+      this.A = A | 0;
+      this.B = B | 0;
+      this.C = C | 0;
+      this.D = D | 0;
+      this.E = E | 0;
+      this.F = F | 0;
+      this.G = G | 0;
+      this.H = H | 0;
+    }
+    process(view, offset) {
+      for (let i = 0; i < 16; i++, offset += 4)
+        SHA256_W2[i] = view.getUint32(offset, false);
+      for (let i = 16; i < 64; i++) {
+        const W15 = SHA256_W2[i - 15];
+        const W2 = SHA256_W2[i - 2];
+        const s0 = rotr2(W15, 7) ^ rotr2(W15, 18) ^ W15 >>> 3;
+        const s1 = rotr2(W2, 17) ^ rotr2(W2, 19) ^ W2 >>> 10;
+        SHA256_W2[i] = s1 + SHA256_W2[i - 7] + s0 + SHA256_W2[i - 16] | 0;
+      }
+      let { A, B, C, D, E, F, G, H } = this;
+      for (let i = 0; i < 64; i++) {
+        const sigma1 = rotr2(E, 6) ^ rotr2(E, 11) ^ rotr2(E, 25);
+        const T1 = H + sigma1 + Chi2(E, F, G) + SHA256_K2[i] + SHA256_W2[i] | 0;
+        const sigma0 = rotr2(A, 2) ^ rotr2(A, 13) ^ rotr2(A, 22);
+        const T2 = sigma0 + Maj2(A, B, C) | 0;
+        H = G;
+        G = F;
+        F = E;
+        E = D + T1 | 0;
+        D = C;
+        C = B;
+        B = A;
+        A = T1 + T2 | 0;
+      }
+      A = A + this.A | 0;
+      B = B + this.B | 0;
+      C = C + this.C | 0;
+      D = D + this.D | 0;
+      E = E + this.E | 0;
+      F = F + this.F | 0;
+      G = G + this.G | 0;
+      H = H + this.H | 0;
+      this.set(A, B, C, D, E, F, G, H);
+    }
+    roundClean() {
+      SHA256_W2.fill(0);
+    }
+    destroy() {
+      this.set(0, 0, 0, 0, 0, 0, 0, 0);
+      this.buffer.fill(0);
+    }
+  };
+  var sha2562 = /* @__PURE__ */ wrapConstructor2(() => new SHA2562());
+
   // node_modules/@noble/curves/esm/secp256k1.js
   var secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
   var secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
@@ -13748,7 +14094,7 @@ ${indent}}` : "}";
         return { k1neg, k1, k2neg, k2 };
       }
     }
-  }, sha256);
+  }, sha2562);
   var _0n6 = BigInt(0);
   var Point = secp256k1.ProjectivePoint;
 
@@ -14167,7 +14513,7 @@ ${indent}}` : "}";
     }
     /**
      * fetch rpc node specVersion
-     * @example this.specVersion = "0.7.1"
+     * @example this.specVersion = "0.8.1"
      */
     getSpecVersion() {
       return this.fetchEndpoint("starknet_specVersion");
@@ -14318,21 +14664,22 @@ ${indent}}` : "}";
     }
     async waitForTransaction(txHash, options) {
       const transactionHash = toHex(txHash);
-      let { retries } = this;
+      let retries = options?.retries ?? this.retries;
+      let lifeCycleRetries = options?.lifeCycleRetries ?? 3;
       let onchain = false;
       let isErrorState = false;
       const retryInterval = options?.retryInterval ?? this.transactionRetryIntervalDefault;
-      const errorStates = options?.errorStates ?? [
-        esm_exports.ETransactionStatus.REJECTED
-        // TODO: commented out to preserve the long-standing behavior of "reverted" not being treated as an error by default
-        // should decide which behavior to keep in the future
-        // RPC.ETransactionExecutionStatus.REVERTED,
-      ];
+      const errorStates = options?.errorStates ?? [esm_exports.ETransactionStatus.REJECTED];
       const successStates = options?.successStates ?? [
         // RPC.ETransactionExecutionStatus.SUCCEEDED, Starknet 0.14.0 this one can have incomplete events
         esm_exports.ETransactionStatus.ACCEPTED_ON_L2,
         esm_exports.ETransactionStatus.ACCEPTED_ON_L1
       ];
+      const LifeCycleErrorMessages = {
+        [esm_exports2.ETransactionStatus.RECEIVED]: SYSTEM_MESSAGES.txEvictedFromMempool,
+        [esm_exports2.ETransactionStatus.PRE_CONFIRMED]: SYSTEM_MESSAGES.consensusFailed,
+        [esm_exports2.ETransactionStatus.CANDIDATE]: SYSTEM_MESSAGES.txFailsBlockBuildingValidation
+      };
       const txLife = [];
       let txStatus;
       while (!onchain) {
@@ -14361,15 +14708,11 @@ ${indent}}` : "}";
           }
           if (error instanceof RpcError && error.isType("TXN_HASH_NOT_FOUND")) {
             logger.info("txLife: ", txLife);
-            const errorMessages = {
-              [esm_exports2.ETransactionStatus.RECEIVED]: SYSTEM_MESSAGES.txEvictedFromMempool,
-              [esm_exports2.ETransactionStatus.PRE_CONFIRMED]: SYSTEM_MESSAGES.consensusFailed,
-              [esm_exports2.ETransactionStatus.CANDIDATE]: SYSTEM_MESSAGES.txFailsBlockBuildingValidation
-            };
-            const errorMessage = errorMessages[txLife.at(-1)];
-            if (errorMessage) {
+            const errorMessage = LifeCycleErrorMessages[txLife.at(-1)];
+            if (errorMessage && lifeCycleRetries <= 0) {
               throw new Error(errorMessage);
             }
+            lifeCycleRetries -= 1;
           }
           if (retries <= 0) {
             throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
@@ -14759,14 +15102,14 @@ ${indent}}` : "}";
     }
     /**
      * fetch rpc node specVersion
-     * @example this.specVersion = "0.7.1"
+     * @example this.specVersion = "0.9.0"
      */
     getSpecVersion() {
       return this.fetchEndpoint("starknet_specVersion");
     }
     /**
      * fetch if undefined else just return this.specVersion
-     * @example this.specVersion = "0.8.1"
+     * @example this.specVersion = "0.9.0"
      */
     async setUpSpecVersion() {
       if (!this.specVersion) {
@@ -14910,7 +15253,8 @@ ${indent}}` : "}";
     }
     async waitForTransaction(txHash, options) {
       const transactionHash = toHex(txHash);
-      let { retries } = this;
+      let retries = options?.retries ?? this.retries;
+      let lifeCycleRetries = options?.lifeCycleRetries ?? 3;
       let onchain = false;
       let isErrorState = false;
       const retryInterval = options?.retryInterval ?? this.transactionRetryIntervalDefault;
@@ -14920,6 +15264,11 @@ ${indent}}` : "}";
         esm_exports2.ETransactionFinalityStatus.ACCEPTED_ON_L2,
         esm_exports2.ETransactionFinalityStatus.ACCEPTED_ON_L1
       ];
+      const errorMessages = {
+        [esm_exports2.ETransactionStatus.RECEIVED]: SYSTEM_MESSAGES.txEvictedFromMempool,
+        [esm_exports2.ETransactionStatus.PRE_CONFIRMED]: SYSTEM_MESSAGES.consensusFailed,
+        [esm_exports2.ETransactionStatus.CANDIDATE]: SYSTEM_MESSAGES.txFailsBlockBuildingValidation
+      };
       const txLife = [];
       let txStatus;
       while (!onchain) {
@@ -14948,15 +15297,11 @@ ${indent}}` : "}";
           }
           if (error instanceof RpcError && error.isType("TXN_HASH_NOT_FOUND")) {
             logger.info("txLife: ", txLife);
-            const errorMessages = {
-              [esm_exports2.ETransactionStatus.RECEIVED]: SYSTEM_MESSAGES.txEvictedFromMempool,
-              [esm_exports2.ETransactionStatus.PRE_CONFIRMED]: SYSTEM_MESSAGES.consensusFailed,
-              [esm_exports2.ETransactionStatus.CANDIDATE]: SYSTEM_MESSAGES.txFailsBlockBuildingValidation
-            };
             const errorMessage = errorMessages[txLife.at(-1)];
-            if (errorMessage) {
+            if (errorMessage && lifeCycleRetries <= 0) {
               throw new Error(errorMessage);
             }
+            lifeCycleRetries -= 1;
           }
           if (retries <= 0) {
             throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
@@ -16143,12 +16488,15 @@ ${indent}}` : "}";
         match(callbacks) {
           return statusReceipt in callbacks ? callbacks[statusReceipt](value) : callbacks._();
         },
+        // @ts-ignore - docs
         isSuccess() {
           return statusReceipt === "SUCCEEDED";
         },
+        // @ts-ignore - docs
         isReverted() {
           return statusReceipt === "REVERTED";
         },
+        // @ts-ignore - docs
         isError() {
           return false;
         }
@@ -16161,12 +16509,15 @@ ${indent}}` : "}";
         match(callbacks) {
           return "ERROR" in callbacks ? callbacks.ERROR(errorValue) : callbacks._();
         },
+        // @ts-ignore - docs
         isSuccess() {
           return false;
         },
+        // @ts-ignore - docs
         isReverted() {
           return false;
         },
+        // @ts-ignore - docs
         isError() {
           return true;
         }
@@ -21036,6 +21387,7 @@ ${indent}}` : "}";
 @noble/curves/esm/secp256k1.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
+@noble/hashes/esm/utils.js:
 @noble/hashes/esm/utils.js:
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)