@fuel-ts/account 0.94.5 → 0.94.6

package/dist/index.global.js

@@ -85,20 +85,20 @@
           ctor.prototype = new TempCtor();
           ctor.prototype.constructor = ctor;
         }
-        function BN2(number3, base, endian) {
-          if (BN2.isBN(number3)) {
-            return number3;
+        function BN2(number2, base, endian) {
+          if (BN2.isBN(number2)) {
+            return number2;
           }
           this.negative = 0;
           this.words = null;
           this.length = 0;
           this.red = null;
-          if (number3 !== null) {
+          if (number2 !== null) {
             if (base === "le" || base === "be") {
               endian = base;
               base = 10;
             }
-            this._init(number3 || 0, base || 10, endian || "be");
+            this._init(number2 || 0, base || 10, endian || "be");
           }
         }
         if (typeof module2 === "object") {
@@ -133,53 +133,53 @@
             return left;
           return right;
         };
-        BN2.prototype._init = function init(number3, base, endian) {
-          if (typeof number3 === "number") {
-            return this._initNumber(number3, base, endian);
+        BN2.prototype._init = function init(number2, base, endian) {
+          if (typeof number2 === "number") {
+            return this._initNumber(number2, base, endian);
           }
-          if (typeof number3 === "object") {
-            return this._initArray(number3, base, endian);
+          if (typeof number2 === "object") {
+            return this._initArray(number2, base, endian);
           }
           if (base === "hex") {
             base = 16;
           }
           assert2(base === (base | 0) && base >= 2 && base <= 36);
-          number3 = number3.toString().replace(/\s+/g, "");
+          number2 = number2.toString().replace(/\s+/g, "");
           var start = 0;
-          if (number3[0] === "-") {
+          if (number2[0] === "-") {
             start++;
             this.negative = 1;
           }
-          if (start < number3.length) {
+          if (start < number2.length) {
             if (base === 16) {
-              this._parseHex(number3, start, endian);
+              this._parseHex(number2, start, endian);
             } else {
-              this._parseBase(number3, base, start);
+              this._parseBase(number2, base, start);
               if (endian === "le") {
                 this._initArray(this.toArray(), base, endian);
               }
             }
           }
         };
-        BN2.prototype._initNumber = function _initNumber(number3, base, endian) {
-          if (number3 < 0) {
+        BN2.prototype._initNumber = function _initNumber(number2, base, endian) {
+          if (number2 < 0) {
             this.negative = 1;
-            number3 = -number3;
+            number2 = -number2;
           }
-          if (number3 < 67108864) {
-            this.words = [number3 & 67108863];
+          if (number2 < 67108864) {
+            this.words = [number2 & 67108863];
             this.length = 1;
-          } else if (number3 < 4503599627370496) {
+          } else if (number2 < 4503599627370496) {
             this.words = [
-              number3 & 67108863,
-              number3 / 67108864 & 67108863
+              number2 & 67108863,
+              number2 / 67108864 & 67108863
             ];
             this.length = 2;
           } else {
-            assert2(number3 < 9007199254740992);
+            assert2(number2 < 9007199254740992);
             this.words = [
-              number3 & 67108863,
-              number3 / 67108864 & 67108863,
+              number2 & 67108863,
+              number2 / 67108864 & 67108863,
               1
             ];
             this.length = 3;
@@ -188,14 +188,14 @@
             return;
           this._initArray(this.toArray(), base, endian);
         };
-        BN2.prototype._initArray = function _initArray(number3, base, endian) {
-          assert2(typeof number3.length === "number");
-          if (number3.length <= 0) {
+        BN2.prototype._initArray = function _initArray(number2, base, endian) {
+          assert2(typeof number2.length === "number");
+          if (number2.length <= 0) {
             this.words = [0];
             this.length = 1;
             return this;
           }
-          this.length = Math.ceil(number3.length / 3);
+          this.length = Math.ceil(number2.length / 3);
           this.words = new Array(this.length);
           for (var i = 0; i < this.length; i++) {
             this.words[i] = 0;
@@ -203,8 +203,8 @@
           var j, w;
           var off = 0;
           if (endian === "be") {
-            for (i = number3.length - 1, j = 0; i >= 0; i -= 3) {
-              w = number3[i] | number3[i - 1] << 8 | number3[i - 2] << 16;
+            for (i = number2.length - 1, j = 0; i >= 0; i -= 3) {
+              w = number2[i] | number2[i - 1] << 8 | number2[i - 2] << 16;
               this.words[j] |= w << off & 67108863;
               this.words[j + 1] = w >>> 26 - off & 67108863;
               off += 24;
@@ -214,8 +214,8 @@
               }
             }
           } else if (endian === "le") {
-            for (i = 0, j = 0; i < number3.length; i += 3) {
-              w = number3[i] | number3[i + 1] << 8 | number3[i + 2] << 16;
+            for (i = 0, j = 0; i < number2.length; i += 3) {
+              w = number2[i] | number2[i + 1] << 8 | number2[i + 2] << 16;
               this.words[j] |= w << off & 67108863;
               this.words[j + 1] = w >>> 26 - off & 67108863;
               off += 24;
@@ -246,8 +246,8 @@
           }
           return r;
         }
-        BN2.prototype._parseHex = function _parseHex(number3, start, endian) {
-          this.length = Math.ceil((number3.length - start) / 6);
+        BN2.prototype._parseHex = function _parseHex(number2, start, endian) {
+          this.length = Math.ceil((number2.length - start) / 6);
           this.words = new Array(this.length);
           for (var i = 0; i < this.length; i++) {
             this.words[i] = 0;
@@ -256,8 +256,8 @@
           var j = 0;
           var w;
           if (endian === "be") {
-            for (i = number3.length - 1; i >= start; i -= 2) {
-              w = parseHexByte(number3, start, i) << off;
+            for (i = number2.length - 1; i >= start; i -= 2) {
+              w = parseHexByte(number2, start, i) << off;
               this.words[j] |= w & 67108863;
               if (off >= 18) {
                 off -= 18;
@@ -268,9 +268,9 @@
               }
             }
           } else {
-            var parseLength = number3.length - start;
-            for (i = parseLength % 2 === 0 ? start + 1 : start; i < number3.length; i += 2) {
-              w = parseHexByte(number3, start, i) << off;
+            var parseLength = number2.length - start;
+            for (i = parseLength % 2 === 0 ? start + 1 : start; i < number2.length; i += 2) {
+              w = parseHexByte(number2, start, i) << off;
               this.words[j] |= w & 67108863;
               if (off >= 18) {
                 off -= 18;
@@ -302,7 +302,7 @@
           }
           return r;
         }
-        BN2.prototype._parseBase = function _parseBase(number3, base, start) {
+        BN2.prototype._parseBase = function _parseBase(number2, base, start) {
           this.words = [0];
           this.length = 1;
           for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
@@ -310,12 +310,12 @@
           }
           limbLen--;
           limbPow = limbPow / base | 0;
-          var total = number3.length - start;
+          var total = number2.length - start;
           var mod2 = total % limbLen;
           var end = Math.min(total, total - mod2) + start;
           var word = 0;
           for (var i = start; i < end; i += limbLen) {
-            word = parseBase(number3, i, i + limbLen, base);
+            word = parseBase(number2, i, i + limbLen, base);
             this.imuln(limbPow);
             if (this.words[0] + word < 67108864) {
               this.words[0] += word;
@@ -325,7 +325,7 @@
           }
           if (mod2 !== 0) {
             var pow3 = 1;
-            word = parseBase(number3, i, number3.length, base);
+            word = parseBase(number2, i, number2.length, base);
             for (i = 0; i < mod2; i++) {
               pow3 *= base;
             }
@@ -2651,20 +2651,20 @@
           );
         }
         inherits(K256, MPrime);
-        K256.prototype.split = function split2(input, output3) {
+        K256.prototype.split = function split2(input, output2) {
           var mask = 4194303;
           var outLen = Math.min(input.length, 9);
           for (var i = 0; i < outLen; i++) {
-            output3.words[i] = input.words[i];
+            output2.words[i] = input.words[i];
           }
-          output3.length = outLen;
+          output2.length = outLen;
           if (input.length <= 9) {
             input.words[0] = 0;
             input.length = 1;
             return;
           }
           var prev = input.words[9];
-          output3.words[output3.length++] = prev & mask;
+          output2.words[output2.length++] = prev & mask;
           for (i = 10; i < input.length; i++) {
             var next = input.words[i] | 0;
             input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
@@ -3060,8 +3060,8 @@
         }
         return result;
       }
-      function toWords(bytes3) {
-        return convert2(bytes3, 8, 5, true);
+      function toWords(bytes2) {
+        return convert2(bytes2, 8, 5, true);
       }
       function fromWordsUnsafe(words) {
         const res = convert2(words, 5, 8, false);
@@ -3600,18 +3600,18 @@
       }
       function utf8PercentDecode(str) {
         const input = new Buffer(str);
-        const output3 = [];
+        const output2 = [];
         for (let i = 0; i < input.length; ++i) {
           if (input[i] !== 37) {
-            output3.push(input[i]);
+            output2.push(input[i]);
           } else if (input[i] === 37 && isASCIIHex(input[i + 1]) && isASCIIHex(input[i + 2])) {
-            output3.push(parseInt(input.slice(i + 1, i + 3).toString(), 16));
+            output2.push(parseInt(input.slice(i + 1, i + 3).toString(), 16));
             i += 2;
           } else {
-            output3.push(input[i]);
+            output2.push(input[i]);
           }
         }
-        return new Buffer(output3).toString();
+        return new Buffer(output2).toString();
       }
       function isC0ControlPercentEncode(c) {
         return c <= 31 || c > 126;
@@ -3687,16 +3687,16 @@
         return ipv4;
       }
       function serializeIPv4(address) {
-        let output3 = "";
+        let output2 = "";
         let n = address;
         for (let i = 1; i <= 4; ++i) {
-          output3 = String(n % 256) + output3;
+          output2 = String(n % 256) + output2;
           if (i !== 4) {
-            output3 = "." + output3;
+            output2 = "." + output2;
           }
           n = Math.floor(n / 256);
         }
-        return output3;
+        return output2;
       }
       function parseIPv6(input) {
         const address = [0, 0, 0, 0, 0, 0, 0, 0];
@@ -3754,13 +3754,13 @@
                 return failure;
               }
               while (isASCIIDigit(input[pointer])) {
-                const number3 = parseInt(at(input, pointer));
+                const number2 = parseInt(at(input, pointer));
                 if (ipv4Piece === null) {
-                  ipv4Piece = number3;
+                  ipv4Piece = number2;
                 } else if (ipv4Piece === 0) {
                   return failure;
                 } else {
-                  ipv4Piece = ipv4Piece * 10 + number3;
+                  ipv4Piece = ipv4Piece * 10 + number2;
                 }
                 if (ipv4Piece > 255) {
                   return failure;
@@ -3804,7 +3804,7 @@
         return address;
       }
       function serializeIPv6(address) {
-        let output3 = "";
+        let output2 = "";
         const seqResult = findLongestZeroSequence(address);
         const compress = seqResult.idx;
         let ignore0 = false;
@@ -3816,16 +3816,16 @@
           }
           if (compress === pieceIndex) {
             const separator = pieceIndex === 0 ? "::" : ":";
-            output3 += separator;
+            output2 += separator;
             ignore0 = true;
             continue;
           }
-          output3 += address[pieceIndex].toString(16);
+          output2 += address[pieceIndex].toString(16);
           if (pieceIndex !== 7) {
-            output3 += ":";
+            output2 += ":";
           }
         }
-        return output3;
+        return output2;
       }
       function parseHost(input, isSpecialArg) {
         if (input[0] === "[") {
@@ -3855,12 +3855,12 @@
         if (containsForbiddenHostCodePointExcludingPercent(input)) {
           return failure;
         }
-        let output3 = "";
+        let output2 = "";
         const decoded = punycode.ucs2.decode(input);
         for (let i = 0; i < decoded.length; ++i) {
-          output3 += percentEncodeChar(decoded[i], isC0ControlPercentEncode);
+          output2 += percentEncodeChar(decoded[i], isC0ControlPercentEncode);
         }
-        return output3;
+        return output2;
       }
       function findLongestZeroSequence(arr) {
         let maxIdx = null;
@@ -4485,37 +4485,37 @@
         return true;
       };
       function serializeURL(url, excludeFragment) {
-        let output3 = url.scheme + ":";
+        let output2 = url.scheme + ":";
         if (url.host !== null) {
-          output3 += "//";
+          output2 += "//";
           if (url.username !== "" || url.password !== "") {
-            output3 += url.username;
+            output2 += url.username;
             if (url.password !== "") {
-              output3 += ":" + url.password;
+              output2 += ":" + url.password;
             }
-            output3 += "@";
+            output2 += "@";
           }
-          output3 += serializeHost(url.host);
+          output2 += serializeHost(url.host);
           if (url.port !== null) {
-            output3 += ":" + url.port;
+            output2 += ":" + url.port;
           }
         } else if (url.host === null && url.scheme === "file") {
-          output3 += "//";
+          output2 += "//";
         }
         if (url.cannotBeABaseURL) {
-          output3 += url.path[0];
+          output2 += url.path[0];
         } else {
           for (const string of url.path) {
-            output3 += "/" + string;
+            output2 += "/" + string;
           }
         }
         if (url.query !== null) {
-          output3 += "?" + url.query;
+          output2 += "?" + url.query;
         }
         if (!excludeFragment && url.fragment !== null) {
-          output3 += "#" + url.fragment;
+          output2 += "#" + url.fragment;
         }
-        return output3;
+        return output2;
       }
       function serializeOrigin(tuple) {
         let result = tuple.scheme + "://";
@@ -6459,19 +6459,19 @@
           return "GraphQLError";
         }
         toString() {
-          let output3 = this.message;
+          let output2 = this.message;
           if (this.nodes) {
             for (const node of this.nodes) {
               if (node.loc) {
-                output3 += "\n\n" + (0, _printLocation.printLocation)(node.loc);
+                output2 += "\n\n" + (0, _printLocation.printLocation)(node.loc);
               }
             }
           } else if (this.source && this.locations) {
             for (const location of this.locations) {
-              output3 += "\n\n" + (0, _printLocation.printSourceLocation)(this.source, location);
+              output2 += "\n\n" + (0, _printLocation.printSourceLocation)(this.source, location);
             }
           }
-          return output3;
+          return output2;
         }
         toJSON() {
           const formattedError = {
@@ -18788,7 +18788,7 @@ spurious results.`);
       module.exports = iterate;
       function iterate(list, iterator, state, callback) {
         var key = state["keyedList"] ? state["keyedList"][state.index] : state.index;
-        state.jobs[key] = runJob(iterator, key, list[key], function(error, output3) {
+        state.jobs[key] = runJob(iterator, key, list[key], function(error, output2) {
           if (!(key in state.jobs)) {
             return;
           }
@@ -18796,7 +18796,7 @@ spurious results.`);
           if (error) {
             abort(state);
           } else {
-            state.results[key] = output3;
+            state.results[key] = output2;
           }
           callback(error, state.results);
         });
@@ -20558,8 +20558,8 @@ spurious results.`);
         const ret3 = wasm$1.retd(addr, len);
         return Instruction.__wrap(ret3);
       }
-      function aloc(bytes3) {
-        const ret3 = wasm$1.aloc(bytes3);
+      function aloc(bytes2) {
+        const ret3 = wasm$1.aloc(bytes2);
         return Instruction.__wrap(ret3);
       }
       function mcl(dst_addr, len) {
@@ -21791,9 +21791,9 @@ spurious results.`);
         * Construct the instruction from its parts.
         * @param {RegId} bytes
         */
-        constructor(bytes3) {
-          _assertClass(bytes3, RegId);
-          var ptr0 = bytes3.__destroy_into_raw();
+        constructor(bytes2) {
+          _assertClass(bytes2, RegId);
+          var ptr0 = bytes2.__destroy_into_raw();
           const ret3 = wasm$1.aloc_new_typescript(ptr0);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
@@ -28464,8 +28464,8 @@ spurious results.`);
               }
             }
           }
-          const bytes3 = await module2.arrayBuffer();
-          return await WebAssembly.instantiate(bytes3, imports);
+          const bytes2 = await module2.arrayBuffer();
+          return await WebAssembly.instantiate(bytes2, imports);
         } else {
           const instance = await WebAssembly.instantiate(module2, imports);
           if (instance instanceof WebAssembly.Instance) {
@@ -28801,7 +28801,7 @@ spurious results.`);
     return {
       FORC: "0.63.5",
       FUEL_CORE: "0.35.0",
-      FUELS: "0.94.5"
+      FUELS: "0.94.6"
     };
   }
   function parseVersion(version) {
@@ -28884,6 +28884,7 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["MISSING_PROVIDER"] = "missing-provider";
     ErrorCode2["INVALID_PROVIDER"] = "invalid-provider";
     ErrorCode2["CONNECTION_REFUSED"] = "connection-refused";
+    ErrorCode2["INVALID_URL"] = "invalid-url";
     ErrorCode2["INVALID_PUBLIC_KEY"] = "invalid-public-key";
     ErrorCode2["WALLET_MANAGER_ERROR"] = "wallet-manager-error";
     ErrorCode2["HD_WALLET_ERROR"] = "hd-wallet-error";
@@ -29015,15 +29016,15 @@ This unreleased fuel-core build may include features and updates not yet support
     // ANCHOR: HELPERS
     // make sure we always include `0x` in hex strings
     toString(base, length) {
-      const output3 = super.toString(base, length);
+      const output2 = super.toString(base, length);
       if (base === 16 || base === "hex") {
-        return `0x${output3}`;
+        return `0x${output2}`;
       }
-      return output3;
+      return output2;
     }
     toHex(bytesPadding) {
-      const bytes3 = bytesPadding || 0;
-      const bytesLength = bytes3 * 2;
+      const bytes2 = bytesPadding || 0;
+      const bytesLength = bytes2 * 2;
       if (this.isNeg()) {
         throw new FuelError(ErrorCode.CONVERTING_FAILED, "Cannot convert negative value to hex.");
       }
@@ -29134,21 +29135,21 @@ This unreleased fuel-core build may include features and updates not yet support
     // END ANCHOR: OVERRIDES to output our BN type
     // ANCHOR: OVERRIDES to avoid losing references
     caller(v, methodName) {
-      const output3 = super[methodName](new BN(v));
-      if (BN.isBN(output3)) {
-        return new BN(output3.toArray());
+      const output2 = super[methodName](new BN(v));
+      if (BN.isBN(output2)) {
+        return new BN(output2.toArray());
       }
-      if (typeof output3 === "boolean") {
-        return output3;
+      if (typeof output2 === "boolean") {
+        return output2;
       }
-      return output3;
+      return output2;
     }
     clone() {
       return new BN(this.toArray());
     }
     mulTo(num, out) {
-      const output3 = new import_bn.default(this.toArray()).mulTo(num, out);
-      return new BN(output3.toArray());
+      const output2 = new import_bn.default(this.toArray()).mulTo(num, out);
+      return new BN(output2.toArray());
     }
     egcd(p) {
       const { a, b, gcd } = new import_bn.default(this.toArray()).egcd(p);
@@ -29206,15 +29207,15 @@ This unreleased fuel-core build may include features and updates not yet support
     __defNormalProp3(obj, typeof key !== "symbol" ? key + "" : key, value);
     return value;
   };
-  var chunkAndPadBytes = (bytes3, chunkSize) => {
+  var chunkAndPadBytes = (bytes2, chunkSize) => {
     const chunks = [];
-    for (let offset = 0; offset < bytes3.length; offset += chunkSize) {
+    for (let offset = 0; offset < bytes2.length; offset += chunkSize) {
       const chunk = new Uint8Array(chunkSize);
-      chunk.set(bytes3.slice(offset, offset + chunkSize));
+      chunk.set(bytes2.slice(offset, offset + chunkSize));
       chunks.push(chunk);
     }
     const lastChunk = chunks[chunks.length - 1];
-    const remainingBytes = bytes3.length % chunkSize;
+    const remainingBytes = bytes2.length % chunkSize;
     const paddedChunkLength = remainingBytes + (8 - remainingBytes % 8) % 8;
     const newChunk = lastChunk.slice(0, paddedChunkLength);
     chunks[chunks.length - 1] = newChunk;
@@ -29257,15 +29258,15 @@ If you are attempting to transform a hex value, please make sure it is being pas
     return concatenated;
   };
   var concat = (arrays) => {
-    const bytes3 = arrays.map((v) => arrayify(v));
-    return concatBytes(bytes3);
+    const bytes2 = arrays.map((v) => arrayify(v));
+    return concatBytes(bytes2);
   };
   var HexCharacters = "0123456789abcdef";
   function hexlify(data) {
-    const bytes3 = arrayify(data);
+    const bytes2 = arrayify(data);
     let result = "0x";
-    for (let i = 0; i < bytes3.length; i++) {
-      const v = bytes3[i];
+    for (let i = 0; i < bytes2.length; i++) {
+      const v = bytes2[i];
       result += HexCharacters[(v & 240) >> 4] + HexCharacters[v & 15];
     }
     return result;
@@ -29358,15 +29359,15 @@ If you are attempting to transform a hex value, please make sure it is being pas
     return bn(result);
   }
   function encodeBase58(_value) {
-    const bytes3 = arrayify(_value);
-    let value = bn(bytes3);
+    const bytes2 = arrayify(_value);
+    let value = bn(bytes2);
     let result = "";
     while (value.gt(BN_0)) {
       result = Alphabet[Number(value.mod(BN_58))] + result;
       value = value.div(BN_58);
     }
-    for (let i = 0; i < bytes3.length; i++) {
-      if (bytes3[i]) {
+    for (let i = 0; i < bytes2.length; i++) {
+      if (bytes2[i]) {
         break;
       }
       result = Alphabet[0] + result;
@@ -29382,11 +29383,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
     return result;
   }
   function dataSlice(data, start, end) {
-    const bytes3 = arrayify(data);
-    if (end != null && end > bytes3.length) {
+    const bytes2 = arrayify(data);
+    if (end != null && end > bytes2.length) {
       throw new FuelError(ErrorCode.INVALID_DATA, "cannot slice beyond data bounds");
     }
-    return hexlify(bytes3.slice(start == null ? 0 : start, end == null ? bytes3.length : end));
+    return hexlify(bytes2.slice(start == null ? 0 : start, end == null ? bytes2.length : end));
   }
   function toUtf8Bytes(stri, form = true) {
     let str = stri;
@@ -29423,8 +29424,8 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }
     return new Uint8Array(result);
   }
-  function onError(reason, offset, bytes3, output3, badCodepoint) {
-    console.log(`invalid codepoint at offset ${offset}; ${reason}, bytes: ${bytes3}`);
+  function onError(reason, offset, bytes2, output2, badCodepoint) {
+    console.log(`invalid codepoint at offset ${offset}; ${reason}, bytes: ${bytes2}`);
     return offset;
   }
   function helper(codePoints) {
@@ -29440,11 +29441,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }).join("");
   }
   function getUtf8CodePoints(_bytes) {
-    const bytes3 = arrayify(_bytes, "bytes");
+    const bytes2 = arrayify(_bytes, "bytes");
     const result = [];
     let i = 0;
-    while (i < bytes3.length) {
-      const c = bytes3[i++];
+    while (i < bytes2.length) {
+      const c = bytes2[i++];
       if (c >> 7 === 0) {
         result.push(c);
         continue;
@@ -29462,21 +29463,21 @@ If you are attempting to transform a hex value, please make sure it is being pas
         overlongMask = 65535;
       } else {
         if ((c & 192) === 128) {
-          i += onError("UNEXPECTED_CONTINUE", i - 1, bytes3, result);
+          i += onError("UNEXPECTED_CONTINUE", i - 1, bytes2, result);
         } else {
-          i += onError("BAD_PREFIX", i - 1, bytes3, result);
+          i += onError("BAD_PREFIX", i - 1, bytes2, result);
         }
         continue;
       }
-      if (i - 1 + extraLength >= bytes3.length) {
-        i += onError("OVERRUN", i - 1, bytes3, result);
+      if (i - 1 + extraLength >= bytes2.length) {
+        i += onError("OVERRUN", i - 1, bytes2, result);
         continue;
       }
       let res = c & (1 << 8 - extraLength - 1) - 1;
       for (let j = 0; j < extraLength; j++) {
-        const nextChar = bytes3[i];
+        const nextChar = bytes2[i];
         if ((nextChar & 192) !== 128) {
-          i += onError("MISSING_CONTINUE", i, bytes3, result);
+          i += onError("MISSING_CONTINUE", i, bytes2, result);
           res = null;
           break;
         }
@@ -29487,47 +29488,47 @@ If you are attempting to transform a hex value, please make sure it is being pas
         continue;
       }
       if (res > 1114111) {
-        i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes3, result, res);
+        i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes2, result, res);
         continue;
       }
       if (res >= 55296 && res <= 57343) {
-        i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes3, result, res);
+        i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes2, result, res);
         continue;
       }
       if (res <= overlongMask) {
-        i += onError("OVERLONG", i - 1 - extraLength, bytes3, result, res);
+        i += onError("OVERLONG", i - 1 - extraLength, bytes2, result, res);
         continue;
       }
       result.push(res);
     }
     return result;
   }
-  function toUtf8String(bytes3) {
-    return helper(getUtf8CodePoints(bytes3));
+  function toUtf8String(bytes2) {
+    return helper(getUtf8CodePoints(bytes2));
   }
   function assertUnreachable(_x) {
     throw new Error("Didn't expect to get here");
   }
 
-  // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/_assert.js
+  // ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
   function number(n) {
     if (!Number.isSafeInteger(n) || n < 0)
-      throw new Error(`Wrong positive integer: ${n}`);
+      throw new Error(`positive integer expected, not ${n}`);
   }
   function isBytes(a) {
     return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
   }
   function bytes(b, ...lengths) {
     if (!isBytes(b))
-      throw new Error("Expected Uint8Array");
+      throw new Error("Uint8Array expected");
     if (lengths.length > 0 && !lengths.includes(b.length))
-      throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+      throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
   }
-  function hash(hash4) {
-    if (typeof hash4 !== "function" || typeof hash4.create !== "function")
+  function hash(h) {
+    if (typeof h !== "function" || typeof h.create !== "function")
       throw new Error("Hash should be wrapped by utils.wrapConstructor");
-    number(hash4.outputLen);
-    number(hash4.blockLen);
+    number(h.outputLen);
+    number(h.blockLen);
   }
   function exists(instance, checkFinished = true) {
     if (instance.destroyed)
@@ -29543,16 +29544,22 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }
   }
 
-  // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/utils.js
+  // ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/cryptoNode.js
+  var nc = __toESM(__require("crypto"), 1);
+  var crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
+
+  // ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
   var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-  function isBytes2(a) {
-    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
-  }
   var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
   var rotr = (word, shift) => word << 32 - shift | word >>> shift;
+  var rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
   var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-  if (!isLE)
-    throw new Error("Non little-endian hardware is not supported");
+  var byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+  function byteSwap32(arr) {
+    for (let i = 0; i < arr.length; i++) {
+      arr[i] = byteSwap(arr[i]);
+    }
+  }
   function utf8ToBytes(str) {
     if (typeof str !== "string")
       throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
@@ -29561,10 +29568,24 @@ If you are attempting to transform a hex value, please make sure it is being pas
   function toBytes2(data) {
     if (typeof data === "string")
       data = utf8ToBytes(data);
-    if (!isBytes2(data))
-      throw new Error(`expected Uint8Array, got ${typeof data}`);
+    bytes(data);
     return data;
   }
+  function concatBytes2(...arrays) {
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      bytes(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() {
@@ -29594,27 +29615,38 @@ If you are attempting to transform a hex value, please make sure it is being pas
     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/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/_sha2.js
-  function setBigUint64(view, byteOffset, value, isLE3) {
+  // ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_md.js
+  function setBigUint64(view, byteOffset, value, isLE2) {
     if (typeof view.setBigUint64 === "function")
-      return view.setBigUint64(byteOffset, value, isLE3);
+      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 = isLE3 ? 4 : 0;
-    const l = isLE3 ? 0 : 4;
-    view.setUint32(byteOffset + h, wh, isLE3);
-    view.setUint32(byteOffset + l, wl, isLE3);
+    const h = isLE2 ? 4 : 0;
+    const l = isLE2 ? 0 : 4;
+    view.setUint32(byteOffset + h, wh, isLE2);
+    view.setUint32(byteOffset + l, wl, isLE2);
   }
-  var SHA2 = class extends Hash {
-    constructor(blockLen, outputLen, padOffset, isLE3) {
+  var Chi = (a, b, c) => a & b ^ ~a & c;
+  var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
+  var HashMD = class extends Hash {
+    constructor(blockLen, outputLen, padOffset, isLE2) {
       super();
       this.blockLen = blockLen;
       this.outputLen = outputLen;
       this.padOffset = padOffset;
-      this.isLE = isLE3;
+      this.isLE = isLE2;
       this.finished = false;
       this.length = 0;
       this.pos = 0;
@@ -29651,7 +29683,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
       exists(this);
       output(out, this);
       this.finished = true;
-      const { buffer, view, blockLen, isLE: isLE3 } = this;
+      const { buffer, view, blockLen, isLE: isLE2 } = this;
       let { pos } = this;
       buffer[pos++] = 128;
       this.buffer.subarray(pos).fill(0);
@@ -29661,7 +29693,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
       }
       for (let i = pos; i < blockLen; i++)
         buffer[i] = 0;
-      setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE3);
+      setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
       this.process(view, 0);
       const oview = createView(out);
       const len = this.outputLen;
@@ -29672,7 +29704,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
       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], isLE3);
+        oview.setUint32(4 * i, state[i], isLE2);
     }
     digest() {
       const { buffer, outputLen } = this;
@@ -29695,9 +29727,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }
   };
 
-  // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/sha256.js
-  var Chi = (a, b, c) => a & b ^ ~a & c;
-  var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
+  // ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha256.js
   var SHA256_K = /* @__PURE__ */ new Uint32Array([
     1116352408,
     1899447441,
@@ -29764,7 +29794,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     3204031479,
     3329325298
   ]);
-  var IV = /* @__PURE__ */ new Uint32Array([
+  var SHA256_IV = /* @__PURE__ */ new Uint32Array([
     1779033703,
     3144134277,
     1013904242,
@@ -29775,17 +29805,17 @@ If you are attempting to transform a hex value, please make sure it is being pas
     1541459225
   ]);
   var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-  var SHA256 = class extends SHA2 {
+  var SHA256 = class extends HashMD {
     constructor() {
       super(64, 32, 8, false);
-      this.A = IV[0] | 0;
-      this.B = IV[1] | 0;
-      this.C = IV[2] | 0;
-      this.D = IV[3] | 0;
-      this.E = IV[4] | 0;
-      this.F = IV[5] | 0;
-      this.G = IV[6] | 0;
-      this.H = IV[7] | 0;
+      this.A = SHA256_IV[0] | 0;
+      this.B = SHA256_IV[1] | 0;
+      this.C = SHA256_IV[2] | 0;
+      this.D = SHA256_IV[3] | 0;
+      this.E = SHA256_IV[4] | 0;
+      this.F = SHA256_IV[5] | 0;
+      this.G = SHA256_IV[6] | 0;
+      this.H = SHA256_IV[7] | 0;
     }
     get() {
       const { A, B, C, D, E, F, G, H } = this;
@@ -29847,26 +29877,26 @@ If you are attempting to transform a hex value, please make sure it is being pas
   };
   var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 
-  // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/hmac.js
+  // ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/hmac.js
   var HMAC = class extends Hash {
-    constructor(hash4, _key) {
+    constructor(hash3, _key) {
       super();
       this.finished = false;
       this.destroyed = false;
-      hash(hash4);
+      hash(hash3);
       const key = toBytes2(_key);
-      this.iHash = hash4.create();
+      this.iHash = hash3.create();
       if (typeof this.iHash.update !== "function")
         throw new Error("Expected instance of class which extends utils.Hash");
       this.blockLen = this.iHash.blockLen;
       this.outputLen = this.iHash.outputLen;
       const blockLen = this.blockLen;
       const pad = new Uint8Array(blockLen);
-      pad.set(key.length > blockLen ? hash4.create().update(key).digest() : key);
+      pad.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
       for (let i = 0; i < pad.length; i++)
         pad[i] ^= 54;
       this.iHash.update(pad);
-      this.oHash = hash4.create();
+      this.oHash = hash3.create();
       for (let i = 0; i < pad.length; i++)
         pad[i] ^= 54 ^ 92;
       this.oHash.update(pad);
@@ -29909,12 +29939,12 @@ If you are attempting to transform a hex value, please make sure it is being pas
       this.iHash.destroy();
     }
   };
-  var hmac = (hash4, key, message) => new HMAC(hash4, key).update(message).digest();
-  hmac.create = (hash4, key) => new HMAC(hash4, key);
+  var hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
+  hmac.create = (hash3, key) => new HMAC(hash3, key);
 
-  // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/pbkdf2.js
-  function pbkdf2Init(hash4, _password, _salt, _opts) {
-    hash(hash4);
+  // ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/pbkdf2.js
+  function pbkdf2Init(hash3, _password, _salt, _opts) {
+    hash(hash3);
     const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
     const { c, dkLen, asyncTick } = opts;
     number(c);
@@ -29925,7 +29955,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     const password = toBytes2(_password);
     const salt = toBytes2(_salt);
     const DK = new Uint8Array(dkLen);
-    const PRF = hmac.create(hash4, password);
+    const PRF = hmac.create(hash3, password);
     const PRFSalt = PRF._cloneInto().update(salt);
     return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
   }
@@ -29937,8 +29967,8 @@ If you are attempting to transform a hex value, please make sure it is being pas
     u.fill(0);
     return DK;
   }
-  function pbkdf2(hash4, password, salt, opts) {
-    const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash4, password, salt, opts);
+  function pbkdf2(hash3, password, salt, opts) {
+    const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash3, password, salt, opts);
     let prfW;
     const arr = new Uint8Array(4);
     const view = createView(arr);
@@ -29957,8 +29987,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
   }
 
-  // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/scrypt.js
-  var rotl = (a, b) => a << b | a >>> 32 - b;
+  // ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/scrypt.js
   function XorAndSalsa(prev, pi, input, ii, out, oi) {
     let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];
     let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];
@@ -30049,8 +30078,8 @@ If you are attempting to transform a hex value, please make sure it is being pas
       throw new Error("progressCb should be function");
     const blockSize = 128 * r;
     const blockSize32 = blockSize / 4;
-    if (N <= 1 || (N & N - 1) !== 0 || N >= 2 ** (blockSize / 8) || N > 2 ** 32) {
-      throw new Error("Scrypt: N must be larger than 1, a power of 2, less than 2^(128 * r / 8) and less than 2^32");
+    if (N <= 1 || (N & N - 1) !== 0 || N > 2 ** 32) {
+      throw new Error("Scrypt: N must be larger than 1, a power of 2, and less than 2^32");
     }
     if (p < 0 || p > (2 ** 32 - 1) * 32 / blockSize) {
       throw new Error("Scrypt: p must be a positive integer less than or equal to ((2^32 - 1) * 32) / (128 * r)");
@@ -30089,6 +30118,8 @@ If you are attempting to transform a hex value, please make sure it is being pas
   }
   function scrypt(password, salt, opts) {
     const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(password, salt, opts);
+    if (!isLE)
+      byteSwap32(B32);
     for (let pi = 0; pi < p; pi++) {
       const Pi2 = blockSize32 * pi;
       for (let i = 0; i < blockSize32; i++)
@@ -30107,10 +30138,12 @@ If you are attempting to transform a hex value, please make sure it is being pas
         blockMixCb();
       }
     }
+    if (!isLE)
+      byteSwap32(B32);
     return scryptOutput(password, dkLen, B, V, tmp);
   }
 
-  // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/_u64.js
+  // ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
   var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
   var _32n = /* @__PURE__ */ BigInt(32);
   function fromBig(n, le = false) {
@@ -30132,8 +30165,10 @@ If you are attempting to transform a hex value, please make sure it is being pas
   var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
   var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
 
-  // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/sha3.js
-  var [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
+  // ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/sha3.js
+  var SHA3_PI = [];
+  var SHA3_ROTL = [];
+  var _SHA3_IOTA = [];
   var _0n = /* @__PURE__ */ BigInt(0);
   var _1n = /* @__PURE__ */ BigInt(1);
   var _2n = /* @__PURE__ */ BigInt(2);
@@ -30215,7 +30250,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
       this.state32 = u32(this.state);
     }
     keccak() {
+      if (!isLE)
+        byteSwap32(this.state32);
       keccakP(this.state32, this.rounds);
+      if (!isLE)
+        byteSwap32(this.state32);
       this.posOut = 0;
       this.pos = 0;
     }
@@ -30265,9 +30304,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
         throw new Error("XOF is not possible for this instance");
       return this.writeInto(out);
     }
-    xof(bytes3) {
-      number(bytes3);
-      return this.xofInto(new Uint8Array(bytes3));
+    xof(bytes2) {
+      number(bytes2);
+      return this.xofInto(new Uint8Array(bytes2));
     }
     digestInto(out) {
       output(out, this);
@@ -30312,9 +30351,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
   var shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
   var shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
 
-  // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/ripemd160.js
+  // ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/ripemd160.js
   var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
-  var Id = /* @__PURE__ */ Uint8Array.from({ length: 16 }, (_, i) => i);
+  var Id = /* @__PURE__ */ new Uint8Array(new Array(16).fill(0).map((_, i) => i));
   var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
   var idxL = [Id];
   var idxR = [Pi];
@@ -30344,7 +30383,6 @@ If you are attempting to transform a hex value, please make sure it is being pas
     2053994217,
     0
   ]);
-  var rotl2 = (word, shift) => word << shift | word >>> 32 - shift;
   function f(group, x, y, z) {
     if (group === 0)
       return x ^ y ^ z;
@@ -30357,8 +30395,8 @@ If you are attempting to transform a hex value, please make sure it is being pas
     else
       return x ^ (y | ~z);
   }
-  var BUF = /* @__PURE__ */ new Uint32Array(16);
-  var RIPEMD160 = class extends SHA2 {
+  var R_BUF = /* @__PURE__ */ new Uint32Array(16);
+  var RIPEMD160 = class extends HashMD {
     constructor() {
       super(64, 20, 8, true);
       this.h0 = 1732584193 | 0;
@@ -30380,7 +30418,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }
     process(view, offset) {
       for (let i = 0; i < 16; i++, offset += 4)
-        BUF[i] = view.getUint32(offset, true);
+        R_BUF[i] = view.getUint32(offset, true);
       let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
       for (let group = 0; group < 5; group++) {
         const rGroup = 4 - group;
@@ -30388,18 +30426,18 @@ If you are attempting to transform a hex value, please make sure it is being pas
         const rl = idxL[group], rr = idxR[group];
         const sl = shiftsL[group], sr = shiftsR[group];
         for (let i = 0; i < 16; i++) {
-          const tl = rotl2(al + f(group, bl, cl, dl) + BUF[rl[i]] + hbl, sl[i]) + el | 0;
-          al = el, el = dl, dl = rotl2(cl, 10) | 0, cl = bl, bl = tl;
+          const tl = rotl(al + f(group, bl, cl, dl) + R_BUF[rl[i]] + hbl, sl[i]) + el | 0;
+          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
         }
         for (let i = 0; i < 16; i++) {
-          const tr2 = rotl2(ar + f(rGroup, br, cr, dr) + BUF[rr[i]] + hbr, sr[i]) + er | 0;
-          ar = er, er = dr, dr = rotl2(cr, 10) | 0, cr = br, br = tr2;
+          const tr2 = rotl(ar + f(rGroup, br, cr, dr) + R_BUF[rr[i]] + hbr, sr[i]) + er | 0;
+          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr2;
         }
       }
       this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
     }
     roundClean() {
-      BUF.fill(0);
+      R_BUF.fill(0);
     }
     destroy() {
       this.destroyed = true;
@@ -30410,12 +30448,12 @@ If you are attempting to transform a hex value, please make sure it is being pas
   var ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());
 
   // ../crypto/dist/index.mjs
-  var import_crypto = __toESM(__require("crypto"), 1);
-  var import_crypto2 = __require("crypto");
-  var import_crypto3 = __toESM(__require("crypto"), 1);
+  var import_crypto2 = __toESM(__require("crypto"), 1);
+  var import_crypto3 = __require("crypto");
   var import_crypto4 = __toESM(__require("crypto"), 1);
-  var import_crypto5 = __require("crypto");
+  var import_crypto5 = __toESM(__require("crypto"), 1);
   var import_crypto6 = __require("crypto");
+  var import_crypto7 = __require("crypto");
   var scrypt2 = (params) => {
     const { password, salt, n, p, r, dklen } = params;
     const derivedKey = scrypt(password, salt, { N: n, r, p, dkLen: dklen });
@@ -30430,10 +30468,10 @@ If you are attempting to transform a hex value, please make sure it is being pas
   function pbkdf22(_password, _salt, iterations, keylen, algo) {
     const password = arrayify(_password, "password");
     const salt = arrayify(_salt, "salt");
-    return hexlify((0, import_crypto2.pbkdf2Sync)(password, salt, iterations, keylen, algo));
+    return hexlify((0, import_crypto3.pbkdf2Sync)(password, salt, iterations, keylen, algo));
   }
-  var randomBytes = (length) => {
-    const randomValues = Uint8Array.from(import_crypto3.default.randomBytes(length));
+  var randomBytes2 = (length) => {
+    const randomValues = Uint8Array.from(import_crypto4.default.randomBytes(length));
     return randomValues;
   };
   var stringFromBuffer = (buffer, encoding = "base64") => Buffer.from(buffer).toString(encoding);
@@ -30444,11 +30482,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
     return arrayify(key);
   };
   var encrypt = async (password, data) => {
-    const iv = randomBytes(16);
-    const salt = randomBytes(32);
+    const iv = randomBytes2(16);
+    const salt = randomBytes2(32);
     const secret = keyFromPassword(password, salt);
     const dataBuffer = Uint8Array.from(Buffer.from(JSON.stringify(data), "utf-8"));
-    const cipher = await import_crypto.default.createCipheriv(ALGORITHM, secret, iv);
+    const cipher = await import_crypto2.default.createCipheriv(ALGORITHM, secret, iv);
     let cipherData = cipher.update(dataBuffer);
     cipherData = Buffer.concat([cipherData, cipher.final()]);
     return {
@@ -30462,7 +30500,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     const salt = bufferFromString(keystore.salt);
     const secret = keyFromPassword(password, salt);
     const encryptedText = bufferFromString(keystore.data);
-    const decipher = await import_crypto.default.createDecipheriv(ALGORITHM, secret, iv);
+    const decipher = await import_crypto2.default.createDecipheriv(ALGORITHM, secret, iv);
     const decrypted = decipher.update(encryptedText);
     const deBuff = Buffer.concat([decrypted, decipher.final()]);
     const decryptedData = Buffer.from(deBuff).toString("utf-8");
@@ -30473,28 +30511,28 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }
   };
   async function encryptJsonWalletData(data, key, iv) {
-    const cipher = await import_crypto4.default.createCipheriv("aes-128-ctr", key.subarray(0, 16), iv);
+    const cipher = await import_crypto5.default.createCipheriv("aes-128-ctr", key.subarray(0, 16), iv);
     const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
     return new Uint8Array(encrypted);
   }
   async function decryptJsonWalletData(data, key, iv) {
-    const decipher = import_crypto4.default.createDecipheriv("aes-128-ctr", key.subarray(0, 16), iv);
+    const decipher = import_crypto5.default.createDecipheriv("aes-128-ctr", key.subarray(0, 16), iv);
     const decrypted = await Buffer.concat([decipher.update(data), decipher.final()]);
     return new Uint8Array(decrypted);
   }
   function computeHmac(algorithm, _key, _data) {
     const key = arrayify(_key, "key");
     const data = arrayify(_data, "data");
-    return hexlify((0, import_crypto5.createHmac)(algorithm, key).update(data).digest());
+    return hexlify((0, import_crypto6.createHmac)(algorithm, key).update(data).digest());
   }
-  var randomUUID = () => (0, import_crypto6.randomUUID)();
+  var randomUUID = () => (0, import_crypto7.randomUUID)();
   var api = {
     bufferFromString,
     stringFromBuffer,
     decrypt,
     encrypt,
     keyFromPassword,
-    randomBytes,
+    randomBytes: randomBytes2,
     scrypt: scrypt2,
     keccak256,
     decryptJsonWalletData,
@@ -30510,7 +30548,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     decrypt: decrypt2,
     encrypt: encrypt2,
     keyFromPassword: keyFromPassword2,
-    randomBytes: randomBytes2,
+    randomBytes: randomBytes22,
     stringFromBuffer: stringFromBuffer2,
     scrypt: scrypt22,
     keccak256: keccak2562,
@@ -30574,9 +30612,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
   var STR_SLICE_CODER_TYPE = "str";
   var VOID_TYPE = "()";
   var optionRegEx = /^enum (std::option::)?Option$/m;
-  var stringRegEx = /str\[(?<length>[0-9]+)\]/;
-  var arrayRegEx = /\[(?<item>[\w\s\\[\]]+);\s*(?<length>[0-9]+)\]/;
-  var structRegEx = /struct.+/;
+  var stringRegEx = /^str\[(?<length>[0-9]+)\]/;
+  var arrayRegEx = /^\[(?<item>[\w\s\\[\]]+);\s*(?<length>[0-9]+)\]/;
+  var structRegEx = /^struct.+/;
   var enumRegEx = /^enum.+$/;
   var tupleRegEx = /^\((?<items>.*)\)$/;
   var genericRegEx = /^generic.+$/;
@@ -30692,15 +30730,15 @@ If you are attempting to transform a hex value, please make sure it is being pas
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid b256 data size.`);
       }
-      let bytes3 = data.slice(offset, offset + this.encodedLength);
-      const decoded = bn(bytes3);
+      let bytes2 = data.slice(offset, offset + this.encodedLength);
+      const decoded = bn(bytes2);
       if (decoded.isZero()) {
-        bytes3 = new Uint8Array(32);
+        bytes2 = new Uint8Array(32);
       }
-      if (bytes3.length !== this.encodedLength) {
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid b256 byte data size.`);
       }
-      return [toHex(bytes3, 32), offset + 32];
+      return [toHex(bytes2, 32), offset + 32];
     }
   };
   var B512Coder = class extends Coder {
@@ -30723,15 +30761,15 @@ If you are attempting to transform a hex value, please make sure it is being pas
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid b512 data size.`);
       }
-      let bytes3 = data.slice(offset, offset + this.encodedLength);
-      const decoded = bn(bytes3);
+      let bytes2 = data.slice(offset, offset + this.encodedLength);
+      const decoded = bn(bytes2);
       if (decoded.isZero()) {
-        bytes3 = new Uint8Array(64);
+        bytes2 = new Uint8Array(64);
       }
-      if (bytes3.length !== this.encodedLength) {
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid b512 byte data size.`);
       }
-      return [toHex(bytes3, this.encodedLength), offset + this.encodedLength];
+      return [toHex(bytes2, this.encodedLength), offset + this.encodedLength];
     }
   };
   var encodedLengths = {
@@ -30743,24 +30781,24 @@ If you are attempting to transform a hex value, please make sure it is being pas
       super("bigNumber", baseType, encodedLengths[baseType]);
     }
     encode(value) {
-      let bytes3;
+      let bytes2;
       try {
-        bytes3 = toBytes(value, this.encodedLength);
+        bytes2 = toBytes(value, this.encodedLength);
       } catch (error) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.type}.`);
       }
-      return bytes3;
+      return bytes2;
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} data size.`);
       }
-      let bytes3 = data.slice(offset, offset + this.encodedLength);
-      bytes3 = bytes3.slice(0, this.encodedLength);
-      if (bytes3.length !== this.encodedLength) {
+      let bytes2 = data.slice(offset, offset + this.encodedLength);
+      bytes2 = bytes2.slice(0, this.encodedLength);
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} byte data size.`);
       }
-      return [bn(bytes3), offset + this.encodedLength];
+      return [bn(bytes2), offset + this.encodedLength];
     }
   };
   var BooleanCoder = class extends Coder {
@@ -30783,11 +30821,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean data size.`);
       }
-      const bytes3 = bn(data.slice(offset, offset + this.encodedLength));
-      if (bytes3.isZero()) {
+      const bytes2 = bn(data.slice(offset, offset + this.encodedLength));
+      if (bytes2.isZero()) {
         return [false, offset + this.encodedLength];
       }
-      if (!bytes3.eq(bn(1))) {
+      if (!bytes2.eq(bn(1))) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean value.`);
       }
       return [true, offset + this.encodedLength];
@@ -30798,9 +30836,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
       super("struct", "struct Bytes", WORD_SIZE);
     }
     encode(value) {
-      const bytes3 = value instanceof Uint8Array ? value : new Uint8Array(value);
-      const lengthBytes = new BigNumberCoder("u64").encode(bytes3.length);
-      return new Uint8Array([...lengthBytes, ...bytes3]);
+      const bytes2 = value instanceof Uint8Array ? value : new Uint8Array(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
     }
     decode(data, offset) {
       if (data.length < WORD_SIZE) {
@@ -30922,26 +30960,26 @@ If you are attempting to transform a hex value, please make sure it is being pas
       this.options = options;
     }
     encode(value) {
-      let bytes3;
+      let bytes2;
       try {
-        bytes3 = toBytes(value);
+        bytes2 = toBytes(value);
       } catch (error) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}.`);
       }
-      if (bytes3.length > this.encodedLength) {
+      if (bytes2.length > this.encodedLength) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}, too many bytes.`);
       }
-      return toBytes(bytes3, this.encodedLength);
+      return toBytes(bytes2, this.encodedLength);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number data size.`);
       }
-      const bytes3 = data.slice(offset, offset + this.encodedLength);
-      if (bytes3.length !== this.encodedLength) {
+      const bytes2 = data.slice(offset, offset + this.encodedLength);
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number byte data size.`);
       }
-      return [toNumber(bytes3), offset + this.encodedLength];
+      return [toNumber(bytes2), offset + this.encodedLength];
     }
   };
   var OptionCoder = class extends EnumCoder {
@@ -30959,9 +30997,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
       const [decoded, newOffset] = super.decode(data, offset);
       return [this.toOption(decoded), newOffset];
     }
-    toOption(output3) {
-      if (output3 && "Some" in output3) {
-        return output3.Some;
+    toOption(output2) {
+      if (output2 && "Some" in output2) {
+        return output2.Some;
       }
       return void 0;
     }
@@ -30975,9 +31013,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
       }
       const internalCoder = new ArrayCoder(new NumberCoder("u8"), value.length);
-      const bytes3 = internalCoder.encode(value);
-      const lengthBytes = new BigNumberCoder("u64").encode(bytes3.length);
-      return new Uint8Array([...lengthBytes, ...bytes3]);
+      const bytes2 = internalCoder.encode(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -31000,9 +31038,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
       super("struct", "struct String", WORD_SIZE);
     }
     encode(value) {
-      const bytes3 = toUtf8Bytes(value);
+      const bytes2 = toUtf8Bytes(value);
       const lengthBytes = new BigNumberCoder("u64").encode(value.length);
-      return new Uint8Array([...lengthBytes, ...bytes3]);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -31024,9 +31062,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
       super("strSlice", "str", WORD_SIZE);
     }
     encode(value) {
-      const bytes3 = toUtf8Bytes(value);
+      const bytes2 = toUtf8Bytes(value);
       const lengthBytes = new BigNumberCoder("u64").encode(value.length);
-      return new Uint8Array([...lengthBytes, ...bytes3]);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -31035,11 +31073,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
       const offsetAndLength = offset + WORD_SIZE;
       const lengthBytes = data.slice(offset, offsetAndLength);
       const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
-      const bytes3 = data.slice(offsetAndLength, offsetAndLength + length);
-      if (bytes3.length !== length) {
+      const bytes2 = data.slice(offsetAndLength, offsetAndLength + length);
+      if (bytes2.length !== length) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string slice byte data size.`);
       }
-      return [toUtf8String(bytes3), offsetAndLength + length];
+      return [toUtf8String(bytes2), offsetAndLength + length];
     }
   };
   __publicField4(StrSliceCoder, "memorySize", 1);
@@ -31057,11 +31095,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string data size.`);
       }
-      const bytes3 = data.slice(offset, offset + this.encodedLength);
-      if (bytes3.length !== this.encodedLength) {
+      const bytes2 = data.slice(offset, offset + this.encodedLength);
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string byte data size.`);
       }
-      return [toUtf8String(bytes3), offset + this.encodedLength];
+      return [toUtf8String(bytes2), offset + this.encodedLength];
     }
   };
   var StructCoder = class extends Coder {
@@ -31155,9 +31193,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
       if (isUint8Array(value)) {
         return new Uint8Array([...lengthCoder.encode(value.length), ...value]);
       }
-      const bytes3 = value.map((v) => this.coder.encode(v));
+      const bytes2 = value.map((v) => this.coder.encode(v));
       const lengthBytes = lengthCoder.encode(value.length);
-      return new Uint8Array([...lengthBytes, ...concatBytes(bytes3)]);
+      return new Uint8Array([...lengthBytes, ...concatBytes(bytes2)]);
     }
     decode(data, offset) {
       if (!this.#hasNestedOption && data.length < this.encodedLength || data.length > MAX_BYTES) {
@@ -31545,10 +31583,10 @@ If you are attempting to transform a hex value, please make sure it is being pas
       return new TupleCoder(coders).encode(argumentValues);
     }
     decodeArguments(data) {
-      const bytes3 = arrayify(data);
+      const bytes2 = arrayify(data);
       const nonVoidInputs = findNonVoidInputs(this.jsonAbiOld, this.jsonFnOld.inputs);
       if (nonVoidInputs.length === 0) {
-        if (bytes3.length === 0) {
+        if (bytes2.length === 0) {
           return void 0;
         }
         throw new FuelError(
@@ -31557,12 +31595,12 @@ If you are attempting to transform a hex value, please make sure it is being pas
             count: {
               types: this.jsonFn.inputs.length,
               nonVoidInputs: nonVoidInputs.length,
-              values: bytes3.length
+              values: bytes2.length
             },
             value: {
               args: this.jsonFn.inputs,
               nonVoidInputs,
-              values: bytes3
+              values: bytes2
             }
           })}`
         );
@@ -31570,7 +31608,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
       const result = this.jsonFnOld.inputs.reduce(
         (obj, input) => {
           const coder = AbiCoder.getCoder(this.jsonAbiOld, input, { encoding: this.encoding });
-          const [decodedValue, decodedValueByteSize] = coder.decode(bytes3, obj.offset);
+          const [decodedValue, decodedValueByteSize] = coder.decode(bytes2, obj.offset);
           return {
             decoded: [...obj.decoded, decodedValue],
             offset: obj.offset + decodedValueByteSize
@@ -31581,11 +31619,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
       return result.decoded;
     }
     decodeOutput(data) {
-      const bytes3 = arrayify(data);
+      const bytes2 = arrayify(data);
       const coder = AbiCoder.getCoder(this.jsonAbiOld, this.jsonFnOld.output, {
         encoding: this.encoding
       });
-      return coder.decode(bytes3, 0);
+      return coder.decode(bytes2, 0);
     }
     /**
      * Checks if the function is read-only i.e. it only reads from storage, does not write to it.
@@ -31673,8 +31711,8 @@ If you are attempting to transform a hex value, please make sure it is being pas
       const inputs = fn.inputs.map(
         ({ concreteTypeId, name }) => parseConcreteType(abi, types, concreteTypeId, name)
       );
-      const output3 = parseConcreteType(abi, types, fn.output, "");
-      return { ...fn, inputs, output: output3 };
+      const output2 = parseConcreteType(abi, types, fn.output, "");
+      return { ...fn, inputs, output: output2 };
     });
     const configurables = abi.configurables.map((conf) => ({
       name: conf.name,
@@ -31836,9 +31874,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }
     return addressLike;
   };
-  var getRandomB256 = () => hexlify(randomBytes2(32));
+  var getRandomB256 = () => hexlify(randomBytes22(32));
   var clearFirst12BytesFromB256 = (b256) => {
-    let bytes3;
+    let bytes2;
     try {
       if (!isB256(b256)) {
         throw new FuelError(
@@ -31846,15 +31884,15 @@ If you are attempting to transform a hex value, please make sure it is being pas
           `Invalid Bech32 Address: ${b256}.`
         );
       }
-      bytes3 = getBytesFromBech32(toBech32(b256));
-      bytes3 = hexlify(bytes3.fill(0, 0, 12));
+      bytes2 = getBytesFromBech32(toBech32(b256));
+      bytes2 = hexlify(bytes2.fill(0, 0, 12));
     } catch (error) {
       throw new FuelError(
         FuelError.CODES.PARSE_FAILED,
         `Cannot generate EVM Address B256 from: ${b256}.`
       );
     }
-    return bytes3;
+    return bytes2;
   };
   var padFirst12BytesOfEvmAddress = (address) => {
     if (!isEvmAddress(address)) {
@@ -32255,9 +32293,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
       return sha2562(concat(parts));
     }
     static encodeData(messageData) {
-      const bytes3 = arrayify(messageData || "0x");
-      const dataLength = bytes3.length;
-      return new ByteArrayCoder(dataLength).encode(bytes3);
+      const bytes2 = arrayify(messageData || "0x");
+      const dataLength = bytes2.length;
+      return new ByteArrayCoder(dataLength).encode(bytes2);
     }
     encode(value) {
       const parts = [];
@@ -32279,9 +32317,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
       return concat(parts);
     }
     static decodeData(messageData) {
-      const bytes3 = arrayify(messageData);
-      const dataLength = bytes3.length;
-      const [data] = new ByteArrayCoder(dataLength).decode(bytes3, 0);
+      const bytes2 = arrayify(messageData);
+      const dataLength = bytes2.length;
+      const [data] = new ByteArrayCoder(dataLength).decode(bytes2, 0);
       return arrayify(data);
     }
     decode(data, offset) {
@@ -32723,6 +32761,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
       });
     }
   };
+  var UpgradePurposeTypeEnum = /* @__PURE__ */ ((UpgradePurposeTypeEnum2) => {
+    UpgradePurposeTypeEnum2[UpgradePurposeTypeEnum2["ConsensusParameters"] = 0] = "ConsensusParameters";
+    UpgradePurposeTypeEnum2[UpgradePurposeTypeEnum2["StateTransition"] = 1] = "StateTransition";
+    return UpgradePurposeTypeEnum2;
+  })(UpgradePurposeTypeEnum || {});
   var UpgradePurposeCoder = class extends Coder {
     constructor() {
       super("UpgradePurpose", "UpgradePurpose", 0);
@@ -33453,9 +33496,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
     return coinQuantities;
   };
 
-  // ../../node_modules/.pnpm/@noble+curves@1.4.2/node_modules/@noble/curves/esm/abstract/utils.js
+  // ../../node_modules/.pnpm/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/utils.js
   var utils_exports = {};
   __export(utils_exports, {
+    aInRange: () => aInRange,
+    abool: () => abool,
     abytes: () => abytes,
     bitGet: () => bitGet,
     bitLen: () => bitLen,
@@ -33464,13 +33509,16 @@ If you are attempting to transform a hex value, please make sure it is being pas
     bytesToHex: () => bytesToHex,
     bytesToNumberBE: () => bytesToNumberBE,
     bytesToNumberLE: () => bytesToNumberLE,
-    concatBytes: () => concatBytes2,
+    concatBytes: () => concatBytes3,
     createHmacDrbg: () => createHmacDrbg,
     ensureBytes: () => ensureBytes,
     equalBytes: () => equalBytes,
     hexToBytes: () => hexToBytes,
     hexToNumber: () => hexToNumber,
-    isBytes: () => isBytes3,
+    inRange: () => inRange,
+    isBytes: () => isBytes2,
+    memoized: () => memoized,
+    notImplemented: () => notImplemented,
     numberToBytesBE: () => numberToBytesBE,
     numberToBytesLE: () => numberToBytesLE,
     numberToHexUnpadded: () => numberToHexUnpadded,
@@ -33481,19 +33529,23 @@ If you are attempting to transform a hex value, please make sure it is being pas
   var _0n2 = /* @__PURE__ */ BigInt(0);
   var _1n2 = /* @__PURE__ */ BigInt(1);
   var _2n2 = /* @__PURE__ */ BigInt(2);
-  function isBytes3(a) {
+  function isBytes2(a) {
     return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
   }
   function abytes(item) {
-    if (!isBytes3(item))
+    if (!isBytes2(item))
       throw new Error("Uint8Array expected");
   }
+  function abool(title, value) {
+    if (typeof value !== "boolean")
+      throw new Error(`${title} must be valid boolean, got "${value}".`);
+  }
   var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-  function bytesToHex(bytes3) {
-    abytes(bytes3);
+  function bytesToHex(bytes2) {
+    abytes(bytes2);
     let hex = "";
-    for (let i = 0; i < bytes3.length; i++) {
-      hex += hexes[bytes3[i]];
+    for (let i = 0; i < bytes2.length; i++) {
+      hex += hexes[bytes2[i]];
     }
     return hex;
   }
@@ -33535,12 +33587,12 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }
     return array;
   }
-  function bytesToNumberBE(bytes3) {
-    return hexToNumber(bytesToHex(bytes3));
+  function bytesToNumberBE(bytes2) {
+    return hexToNumber(bytesToHex(bytes2));
   }
-  function bytesToNumberLE(bytes3) {
-    abytes(bytes3);
-    return hexToNumber(bytesToHex(Uint8Array.from(bytes3).reverse()));
+  function bytesToNumberLE(bytes2) {
+    abytes(bytes2);
+    return hexToNumber(bytesToHex(Uint8Array.from(bytes2).reverse()));
   }
   function numberToBytesBE(n, len) {
     return hexToBytes(n.toString(16).padStart(len * 2, "0"));
@@ -33559,7 +33611,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
       } catch (e) {
         throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
       }
-    } else if (isBytes3(hex)) {
+    } else if (isBytes2(hex)) {
       res = Uint8Array.from(hex);
     } else {
       throw new Error(`${title} must be hex string or Uint8Array`);
@@ -33569,7 +33621,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
       throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
     return res;
   }
-  function concatBytes2(...arrays) {
+  function concatBytes3(...arrays) {
     let sum = 0;
     for (let i = 0; i < arrays.length; i++) {
       const a = arrays[i];
@@ -33597,6 +33649,14 @@ If you are attempting to transform a hex value, please make sure it is being pas
       throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
     return new Uint8Array(new TextEncoder().encode(str));
   }
+  var isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
+  function inRange(n, min, max) {
+    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
+  }
+  function aInRange(title, n, min, max) {
+    if (!inRange(n, min, max))
+      throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
+  }
   function bitLen(n) {
     let len;
     for (len = 0; n > _0n2; n >>= _1n2, len += 1)
@@ -33647,7 +33707,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
         out.push(sl);
         len += v.length;
       }
-      return concatBytes2(...out);
+      return concatBytes3(...out);
     };
     const genUntil = (seed, pred) => {
       reset();
@@ -33665,7 +33725,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     function: (val) => typeof val === "function",
     boolean: (val) => typeof val === "boolean",
     string: (val) => typeof val === "string",
-    stringOrUint8Array: (val) => typeof val === "string" || isBytes3(val),
+    stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
     isSafeInteger: (val) => Number.isSafeInteger(val),
     array: (val) => Array.isArray(val),
     field: (val, object) => object.Fp.isValid(val),
@@ -33689,6 +33749,20 @@ If you are attempting to transform a hex value, please make sure it is being pas
       checkField(fieldName, type3, true);
     return object;
   }
+  var notImplemented = () => {
+    throw new Error("not implemented");
+  };
+  function memoized(fn) {
+    const map = /* @__PURE__ */ new WeakMap();
+    return (arg, ...args) => {
+      const val = map.get(arg);
+      if (val !== void 0)
+        return val;
+      const computed = fn(arg, ...args);
+      map.set(arg, computed);
+      return computed;
+    };
+  }
 
   // src/providers/provider.ts
   var import_graphql_request = __toESM(require_dist2());
@@ -33911,19 +33985,19 @@ If you are attempting to transform a hex value, please make sure it is being pas
       return "GraphQLError";
     }
     toString() {
-      let output3 = this.message;
+      let output2 = this.message;
       if (this.nodes) {
         for (const node of this.nodes) {
           if (node.loc) {
-            output3 += "\n\n" + printLocation(node.loc);
+            output2 += "\n\n" + printLocation(node.loc);
           }
         }
       } else if (this.source && this.locations) {
         for (const location of this.locations) {
-          output3 += "\n\n" + printSourceLocation(this.source, location);
+          output2 += "\n\n" + printSourceLocation(this.source, location);
         }
       }
-      return output3;
+      return output2;
     }
     toJSON() {
       const formattedError = {
@@ -38454,7 +38528,7 @@ ${MessageFragmentDoc}`;
   }
 
   // src/providers/utils/block-explorer.ts
-  var DEFAULT_BLOCK_EXPLORER_URL = "https://fuellabs.github.io/block-explorer-v2";
+  var DEFAULT_BLOCK_EXPLORER_URL = "https://app.fuel.network";
   var getPathFromInput = (key, value) => {
     const pathMap = {
       address: `address`,
@@ -38611,6 +38685,39 @@ ${MessageFragmentDoc}`;
     const blobLen = resolveGasDependentCosts(witnessBytesSize, gasCosts.s256);
     return txId.add(blobLen);
   }
+  function calculateMetadataGasForTxUpgrade({
+    gasCosts,
+    txBytesSize,
+    consensusSize
+  }) {
+    const txId = resolveGasDependentCosts(txBytesSize, gasCosts.s256);
+    if (consensusSize) {
+      const consensusLen = resolveGasDependentCosts(consensusSize, gasCosts.s256);
+      txId.add(consensusLen);
+    }
+    return txId;
+  }
+  function calculateMetadataGasForTxUpload({
+    gasCosts,
+    txBytesSize,
+    subsectionSize,
+    subsectionsSize
+  }) {
+    const txId = resolveGasDependentCosts(txBytesSize, gasCosts.s256);
+    const subsectionLen = resolveGasDependentCosts(subsectionSize, gasCosts.s256);
+    txId.add(subsectionLen);
+    const subsectionsLen = resolveGasDependentCosts(subsectionsSize, gasCosts.stateRoot);
+    txId.add(subsectionsLen);
+    return txId;
+  }
+  function calculateMinGasForTxUpload({
+    gasCosts,
+    baseMinGas,
+    subsectionSize
+  }) {
+    const additionalStoragePerByte = bn(gasCosts.newStoragePerByte).mul(subsectionSize);
+    return bn(baseMinGas).add(additionalStoragePerByte);
+  }
   var calculateGasFee = (params) => {
     const { gas, gasPrice, priceFactor, tip } = params;
     return gas.mul(gasPrice).div(priceFactor).add(bn(tip));
@@ -38909,8 +39016,8 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      *
      * Pushes an output to the list without any side effects and returns the index
      */
-    pushOutput(output3) {
-      this.outputs.push(output3);
+    pushOutput(output2) {
+      this.outputs.push(output2);
       return this.outputs.length - 1;
     }
     /**
@@ -38994,7 +39101,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     getCoinOutputs() {
       return this.outputs.filter(
-        (output3) => output3.type === OutputType.Coin
+        (output2) => output2.type === OutputType.Coin
       );
     }
     /**
@@ -39004,7 +39111,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     getChangeOutputs() {
       return this.outputs.filter(
-        (output3) => output3.type === OutputType.Change
+        (output2) => output2.type === OutputType.Change
       );
     }
     /**
@@ -39157,7 +39264,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     addChangeOutput(to, assetId) {
       const changeOutput = this.getChangeOutputs().find(
-        (output3) => hexlify(output3.assetId) === assetId
+        (output2) => hexlify(output2.assetId) === assetId
       );
       if (!changeOutput) {
         this.pushOutput({
@@ -39237,12 +39344,12 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
           usedQuantity = bn("1000000000000000000");
         }
         if (assetInput && "assetId" in assetInput) {
-          assetInput.id = hexlify(randomBytes2(UTXO_ID_LEN));
+          assetInput.id = hexlify(randomBytes22(UTXO_ID_LEN));
           assetInput.amount = usedQuantity;
         } else {
           this.addResources([
             {
-              id: hexlify(randomBytes2(UTXO_ID_LEN)),
+              id: hexlify(randomBytes22(UTXO_ID_LEN)),
               amount: usedQuantity,
               assetId,
               owner: resourcesOwner || Address.fromRandom(),
@@ -39342,8 +39449,8 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
           return inputClone;
       }
     });
-    transaction.outputs = transaction.outputs.map((output3) => {
-      const outputClone = clone_default(output3);
+    transaction.outputs = transaction.outputs.map((output2) => {
+      const outputClone = clone_default(output2);
       switch (outputClone.type) {
         case OutputType.Contract: {
           outputClone.balanceRoot = ZeroBytes32;
@@ -39503,7 +39610,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     getContractCreatedOutputs() {
       return this.outputs.filter(
-        (output3) => output3.type === OutputType.ContractCreated
+        (output2) => output2.type === OutputType.ContractCreated
       );
     }
     /**
@@ -39626,7 +39733,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     getContractOutputs() {
       return this.outputs.filter(
-        (output3) => output3.type === OutputType.Contract
+        (output2) => output2.type === OutputType.Contract
       );
     }
     /**
@@ -39636,7 +39743,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     getVariableOutputs() {
       return this.outputs.filter(
-        (output3) => output3.type === OutputType.Variable
+        (output2) => output2.type === OutputType.Variable
       );
     }
     /**
@@ -39743,9 +39850,257 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     }
   };
 
+  // src/providers/transaction-request/upgrade-transaction-request.ts
+  var UpgradeTransactionRequest = class extends BaseTransactionRequest {
+    static from(obj) {
+      if (obj instanceof UpgradeTransactionRequest) {
+        return obj;
+      }
+      return new this(clone_default(obj));
+    }
+    /** The type of transaction */
+    type = TransactionType.Upgrade;
+    /** The upgrade purpose */
+    upgradePurpose;
+    /** Witness index of consensus */
+    bytecodeWitnessIndex;
+    /**
+     * Creates an instance `UpgradeTransactionRequest`.
+     *
+     * @param upgradeTransactionRequestLike - The initial values for the instance
+     */
+    constructor({
+      upgradePurpose,
+      bytecodeWitnessIndex,
+      ...rest
+    } = {}) {
+      super(rest);
+      this.bytecodeWitnessIndex = bytecodeWitnessIndex ?? 0;
+      this.upgradePurpose = upgradePurpose ?? {
+        type: UpgradePurposeTypeEnum.ConsensusParameters,
+        checksum: "0x"
+      };
+    }
+    /**
+     * Adds a consensus parameters upgrade purpose.
+     *
+     * @param consensus - The consensus bytecode.
+     *
+     * @returns - The current instance of `UpgradeTransactionRequest`.
+     */
+    addConsensusParametersUpgradePurpose(consensus) {
+      this.bytecodeWitnessIndex = this.addWitness(consensus);
+      this.upgradePurpose = {
+        type: UpgradePurposeTypeEnum.ConsensusParameters,
+        checksum: hash2(consensus)
+      };
+      return this;
+    }
+    /**
+     * Adds a state transition upgrade purpose.
+     *
+     * @param bytecodeRoot - The Merkle root of the state transition.
+     *
+     * @returns - The current instance of `UpgradeTransactionRequest`.
+     */
+    addStateTransitionUpgradePurpose(bytecodeRoot) {
+      this.upgradePurpose = {
+        type: UpgradePurposeTypeEnum.StateTransition,
+        data: hexlify(bytecodeRoot)
+      };
+      return this;
+    }
+    /**
+     * Adds an upgrade purpose.
+     *
+     * @param type - The upgrade purpose type.
+     * @param data - The bytecode or merkle root of upgrade purpose
+     *
+     * @returns - The current instance of `UpgradeTransactionRequest`.
+     */
+    addUpgradePurpose(type3, data) {
+      if (type3 === UpgradePurposeTypeEnum.ConsensusParameters) {
+        this.addConsensusParametersUpgradePurpose(data);
+      }
+      if (type3 === UpgradePurposeTypeEnum.StateTransition) {
+        this.addStateTransitionUpgradePurpose(data);
+      }
+      return this;
+    }
+    /**
+     * Converts the transaction request to a `TransactionUpgrade`.
+     *
+     * @returns The transaction create object.
+     */
+    toTransaction() {
+      let upgradePurpose;
+      if (this.upgradePurpose.type === UpgradePurposeTypeEnum.ConsensusParameters) {
+        upgradePurpose = {
+          type: UpgradePurposeTypeEnum.ConsensusParameters,
+          data: {
+            witnessIndex: this.bytecodeWitnessIndex,
+            checksum: this.upgradePurpose.checksum
+          }
+        };
+      } else if (this.upgradePurpose.type === UpgradePurposeTypeEnum.StateTransition) {
+        upgradePurpose = {
+          type: UpgradePurposeTypeEnum.StateTransition,
+          data: {
+            bytecodeRoot: hexlify(this.upgradePurpose.data)
+          }
+        };
+      } else {
+        throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Invalid upgrade purpose");
+      }
+      return {
+        type: TransactionType.Upgrade,
+        ...super.getBaseTransaction(),
+        upgradePurpose
+      };
+    }
+    /**
+     * Gets the Transaction ID by hashing the transaction
+     *
+     * @param chainId - The chain ID.
+     *
+     * @returns - A hash of the transaction, which is the transaction ID.
+     */
+    getTransactionId(chainId) {
+      return hashTransaction(this, chainId);
+    }
+    /**
+     * Calculates the metadata gas cost for an upgrade transaction.
+     *
+     * @param gasCosts - gas costs passed from the chain.
+     *
+     * @returns metadata gas cost for the upgrade transaction.
+     */
+    metadataGas(gasCosts) {
+      const txBytesSize = this.byteSize();
+      if (this.upgradePurpose.type === UpgradePurposeTypeEnum.ConsensusParameters) {
+        const witnessIndex = this.bytecodeWitnessIndex;
+        const consensusSize = this.witnesses[witnessIndex].length;
+        return calculateMetadataGasForTxUpgrade({
+          gasCosts,
+          txBytesSize,
+          consensusSize
+        });
+      }
+      if (this.upgradePurpose.type === UpgradePurposeTypeEnum.StateTransition) {
+        return calculateMetadataGasForTxUpgrade({
+          gasCosts,
+          txBytesSize
+        });
+      }
+      throw new FuelError(FuelError.CODES.NOT_IMPLEMENTED, "Invalid upgrade purpose");
+    }
+  };
+
+  // src/providers/transaction-request/upload-transaction-request.ts
+  var UploadTransactionRequest = class extends BaseTransactionRequest {
+    static from(obj) {
+      if (obj instanceof UploadTransactionRequest) {
+        return obj;
+      }
+      return new this(clone_default(obj));
+    }
+    /** Type of the transaction */
+    type = TransactionType.Upload;
+    /** The witness index of the subsection of the bytecode. */
+    witnessIndex;
+    /** The subsection data. */
+    subsection;
+    /**
+     * Creates an instance `UploadTransactionRequest`.
+     *
+     * @param uploadTransactionRequestLike - The initial values for the instance
+     */
+    constructor({ witnessIndex, subsection, ...rest } = {}) {
+      super(rest);
+      this.witnessIndex = witnessIndex ?? 0;
+      this.subsection = subsection ?? {
+        proofSet: [],
+        root: ZeroBytes32,
+        subsectionIndex: 0,
+        subsectionsNumber: 0
+      };
+    }
+    /**
+     * Adds the subsection.
+     *
+     * @param subsection - The subsection data.
+     */
+    addSubsection(subsection) {
+      const { subsection: subsectionBytecode, ...rest } = subsection;
+      this.subsection = rest;
+      this.witnessIndex = this.addWitness(subsectionBytecode);
+    }
+    /**
+     * Gets the Transaction Request by hashing the transaction.
+     *
+     * @param chainId - The chain ID.
+     *
+     * @returns - A hash of the transaction, which is the transaction ID.
+     */
+    getTransactionId(chainId) {
+      return hashTransaction(this, chainId);
+    }
+    /**
+     * Converts the transaction request to a `TransactionUpload`.
+     *
+     * @returns The transaction create object.
+     */
+    toTransaction() {
+      const baseTransaction = this.getBaseTransaction();
+      const { subsectionIndex, subsectionsNumber, root, proofSet } = this.subsection;
+      return {
+        type: TransactionType.Upload,
+        ...baseTransaction,
+        subsectionIndex,
+        subsectionsNumber,
+        root: hexlify(root),
+        proofSet: proofSet.map(hexlify),
+        witnessIndex: this.witnessIndex,
+        proofSetCount: proofSet.length
+      };
+    }
+    /**
+     * Calculates the metadata gas cost for an upload transaction.
+     *
+     * @param gasCosts - gas costs passed from the chain.
+     *
+     * @returns metadata gas cost for the upload transaction.
+     */
+    metadataGas(gasCosts) {
+      return calculateMetadataGasForTxUpload({
+        gasCosts,
+        txBytesSize: this.byteSize(),
+        subsectionSize: arrayify(this.witnesses[this.witnessIndex]).length,
+        subsectionsSize: this.subsection.subsectionsNumber
+      });
+    }
+    /**
+     * Calculates the minimum gas for an upload transaction.
+     *
+     * @param chainInfo - The chain information.
+     *
+     * @returns the minimum gas for the upload transaction
+     */
+    calculateMinGas(chainInfo) {
+      const minGas = super.calculateMinGas(chainInfo);
+      const { gasCosts } = chainInfo.consensusParameters;
+      const bytecode = this.witnesses[this.witnessIndex] ?? ZeroBytes32;
+      return calculateMinGasForTxUpload({
+        gasCosts,
+        baseMinGas: minGas.toNumber(),
+        subsectionSize: arrayify(bytecode).length
+      });
+    }
+  };
+
   // src/providers/transaction-request/utils.ts
   var transactionRequestify = (obj) => {
-    if (obj instanceof ScriptTransactionRequest || obj instanceof CreateTransactionRequest || obj instanceof BlobTransactionRequest) {
+    if (obj instanceof ScriptTransactionRequest || obj instanceof CreateTransactionRequest || obj instanceof BlobTransactionRequest || obj instanceof UpgradeTransactionRequest || obj instanceof UploadTransactionRequest) {
       return obj;
     }
     const { type: type3 } = obj;
@@ -39759,6 +40114,12 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       case TransactionType.Blob: {
         return BlobTransactionRequest.from(obj);
       }
+      case TransactionType.Upgrade: {
+        return UpgradeTransactionRequest.from(obj);
+      }
+      case TransactionType.Upload: {
+        return UploadTransactionRequest.from(obj);
+      }
       default: {
         throw new FuelError(
           ErrorCode.UNSUPPORTED_TRANSACTION_TYPE,
@@ -39770,6 +40131,8 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
   var isTransactionTypeScript = (request) => request.type === TransactionType.Script;
   var isTransactionTypeCreate = (request) => request.type === TransactionType.Create;
   var isTransactionTypeBlob = (request) => request.type === TransactionType.Blob;
+  var isTransactionTypeUpgrade = (request) => request.type === TransactionType.Upgrade;
+  var isTransactionTypeUpload = (request) => request.type === TransactionType.Upload;
 
   // src/providers/transaction-summary/calculate-tx-fee-for-summary.ts
   var calculateTXFeeForSummary = (params) => {
@@ -40029,6 +40392,10 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
         return "Script" /* Script */;
       case TransactionType.Blob:
         return "Blob" /* Blob */;
+      case TransactionType.Upgrade:
+        return "Upgrade" /* Upgrade */;
+      case TransactionType.Upload:
+        return "Upload" /* Upload */;
       default:
         throw new FuelError(
           ErrorCode.UNSUPPORTED_TRANSACTION_TYPE,
@@ -40210,8 +40577,8 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
   }) {
     const contractCallReceipts = getReceiptsCall(receipts);
     const contractOutputs = getOutputsContract(outputs);
-    return contractOutputs.flatMap((output3) => {
-      const contractInput = getInputContractFromIndex(inputs, output3.inputIndex);
+    return contractOutputs.flatMap((output2) => {
+      const contractInput = getInputContractFromIndex(inputs, output2.inputIndex);
       if (!contractInput) {
         return [];
       }
@@ -40233,7 +40600,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     let { from: fromAddress } = receipt;
     const toType = contractInputs.some((input) => input.contractID === toAddress) ? 0 /* contract */ : 1 /* account */;
     if (ZeroBytes32 === fromAddress) {
-      const change = changeOutputs.find((output3) => output3.assetId === assetId);
+      const change = changeOutputs.find((output2) => output2.assetId === assetId);
       fromAddress = change?.to || fromAddress;
     }
     const fromType = contractInputs.some((input) => input.contractID === fromAddress) ? 0 /* contract */ : 1 /* account */;
@@ -40311,7 +40678,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
   }
   function getPayProducerOperations(outputs) {
     const coinOutputs = getOutputsCoin(outputs);
-    const payProducerOperations = coinOutputs.reduce((prev, output3) => {
+    const payProducerOperations = coinOutputs.reduce((prev, output2) => {
       const operations = addOperation(prev, {
         name: "Pay network fee to block producer" /* payBlockProducer */,
         from: {
@@ -40320,12 +40687,12 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
         },
         to: {
           type: 1 /* account */,
-          address: output3.to.toString()
+          address: output2.to.toString()
         },
         assetsSent: [
           {
-            assetId: output3.assetId.toString(),
-            amount: output3.amount
+            assetId: output2.assetId.toString(),
+            amount: output2.amount
           }
         ]
       });
@@ -40986,21 +41353,31 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @hidden
      */
     constructor(url, options = {}) {
-      this.url = url;
       /**
        * @hidden
        */
       __privateAdd(this, _cacheInputs);
       __publicField(this, "operations");
       __publicField(this, "cache");
+      /** @hidden */
+      __publicField(this, "url");
+      /** @hidden */
+      __publicField(this, "urlWithoutAuth");
       __publicField(this, "options", {
         timeout: void 0,
         resourceCacheTTL: void 0,
         fetch: void 0,
-        retryOptions: void 0
+        retryOptions: void 0,
+        headers: void 0
       });
+      const { url: rawUrl, urlWithoutAuth, headers } = _Provider.extractBasicAuth(url);
+      this.url = rawUrl;
+      this.urlWithoutAuth = urlWithoutAuth;
       this.options = { ...this.options, ...options };
       this.url = url;
+      if (headers) {
+        this.options = { ...this.options, headers: { ...this.options.headers, ...headers } };
+      }
       this.operations = this.createOperations();
       const { resourceCacheTTL } = this.options;
       if (isDefined(resourceCacheTTL)) {
@@ -41022,12 +41399,16 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @hidden
      */
     static getFetchFn(options) {
-      const { retryOptions, timeout } = options;
+      const { retryOptions, timeout, headers } = options;
       return autoRetryFetch(async (...args) => {
         const url = args[0];
         const request = args[1];
         const signal = timeout ? AbortSignal.timeout(timeout) : void 0;
-        let fullRequest = { ...request, signal };
+        let fullRequest = {
+          ...request,
+          signal,
+          headers: { ...request?.headers, ...headers }
+        };
         if (options.requestMiddleware) {
           fullRequest = await options.requestMiddleware(fullRequest);
         }
@@ -41035,15 +41416,23 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       }, retryOptions);
     }
     static extractBasicAuth(url) {
-      const parsedUrl = new URL(url);
+      let parsedUrl;
+      try {
+        parsedUrl = new URL(url);
+      } catch (error) {
+        throw new FuelError(FuelError.CODES.INVALID_URL, "Invalid URL provided.", { url }, error);
+      }
       const username = parsedUrl.username;
       const password = parsedUrl.password;
-      const urlNoBasicAuth = `${parsedUrl.origin}${parsedUrl.pathname}`;
+      const urlWithoutAuth = `${parsedUrl.origin}${parsedUrl.pathname}`;
       if (!(username && password)) {
-        return { url, auth: void 0 };
+        return { url, urlWithoutAuth: url, headers: void 0 };
       }
-      const auth = `Basic ${btoa(`${username}:${password}`)}`;
-      return { url: urlNoBasicAuth, auth };
+      return {
+        url,
+        urlWithoutAuth,
+        headers: { Authorization: `Basic ${btoa(`${username}:${password}`)}` }
+      };
     }
     /**
      * Creates a new instance of the Provider class. This is the recommended way to initialize a Provider.
@@ -41054,17 +41443,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @returns A promise that resolves to a Provider instance.
      */
     static async create(url, options = {}) {
-      const { url: urlToUse, auth } = this.extractBasicAuth(url);
-      const provider = new _Provider(urlToUse, {
-        ...options,
-        requestMiddleware: async (request) => {
-          if (auth && request) {
-            request.headers ??= {};
-            request.headers.Authorization = auth;
-          }
-          return options.requestMiddleware?.(request) ?? request;
-        }
-      });
+      const provider = new _Provider(url, options);
       await provider.fetchChainAndNodeInfo();
       return provider;
     }
@@ -41074,7 +41453,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @returns the chain information configuration.
      */
     getChain() {
-      const chain = _Provider.chainInfoCache[this.url];
+      const chain = _Provider.chainInfoCache[this.urlWithoutAuth];
       if (!chain) {
         throw new FuelError(
           ErrorCode.CHAIN_INFO_CACHE_EMPTY,
@@ -41089,7 +41468,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @returns the node information configuration.
      */
     getNode() {
-      const node = _Provider.nodeInfoCache[this.url];
+      const node = _Provider.nodeInfoCache[this.urlWithoutAuth];
       if (!node) {
         throw new FuelError(
           ErrorCode.NODE_INFO_CACHE_EMPTY,
@@ -41123,8 +41502,11 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @param options - Additional options for the provider.
      */
     async connect(url, options) {
-      this.url = url;
+      const { url: rawUrl, urlWithoutAuth, headers } = _Provider.extractBasicAuth(url);
+      this.url = rawUrl;
+      this.urlWithoutAuth = urlWithoutAuth;
       this.options = options ?? this.options;
+      this.options = { ...this.options, headers: { ...this.options.headers, ...headers } };
       this.operations = this.createOperations();
       await this.fetchChainAndNodeInfo();
     }
@@ -41164,7 +41546,7 @@ Supported fuel-core version: ${supportedVersion}.`
      */
     createOperations() {
       const fetchFn = _Provider.getFetchFn(this.options);
-      const gqlClient = new import_graphql_request.GraphQLClient(this.url, {
+      const gqlClient = new import_graphql_request.GraphQLClient(this.urlWithoutAuth, {
         fetch: (url, requestInit) => fetchFn(url, requestInit, this.options),
         responseMiddleware: (response) => {
           if ("response" in response) {
@@ -41182,7 +41564,7 @@ Supported fuel-core version: ${supportedVersion}.`
         const isSubscription = opDefinition?.operation === "subscription";
         if (isSubscription) {
           return FuelGraphqlSubscriber.create({
-            url: this.url,
+            url: this.urlWithoutAuth,
             query,
             fetchFn: (url, requestInit) => fetchFn(url, requestInit, this.options),
             variables: vars
@@ -41245,7 +41627,7 @@ Supported fuel-core version: ${supportedVersion}.`
         utxoValidation: nodeInfo.utxoValidation,
         vmBacktrace: nodeInfo.vmBacktrace
       };
-      _Provider.nodeInfoCache[this.url] = processedNodeInfo;
+      _Provider.nodeInfoCache[this.urlWithoutAuth] = processedNodeInfo;
       return processedNodeInfo;
     }
     /**
@@ -41256,7 +41638,7 @@ Supported fuel-core version: ${supportedVersion}.`
     async fetchChain() {
       const { chain } = await this.operations.getChain();
       const processedChain = processGqlChain(chain);
-      _Provider.chainInfoCache[this.url] = processedChain;
+      _Provider.chainInfoCache[this.urlWithoutAuth] = processedChain;
       return processedChain;
     }
     /**
@@ -42411,10 +42793,10 @@ Supported fuel-core version: ${supportedVersion}.`
         gasPrice,
         baseAssetId
       });
-      const output3 = {
+      const output2 = {
         ...transactionSummary
       };
-      return output3;
+      return output2;
     });
     return {
       transactions,
@@ -42425,12 +42807,14 @@ Supported fuel-core version: ${supportedVersion}.`
   // src/providers/chains.ts
   var CHAIN_IDS = {
     eth: {
+      mainnet: 1,
       sepolia: 11155111,
       foundry: 31337
     },
     fuel: {
       devnet: 0,
-      testnet: 0
+      testnet: 0,
+      mainnet: 9889
     }
   };
 
@@ -42530,6 +42914,11 @@ Supported fuel-core version: ${supportedVersion}.`
           chainId: CHAIN_IDS.eth.foundry,
           decimals: 18
         },
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          decimals: 18
+        },
         {
           type: "fuel",
           chainId: CHAIN_IDS.fuel.devnet,
@@ -42541,6 +42930,571 @@ Supported fuel-core version: ${supportedVersion}.`
           chainId: CHAIN_IDS.fuel.testnet,
           decimals: 9,
           assetId: "0xf8f8b6283d7fa5b672b530cbb84fcccb4ff8dc40f8176ef4544ddb1f1952ad07"
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          decimals: 9,
+          assetId: "0xf8f8b6283d7fa5b672b530cbb84fcccb4ff8dc40f8176ef4544ddb1f1952ad07"
+        }
+      ]
+    },
+    {
+      name: "WETH",
+      symbol: "WETH",
+      icon: "weth.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0xa38a5a8beeb08d95744bc7f58528073f4052b254def59eba20c99c202b5acaa3",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "weETH",
+      symbol: "weETH",
+      icon: "weETH.webp",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x239ed6e12b7ce4089ee245244e3bf906999a6429c2a9a445a1e1faf56914a4ab",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "rsETH",
+      symbol: "rsETH",
+      icon: "rsETH.webp",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xA1290d69c65A6Fe4DF752f95823fae25cB99e5A7",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0xbae80f7fb8aa6b90d9b01ef726ec847cc4f59419c4d5f2ea88fec785d1b0e849",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "rETH",
+      symbol: "rETH",
+      icon: "reth.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xae78736cd615f374d3085123a210448e74fc6393",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0xf3f9a0ed0ce8eac5f89d6b83e41b3848212d5b5f56108c54a205bb228ca30c16",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "wbETH",
+      symbol: "wbETH",
+      icon: "wbeth.png",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xa2E3356610840701BDf5611a53974510Ae27E2e1",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x7843c74bef935e837f2bcf67b5d64ecb46dd53ff86375530b0caf3699e8ffafe",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "rstETH",
+      symbol: "rstETH",
+      icon: "rstETH.webp",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x7a4EffD87C2f3C55CA251080b1343b605f327E3a",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x962792286fbc9b1d5860b4551362a12249362c21594c77abf4b3fe2bbe8d977a",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "amphrETH",
+      symbol: "amphrETH",
+      icon: "amphrETH.png",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x5fD13359Ba15A84B76f7F87568309040176167cd",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x05fc623e57bd7bc1258efa8e4f62b05af5471d73df6f2c2dc11ecc81134c4f36",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "Manta mBTC",
+      symbol: "Manta mBTC",
+      icon: "manta-mbtc.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x4041381e947CFD3D483d67a25C6aa9Dc924250c5",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0xaf3111a248ff7a3238cdeea845bb2d43cf3835f1f6b8c9d28360728b55b9ce5b",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "Manta mETH",
+      symbol: "Manta mETH",
+      icon: "manta-meth.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x8CdF550C04Bc9B9F10938368349C9c8051A772b6",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0xafd219f513317b1750783c6581f55530d6cf189a5863fd18bd1b3ffcec1714b4",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "Manta mUSD",
+      symbol: "Manta mUSD",
+      icon: "manta-musd.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x3f24E1d7a973867fC2A03fE199E5502514E0e11E",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x89cb9401e55d49c3269654dd1cdfb0e80e57823a4a7db98ba8fc5953b120fef4",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "pumpBTC",
+      symbol: "pumpBTC",
+      icon: "pumpbtc.webp",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xf469fbd2abcd6b9de8e169d128226c0fc90a012e",
+          decimals: 8
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x0aa5eb2bb97ca915288b653a2529355d4dc66de2b37533213f0e4aeee3d3421f",
+          decimals: 8
+        }
+      ]
+    },
+    {
+      name: "FBTC",
+      symbol: "FBTC",
+      icon: "fbtc.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xc96de26018a54d51c097160568752c4e3bd6c364",
+          decimals: 8
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0xb5ecb0a1e08e2abbabf624ffea089df933376855f468ade35c6375b00c33996a",
+          decimals: 8
+        }
+      ]
+    },
+    {
+      name: "SolvBTC",
+      symbol: "SolvBTC",
+      icon: "solvBTC.webp",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x7a56e1c57c7475ccf742a1832b028f0456652f97",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x1186afea9affb88809c210e13e2330b5258c2cef04bb8fff5eff372b7bd3f40f",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "SolvBTC.BBN",
+      symbol: "SolvBTC.BBN",
+      icon: "SolvBTC.BBN.png",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xd9d920aa40f578ab794426f5c90f6c731d159def",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x7a4f087c957d30218223c2baaaa365355c9ca81b6ea49004cfb1590a5399216f",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "Mantle mETH",
+      symbol: "Mantle mETH",
+      icon: "mantle-meth.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xd5F7838F5C461fefF7FE49ea5ebaF7728bB0ADfa",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x642a5db59ec323c2f846d4d4cf3e58d78aff64accf4f8f6455ba0aa3ef000a3b",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "sDAI",
+      symbol: "sDAI",
+      icon: "sdai.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x83f20f44975d03b1b09e64809b757c47f942beea",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x9e46f919fbf978f3cad7cd34cca982d5613af63ff8aab6c379e4faa179552958",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "USDT",
+      symbol: "USDT",
+      icon: "usdt.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+          decimals: 6
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0xa0265fb5c32f6e8db3197af3c7eb05c48ae373605b8165b6f4a51c5b0ba4812e",
+          decimals: 6
+        }
+      ]
+    },
+    {
+      name: "USDC",
+      symbol: "USDC",
+      icon: "usdc.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+          decimals: 6
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x286c479da40dc953bddc3bb4c453b608bba2e0ac483b077bd475174115395e6b",
+          decimals: 6
+        }
+      ]
+    },
+    {
+      name: "USDe",
+      symbol: "USDe",
+      icon: "USDe.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x4c9edd5852cd905f086c759e8383e09bff1e68b3",
+          decimals: 18
+        },
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.sepolia,
+          address: "0xc6387efad0f184a90b34f397c3d6fd63135ef790",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0xb6133b2ef9f6153eb869125d23dcf20d1e735331b5e41b15a6a7a6cec70e8651",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.testnet,
+          contractId: "0xC6387efAD0F184a90B34f397C3d6Fd63135ef790",
+          assetId: "0xf5c6d72d0f2c782fa47d8e228c198a08654e9fc66ca60ad85902b1d09046a7ab",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "sUSDe",
+      symbol: "sUSDe",
+      icon: "sUSDe.webp",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x9d39a5de30e57443bff2a8307a4256c8797a3497",
+          decimals: 18
+        },
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.sepolia,
+          address: "0xb8f4f4eafc1d2a3c0a4d519bbf1114c311cc9b1b",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0xd05563025104fc36496c15c7021ad6b31034b0e89a356f4f818045d1f48808bc",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.testnet,
+          contractId: "0xC6387efAD0F184a90B34f397C3d6Fd63135ef790",
+          assetId: "0xa86e37d385c08beddbb02c8260f9ec535d484c8ea908fc19d4e6dc8d5141fb2e",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "rsUSDe",
+      symbol: "rsUSDe",
+      icon: "rsUSDe.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x82f5104b23FF2FA54C2345F821dAc9369e9E0B26",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x78d4522ec607f6e8efb66ea49439d1ee48623cf763f9688a8eada025def033d9",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "wstETH",
+      symbol: "wstETH",
+      icon: "wsteth.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+          decimals: 18
+        },
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.sepolia,
+          address: "0xB82381A3fBD3FaFA77B3a7bE693342618240067b",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x1a7815cc9f75db5c24a5b0814bfb706bb9fe485333e98254015de8f48f84c67b",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.testnet,
+          contractId: "0xC6387efAD0F184a90B34f397C3d6Fd63135ef790",
+          assetId: "0x4c467e3fd4f32179e1aad3b92ebbdaa6ff6aeda5b8da5f8e64e96405eb52a7f5",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "ezETH",
+      symbol: "ezETH",
+      icon: "ezeth.webp",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xbf5495Efe5DB9ce00f80364C8B423567e58d2110",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x91b3559edb2619cde8ffb2aa7b3c3be97efd794ea46700db7092abeee62281b0",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "pzETH",
+      symbol: "pzETH",
+      icon: "pzETH.webp",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x8c9532a60e0e7c6bbd2b2c1303f63ace1c3e9811",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x1493d4ec82124de8f9b625682de69dcccda79e882b89a55a8c737b12de67bd68",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "Re7LRT",
+      symbol: "Re7LRT",
+      icon: "Re7LRT.png",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0x84631c0d0081FDe56DeB72F6DE77abBbF6A9f93a",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0xf2fc648c23a5db24610a1cf696acc4f0f6d9a7d6028dd9944964ab23f6e35995",
+          decimals: 18
+        }
+      ]
+    },
+    {
+      name: "steakLRT",
+      symbol: "steakLRT",
+      icon: "steakLRT.png",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.mainnet,
+          address: "0xBEEF69Ac7870777598A04B2bd4771c71212E6aBc",
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.mainnet,
+          contractId: "0x4ea6ccef1215d9479f1024dff70fc055ca538215d2c8c348beddffd54583d0e8",
+          assetId: "0x4fc8ac9f101df07e2c2dec4a53c8c42c439bdbe5e36ea2d863a61ff60afafc30",
+          decimals: 18
         }
       ]
     }
@@ -43077,7 +44031,7 @@ Supported fuel-core version: ${supportedVersion}.`
      */
     generateFakeResources(coins) {
       return coins.map((coin) => ({
-        id: hexlify(randomBytes2(UTXO_ID_LEN)),
+        id: hexlify(randomBytes22(UTXO_ID_LEN)),
         owner: this.address,
         blockCreated: bn(1),
         txCreatedIdx: bn(1),
@@ -43134,414 +44088,7 @@ Supported fuel-core version: ${supportedVersion}.`
     }
   };
 
-  // ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_assert.js
-  function number2(n) {
-    if (!Number.isSafeInteger(n) || n < 0)
-      throw new Error(`positive integer expected, not ${n}`);
-  }
-  function isBytes4(a) {
-    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
-  }
-  function bytes2(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}, not of length=${b.length}`);
-  }
-  function hash3(h) {
-    if (typeof h !== "function" || typeof h.create !== "function")
-      throw new Error("Hash should be wrapped by utils.wrapConstructor");
-    number2(h.outputLen);
-    number2(h.blockLen);
-  }
-  function exists2(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 output2(out, instance) {
-    bytes2(out);
-    const min = instance.outputLen;
-    if (out.length < min) {
-      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
-    }
-  }
-
-  // ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/cryptoNode.js
-  var nc = __toESM(__require("crypto"), 1);
-  var crypto4 = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : void 0;
-
-  // ../../node_modules/.pnpm/@noble+hashes@1.4.0/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;
-  var isLE2 = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-  function utf8ToBytes3(str) {
-    if (typeof str !== "string")
-      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
-    return new Uint8Array(new TextEncoder().encode(str));
-  }
-  function toBytes3(data) {
-    if (typeof data === "string")
-      data = utf8ToBytes3(data);
-    bytes2(data);
-    return data;
-  }
-  function concatBytes3(...arrays) {
-    let sum = 0;
-    for (let i = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      bytes2(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();
-    }
-  };
-  var toStr2 = {}.toString;
-  function wrapConstructor2(hashCons) {
-    const hashC = (msg) => hashCons().update(toBytes3(msg)).digest();
-    const tmp = hashCons();
-    hashC.outputLen = tmp.outputLen;
-    hashC.blockLen = tmp.blockLen;
-    hashC.create = () => hashCons();
-    return hashC;
-  }
-  function randomBytes3(bytesLength = 32) {
-    if (crypto4 && typeof crypto4.getRandomValues === "function") {
-      return crypto4.getRandomValues(new Uint8Array(bytesLength));
-    }
-    throw new Error("crypto.getRandomValues must be defined");
-  }
-
-  // ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_md.js
-  function setBigUint642(view, byteOffset, value, isLE3) {
-    if (typeof view.setBigUint64 === "function")
-      return view.setBigUint64(byteOffset, value, isLE3);
-    const _32n2 = BigInt(32);
-    const _u32_max = BigInt(4294967295);
-    const wh = Number(value >> _32n2 & _u32_max);
-    const wl = Number(value & _u32_max);
-    const h = isLE3 ? 4 : 0;
-    const l = isLE3 ? 0 : 4;
-    view.setUint32(byteOffset + h, wh, isLE3);
-    view.setUint32(byteOffset + l, wl, isLE3);
-  }
-  var Chi2 = (a, b, c) => a & b ^ ~a & c;
-  var Maj2 = (a, b, c) => a & b ^ a & c ^ b & c;
-  var HashMD = class extends Hash2 {
-    constructor(blockLen, outputLen, padOffset, isLE3) {
-      super();
-      this.blockLen = blockLen;
-      this.outputLen = outputLen;
-      this.padOffset = padOffset;
-      this.isLE = isLE3;
-      this.finished = false;
-      this.length = 0;
-      this.pos = 0;
-      this.destroyed = false;
-      this.buffer = new Uint8Array(blockLen);
-      this.view = createView2(this.buffer);
-    }
-    update(data) {
-      exists2(this);
-      const { view, buffer, blockLen } = this;
-      data = toBytes3(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) {
-      exists2(this);
-      output2(out, this);
-      this.finished = true;
-      const { buffer, view, blockLen, isLE: isLE3 } = 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), isLE3);
-      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], isLE3);
-    }
-    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/.pnpm/@noble+hashes@1.4.0/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_IV = /* @__PURE__ */ new Uint32Array([
-    1779033703,
-    3144134277,
-    1013904242,
-    2773480762,
-    1359893119,
-    2600822924,
-    528734635,
-    1541459225
-  ]);
-  var SHA256_W2 = /* @__PURE__ */ new Uint32Array(64);
-  var SHA2562 = class extends HashMD {
-    constructor() {
-      super(64, 32, 8, false);
-      this.A = SHA256_IV[0] | 0;
-      this.B = SHA256_IV[1] | 0;
-      this.C = SHA256_IV[2] | 0;
-      this.D = SHA256_IV[3] | 0;
-      this.E = SHA256_IV[4] | 0;
-      this.F = SHA256_IV[5] | 0;
-      this.G = SHA256_IV[6] | 0;
-      this.H = SHA256_IV[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 sha2563 = /* @__PURE__ */ wrapConstructor2(() => new SHA2562());
-
-  // ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/hmac.js
-  var HMAC2 = class extends Hash2 {
-    constructor(hash4, _key) {
-      super();
-      this.finished = false;
-      this.destroyed = false;
-      hash3(hash4);
-      const key = toBytes3(_key);
-      this.iHash = hash4.create();
-      if (typeof this.iHash.update !== "function")
-        throw new Error("Expected instance of class which extends utils.Hash");
-      this.blockLen = this.iHash.blockLen;
-      this.outputLen = this.iHash.outputLen;
-      const blockLen = this.blockLen;
-      const pad = new Uint8Array(blockLen);
-      pad.set(key.length > blockLen ? hash4.create().update(key).digest() : key);
-      for (let i = 0; i < pad.length; i++)
-        pad[i] ^= 54;
-      this.iHash.update(pad);
-      this.oHash = hash4.create();
-      for (let i = 0; i < pad.length; i++)
-        pad[i] ^= 54 ^ 92;
-      this.oHash.update(pad);
-      pad.fill(0);
-    }
-    update(buf) {
-      exists2(this);
-      this.iHash.update(buf);
-      return this;
-    }
-    digestInto(out) {
-      exists2(this);
-      bytes2(out, this.outputLen);
-      this.finished = true;
-      this.iHash.digestInto(out);
-      this.oHash.update(out);
-      this.oHash.digestInto(out);
-      this.destroy();
-    }
-    digest() {
-      const out = new Uint8Array(this.oHash.outputLen);
-      this.digestInto(out);
-      return out;
-    }
-    _cloneInto(to) {
-      to || (to = Object.create(Object.getPrototypeOf(this), {}));
-      const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
-      to = to;
-      to.finished = finished;
-      to.destroyed = destroyed;
-      to.blockLen = blockLen;
-      to.outputLen = outputLen;
-      to.oHash = oHash._cloneInto(to.oHash);
-      to.iHash = iHash._cloneInto(to.iHash);
-      return to;
-    }
-    destroy() {
-      this.destroyed = true;
-      this.oHash.destroy();
-      this.iHash.destroy();
-    }
-  };
-  var hmac2 = (hash4, key, message) => new HMAC2(hash4, key).update(message).digest();
-  hmac2.create = (hash4, key) => new HMAC2(hash4, key);
-
-  // ../../node_modules/.pnpm/@noble+curves@1.4.2/node_modules/@noble/curves/esm/abstract/modular.js
+  // ../../node_modules/.pnpm/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/modular.js
   var _0n3 = BigInt(0);
   var _1n3 = BigInt(1);
   var _2n3 = BigInt(2);
@@ -43577,11 +44124,11 @@ Supported fuel-core version: ${supportedVersion}.`
     }
     return res;
   }
-  function invert(number3, modulo) {
-    if (number3 === _0n3 || modulo <= _0n3) {
-      throw new Error(`invert: expected positive integers, got n=${number3} mod=${modulo}`);
+  function invert(number2, modulo) {
+    if (number2 === _0n3 || modulo <= _0n3) {
+      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
     }
-    let a = mod(number3, modulo);
+    let a = mod(number2, modulo);
     let b = modulo;
     let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
     while (a !== _0n3) {
@@ -43736,7 +44283,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const nByteLength = Math.ceil(_nBitLength / 8);
     return { nBitLength: _nBitLength, nByteLength };
   }
-  function Field(ORDER, bitLen2, isLE3 = false, redef = {}) {
+  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
     if (ORDER <= _0n3)
       throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
     const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
@@ -43777,11 +44324,11 @@ Supported fuel-core version: ${supportedVersion}.`
       // TODO: do we really need constant cmov?
       // We don't have const-time bigints anyway, so probably will be not very useful
       cmov: (a, b, c) => c ? b : a,
-      toBytes: (num) => isLE3 ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES),
-      fromBytes: (bytes3) => {
-        if (bytes3.length !== BYTES)
-          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes3.length}`);
-        return isLE3 ? bytesToNumberLE(bytes3) : bytesToNumberBE(bytes3);
+      toBytes: (num) => isLE2 ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES),
+      fromBytes: (bytes2) => {
+        if (bytes2.length !== BYTES)
+          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
+        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
       }
     });
     return Object.freeze(f2);
@@ -43796,26 +44343,33 @@ Supported fuel-core version: ${supportedVersion}.`
     const length = getFieldBytesLength(fieldOrder);
     return length + Math.ceil(length / 2);
   }
-  function mapHashToField(key, fieldOrder, isLE3 = false) {
+  function mapHashToField(key, fieldOrder, isLE2 = false) {
     const len = key.length;
     const fieldLen = getFieldBytesLength(fieldOrder);
     const minLen = getMinHashLength(fieldOrder);
     if (len < 16 || len < minLen || len > 1024)
       throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
-    const num = isLE3 ? bytesToNumberBE(key) : bytesToNumberLE(key);
+    const num = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
     const reduced = mod(num, fieldOrder - _1n3) + _1n3;
-    return isLE3 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
+    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
   }
 
-  // ../../node_modules/.pnpm/@noble+curves@1.4.2/node_modules/@noble/curves/esm/abstract/curve.js
+  // ../../node_modules/.pnpm/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/curve.js
   var _0n4 = BigInt(0);
   var _1n4 = BigInt(1);
+  var pointPrecomputes = /* @__PURE__ */ new WeakMap();
+  var pointWindowSizes = /* @__PURE__ */ new WeakMap();
   function wNAF(c, bits) {
     const constTimeNegate = (condition, item) => {
       const neg = item.negate();
       return condition ? neg : item;
     };
+    const validateW = (W) => {
+      if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
+        throw new Error(`Wrong window size=${W}, should be [1..${bits}]`);
+    };
     const opts = (W) => {
+      validateW(W);
       const windows = Math.ceil(bits / W) + 1;
       const windowSize = 2 ** (W - 1);
       return { windows, windowSize };
@@ -43894,19 +44448,62 @@ Supported fuel-core version: ${supportedVersion}.`
         }
         return { p, f: f2 };
       },
-      wNAFCached(P, precomputesMap, n, transform) {
-        const W = P._WINDOW_SIZE || 1;
-        let comp = precomputesMap.get(P);
+      wNAFCached(P, n, transform) {
+        const W = pointWindowSizes.get(P) || 1;
+        let comp = pointPrecomputes.get(P);
         if (!comp) {
           comp = this.precomputeWindow(P, W);
-          if (W !== 1) {
-            precomputesMap.set(P, transform(comp));
-          }
+          if (W !== 1)
+            pointPrecomputes.set(P, transform(comp));
         }
         return this.wNAF(W, comp, n);
+      },
+      // We calculate precomputes for elliptic curve point multiplication
+      // using windowed method. This specifies window size and
+      // stores precomputed values. Usually only base point would be precomputed.
+      setWindowSize(P, W) {
+        validateW(W);
+        pointWindowSizes.set(P, W);
+        pointPrecomputes.delete(P);
       }
     };
   }
+  function pippenger(c, field, points, scalars) {
+    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
+      throw new Error("arrays of points and scalars must have equal length");
+    scalars.forEach((s, i) => {
+      if (!field.isValid(s))
+        throw new Error(`wrong scalar at index ${i}`);
+    });
+    points.forEach((p, i) => {
+      if (!(p instanceof c))
+        throw new Error(`wrong point at index ${i}`);
+    });
+    const wbits = bitLen(BigInt(points.length));
+    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
+    const MASK = (1 << windowSize) - 1;
+    const buckets = new Array(MASK + 1).fill(c.ZERO);
+    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
+    let sum = c.ZERO;
+    for (let i = lastBits; i >= 0; i -= windowSize) {
+      buckets.fill(c.ZERO);
+      for (let j = 0; j < scalars.length; j++) {
+        const scalar = scalars[j];
+        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
+        buckets[wbits2] = buckets[wbits2].add(points[j]);
+      }
+      let resI = c.ZERO;
+      for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
+        sumI = sumI.add(buckets[j]);
+        resI = resI.add(sumI);
+      }
+      sum = sum.add(resI);
+      if (i !== 0)
+        for (let j = 0; j < windowSize; j++)
+          sum = sum.double();
+    }
+    return sum;
+  }
   function validateBasic(curve) {
     validateField(curve.Fp);
     validateObject(curve, {
@@ -43925,7 +44522,13 @@ Supported fuel-core version: ${supportedVersion}.`
     });
   }
 
-  // ../../node_modules/.pnpm/@noble+curves@1.4.2/node_modules/@noble/curves/esm/abstract/weierstrass.js
+  // ../../node_modules/.pnpm/@noble+curves@1.6.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
+  function validateSigVerOpts(opts) {
+    if (opts.lowS !== void 0)
+      abool("lowS", opts.lowS);
+    if (opts.prehash !== void 0)
+      abool("prehash", opts.prehash);
+  }
   function validatePointOpts(curve) {
     const opts = validateBasic(curve);
     validateObject(opts, {
@@ -43959,48 +44562,99 @@ Supported fuel-core version: ${supportedVersion}.`
         super(m);
       }
     },
-    _parseInt(data) {
-      const { Err: E } = DER;
-      if (data.length < 2 || data[0] !== 2)
-        throw new E("Invalid signature integer tag");
-      const len = data[1];
-      const res = data.subarray(2, len + 2);
-      if (!len || res.length !== len)
-        throw new E("Invalid signature integer: wrong length");
-      if (res[0] & 128)
-        throw new E("Invalid signature integer: negative");
-      if (res[0] === 0 && !(res[1] & 128))
-        throw new E("Invalid signature integer: unnecessary leading zero");
-      return { d: b2n(res), l: data.subarray(len + 2) };
+    // Basic building block is TLV (Tag-Length-Value)
+    _tlv: {
+      encode: (tag, data) => {
+        const { Err: E } = DER;
+        if (tag < 0 || tag > 256)
+          throw new E("tlv.encode: wrong tag");
+        if (data.length & 1)
+          throw new E("tlv.encode: unpadded data");
+        const dataLen = data.length / 2;
+        const len = numberToHexUnpadded(dataLen);
+        if (len.length / 2 & 128)
+          throw new E("tlv.encode: long form length too big");
+        const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
+        return `${numberToHexUnpadded(tag)}${lenLen}${len}${data}`;
+      },
+      // v - value, l - left bytes (unparsed)
+      decode(tag, data) {
+        const { Err: E } = DER;
+        let pos = 0;
+        if (tag < 0 || tag > 256)
+          throw new E("tlv.encode: wrong tag");
+        if (data.length < 2 || data[pos++] !== tag)
+          throw new E("tlv.decode: wrong tlv");
+        const first = data[pos++];
+        const isLong = !!(first & 128);
+        let length = 0;
+        if (!isLong)
+          length = first;
+        else {
+          const lenLen = first & 127;
+          if (!lenLen)
+            throw new E("tlv.decode(long): indefinite length not supported");
+          if (lenLen > 4)
+            throw new E("tlv.decode(long): byte length is too big");
+          const lengthBytes = data.subarray(pos, pos + lenLen);
+          if (lengthBytes.length !== lenLen)
+            throw new E("tlv.decode: length bytes not complete");
+          if (lengthBytes[0] === 0)
+            throw new E("tlv.decode(long): zero leftmost byte");
+          for (const b of lengthBytes)
+            length = length << 8 | b;
+          pos += lenLen;
+          if (length < 128)
+            throw new E("tlv.decode(long): not minimal encoding");
+        }
+        const v = data.subarray(pos, pos + length);
+        if (v.length !== length)
+          throw new E("tlv.decode: wrong value length");
+        return { v, l: data.subarray(pos + length) };
+      }
+    },
+    // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+    // since we always use positive integers here. It must always be empty:
+    // - add zero byte if exists
+    // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+    _int: {
+      encode(num) {
+        const { Err: E } = DER;
+        if (num < _0n5)
+          throw new E("integer: negative integers are not allowed");
+        let hex = numberToHexUnpadded(num);
+        if (Number.parseInt(hex[0], 16) & 8)
+          hex = "00" + hex;
+        if (hex.length & 1)
+          throw new E("unexpected assertion");
+        return hex;
+      },
+      decode(data) {
+        const { Err: E } = DER;
+        if (data[0] & 128)
+          throw new E("Invalid signature integer: negative");
+        if (data[0] === 0 && !(data[1] & 128))
+          throw new E("Invalid signature integer: unnecessary leading zero");
+        return b2n(data);
+      }
     },
     toSig(hex) {
-      const { Err: E } = DER;
+      const { Err: E, _int: int, _tlv: tlv } = DER;
       const data = typeof hex === "string" ? h2b(hex) : hex;
       abytes(data);
-      let l = data.length;
-      if (l < 2 || data[0] != 48)
-        throw new E("Invalid signature tag");
-      if (data[1] !== l - 2)
-        throw new E("Invalid signature: incorrect length");
-      const { d: r, l: sBytes } = DER._parseInt(data.subarray(2));
-      const { d: s, l: rBytesLeft } = DER._parseInt(sBytes);
-      if (rBytesLeft.length)
+      const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
+      if (seqLeftBytes.length)
+        throw new E("Invalid signature: left bytes after parsing");
+      const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
+      const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
+      if (sLeftBytes.length)
         throw new E("Invalid signature: left bytes after parsing");
-      return { r, s };
+      return { r: int.decode(rBytes), s: int.decode(sBytes) };
     },
     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 s = slice(h(sig.s));
-      const r = slice(h(sig.r));
-      const shl = s.length / 2;
-      const rhl = r.length / 2;
-      const sl = h(shl);
-      const rl = h(rhl);
-      return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
+      const { _tlv: tlv, _int: int } = DER;
+      const seq = `${tlv.encode(2, int.encode(sig.r))}${tlv.encode(2, int.encode(sig.s))}`;
+      return tlv.encode(48, seq);
     }
   };
   var _0n5 = BigInt(0);
@@ -44011,12 +44665,13 @@ Supported fuel-core version: ${supportedVersion}.`
   function weierstrassPoints(opts) {
     const CURVE = validatePointOpts(opts);
     const { Fp: Fp2 } = CURVE;
-    const toBytes4 = CURVE.toBytes || ((_c, point, _isCompressed) => {
+    const Fn = Field(CURVE.n, CURVE.nBitLength);
+    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
       const a = point.toAffine();
-      return concatBytes2(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
+      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
     });
-    const fromBytes = CURVE.fromBytes || ((bytes3) => {
-      const tail = bytes3.subarray(1);
+    const fromBytes = CURVE.fromBytes || ((bytes2) => {
+      const tail = bytes2.subarray(1);
       const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
       const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
       return { x, y };
@@ -44030,16 +44685,12 @@ Supported fuel-core version: ${supportedVersion}.`
     if (!Fp2.eql(Fp2.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
       throw new Error("bad generator point: equation left != right");
     function isWithinCurveOrder(num) {
-      return typeof num === "bigint" && _0n5 < num && num < CURVE.n;
-    }
-    function assertGE(num) {
-      if (!isWithinCurveOrder(num))
-        throw new Error("Expected valid bigint: 0 < bigint < curve.n");
+      return inRange(num, _1n5, CURVE.n);
     }
     function normPrivateKeyToScalar(key) {
-      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;
+      const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
       if (lengths && typeof key !== "bigint") {
-        if (isBytes3(key))
+        if (isBytes2(key))
           key = bytesToHex(key);
         if (typeof key !== "string" || !lengths.includes(key.length))
           throw new Error("Invalid key");
@@ -44052,15 +44703,47 @@ Supported fuel-core version: ${supportedVersion}.`
         throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
       }
       if (wrapPrivateKey)
-        num = mod(num, n);
-      assertGE(num);
+        num = mod(num, N);
+      aInRange("private key", num, _1n5, N);
       return num;
     }
-    const pointPrecomputes = /* @__PURE__ */ new Map();
     function assertPrjPoint(other) {
       if (!(other instanceof Point2))
         throw new Error("ProjectivePoint expected");
     }
+    const toAffineMemo = memoized((p, iz) => {
+      const { px: x, py: y, pz: z } = p;
+      if (Fp2.eql(z, Fp2.ONE))
+        return { x, y };
+      const is0 = p.is0();
+      if (iz == null)
+        iz = is0 ? Fp2.ONE : Fp2.inv(z);
+      const ax = Fp2.mul(x, iz);
+      const ay = Fp2.mul(y, iz);
+      const zz = Fp2.mul(z, iz);
+      if (is0)
+        return { x: Fp2.ZERO, y: Fp2.ZERO };
+      if (!Fp2.eql(zz, Fp2.ONE))
+        throw new Error("invZ was invalid");
+      return { x: ax, y: ay };
+    });
+    const assertValidMemo = memoized((p) => {
+      if (p.is0()) {
+        if (CURVE.allowInfinityPoint && !Fp2.is0(p.py))
+          return;
+        throw new Error("bad point: ZERO");
+      }
+      const { x, y } = p.toAffine();
+      if (!Fp2.isValid(x) || !Fp2.isValid(y))
+        throw new Error("bad point: x or y not FE");
+      const left = Fp2.sqr(y);
+      const right = weierstrassEquation(x);
+      if (!Fp2.eql(left, right))
+        throw new Error("bad point: equation left != right");
+      if (!p.isTorsionFree())
+        throw new Error("bad point: not in prime-order subgroup");
+      return true;
+    });
     class Point2 {
       constructor(px, py, pz) {
         this.px = px;
@@ -44072,6 +44755,7 @@ Supported fuel-core version: ${supportedVersion}.`
           throw new Error("y required");
         if (pz == null || !Fp2.isValid(pz))
           throw new Error("z required");
+        Object.freeze(this);
       }
       // Does not validate if the point is on-curve.
       // Use fromHex instead, or call assertValidity() later.
@@ -44115,27 +44799,17 @@ Supported fuel-core version: ${supportedVersion}.`
       static fromPrivateKey(privateKey) {
         return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
       }
+      // Multiscalar Multiplication
+      static msm(points, scalars) {
+        return pippenger(Point2, Fn, points, scalars);
+      }
       // "Private method", don't use it directly
       _setWindowSize(windowSize) {
-        this._WINDOW_SIZE = windowSize;
-        pointPrecomputes.delete(this);
+        wnaf.setWindowSize(this, windowSize);
       }
       // A point on curve is valid if it conforms to equation.
       assertValidity() {
-        if (this.is0()) {
-          if (CURVE.allowInfinityPoint && !Fp2.is0(this.py))
-            return;
-          throw new Error("bad point: ZERO");
-        }
-        const { x, y } = this.toAffine();
-        if (!Fp2.isValid(x) || !Fp2.isValid(y))
-          throw new Error("bad point: x or y not FE");
-        const left = Fp2.sqr(y);
-        const right = weierstrassEquation(x);
-        if (!Fp2.eql(left, right))
-          throw new Error("bad point: equation left != right");
-        if (!this.isTorsionFree())
-          throw new Error("bad point: not in prime-order subgroup");
+        assertValidMemo(this);
       }
       hasEvenY() {
         const { y } = this.toAffine();
@@ -44262,27 +44936,24 @@ Supported fuel-core version: ${supportedVersion}.`
         return this.equals(Point2.ZERO);
       }
       wNAF(n) {
-        return wnaf.wNAFCached(this, pointPrecomputes, n, (comp) => {
-          const toInv = Fp2.invertBatch(comp.map((p) => p.pz));
-          return comp.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
-        });
+        return wnaf.wNAFCached(this, n, Point2.normalizeZ);
       }
       /**
        * Non-constant-time multiplication. Uses double-and-add algorithm.
        * It's faster, but should only be used when you don't care about
        * an exposed private key e.g. sig verification, which works over *public* keys.
        */
-      multiplyUnsafe(n) {
+      multiplyUnsafe(sc) {
+        aInRange("scalar", sc, _0n5, CURVE.n);
         const I = Point2.ZERO;
-        if (n === _0n5)
+        if (sc === _0n5)
           return I;
-        assertGE(n);
-        if (n === _1n5)
+        if (sc === _1n5)
           return this;
         const { endo } = CURVE;
         if (!endo)
-          return wnaf.unsafeLadder(this, n);
-        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
+          return wnaf.unsafeLadder(this, sc);
+        let { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);
         let k1p = I;
         let k2p = I;
         let d = this;
@@ -44312,12 +44983,11 @@ Supported fuel-core version: ${supportedVersion}.`
        * @returns New point
        */
       multiply(scalar) {
-        assertGE(scalar);
-        let n = scalar;
+        const { endo, n: N } = CURVE;
+        aInRange("scalar", scalar, _1n5, N);
         let point, fake;
-        const { endo } = CURVE;
         if (endo) {
-          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
+          const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
           let { p: k1p, f: f1p } = this.wNAF(k1);
           let { p: k2p, f: f2p } = this.wNAF(k2);
           k1p = wnaf.constTimeNegate(k1neg, k1p);
@@ -44326,7 +44996,7 @@ Supported fuel-core version: ${supportedVersion}.`
           point = k1p.add(k2p);
           fake = f1p.add(f2p);
         } else {
-          const { p, f: f2 } = this.wNAF(n);
+          const { p, f: f2 } = this.wNAF(scalar);
           point = p;
           fake = f2;
         }
@@ -44348,18 +45018,7 @@ Supported fuel-core version: ${supportedVersion}.`
       // Can accept precomputed Z^-1 - for example, from invertBatch.
       // (x, y, z) ∋ (x=x/z, y=y/z)
       toAffine(iz) {
-        const { px: x, py: y, pz: z } = this;
-        const is0 = this.is0();
-        if (iz == null)
-          iz = is0 ? Fp2.ONE : Fp2.inv(z);
-        const ax = Fp2.mul(x, iz);
-        const ay = Fp2.mul(y, iz);
-        const zz = Fp2.mul(z, iz);
-        if (is0)
-          return { x: Fp2.ZERO, y: Fp2.ZERO };
-        if (!Fp2.eql(zz, Fp2.ONE))
-          throw new Error("invZ was invalid");
-        return { x: ax, y: ay };
+        return toAffineMemo(this, iz);
       }
       isTorsionFree() {
         const { h: cofactor, isTorsionFree } = CURVE;
@@ -44378,10 +45037,12 @@ Supported fuel-core version: ${supportedVersion}.`
         return this.multiplyUnsafe(CURVE.h);
       }
       toRawBytes(isCompressed = true) {
+        abool("isCompressed", isCompressed);
         this.assertValidity();
-        return toBytes4(Point2, this, isCompressed);
+        return toBytes3(Point2, this, isCompressed);
       }
       toHex(isCompressed = true) {
+        abool("isCompressed", isCompressed);
         return bytesToHex(this.toRawBytes(isCompressed));
       }
     }
@@ -44415,9 +45076,6 @@ Supported fuel-core version: ${supportedVersion}.`
     const { Fp: Fp2, n: CURVE_ORDER } = CURVE;
     const compressedLen = Fp2.BYTES + 1;
     const uncompressedLen = 2 * Fp2.BYTES + 1;
-    function isValidFieldElement(num) {
-      return _0n5 < num && num < Fp2.ORDER;
-    }
     function modN(a) {
       return mod(a, CURVE_ORDER);
     }
@@ -44429,20 +45087,21 @@ Supported fuel-core version: ${supportedVersion}.`
       toBytes(_c, point, isCompressed) {
         const a = point.toAffine();
         const x = Fp2.toBytes(a.x);
-        const cat = concatBytes2;
+        const cat = concatBytes3;
+        abool("isCompressed", isCompressed);
         if (isCompressed) {
           return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
         } else {
           return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
         }
       },
-      fromBytes(bytes3) {
-        const len = bytes3.length;
-        const head = bytes3[0];
-        const tail = bytes3.subarray(1);
+      fromBytes(bytes2) {
+        const len = bytes2.length;
+        const head = bytes2[0];
+        const tail = bytes2.subarray(1);
         if (len === compressedLen && (head === 2 || head === 3)) {
           const x = bytesToNumberBE(tail);
-          if (!isValidFieldElement(x))
+          if (!inRange(x, _1n5, Fp2.ORDER))
             throw new Error("Point is not on curve");
           const y2 = weierstrassEquation(x);
           let y;
@@ -44467,9 +45126,9 @@ Supported fuel-core version: ${supportedVersion}.`
       }
     });
     const numToNByteStr = (num) => bytesToHex(numberToBytesBE(num, CURVE.nByteLength));
-    function isBiggerThanHalfOrder(number3) {
+    function isBiggerThanHalfOrder(number2) {
       const HALF = CURVE_ORDER >> _1n5;
-      return number3 > HALF;
+      return number2 > HALF;
     }
     function normalizeS(s) {
       return isBiggerThanHalfOrder(s) ? modN(-s) : s;
@@ -44495,10 +45154,8 @@ Supported fuel-core version: ${supportedVersion}.`
         return new Signature(r, s);
       }
       assertValidity() {
-        if (!isWithinCurveOrder(this.r))
-          throw new Error("r must be 0 < r < CURVE.n");
-        if (!isWithinCurveOrder(this.s))
-          throw new Error("s must be 0 < s < CURVE.n");
+        aInRange("r", this.r, _1n5, CURVE_ORDER);
+        aInRange("s", this.s, _1n5, CURVE_ORDER);
       }
       addRecoveryBit(recovery) {
         return new Signature(this.r, this.s, recovery);
@@ -44580,7 +45237,7 @@ Supported fuel-core version: ${supportedVersion}.`
       return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
     }
     function isProbPub(item) {
-      const arr = isBytes3(item);
+      const arr = isBytes2(item);
       const str = typeof item === "string";
       const len = (arr || str) && item.length;
       if (arr)
@@ -44599,40 +45256,38 @@ Supported fuel-core version: ${supportedVersion}.`
       const b = Point2.fromHex(publicB);
       return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
     }
-    const bits2int = CURVE.bits2int || function(bytes3) {
-      const num = bytesToNumberBE(bytes3);
-      const delta = bytes3.length * 8 - CURVE.nBitLength;
+    const bits2int = CURVE.bits2int || function(bytes2) {
+      const num = bytesToNumberBE(bytes2);
+      const delta = bytes2.length * 8 - CURVE.nBitLength;
       return delta > 0 ? num >> BigInt(delta) : num;
     };
-    const bits2int_modN = CURVE.bits2int_modN || function(bytes3) {
-      return modN(bits2int(bytes3));
+    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
+      return modN(bits2int(bytes2));
     };
     const ORDER_MASK = bitMask(CURVE.nBitLength);
     function int2octets(num) {
-      if (typeof num !== "bigint")
-        throw new Error("bigint expected");
-      if (!(_0n5 <= num && num < ORDER_MASK))
-        throw new Error(`bigint expected < 2^${CURVE.nBitLength}`);
+      aInRange(`num < 2^${CURVE.nBitLength}`, num, _0n5, ORDER_MASK);
       return numberToBytesBE(num, CURVE.nByteLength);
     }
     function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
       if (["recovered", "canonical"].some((k) => k in opts))
         throw new Error("sign() legacy options not supported");
-      const { hash: hash4, randomBytes: randomBytes4 } = CURVE;
+      const { hash: hash3, randomBytes: randomBytes3 } = CURVE;
       let { lowS, prehash, extraEntropy: ent } = opts;
       if (lowS == null)
         lowS = true;
       msgHash = ensureBytes("msgHash", msgHash);
+      validateSigVerOpts(opts);
       if (prehash)
-        msgHash = ensureBytes("prehashed msgHash", hash4(msgHash));
+        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
       const h1int = bits2int_modN(msgHash);
       const d = normPrivateKeyToScalar(privateKey);
       const seedArgs = [int2octets(d), int2octets(h1int)];
       if (ent != null && ent !== false) {
-        const e = ent === true ? randomBytes4(Fp2.BYTES) : ent;
+        const e = ent === true ? randomBytes3(Fp2.BYTES) : ent;
         seedArgs.push(ensureBytes("extraEntropy", e));
       }
-      const seed = concatBytes2(...seedArgs);
+      const seed = concatBytes3(...seedArgs);
       const m = h1int;
       function k2sig(kBytes) {
         const k = bits2int(kBytes);
@@ -44671,11 +45326,12 @@ Supported fuel-core version: ${supportedVersion}.`
       publicKey = ensureBytes("publicKey", publicKey);
       if ("strict" in opts)
         throw new Error("options.strict was renamed to lowS");
+      validateSigVerOpts(opts);
       const { lowS, prehash } = opts;
       let _sig = void 0;
       let P;
       try {
-        if (typeof sg === "string" || isBytes3(sg)) {
+        if (typeof sg === "string" || isBytes2(sg)) {
           try {
             _sig = Signature.fromDER(sg);
           } catch (derError) {
@@ -44722,20 +45378,20 @@ Supported fuel-core version: ${supportedVersion}.`
     };
   }
 
-  // ../../node_modules/.pnpm/@noble+curves@1.4.2/node_modules/@noble/curves/esm/_shortw_utils.js
-  function getHash(hash4) {
+  // ../../node_modules/.pnpm/@noble+curves@1.6.0/node_modules/@noble/curves/esm/_shortw_utils.js
+  function getHash(hash3) {
     return {
-      hash: hash4,
-      hmac: (key, ...msgs) => hmac2(hash4, key, concatBytes3(...msgs)),
-      randomBytes: randomBytes3
+      hash: hash3,
+      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes2(...msgs)),
+      randomBytes
     };
   }
   function createCurve(curveDef, defHash) {
-    const create = (hash4) => weierstrass({ ...curveDef, ...getHash(hash4) });
+    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
     return Object.freeze({ ...create(defHash), create });
   }
 
-  // ../../node_modules/.pnpm/@noble+curves@1.4.2/node_modules/@noble/curves/esm/secp256k1.js
+  // ../../node_modules/.pnpm/@noble+curves@1.6.0/node_modules/@noble/curves/esm/secp256k1.js
   var secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
   var secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
   var _1n6 = BigInt(1);
@@ -44811,7 +45467,7 @@ Supported fuel-core version: ${supportedVersion}.`
         return { k1neg, k1, k2neg, k2 };
       }
     }
-  }, sha2563);
+  }, sha256);
   var _0n6 = BigInt(0);
   var Point = secp256k1.ProjectivePoint;
 
@@ -44904,7 +45560,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns random 32-byte hashed
      */
     static generatePrivateKey(entropy) {
-      return entropy ? hash2(concat([randomBytes2(32), arrayify(entropy)])) : randomBytes2(32);
+      return entropy ? hash2(concat([randomBytes22(32), arrayify(entropy)])) : randomBytes22(32);
     }
     /**
      * Extended publicKey from a compact publicKey
@@ -44933,7 +45589,7 @@ Supported fuel-core version: ${supportedVersion}.`
   async function encryptKeystoreWallet(privateKey, address, password) {
     const privateKeyBuffer = bufferFromString2(removeHexPrefix(privateKey), "hex");
     const ownerAddress = Address.fromAddressOrString(address);
-    const salt = randomBytes2(DEFAULT_KEY_SIZE);
+    const salt = randomBytes22(DEFAULT_KEY_SIZE);
     const key = scrypt22({
       password: bufferFromString2(password),
       salt,
@@ -44942,7 +45598,7 @@ Supported fuel-core version: ${supportedVersion}.`
       r: DEFAULT_KDF_PARAMS_R,
       p: DEFAULT_KDF_PARAMS_P
     });
-    const iv = randomBytes2(DEFAULT_IV_SIZE);
+    const iv = randomBytes22(DEFAULT_IV_SIZE);
     const ciphertext = await encryptJsonWalletData2(privateKeyBuffer, key, iv);
     const data = Uint8Array.from([...key.subarray(16, 32), ...ciphertext]);
     const macHashUint8Array = keccak2562(data);
@@ -47443,7 +48099,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns A randomly generated mnemonic
      */
     static generate(size = 32, extraEntropy = "") {
-      const entropy = extraEntropy ? sha2562(concat([randomBytes2(size), arrayify(extraEntropy)])) : randomBytes2(size);
+      const entropy = extraEntropy ? sha2562(concat([randomBytes22(size), arrayify(extraEntropy)])) : randomBytes22(size);
       return Mnemonic.entropyToMnemonic(entropy);
     }
   };
@@ -47544,9 +48200,9 @@ Supported fuel-core version: ${supportedVersion}.`
         data.set(arrayify(this.publicKey));
       }
       data.set(toBytes(index, 4), 33);
-      const bytes3 = arrayify(computeHmac2("sha512", chainCode, data));
-      const IL = bytes3.slice(0, 32);
-      const IR = bytes3.slice(32);
+      const bytes2 = arrayify(computeHmac2("sha512", chainCode, data));
+      const IL = bytes2.slice(0, 32);
+      const IR = bytes2.slice(32);
       if (privateKey) {
         const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
         const ki = bn(IL).add(privateKey).mod(N).toBytes(32);
@@ -47616,26 +48272,26 @@ Supported fuel-core version: ${supportedVersion}.`
     }
     static fromExtendedKey(extendedKey) {
       const decoded = hexlify(toBytes(decodeBase58(extendedKey)));
-      const bytes3 = arrayify(decoded);
-      const validChecksum = base58check(bytes3.slice(0, 78)) === extendedKey;
-      if (bytes3.length !== 82 || !isValidExtendedKey(bytes3)) {
+      const bytes2 = arrayify(decoded);
+      const validChecksum = base58check(bytes2.slice(0, 78)) === extendedKey;
+      if (bytes2.length !== 82 || !isValidExtendedKey(bytes2)) {
         throw new FuelError(ErrorCode.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
       }
       if (!validChecksum) {
         throw new FuelError(ErrorCode.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
       }
-      const depth = bytes3[4];
-      const parentFingerprint = hexlify(bytes3.slice(5, 9));
-      const index = parseInt(hexlify(bytes3.slice(9, 13)).substring(2), 16);
-      const chainCode = hexlify(bytes3.slice(13, 45));
-      const key = bytes3.slice(45, 78);
+      const depth = bytes2[4];
+      const parentFingerprint = hexlify(bytes2.slice(5, 9));
+      const index = parseInt(hexlify(bytes2.slice(9, 13)).substring(2), 16);
+      const chainCode = hexlify(bytes2.slice(13, 45));
+      const key = bytes2.slice(45, 78);
       if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
         throw new FuelError(
           ErrorCode.HD_WALLET_ERROR,
           "Inconsistency detected: Depth is zero but fingerprint/index is non-zero."
         );
       }
-      if (isPublicExtendedKey(bytes3)) {
+      if (isPublicExtendedKey(bytes2)) {
         if (key[0] !== 3) {
           throw new FuelError(ErrorCode.HD_WALLET_ERROR, "Invalid public extended key.");
         }
@@ -48279,8 +48935,8 @@ Supported fuel-core version: ${supportedVersion}.`
   // src/predicate/utils/getPredicateRoot.ts
   var getPredicateRoot = (bytecode) => {
     const chunkSize = 16 * 1024;
-    const bytes3 = arrayify(bytecode);
-    const chunks = chunkAndPadBytes(bytes3, chunkSize);
+    const bytes2 = arrayify(bytecode);
+    const chunks = chunkAndPadBytes(bytes2, chunkSize);
     const codeRoot = calcRoot(chunks.map((c) => hexlify(c)));
     const predicateRoot = hash2(concat(["0x4655454C", codeRoot]));
     return predicateRoot;
@@ -48376,8 +49032,8 @@ Supported fuel-core version: ${supportedVersion}.`
      * @param configurableConstants - Optional configurable constants for the predicate.
      * @returns An object containing the new predicate bytes and interface.
      */
-    static processPredicateData(bytes3, jsonAbi, configurableConstants) {
-      let predicateBytes = arrayify(bytes3);
+    static processPredicateData(bytes2, jsonAbi, configurableConstants) {
+      let predicateBytes = arrayify(bytes2);
       let abiInterface;
       if (jsonAbi) {
         abiInterface = new Interface(jsonAbi);
@@ -48440,8 +49096,8 @@ Supported fuel-core version: ${supportedVersion}.`
      * @param abiInterface - The ABI interface of the predicate.
      * @returns The mutated bytes with the configurable constants set.
      */
-    static setConfigurableConstants(bytes3, configurableConstants, abiInterface) {
-      const mutatedBytes = bytes3;
+    static setConfigurableConstants(bytes2, configurableConstants, abiInterface) {
+      const mutatedBytes = bytes2;
       try {
         if (!abiInterface) {
           throw new FuelError(
@@ -49206,9 +49862,6 @@ mime-types/index.js:
 @noble/curves/esm/abstract/utils.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
-@noble/hashes/esm/utils.js:
-  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
 @noble/curves/esm/abstract/modular.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)