@fuel-ts/account 0.0.0-rc-2408-20240620125747 → 0.0.0-rc-2408-20240620151941

package/dist/test-utils.global.js

@@ -76,20 +76,20 @@
           ctor.prototype = new TempCtor();
           ctor.prototype.constructor = ctor;
         }
-        function BN2(number2, base, endian) {
-          if (BN2.isBN(number2)) {
-            return number2;
+        function BN2(number3, base, endian) {
+          if (BN2.isBN(number3)) {
+            return number3;
           }
           this.negative = 0;
           this.words = null;
           this.length = 0;
           this.red = null;
-          if (number2 !== null) {
+          if (number3 !== null) {
             if (base === "le" || base === "be") {
               endian = base;
               base = 10;
             }
-            this._init(number2 || 0, base || 10, endian || "be");
+            this._init(number3 || 0, base || 10, endian || "be");
           }
         }
         if (typeof module2 === "object") {
@@ -124,53 +124,53 @@
             return left;
           return right;
         };
-        BN2.prototype._init = function init(number2, base, endian) {
-          if (typeof number2 === "number") {
-            return this._initNumber(number2, base, endian);
+        BN2.prototype._init = function init(number3, base, endian) {
+          if (typeof number3 === "number") {
+            return this._initNumber(number3, base, endian);
           }
-          if (typeof number2 === "object") {
-            return this._initArray(number2, base, endian);
+          if (typeof number3 === "object") {
+            return this._initArray(number3, base, endian);
           }
           if (base === "hex") {
             base = 16;
           }
           assert(base === (base | 0) && base >= 2 && base <= 36);
-          number2 = number2.toString().replace(/\s+/g, "");
+          number3 = number3.toString().replace(/\s+/g, "");
           var start = 0;
-          if (number2[0] === "-") {
+          if (number3[0] === "-") {
             start++;
             this.negative = 1;
           }
-          if (start < number2.length) {
+          if (start < number3.length) {
             if (base === 16) {
-              this._parseHex(number2, start, endian);
+              this._parseHex(number3, start, endian);
             } else {
-              this._parseBase(number2, base, start);
+              this._parseBase(number3, base, start);
               if (endian === "le") {
                 this._initArray(this.toArray(), base, endian);
               }
             }
           }
         };
-        BN2.prototype._initNumber = function _initNumber(number2, base, endian) {
-          if (number2 < 0) {
+        BN2.prototype._initNumber = function _initNumber(number3, base, endian) {
+          if (number3 < 0) {
             this.negative = 1;
-            number2 = -number2;
+            number3 = -number3;
           }
-          if (number2 < 67108864) {
-            this.words = [number2 & 67108863];
+          if (number3 < 67108864) {
+            this.words = [number3 & 67108863];
             this.length = 1;
-          } else if (number2 < 4503599627370496) {
+          } else if (number3 < 4503599627370496) {
             this.words = [
-              number2 & 67108863,
-              number2 / 67108864 & 67108863
+              number3 & 67108863,
+              number3 / 67108864 & 67108863
             ];
             this.length = 2;
           } else {
-            assert(number2 < 9007199254740992);
+            assert(number3 < 9007199254740992);
             this.words = [
-              number2 & 67108863,
-              number2 / 67108864 & 67108863,
+              number3 & 67108863,
+              number3 / 67108864 & 67108863,
               1
             ];
             this.length = 3;
@@ -179,14 +179,14 @@
             return;
           this._initArray(this.toArray(), base, endian);
         };
-        BN2.prototype._initArray = function _initArray(number2, base, endian) {
-          assert(typeof number2.length === "number");
-          if (number2.length <= 0) {
+        BN2.prototype._initArray = function _initArray(number3, base, endian) {
+          assert(typeof number3.length === "number");
+          if (number3.length <= 0) {
             this.words = [0];
             this.length = 1;
             return this;
           }
-          this.length = Math.ceil(number2.length / 3);
+          this.length = Math.ceil(number3.length / 3);
           this.words = new Array(this.length);
           for (var i = 0; i < this.length; i++) {
             this.words[i] = 0;
@@ -194,8 +194,8 @@
           var j, w;
           var off = 0;
           if (endian === "be") {
-            for (i = number2.length - 1, j = 0; i >= 0; i -= 3) {
-              w = number2[i] | number2[i - 1] << 8 | number2[i - 2] << 16;
+            for (i = number3.length - 1, j = 0; i >= 0; i -= 3) {
+              w = number3[i] | number3[i - 1] << 8 | number3[i - 2] << 16;
               this.words[j] |= w << off & 67108863;
               this.words[j + 1] = w >>> 26 - off & 67108863;
               off += 24;
@@ -205,8 +205,8 @@
               }
             }
           } else if (endian === "le") {
-            for (i = 0, j = 0; i < number2.length; i += 3) {
-              w = number2[i] | number2[i + 1] << 8 | number2[i + 2] << 16;
+            for (i = 0, j = 0; i < number3.length; i += 3) {
+              w = number3[i] | number3[i + 1] << 8 | number3[i + 2] << 16;
               this.words[j] |= w << off & 67108863;
               this.words[j + 1] = w >>> 26 - off & 67108863;
               off += 24;
@@ -237,8 +237,8 @@
           }
           return r;
         }
-        BN2.prototype._parseHex = function _parseHex(number2, start, endian) {
-          this.length = Math.ceil((number2.length - start) / 6);
+        BN2.prototype._parseHex = function _parseHex(number3, start, endian) {
+          this.length = Math.ceil((number3.length - start) / 6);
           this.words = new Array(this.length);
           for (var i = 0; i < this.length; i++) {
             this.words[i] = 0;
@@ -247,8 +247,8 @@
           var j = 0;
           var w;
           if (endian === "be") {
-            for (i = number2.length - 1; i >= start; i -= 2) {
-              w = parseHexByte(number2, start, i) << off;
+            for (i = number3.length - 1; i >= start; i -= 2) {
+              w = parseHexByte(number3, start, i) << off;
               this.words[j] |= w & 67108863;
               if (off >= 18) {
                 off -= 18;
@@ -259,9 +259,9 @@
               }
             }
           } else {
-            var parseLength = number2.length - start;
-            for (i = parseLength % 2 === 0 ? start + 1 : start; i < number2.length; i += 2) {
-              w = parseHexByte(number2, start, i) << off;
+            var parseLength = number3.length - start;
+            for (i = parseLength % 2 === 0 ? start + 1 : start; i < number3.length; i += 2) {
+              w = parseHexByte(number3, start, i) << off;
               this.words[j] |= w & 67108863;
               if (off >= 18) {
                 off -= 18;
@@ -293,7 +293,7 @@
           }
           return r;
         }
-        BN2.prototype._parseBase = function _parseBase(number2, base, start) {
+        BN2.prototype._parseBase = function _parseBase(number3, base, start) {
           this.words = [0];
           this.length = 1;
           for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
@@ -301,12 +301,12 @@
           }
           limbLen--;
           limbPow = limbPow / base | 0;
-          var total = number2.length - start;
+          var total = number3.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(number2, i, i + limbLen, base);
+            word = parseBase(number3, i, i + limbLen, base);
             this.imuln(limbPow);
             if (this.words[0] + word < 67108864) {
               this.words[0] += word;
@@ -316,7 +316,7 @@
           }
           if (mod2 !== 0) {
             var pow3 = 1;
-            word = parseBase(number2, i, number2.length, base);
+            word = parseBase(number3, i, number3.length, base);
             for (i = 0; i < mod2; i++) {
               pow3 *= base;
             }
@@ -2642,20 +2642,20 @@
           );
         }
         inherits(K256, MPrime);
-        K256.prototype.split = function split2(input, output2) {
+        K256.prototype.split = function split2(input, output3) {
           var mask = 4194303;
           var outLen = Math.min(input.length, 9);
           for (var i = 0; i < outLen; i++) {
-            output2.words[i] = input.words[i];
+            output3.words[i] = input.words[i];
           }
-          output2.length = outLen;
+          output3.length = outLen;
           if (input.length <= 9) {
             input.words[0] = 0;
             input.length = 1;
             return;
           }
           var prev = input.words[9];
-          output2.words[output2.length++] = prev & mask;
+          output3.words[output3.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;
@@ -3051,8 +3051,8 @@
         }
         return result;
       }
-      function toWords(bytes2) {
-        return convert2(bytes2, 8, 5, true);
+      function toWords(bytes3) {
+        return convert2(bytes3, 8, 5, true);
       }
       function fromWordsUnsafe(words) {
         const res = convert2(words, 5, 8, false);
@@ -3591,18 +3591,18 @@
       }
       function utf8PercentDecode(str) {
         const input = new Buffer(str);
-        const output2 = [];
+        const output3 = [];
         for (let i = 0; i < input.length; ++i) {
           if (input[i] !== 37) {
-            output2.push(input[i]);
+            output3.push(input[i]);
           } else if (input[i] === 37 && isASCIIHex(input[i + 1]) && isASCIIHex(input[i + 2])) {
-            output2.push(parseInt(input.slice(i + 1, i + 3).toString(), 16));
+            output3.push(parseInt(input.slice(i + 1, i + 3).toString(), 16));
             i += 2;
           } else {
-            output2.push(input[i]);
+            output3.push(input[i]);
           }
         }
-        return new Buffer(output2).toString();
+        return new Buffer(output3).toString();
       }
       function isC0ControlPercentEncode(c) {
         return c <= 31 || c > 126;
@@ -3678,16 +3678,16 @@
         return ipv4;
       }
       function serializeIPv4(address) {
-        let output2 = "";
+        let output3 = "";
         let n = address;
         for (let i = 1; i <= 4; ++i) {
-          output2 = String(n % 256) + output2;
+          output3 = String(n % 256) + output3;
           if (i !== 4) {
-            output2 = "." + output2;
+            output3 = "." + output3;
           }
           n = Math.floor(n / 256);
         }
-        return output2;
+        return output3;
       }
       function parseIPv6(input) {
         const address = [0, 0, 0, 0, 0, 0, 0, 0];
@@ -3745,13 +3745,13 @@
                 return failure;
               }
               while (isASCIIDigit(input[pointer])) {
-                const number2 = parseInt(at(input, pointer));
+                const number3 = parseInt(at(input, pointer));
                 if (ipv4Piece === null) {
-                  ipv4Piece = number2;
+                  ipv4Piece = number3;
                 } else if (ipv4Piece === 0) {
                   return failure;
                 } else {
-                  ipv4Piece = ipv4Piece * 10 + number2;
+                  ipv4Piece = ipv4Piece * 10 + number3;
                 }
                 if (ipv4Piece > 255) {
                   return failure;
@@ -3795,7 +3795,7 @@
         return address;
       }
       function serializeIPv6(address) {
-        let output2 = "";
+        let output3 = "";
         const seqResult = findLongestZeroSequence(address);
         const compress = seqResult.idx;
         let ignore0 = false;
@@ -3807,16 +3807,16 @@
           }
           if (compress === pieceIndex) {
             const separator = pieceIndex === 0 ? "::" : ":";
-            output2 += separator;
+            output3 += separator;
             ignore0 = true;
             continue;
           }
-          output2 += address[pieceIndex].toString(16);
+          output3 += address[pieceIndex].toString(16);
           if (pieceIndex !== 7) {
-            output2 += ":";
+            output3 += ":";
           }
         }
-        return output2;
+        return output3;
       }
       function parseHost(input, isSpecialArg) {
         if (input[0] === "[") {
@@ -3846,12 +3846,12 @@
         if (containsForbiddenHostCodePointExcludingPercent(input)) {
           return failure;
         }
-        let output2 = "";
+        let output3 = "";
         const decoded = punycode.ucs2.decode(input);
         for (let i = 0; i < decoded.length; ++i) {
-          output2 += percentEncodeChar(decoded[i], isC0ControlPercentEncode);
+          output3 += percentEncodeChar(decoded[i], isC0ControlPercentEncode);
         }
-        return output2;
+        return output3;
       }
       function findLongestZeroSequence(arr) {
         let maxIdx = null;
@@ -4476,37 +4476,37 @@
         return true;
       };
       function serializeURL(url, excludeFragment) {
-        let output2 = url.scheme + ":";
+        let output3 = url.scheme + ":";
         if (url.host !== null) {
-          output2 += "//";
+          output3 += "//";
           if (url.username !== "" || url.password !== "") {
-            output2 += url.username;
+            output3 += url.username;
             if (url.password !== "") {
-              output2 += ":" + url.password;
+              output3 += ":" + url.password;
             }
-            output2 += "@";
+            output3 += "@";
           }
-          output2 += serializeHost(url.host);
+          output3 += serializeHost(url.host);
           if (url.port !== null) {
-            output2 += ":" + url.port;
+            output3 += ":" + url.port;
           }
         } else if (url.host === null && url.scheme === "file") {
-          output2 += "//";
+          output3 += "//";
         }
         if (url.cannotBeABaseURL) {
-          output2 += url.path[0];
+          output3 += url.path[0];
         } else {
           for (const string of url.path) {
-            output2 += "/" + string;
+            output3 += "/" + string;
           }
         }
         if (url.query !== null) {
-          output2 += "?" + url.query;
+          output3 += "?" + url.query;
         }
         if (!excludeFragment && url.fragment !== null) {
-          output2 += "#" + url.fragment;
+          output3 += "#" + url.fragment;
         }
-        return output2;
+        return output3;
       }
       function serializeOrigin(tuple) {
         let result = tuple.scheme + "://";
@@ -6450,19 +6450,19 @@
           return "GraphQLError";
         }
         toString() {
-          let output2 = this.message;
+          let output3 = this.message;
           if (this.nodes) {
             for (const node of this.nodes) {
               if (node.loc) {
-                output2 += "\n\n" + (0, _printLocation.printLocation)(node.loc);
+                output3 += "\n\n" + (0, _printLocation.printLocation)(node.loc);
               }
             }
           } else if (this.source && this.locations) {
             for (const location of this.locations) {
-              output2 += "\n\n" + (0, _printLocation.printSourceLocation)(this.source, location);
+              output3 += "\n\n" + (0, _printLocation.printSourceLocation)(this.source, location);
             }
           }
-          return output2;
+          return output3;
         }
         toJSON() {
           const formattedError = {
@@ -18777,7 +18777,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, output2) {
+        state.jobs[key] = runJob(iterator, key, list[key], function(error, output3) {
           if (!(key in state.jobs)) {
             return;
           }
@@ -18785,7 +18785,7 @@ spurious results.`);
           if (error) {
             abort(state);
           } else {
-            state.results[key] = output2;
+            state.results[key] = output3;
           }
           callback(error, state.results);
         });
@@ -20547,8 +20547,8 @@ spurious results.`);
         const ret3 = wasm$1.retd(addr, len);
         return Instruction.__wrap(ret3);
       }
-      function aloc(bytes2) {
-        const ret3 = wasm$1.aloc(bytes2);
+      function aloc(bytes3) {
+        const ret3 = wasm$1.aloc(bytes3);
         return Instruction.__wrap(ret3);
       }
       function mcl(dst_addr, len) {
@@ -21757,9 +21757,9 @@ spurious results.`);
         * Construct the instruction from its parts.
         * @param {RegId} bytes
         */
-        constructor(bytes2) {
-          _assertClass(bytes2, RegId);
-          var ptr0 = bytes2.__destroy_into_raw();
+        constructor(bytes3) {
+          _assertClass(bytes3, RegId);
+          var ptr0 = bytes3.__destroy_into_raw();
           const ret3 = wasm$1.aloc_new_typescript(ptr0);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
@@ -28296,8 +28296,8 @@ spurious results.`);
               }
             }
           }
-          const bytes2 = await module2.arrayBuffer();
-          return await WebAssembly.instantiate(bytes2, imports);
+          const bytes3 = await module2.arrayBuffer();
+          return await WebAssembly.instantiate(bytes3, imports);
         } else {
           const instance = await WebAssembly.instantiate(module2, imports);
           if (instance instanceof WebAssembly.Instance) {
@@ -30702,12 +30702,12 @@ spurious results.`);
         createDebug.skips = [];
         createDebug.formatters = {};
         function selectColor(namespace) {
-          var hash3 = 0;
+          var hash4 = 0;
           for (var i = 0; i < namespace.length; i++) {
-            hash3 = (hash3 << 5) - hash3 + namespace.charCodeAt(i);
-            hash3 |= 0;
+            hash4 = (hash4 << 5) - hash4 + namespace.charCodeAt(i);
+            hash4 |= 0;
           }
-          return createDebug.colors[Math.abs(hash3) % createDebug.colors.length];
+          return createDebug.colors[Math.abs(hash4) % createDebug.colors.length];
         }
         createDebug.selectColor = selectColor;
         function createDebug(namespace) {
@@ -31609,11 +31609,11 @@ spurious results.`);
     if (lengths.length > 0 && !lengths.includes(b.length))
       throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
   }
-  function hash(hash3) {
-    if (typeof hash3 !== "function" || typeof hash3.create !== "function")
+  function hash(hash4) {
+    if (typeof hash4 !== "function" || typeof hash4.create !== "function")
       throw new Error("Hash should be wrapped by utils.wrapConstructor");
-    number(hash3.outputLen);
-    number(hash3.blockLen);
+    number(hash4.outputLen);
+    number(hash4.blockLen);
   }
   function exists(instance, checkFinished = true) {
     if (instance.destroyed)
@@ -31629,10 +31629,6 @@ spurious results.`);
     }
   }
 
-  // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/cryptoNode.js
-  var nc = __toESM(__require("crypto"), 1);
-  var crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : void 0;
-
   // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/utils.js
   var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
   function isBytes2(a) {
@@ -31655,22 +31651,6 @@ spurious results.`);
       throw new Error(`expected Uint8Array, got ${typeof data}`);
     return data;
   }
-  function concatBytes(...arrays) {
-    let sum = 0;
-    for (let i = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      if (!isBytes2(a))
-        throw new Error("Uint8Array expected");
-      sum += a.length;
-    }
-    const res = new Uint8Array(sum);
-    for (let i = 0, pad3 = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      res.set(a, pad3);
-      pad3 += a.length;
-    }
-    return res;
-  }
   var Hash = class {
     // Safe version that clones internal state
     clone() {
@@ -31700,33 +31680,27 @@ spurious results.`);
     hashC.create = (opts) => hashCons(opts);
     return hashC;
   }
-  function randomBytes(bytesLength = 32) {
-    if (crypto && typeof crypto.getRandomValues === "function") {
-      return crypto.getRandomValues(new Uint8Array(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, isLE2) {
+  function setBigUint64(view, byteOffset, value, isLE3) {
     if (typeof view.setBigUint64 === "function")
-      return view.setBigUint64(byteOffset, value, isLE2);
+      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 = isLE2 ? 4 : 0;
-    const l = isLE2 ? 0 : 4;
-    view.setUint32(byteOffset + h, wh, isLE2);
-    view.setUint32(byteOffset + l, wl, isLE2);
+    const h = isLE3 ? 4 : 0;
+    const l = isLE3 ? 0 : 4;
+    view.setUint32(byteOffset + h, wh, isLE3);
+    view.setUint32(byteOffset + l, wl, isLE3);
   }
   var SHA2 = class extends Hash {
-    constructor(blockLen, outputLen, padOffset, isLE2) {
+    constructor(blockLen, outputLen, padOffset, isLE3) {
       super();
       this.blockLen = blockLen;
       this.outputLen = outputLen;
       this.padOffset = padOffset;
-      this.isLE = isLE2;
+      this.isLE = isLE3;
       this.finished = false;
       this.length = 0;
       this.pos = 0;
@@ -31763,7 +31737,7 @@ spurious results.`);
       exists(this);
       output(out, this);
       this.finished = true;
-      const { buffer, view, blockLen, isLE: isLE2 } = this;
+      const { buffer, view, blockLen, isLE: isLE3 } = this;
       let { pos } = this;
       buffer[pos++] = 128;
       this.buffer.subarray(pos).fill(0);
@@ -31773,7 +31747,7 @@ spurious results.`);
       }
       for (let i = pos; i < blockLen; i++)
         buffer[i] = 0;
-      setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
+      setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE3);
       this.process(view, 0);
       const oview = createView(out);
       const len = this.outputLen;
@@ -31784,7 +31758,7 @@ spurious results.`);
       if (outLen > state.length)
         throw new Error("_sha2: outputLen bigger than state");
       for (let i = 0; i < outLen; i++)
-        oview.setUint32(4 * i, state[i], isLE2);
+        oview.setUint32(4 * i, state[i], isLE3);
     }
     digest() {
       const { buffer, outputLen } = this;
@@ -31961,24 +31935,24 @@ spurious results.`);
 
   // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/hmac.js
   var HMAC = class extends Hash {
-    constructor(hash3, _key) {
+    constructor(hash4, _key) {
       super();
       this.finished = false;
       this.destroyed = false;
-      hash(hash3);
+      hash(hash4);
       const key = toBytes(_key);
-      this.iHash = hash3.create();
+      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 pad3 = new Uint8Array(blockLen);
-      pad3.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
+      pad3.set(key.length > blockLen ? hash4.create().update(key).digest() : key);
       for (let i = 0; i < pad3.length; i++)
         pad3[i] ^= 54;
       this.iHash.update(pad3);
-      this.oHash = hash3.create();
+      this.oHash = hash4.create();
       for (let i = 0; i < pad3.length; i++)
         pad3[i] ^= 54 ^ 92;
       this.oHash.update(pad3);
@@ -32021,12 +31995,12 @@ spurious results.`);
       this.iHash.destroy();
     }
   };
-  var hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
-  hmac.create = (hash3, key) => new HMAC(hash3, key);
+  var hmac = (hash4, key, message) => new HMAC(hash4, key).update(message).digest();
+  hmac.create = (hash4, key) => new HMAC(hash4, key);
 
   // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/pbkdf2.js
-  function pbkdf2Init(hash3, _password, _salt, _opts) {
-    hash(hash3);
+  function pbkdf2Init(hash4, _password, _salt, _opts) {
+    hash(hash4);
     const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
     const { c, dkLen, asyncTick } = opts;
     number(c);
@@ -32037,7 +32011,7 @@ spurious results.`);
     const password = toBytes(_password);
     const salt = toBytes(_salt);
     const DK = new Uint8Array(dkLen);
-    const PRF = hmac.create(hash3, password);
+    const PRF = hmac.create(hash4, password);
     const PRFSalt = PRF._cloneInto().update(salt);
     return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
   }
@@ -32049,8 +32023,8 @@ spurious results.`);
     u.fill(0);
     return DK;
   }
-  function pbkdf2(hash3, password, salt, opts) {
-    const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash3, password, salt, opts);
+  function pbkdf2(hash4, password, salt, opts) {
+    const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash4, password, salt, opts);
     let prfW;
     const arr = new Uint8Array(4);
     const view = createView(arr);
@@ -32377,9 +32351,9 @@ spurious results.`);
         throw new Error("XOF is not possible for this instance");
       return this.writeInto(out);
     }
-    xof(bytes2) {
-      number(bytes2);
-      return this.xofInto(new Uint8Array(bytes2));
+    xof(bytes3) {
+      number(bytes3);
+      return this.xofInto(new Uint8Array(bytes3));
     }
     digestInto(out) {
       output(out, this);
@@ -32630,15 +32604,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 output2 = super.toString(base, length);
+      const output3 = super.toString(base, length);
       if (base === 16 || base === "hex") {
-        return `0x${output2}`;
+        return `0x${output3}`;
       }
-      return output2;
+      return output3;
     }
     toHex(bytesPadding) {
-      const bytes2 = bytesPadding || 0;
-      const bytesLength = bytes2 * 2;
+      const bytes3 = bytesPadding || 0;
+      const bytesLength = bytes3 * 2;
       if (this.isNeg()) {
         throw new FuelError(ErrorCode.CONVERTING_FAILED, "Cannot convert negative value to hex.");
       }
@@ -32749,21 +32723,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 output2 = super[methodName](new BN(v));
-      if (BN.isBN(output2)) {
-        return new BN(output2.toArray());
+      const output3 = super[methodName](new BN(v));
+      if (BN.isBN(output3)) {
+        return new BN(output3.toArray());
       }
-      if (typeof output2 === "boolean") {
-        return output2;
+      if (typeof output3 === "boolean") {
+        return output3;
       }
-      return output2;
+      return output3;
     }
     clone() {
       return new BN(this.toArray());
     }
     mulTo(num, out) {
-      const output2 = new import_bn.default(this.toArray()).mulTo(num, out);
-      return new BN(output2.toArray());
+      const output3 = new import_bn.default(this.toArray()).mulTo(num, out);
+      return new BN(output3.toArray());
     }
     egcd(p) {
       const { a, b, gcd } = new import_bn.default(this.toArray()).egcd(p);
@@ -32842,7 +32816,7 @@ This unreleased fuel-core build may include features and updates not yet support
 If you are attempting to transform a hex value, please make sure it is being passed as a string and wrapped in quotes.`;
     throw new FuelError(ErrorCode.INVALID_DATA, message);
   };
-  var concatBytes2 = (arrays) => {
+  var concatBytes = (arrays) => {
     const byteArrays = arrays.map((array) => {
       if (array instanceof Uint8Array) {
         return array;
@@ -32858,15 +32832,15 @@ If you are attempting to transform a hex value, please make sure it is being pas
     return concatenated;
   };
   var concat = (arrays) => {
-    const bytes2 = arrays.map((v) => arrayify(v));
-    return concatBytes2(bytes2);
+    const bytes3 = arrays.map((v) => arrayify(v));
+    return concatBytes(bytes3);
   };
   var HexCharacters = "0123456789abcdef";
   function hexlify(data) {
-    const bytes2 = arrayify(data);
+    const bytes3 = arrayify(data);
     let result = "0x";
-    for (let i = 0; i < bytes2.length; i++) {
-      const v = bytes2[i];
+    for (let i = 0; i < bytes3.length; i++) {
+      const v = bytes3[i];
       result += HexCharacters[(v & 240) >> 4] + HexCharacters[v & 15];
     }
     return result;
@@ -33748,15 +33722,15 @@ If you are attempting to transform a hex value, please make sure it is being pas
     return bn(result);
   }
   function encodeBase58(_value) {
-    const bytes2 = arrayify(_value);
-    let value = bn(bytes2);
+    const bytes3 = arrayify(_value);
+    let value = bn(bytes3);
     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 < bytes2.length; i++) {
-      if (bytes2[i]) {
+    for (let i = 0; i < bytes3.length; i++) {
+      if (bytes3[i]) {
         break;
       }
       result = Alphabet[0] + result;
@@ -33772,11 +33746,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 bytes2 = arrayify(data);
-    if (end != null && end > bytes2.length) {
+    const bytes3 = arrayify(data);
+    if (end != null && end > bytes3.length) {
       throw new FuelError(ErrorCode.INVALID_DATA, "cannot slice beyond data bounds");
     }
-    return hexlify(bytes2.slice(start == null ? 0 : start, end == null ? bytes2.length : end));
+    return hexlify(bytes3.slice(start == null ? 0 : start, end == null ? bytes3.length : end));
   }
   function toUtf8Bytes(stri, form = true) {
     let str = stri;
@@ -33813,8 +33787,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, bytes2, output2, badCodepoint) {
-    console.log(`invalid codepoint at offset ${offset}; ${reason}, bytes: ${bytes2}`);
+  function onError(reason, offset, bytes3, output3, badCodepoint) {
+    console.log(`invalid codepoint at offset ${offset}; ${reason}, bytes: ${bytes3}`);
     return offset;
   }
   function helper(codePoints) {
@@ -33830,11 +33804,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }).join("");
   }
   function getUtf8CodePoints(_bytes) {
-    const bytes2 = arrayify(_bytes, "bytes");
+    const bytes3 = arrayify(_bytes, "bytes");
     const result = [];
     let i = 0;
-    while (i < bytes2.length) {
-      const c = bytes2[i++];
+    while (i < bytes3.length) {
+      const c = bytes3[i++];
       if (c >> 7 === 0) {
         result.push(c);
         continue;
@@ -33852,21 +33826,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, bytes2, result);
+          i += onError("UNEXPECTED_CONTINUE", i - 1, bytes3, result);
         } else {
-          i += onError("BAD_PREFIX", i - 1, bytes2, result);
+          i += onError("BAD_PREFIX", i - 1, bytes3, result);
         }
         continue;
       }
-      if (i - 1 + extraLength >= bytes2.length) {
-        i += onError("OVERRUN", i - 1, bytes2, result);
+      if (i - 1 + extraLength >= bytes3.length) {
+        i += onError("OVERRUN", i - 1, bytes3, result);
         continue;
       }
       let res = c & (1 << 8 - extraLength - 1) - 1;
       for (let j = 0; j < extraLength; j++) {
-        const nextChar = bytes2[i];
+        const nextChar = bytes3[i];
         if ((nextChar & 192) !== 128) {
-          i += onError("MISSING_CONTINUE", i, bytes2, result);
+          i += onError("MISSING_CONTINUE", i, bytes3, result);
           res = null;
           break;
         }
@@ -33877,23 +33851,23 @@ 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, bytes2, result, res);
+        i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes3, result, res);
         continue;
       }
       if (res >= 55296 && res <= 57343) {
-        i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes2, result, res);
+        i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes3, result, res);
         continue;
       }
       if (res <= overlongMask) {
-        i += onError("OVERLONG", i - 1 - extraLength, bytes2, result, res);
+        i += onError("OVERLONG", i - 1 - extraLength, bytes3, result, res);
         continue;
       }
       result.push(res);
     }
     return result;
   }
-  function toUtf8String(bytes2) {
-    return helper(getUtf8CodePoints(bytes2));
+  function toUtf8String(bytes3) {
+    return helper(getUtf8CodePoints(bytes3));
   }
 
   // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/ripemd160.js
@@ -33994,11 +33968,11 @@ 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_crypto2 = __toESM(__require("crypto"), 1);
-  var import_crypto3 = __require("crypto");
+  var import_crypto = __toESM(__require("crypto"), 1);
+  var import_crypto2 = __require("crypto");
+  var import_crypto3 = __toESM(__require("crypto"), 1);
   var import_crypto4 = __toESM(__require("crypto"), 1);
-  var import_crypto5 = __toESM(__require("crypto"), 1);
-  var import_crypto6 = __require("crypto");
+  var import_crypto5 = __require("crypto");
   var scrypt2 = (params) => {
     const { password, salt, n, p, r, dklen } = params;
     const derivedKey = scrypt(password, salt, { N: n, r, p, dkLen: dklen });
@@ -34025,7 +33999,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
   Object.freeze(ripemd1602);
   var bufferFromString = (string, encoding = "base64") => Uint8Array.from(Buffer.from(string, encoding));
   var locked2 = false;
-  var PBKDF2 = (password, salt, iterations, keylen, algo) => (0, import_crypto3.pbkdf2Sync)(password, salt, iterations, keylen, algo);
+  var PBKDF2 = (password, salt, iterations, keylen, algo) => (0, import_crypto2.pbkdf2Sync)(password, salt, iterations, keylen, algo);
   var pBkdf2 = PBKDF2;
   function pbkdf22(_password, _salt, iterations, keylen, algo) {
     const password = arrayify(_password, "password");
@@ -34043,8 +34017,8 @@ If you are attempting to transform a hex value, please make sure it is being pas
     pBkdf2 = func;
   };
   Object.freeze(pbkdf22);
-  var randomBytes2 = (length) => {
-    const randomValues = Uint8Array.from(import_crypto4.default.randomBytes(length));
+  var randomBytes = (length) => {
+    const randomValues = Uint8Array.from(import_crypto3.default.randomBytes(length));
     return randomValues;
   };
   var stringFromBuffer = (buffer, encoding = "base64") => Buffer.from(buffer).toString(encoding);
@@ -34055,11 +34029,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 = randomBytes2(16);
-    const salt = randomBytes2(32);
+    const iv = randomBytes(16);
+    const salt = randomBytes(32);
     const secret = keyFromPassword(password, salt);
     const dataBuffer = Uint8Array.from(Buffer.from(JSON.stringify(data), "utf-8"));
-    const cipher = await import_crypto2.default.createCipheriv(ALGORITHM, secret, iv);
+    const cipher = await import_crypto.default.createCipheriv(ALGORITHM, secret, iv);
     let cipherData = cipher.update(dataBuffer);
     cipherData = Buffer.concat([cipherData, cipher.final()]);
     return {
@@ -34073,7 +34047,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_crypto2.default.createDecipheriv(ALGORITHM, secret, iv);
+    const decipher = await import_crypto.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");
@@ -34084,17 +34058,17 @@ 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_crypto5.default.createCipheriv("aes-128-ctr", key.subarray(0, 16), iv);
+    const cipher = await import_crypto4.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_crypto5.default.createDecipheriv("aes-128-ctr", key.subarray(0, 16), iv);
+    const decipher = import_crypto4.default.createDecipheriv("aes-128-ctr", key.subarray(0, 16), iv);
     const decrypted = await Buffer.concat([decipher.update(data), decipher.final()]);
     return new Uint8Array(decrypted);
   }
   var locked3 = false;
-  var COMPUTEHMAC = (algorithm, key, data) => (0, import_crypto6.createHmac)(algorithm, key).update(data).digest();
+  var COMPUTEHMAC = (algorithm, key, data) => (0, import_crypto5.createHmac)(algorithm, key).update(data).digest();
   var computeHMAC = COMPUTEHMAC;
   function computeHmac(algorithm, _key, _data) {
     const key = arrayify(_key, "key");
@@ -34118,7 +34092,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     decrypt,
     encrypt,
     keyFromPassword,
-    randomBytes: randomBytes2,
+    randomBytes,
     scrypt: scrypt2,
     keccak256,
     decryptJsonWalletData,
@@ -34133,7 +34107,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     decrypt: decrypt2,
     encrypt: encrypt2,
     keyFromPassword: keyFromPassword2,
-    randomBytes: randomBytes22,
+    randomBytes: randomBytes2,
     stringFromBuffer: stringFromBuffer2,
     scrypt: scrypt22,
     keccak256: keccak2562,
@@ -34311,15 +34285,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 bytes2 = data.slice(offset, offset + this.encodedLength);
-      const decoded = bn(bytes2);
+      let bytes3 = data.slice(offset, offset + this.encodedLength);
+      const decoded = bn(bytes3);
       if (decoded.isZero()) {
-        bytes2 = new Uint8Array(32);
+        bytes3 = new Uint8Array(32);
       }
-      if (bytes2.length !== this.encodedLength) {
+      if (bytes3.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid b256 byte data size.`);
       }
-      return [toHex(bytes2, 32), offset + 32];
+      return [toHex(bytes3, 32), offset + 32];
     }
   };
   var B512Coder = class extends Coder {
@@ -34342,15 +34316,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 bytes2 = data.slice(offset, offset + this.encodedLength);
-      const decoded = bn(bytes2);
+      let bytes3 = data.slice(offset, offset + this.encodedLength);
+      const decoded = bn(bytes3);
       if (decoded.isZero()) {
-        bytes2 = new Uint8Array(64);
+        bytes3 = new Uint8Array(64);
       }
-      if (bytes2.length !== this.encodedLength) {
+      if (bytes3.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid b512 byte data size.`);
       }
-      return [toHex(bytes2, this.encodedLength), offset + this.encodedLength];
+      return [toHex(bytes3, this.encodedLength), offset + this.encodedLength];
     }
   };
   var encodedLengths = {
@@ -34362,24 +34336,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 bytes2;
+      let bytes3;
       try {
-        bytes2 = toBytes2(value, this.encodedLength);
+        bytes3 = toBytes2(value, this.encodedLength);
       } catch (error) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.type}.`);
       }
-      return bytes2;
+      return bytes3;
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} data size.`);
       }
-      let bytes2 = data.slice(offset, offset + this.encodedLength);
-      bytes2 = bytes2.slice(0, this.encodedLength);
-      if (bytes2.length !== this.encodedLength) {
+      let bytes3 = data.slice(offset, offset + this.encodedLength);
+      bytes3 = bytes3.slice(0, this.encodedLength);
+      if (bytes3.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} byte data size.`);
       }
-      return [bn(bytes2), offset + this.encodedLength];
+      return [bn(bytes3), offset + this.encodedLength];
     }
   };
   var BooleanCoder = class extends Coder {
@@ -34402,11 +34376,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 bytes2 = bn(data.slice(offset, offset + this.encodedLength));
-      if (bytes2.isZero()) {
+      const bytes3 = bn(data.slice(offset, offset + this.encodedLength));
+      if (bytes3.isZero()) {
         return [false, offset + this.encodedLength];
       }
-      if (!bytes2.eq(bn(1))) {
+      if (!bytes3.eq(bn(1))) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean value.`);
       }
       return [true, offset + this.encodedLength];
@@ -34417,9 +34391,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 bytes2 = value instanceof Uint8Array ? value : new Uint8Array(value);
-      const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
-      return new Uint8Array([...lengthBytes, ...bytes2]);
+      const bytes3 = value instanceof Uint8Array ? value : new Uint8Array(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(bytes3.length);
+      return new Uint8Array([...lengthBytes, ...bytes3]);
     }
     decode(data, offset) {
       if (data.length < WORD_SIZE) {
@@ -34546,26 +34520,26 @@ If you are attempting to transform a hex value, please make sure it is being pas
       this.options = options;
     }
     encode(value) {
-      let bytes2;
+      let bytes3;
       try {
-        bytes2 = toBytes2(value);
+        bytes3 = toBytes2(value);
       } catch (error) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}.`);
       }
-      if (bytes2.length > this.encodedLength) {
+      if (bytes3.length > this.encodedLength) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}, too many bytes.`);
       }
-      return toBytes2(bytes2, this.encodedLength);
+      return toBytes2(bytes3, this.encodedLength);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number data size.`);
       }
-      const bytes2 = data.slice(offset, offset + this.encodedLength);
-      if (bytes2.length !== this.encodedLength) {
+      const bytes3 = data.slice(offset, offset + this.encodedLength);
+      if (bytes3.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number byte data size.`);
       }
-      return [toNumber(bytes2), offset + this.encodedLength];
+      return [toNumber(bytes3), offset + this.encodedLength];
     }
   };
   var OptionCoder = class extends EnumCoder {
@@ -34583,9 +34557,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(output2) {
-      if (output2 && "Some" in output2) {
-        return output2.Some;
+    toOption(output3) {
+      if (output3 && "Some" in output3) {
+        return output3.Some;
       }
       return void 0;
     }
@@ -34599,9 +34573,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 bytes2 = internalCoder.encode(value);
-      const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
-      return new Uint8Array([...lengthBytes, ...bytes2]);
+      const bytes3 = internalCoder.encode(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(bytes3.length);
+      return new Uint8Array([...lengthBytes, ...bytes3]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -34624,9 +34598,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 bytes2 = toUtf8Bytes(value);
+      const bytes3 = toUtf8Bytes(value);
       const lengthBytes = new BigNumberCoder("u64").encode(value.length);
-      return new Uint8Array([...lengthBytes, ...bytes2]);
+      return new Uint8Array([...lengthBytes, ...bytes3]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -34648,9 +34622,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 bytes2 = toUtf8Bytes(value);
+      const bytes3 = toUtf8Bytes(value);
       const lengthBytes = new BigNumberCoder("u64").encode(value.length);
-      return new Uint8Array([...lengthBytes, ...bytes2]);
+      return new Uint8Array([...lengthBytes, ...bytes3]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -34659,11 +34633,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 bytes2 = data.slice(offsetAndLength, offsetAndLength + length);
-      if (bytes2.length !== length) {
+      const bytes3 = data.slice(offsetAndLength, offsetAndLength + length);
+      if (bytes3.length !== length) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string slice byte data size.`);
       }
-      return [toUtf8String(bytes2), offsetAndLength + length];
+      return [toUtf8String(bytes3), offsetAndLength + length];
     }
   };
   __publicField4(StrSliceCoder, "memorySize", 1);
@@ -34681,11 +34655,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 bytes2 = data.slice(offset, offset + this.encodedLength);
-      if (bytes2.length !== this.encodedLength) {
+      const bytes3 = data.slice(offset, offset + this.encodedLength);
+      if (bytes3.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string byte data size.`);
       }
-      return [toUtf8String(bytes2), offset + this.encodedLength];
+      return [toUtf8String(bytes3), offset + this.encodedLength];
     }
   };
   var StructCoder = class extends Coder {
@@ -34703,7 +34677,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
       this.#hasNestedOption = hasNestedOption(coders);
     }
     encode(value) {
-      return concatBytes2(
+      return concatBytes(
         Object.keys(this.coders).map((fieldName) => {
           const fieldCoder = this.coders[fieldName];
           const fieldValue = value[fieldName];
@@ -34745,7 +34719,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
       if (this.coders.length !== value.length) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Types/values length mismatch.`);
       }
-      return concatBytes2(this.coders.map((coder, i) => coder.encode(value[i])));
+      return concatBytes(this.coders.map((coder, i) => coder.encode(value[i])));
     }
     decode(data, offset) {
       if (!this.#hasNestedOption && data.length < this.encodedLength) {
@@ -34779,9 +34753,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 bytes2 = value.map((v) => this.coder.encode(v));
+      const bytes3 = value.map((v) => this.coder.encode(v));
       const lengthBytes = lengthCoder.encode(value.length);
-      return new Uint8Array([...lengthBytes, ...concatBytes2(bytes2)]);
+      return new Uint8Array([...lengthBytes, ...concatBytes(bytes3)]);
     }
     decode(data, offset) {
       if (!this.#hasNestedOption && data.length < this.encodedLength || data.length > MAX_BYTES) {
@@ -35160,10 +35134,10 @@ If you are attempting to transform a hex value, please make sure it is being pas
       throw new FuelError(ErrorCode.ABI_TYPES_AND_VALUES_MISMATCH, errorMsg);
     }
     decodeArguments(data) {
-      const bytes2 = arrayify(data);
+      const bytes3 = arrayify(data);
       const nonEmptyInputs = findNonEmptyInputs(this.jsonAbi, this.jsonFn.inputs);
       if (nonEmptyInputs.length === 0) {
-        if (bytes2.length === 0) {
+        if (bytes3.length === 0) {
           return void 0;
         }
         throw new FuelError(
@@ -35172,12 +35146,12 @@ If you are attempting to transform a hex value, please make sure it is being pas
             count: {
               types: this.jsonFn.inputs.length,
               nonEmptyInputs: nonEmptyInputs.length,
-              values: bytes2.length
+              values: bytes3.length
             },
             value: {
               args: this.jsonFn.inputs,
               nonEmptyInputs,
-              values: bytes2
+              values: bytes3
             }
           })}`
         );
@@ -35185,7 +35159,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
       const result = nonEmptyInputs.reduce(
         (obj, input) => {
           const coder = AbiCoder.getCoder(this.jsonAbi, input, { encoding: this.encoding });
-          const [decodedValue, decodedValueByteSize] = coder.decode(bytes2, obj.offset);
+          const [decodedValue, decodedValueByteSize] = coder.decode(bytes3, obj.offset);
           return {
             decoded: [...obj.decoded, decodedValue],
             offset: obj.offset + decodedValueByteSize
@@ -35200,11 +35174,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
       if (outputAbiType.type === "()") {
         return [void 0, 0];
       }
-      const bytes2 = arrayify(data);
+      const bytes3 = arrayify(data);
       const coder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output, {
         encoding: this.encoding
       });
-      return coder.decode(bytes2, 0);
+      return coder.decode(bytes3, 0);
     }
     /**
      * Checks if the function is read-only i.e. it only reads from storage, does not write to it.
@@ -35338,9 +35312,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }
     return addressLike;
   };
-  var getRandomB256 = () => hexlify(randomBytes22(32));
+  var getRandomB256 = () => hexlify(randomBytes2(32));
   var clearFirst12BytesFromB256 = (b256) => {
-    let bytes2;
+    let bytes3;
     try {
       if (!isB256(b256)) {
         throw new FuelError(
@@ -35348,15 +35322,15 @@ If you are attempting to transform a hex value, please make sure it is being pas
           `Invalid Bech32 Address: ${b256}.`
         );
       }
-      bytes2 = getBytesFromBech32(toBech32(b256));
-      bytes2 = hexlify(bytes2.fill(0, 0, 12));
+      bytes3 = getBytesFromBech32(toBech32(b256));
+      bytes3 = hexlify(bytes3.fill(0, 0, 12));
     } catch (error) {
       throw new FuelError(
         FuelError.CODES.PARSE_FAILED,
         `Cannot generate EVM Address B256 from: ${b256}.`
       );
     }
-    return bytes2;
+    return bytes3;
   };
   var padFirst12BytesOfEvmAddress = (address) => {
     if (!isEvmAddress(address)) {
@@ -36036,9 +36010,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 bytes2 = arrayify(messageData || "0x");
-      const dataLength = bytes2.length;
-      return new ByteArrayCoder(dataLength).encode(bytes2);
+      const bytes3 = arrayify(messageData || "0x");
+      const dataLength = bytes3.length;
+      return new ByteArrayCoder(dataLength).encode(bytes3);
     }
     encode(value) {
       const parts = [];
@@ -36060,9 +36034,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
       return concat(parts);
     }
     static decodeData(messageData) {
-      const bytes2 = arrayify(messageData);
-      const dataLength = bytes2.length;
-      const [data] = new ByteArrayCoder(dataLength).decode(bytes2, 0);
+      const bytes3 = arrayify(messageData);
+      const dataLength = bytes3.length;
+      const [data] = new ByteArrayCoder(dataLength).decode(bytes3, 0);
       return arrayify(data);
     }
     decode(data, offset) {
@@ -37142,9 +37116,10 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }
   };
 
-  // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/utils.js
+  // ../../node_modules/.pnpm/@noble+curves@1.4.0/node_modules/@noble/curves/esm/abstract/utils.js
   var utils_exports = {};
   __export(utils_exports, {
+    abytes: () => abytes,
     bitGet: () => bitGet,
     bitLen: () => bitLen,
     bitMask: () => bitMask,
@@ -37152,7 +37127,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
     bytesToHex: () => bytesToHex,
     bytesToNumberBE: () => bytesToNumberBE,
     bytesToNumberLE: () => bytesToNumberLE,
-    concatBytes: () => concatBytes3,
+    concatBytes: () => concatBytes2,
     createHmacDrbg: () => createHmacDrbg,
     ensureBytes: () => ensureBytes,
     equalBytes: () => equalBytes,
@@ -37172,13 +37147,16 @@ If you are attempting to transform a hex value, please make sure it is being pas
   function isBytes3(a) {
     return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
   }
-  var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-  function bytesToHex(bytes2) {
-    if (!isBytes3(bytes2))
+  function abytes(item) {
+    if (!isBytes3(item))
       throw new Error("Uint8Array expected");
+  }
+  var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+  function bytesToHex(bytes3) {
+    abytes(bytes3);
     let hex = "";
-    for (let i = 0; i < bytes2.length; i++) {
-      hex += hexes[bytes2[i]];
+    for (let i = 0; i < bytes3.length; i++) {
+      hex += hexes[bytes3[i]];
     }
     return hex;
   }
@@ -37220,13 +37198,12 @@ If you are attempting to transform a hex value, please make sure it is being pas
     }
     return array;
   }
-  function bytesToNumberBE(bytes2) {
-    return hexToNumber(bytesToHex(bytes2));
+  function bytesToNumberBE(bytes3) {
+    return hexToNumber(bytesToHex(bytes3));
   }
-  function bytesToNumberLE(bytes2) {
-    if (!isBytes3(bytes2))
-      throw new Error("Uint8Array expected");
-    return hexToNumber(bytesToHex(Uint8Array.from(bytes2).reverse()));
+  function bytesToNumberLE(bytes3) {
+    abytes(bytes3);
+    return hexToNumber(bytesToHex(Uint8Array.from(bytes3).reverse()));
   }
   function numberToBytesBE(n, len) {
     return hexToBytes(n.toString(16).padStart(len * 2, "0"));
@@ -37255,17 +37232,15 @@ 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 concatBytes3(...arrays) {
+  function concatBytes2(...arrays) {
     let sum = 0;
     for (let i = 0; i < arrays.length; i++) {
       const a = arrays[i];
-      if (!isBytes3(a))
-        throw new Error("Uint8Array expected");
+      abytes(a);
       sum += a.length;
     }
-    let res = new Uint8Array(sum);
-    let pad3 = 0;
-    for (let i = 0; i < arrays.length; i++) {
+    const res = new Uint8Array(sum);
+    for (let i = 0, pad3 = 0; i < arrays.length; i++) {
       const a = arrays[i];
       res.set(a, pad3);
       pad3 += a.length;
@@ -37294,9 +37269,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
   function bitGet(n, pos) {
     return n >> BigInt(pos) & _1n2;
   }
-  var bitSet = (n, pos, value) => {
+  function bitSet(n, pos, value) {
     return n | (value ? _1n2 : _0n2) << BigInt(pos);
-  };
+  }
   var bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
   var u8n = (data) => new Uint8Array(data);
   var u8fr = (arr) => Uint8Array.from(arr);
@@ -37335,7 +37310,7 @@ If you are attempting to transform a hex value, please make sure it is being pas
         out.push(sl);
         len += v.length;
       }
-      return concatBytes3(...out);
+      return concatBytes2(...out);
     };
     const genUntil = (seed, pred) => {
       reset();
@@ -37599,19 +37574,19 @@ If you are attempting to transform a hex value, please make sure it is being pas
       return "GraphQLError";
     }
     toString() {
-      let output2 = this.message;
+      let output3 = this.message;
       if (this.nodes) {
         for (const node of this.nodes) {
           if (node.loc) {
-            output2 += "\n\n" + printLocation(node.loc);
+            output3 += "\n\n" + printLocation(node.loc);
           }
         }
       } else if (this.source && this.locations) {
         for (const location of this.locations) {
-          output2 += "\n\n" + printSourceLocation(this.source, location);
+          output3 += "\n\n" + printSourceLocation(this.source, location);
         }
       }
-      return output2;
+      return output3;
     }
     toJSON() {
       const formattedError = {
@@ -42369,8 +42344,8 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      *
      * Pushes an output to the list without any side effects and returns the index
      */
-    pushOutput(output2) {
-      this.outputs.push(output2);
+    pushOutput(output3) {
+      this.outputs.push(output3);
       return this.outputs.length - 1;
     }
     /**
@@ -42454,7 +42429,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     getCoinOutputs() {
       return this.outputs.filter(
-        (output2) => output2.type === OutputType.Coin
+        (output3) => output3.type === OutputType.Coin
       );
     }
     /**
@@ -42464,7 +42439,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     getChangeOutputs() {
       return this.outputs.filter(
-        (output2) => output2.type === OutputType.Change
+        (output3) => output3.type === OutputType.Change
       );
     }
     /**
@@ -42614,7 +42589,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     addChangeOutput(to, assetId) {
       const changeOutput = this.getChangeOutputs().find(
-        (output2) => hexlify(output2.assetId) === assetId
+        (output3) => hexlify(output3.assetId) === assetId
       );
       if (!changeOutput) {
         this.pushOutput({
@@ -42692,12 +42667,12 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
           usedQuantity = bn("1000000000000000000");
         }
         if (assetInput && "assetId" in assetInput) {
-          assetInput.id = hexlify(randomBytes22(UTXO_ID_LEN));
+          assetInput.id = hexlify(randomBytes2(UTXO_ID_LEN));
           assetInput.amount = usedQuantity;
         } else {
           this.addResources([
             {
-              id: hexlify(randomBytes22(UTXO_ID_LEN)),
+              id: hexlify(randomBytes2(UTXO_ID_LEN)),
               amount: usedQuantity,
               assetId,
               owner: resourcesOwner || Address.fromRandom(),
@@ -42793,8 +42768,8 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
           return inputClone;
       }
     });
-    transaction.outputs = transaction.outputs.map((output2) => {
-      const outputClone = clone_default(output2);
+    transaction.outputs = transaction.outputs.map((output3) => {
+      const outputClone = clone_default(output3);
       switch (outputClone.type) {
         case OutputType.Contract: {
           outputClone.balanceRoot = ZeroBytes32;
@@ -42896,7 +42871,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     getContractCreatedOutputs() {
       return this.outputs.filter(
-        (output2) => output2.type === OutputType.ContractCreated
+        (output3) => output3.type === OutputType.ContractCreated
       );
     }
     /**
@@ -43022,7 +42997,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     getContractOutputs() {
       return this.outputs.filter(
-        (output2) => output2.type === OutputType.Contract
+        (output3) => output3.type === OutputType.Contract
       );
     }
     /**
@@ -43032,7 +43007,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     getVariableOutputs() {
       return this.outputs.filter(
-        (output2) => output2.type === OutputType.Variable
+        (output3) => output3.type === OutputType.Variable
       );
     }
     /**
@@ -43455,8 +43430,8 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
   }) {
     const contractCallReceipts = getReceiptsCall(receipts);
     const contractOutputs = getOutputsContract(outputs);
-    const contractCallOperations = contractOutputs.reduce((prevOutputCallOps, output2) => {
-      const contractInput = getInputContractFromIndex(inputs, output2.inputIndex);
+    const contractCallOperations = contractOutputs.reduce((prevOutputCallOps, output3) => {
+      const contractInput = getInputContractFromIndex(inputs, output3.inputIndex);
       if (contractInput) {
         const newCallOps = contractCallReceipts.reduce((prevContractCallOps, receipt) => {
           if (receipt.to === contractInput.contractID) {
@@ -43510,7 +43485,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((output2) => output2.assetId === assetId);
+      const change = changeOutputs.find((output3) => output3.assetId === assetId);
       fromAddress = change?.to || fromAddress;
     }
     const fromType = contractInputs.some((input) => input.contractID === fromAddress) ? 0 /* contract */ : 1 /* account */;
@@ -43541,8 +43516,8 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     const coinOutputs = getOutputsCoin(outputs);
     const contractInputs = getInputsContract(inputs);
     const changeOutputs = getOutputsChange(outputs);
-    coinOutputs.forEach((output2) => {
-      const { amount, assetId, to } = output2;
+    coinOutputs.forEach((output3) => {
+      const { amount, assetId, to } = output3;
       const changeOutput = changeOutputs.find((change) => change.assetId === assetId);
       if (changeOutput) {
         operations = addOperation(operations, {
@@ -43580,7 +43555,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
   }
   function getPayProducerOperations(outputs) {
     const coinOutputs = getOutputsCoin(outputs);
-    const payProducerOperations = coinOutputs.reduce((prev, output2) => {
+    const payProducerOperations = coinOutputs.reduce((prev, output3) => {
       const operations = addOperation(prev, {
         name: "Pay network fee to block producer" /* payBlockProducer */,
         from: {
@@ -43589,12 +43564,12 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
         },
         to: {
           type: 1 /* account */,
-          address: output2.to.toString()
+          address: output3.to.toString()
         },
         assetsSent: [
           {
-            assetId: output2.assetId.toString(),
-            amount: output2.amount
+            assetId: output3.assetId.toString(),
+            amount: output3.amount
           }
         ]
       });
@@ -44839,6 +44814,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns A promise that resolves to the coins.
      */
     async getCoins(owner, assetId, paginationArgs) {
+      this.validatePaginationArgs(paginationArgs);
       const ownerAddress = Address.fromAddressOrString(owner);
       const {
         coins: { edges, pageInfo }
@@ -45073,8 +45049,8 @@ Supported fuel-core version: ${supportedVersion}.`
         balances: { edges }
       } = await this.operations.getBalances({
         /**
-         * The query signature for this method was create to support pagination but the
-         * current Fuel-Core implementation does not support pagination yet
+         * The query parameters for this method were designed to support pagination,
+         * but the current Fuel-Core implementation does not support pagination yet.
          */
         first: 1e4,
         filter: { owner: Address.fromAddressOrString(owner).toB256() }
@@ -45093,6 +45069,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns A promise that resolves to the messages.
      */
     async getMessages(address, paginationArgs) {
+      this.validatePaginationArgs(paginationArgs);
       const {
         messages: { edges, pageInfo }
       } = await this.operations.getMessages({
@@ -45297,6 +45274,18 @@ Supported fuel-core version: ${supportedVersion}.`
       }
       return relayedTransactionStatus;
     }
+    /**
+     * @hidden
+     */
+    validatePaginationArgs({ first, last } = {}) {
+      const MAX_PAGINATION_LIMIT = 1e3;
+      if ((first || 0) > MAX_PAGINATION_LIMIT || (last || 0) > MAX_PAGINATION_LIMIT) {
+        throw new FuelError(
+          ErrorCode.INVALID_INPUT_PARAMETERS,
+          "Pagination limit cannot exceed 1000 items"
+        );
+      }
+    }
     /**
      * @hidden
      */
@@ -45863,7 +45852,7 @@ Supported fuel-core version: ${supportedVersion}.`
      */
     generateFakeResources(coins) {
       return coins.map((coin) => ({
-        id: hexlify(randomBytes22(UTXO_ID_LEN)),
+        id: hexlify(randomBytes2(UTXO_ID_LEN)),
         owner: this.address,
         blockCreated: bn(1),
         txCreatedIdx: bn(1),
@@ -45922,7 +45911,349 @@ Supported fuel-core version: ${supportedVersion}.`
     }
   };
 
-  // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/modular.js
+  // ../../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, pad3 = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      res.set(a, pad3);
+      pad3 += 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+curves@1.4.0/node_modules/@noble/curves/esm/abstract/modular.js
   var _0n3 = BigInt(0);
   var _1n3 = BigInt(1);
   var _2n3 = BigInt(2);
@@ -45958,11 +46289,11 @@ Supported fuel-core version: ${supportedVersion}.`
     }
     return res;
   }
-  function invert(number2, modulo) {
-    if (number2 === _0n3 || modulo <= _0n3) {
-      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
+  function invert(number3, modulo) {
+    if (number3 === _0n3 || modulo <= _0n3) {
+      throw new Error(`invert: expected positive integers, got n=${number3} mod=${modulo}`);
     }
-    let a = mod(number2, modulo);
+    let a = mod(number3, modulo);
     let b = modulo;
     let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
     while (a !== _0n3) {
@@ -46117,7 +46448,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const nByteLength = Math.ceil(_nBitLength / 8);
     return { nBitLength: _nBitLength, nByteLength };
   }
-  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
+  function Field(ORDER, bitLen2, isLE3 = false, redef = {}) {
     if (ORDER <= _0n3)
       throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
     const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
@@ -46158,11 +46489,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) => 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);
+      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);
       }
     });
     return Object.freeze(f2);
@@ -46177,18 +46508,18 @@ Supported fuel-core version: ${supportedVersion}.`
     const length = getFieldBytesLength(fieldOrder);
     return length + Math.ceil(length / 2);
   }
-  function mapHashToField(key, fieldOrder, isLE2 = false) {
+  function mapHashToField(key, fieldOrder, isLE3 = 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 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
+    const num = isLE3 ? bytesToNumberBE(key) : bytesToNumberLE(key);
     const reduced = mod(num, fieldOrder - _1n3) + _1n3;
-    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
+    return isLE3 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
   }
 
-  // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/curve.js
+  // ../../node_modules/.pnpm/@noble+curves@1.4.0/node_modules/@noble/curves/esm/abstract/curve.js
   var _0n4 = BigInt(0);
   var _1n4 = BigInt(1);
   function wNAF(c, bits) {
@@ -46306,7 +46637,7 @@ Supported fuel-core version: ${supportedVersion}.`
     });
   }
 
-  // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
+  // ../../node_modules/.pnpm/@noble+curves@1.4.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
   function validatePointOpts(curve) {
     const opts = validateBasic(curve);
     validateObject(opts, {
@@ -46357,8 +46688,7 @@ Supported fuel-core version: ${supportedVersion}.`
     toSig(hex) {
       const { Err: E } = DER;
       const data = typeof hex === "string" ? h2b(hex) : hex;
-      if (!isBytes3(data))
-        throw new Error("ui8a expected");
+      abytes(data);
       let l = data.length;
       if (l < 2 || data[0] != 48)
         throw new E("Invalid signature tag");
@@ -46393,12 +46723,12 @@ Supported fuel-core version: ${supportedVersion}.`
   function weierstrassPoints(opts) {
     const CURVE = validatePointOpts(opts);
     const { Fp: Fp2 } = CURVE;
-    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
+    const toBytes4 = CURVE.toBytes || ((_c, point, _isCompressed) => {
       const a = point.toAffine();
-      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
+      return concatBytes2(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
     });
-    const fromBytes = CURVE.fromBytes || ((bytes2) => {
-      const tail = bytes2.subarray(1);
+    const fromBytes = CURVE.fromBytes || ((bytes3) => {
+      const tail = bytes3.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 };
@@ -46761,7 +47091,7 @@ Supported fuel-core version: ${supportedVersion}.`
       }
       toRawBytes(isCompressed = true) {
         this.assertValidity();
-        return toBytes3(Point2, this, isCompressed);
+        return toBytes4(Point2, this, isCompressed);
       }
       toHex(isCompressed = true) {
         return bytesToHex(this.toRawBytes(isCompressed));
@@ -46811,23 +47141,29 @@ Supported fuel-core version: ${supportedVersion}.`
       toBytes(_c, point, isCompressed) {
         const a = point.toAffine();
         const x = Fp2.toBytes(a.x);
-        const cat = concatBytes3;
+        const cat = concatBytes2;
         if (isCompressed) {
           return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
         } else {
           return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
         }
       },
-      fromBytes(bytes2) {
-        const len = bytes2.length;
-        const head = bytes2[0];
-        const tail = bytes2.subarray(1);
+      fromBytes(bytes3) {
+        const len = bytes3.length;
+        const head = bytes3[0];
+        const tail = bytes3.subarray(1);
         if (len === compressedLen && (head === 2 || head === 3)) {
           const x = bytesToNumberBE(tail);
           if (!isValidFieldElement(x))
             throw new Error("Point is not on curve");
           const y2 = weierstrassEquation(x);
-          let y = Fp2.sqrt(y2);
+          let y;
+          try {
+            y = Fp2.sqrt(y2);
+          } catch (sqrtError) {
+            const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
+            throw new Error("Point is not on curve" + suffix);
+          }
           const isYOdd = (y & _1n5) === _1n5;
           const isHeadOdd = (head & 1) === 1;
           if (isHeadOdd !== isYOdd)
@@ -46843,9 +47179,9 @@ Supported fuel-core version: ${supportedVersion}.`
       }
     });
     const numToNByteStr = (num) => bytesToHex(numberToBytesBE(num, CURVE.nByteLength));
-    function isBiggerThanHalfOrder(number2) {
+    function isBiggerThanHalfOrder(number3) {
       const HALF = CURVE_ORDER >> _1n5;
-      return number2 > HALF;
+      return number3 > HALF;
     }
     function normalizeS(s) {
       return isBiggerThanHalfOrder(s) ? modN(-s) : s;
@@ -46975,13 +47311,13 @@ Supported fuel-core version: ${supportedVersion}.`
       const b = Point2.fromHex(publicB);
       return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
     }
-    const bits2int = CURVE.bits2int || function(bytes2) {
-      const num = bytesToNumberBE(bytes2);
-      const delta = bytes2.length * 8 - CURVE.nBitLength;
+    const bits2int = CURVE.bits2int || function(bytes3) {
+      const num = bytesToNumberBE(bytes3);
+      const delta = bytes3.length * 8 - CURVE.nBitLength;
       return delta > 0 ? num >> BigInt(delta) : num;
     };
-    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
-      return modN(bits2int(bytes2));
+    const bits2int_modN = CURVE.bits2int_modN || function(bytes3) {
+      return modN(bits2int(bytes3));
     };
     const ORDER_MASK = bitMask(CURVE.nBitLength);
     function int2octets(num) {
@@ -46994,21 +47330,21 @@ Supported fuel-core version: ${supportedVersion}.`
     function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
       if (["recovered", "canonical"].some((k) => k in opts))
         throw new Error("sign() legacy options not supported");
-      const { hash: hash3, randomBytes: randomBytes3 } = CURVE;
+      const { hash: hash4, randomBytes: randomBytes4 } = CURVE;
       let { lowS, prehash, extraEntropy: ent } = opts;
       if (lowS == null)
         lowS = true;
       msgHash = ensureBytes("msgHash", msgHash);
       if (prehash)
-        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
+        msgHash = ensureBytes("prehashed msgHash", hash4(msgHash));
       const h1int = bits2int_modN(msgHash);
       const d = normPrivateKeyToScalar(privateKey);
       const seedArgs = [int2octets(d), int2octets(h1int)];
-      if (ent != null) {
-        const e = ent === true ? randomBytes3(Fp2.BYTES) : ent;
+      if (ent != null && ent !== false) {
+        const e = ent === true ? randomBytes4(Fp2.BYTES) : ent;
         seedArgs.push(ensureBytes("extraEntropy", e));
       }
-      const seed = concatBytes3(...seedArgs);
+      const seed = concatBytes2(...seedArgs);
       const m = h1int;
       function k2sig(kBytes) {
         const k = bits2int(kBytes);
@@ -47098,20 +47434,85 @@ Supported fuel-core version: ${supportedVersion}.`
     };
   }
 
-  // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/_shortw_utils.js
-  function getHash(hash3) {
+  // ../../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 pad3 = new Uint8Array(blockLen);
+      pad3.set(key.length > blockLen ? hash4.create().update(key).digest() : key);
+      for (let i = 0; i < pad3.length; i++)
+        pad3[i] ^= 54;
+      this.iHash.update(pad3);
+      this.oHash = hash4.create();
+      for (let i = 0; i < pad3.length; i++)
+        pad3[i] ^= 54 ^ 92;
+      this.oHash.update(pad3);
+      pad3.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.0/node_modules/@noble/curves/esm/_shortw_utils.js
+  function getHash(hash4) {
     return {
-      hash: hash3,
-      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes(...msgs)),
-      randomBytes
+      hash: hash4,
+      hmac: (key, ...msgs) => hmac2(hash4, key, concatBytes3(...msgs)),
+      randomBytes: randomBytes3
     };
   }
   function createCurve(curveDef, defHash) {
-    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
+    const create = (hash4) => weierstrass({ ...curveDef, ...getHash(hash4) });
     return Object.freeze({ ...create(defHash), create });
   }
 
-  // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/secp256k1.js
+  // ../../node_modules/.pnpm/@noble+curves@1.4.0/node_modules/@noble/curves/esm/secp256k1.js
   var secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
   var secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
   var _1n6 = BigInt(1);
@@ -47187,7 +47588,7 @@ Supported fuel-core version: ${supportedVersion}.`
         return { k1neg, k1, k2neg, k2 };
       }
     }
-  }, sha256);
+  }, sha2563);
   var _0n6 = BigInt(0);
   var Point = secp256k1.ProjectivePoint;
 
@@ -47280,7 +47681,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns random 32-byte hashed
      */
     static generatePrivateKey(entropy) {
-      return entropy ? hash2(concat([randomBytes22(32), arrayify(entropy)])) : randomBytes22(32);
+      return entropy ? hash2(concat([randomBytes2(32), arrayify(entropy)])) : randomBytes2(32);
     }
     /**
      * Extended publicKey from a compact publicKey
@@ -47356,7 +47757,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 = randomBytes22(DEFAULT_KEY_SIZE);
+    const salt = randomBytes2(DEFAULT_KEY_SIZE);
     const key = scrypt22({
       password: bufferFromString2(password),
       salt,
@@ -47365,7 +47766,7 @@ Supported fuel-core version: ${supportedVersion}.`
       r: DEFAULT_KDF_PARAMS_R,
       p: DEFAULT_KDF_PARAMS_P
     });
-    const iv = randomBytes22(DEFAULT_IV_SIZE);
+    const iv = randomBytes2(DEFAULT_IV_SIZE);
     const ciphertext = await encryptJsonWalletData2(privateKeyBuffer, key, iv);
     const data = Uint8Array.from([...key.subarray(16, 32), ...ciphertext]);
     const macHashUint8Array = keccak2562(data);
@@ -49861,7 +50262,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns A randomly generated mnemonic
      */
     static generate(size = 32, extraEntropy = "") {
-      const entropy = extraEntropy ? sha2562(concat([randomBytes22(size), arrayify(extraEntropy)])) : randomBytes22(size);
+      const entropy = extraEntropy ? sha2562(concat([randomBytes2(size), arrayify(extraEntropy)])) : randomBytes2(size);
       return Mnemonic.entropyToMnemonic(entropy);
     }
   };
@@ -49962,9 +50363,9 @@ Supported fuel-core version: ${supportedVersion}.`
         data.set(arrayify(this.publicKey));
       }
       data.set(toBytes2(index, 4), 33);
-      const bytes2 = arrayify(computeHmac2("sha512", chainCode, data));
-      const IL = bytes2.slice(0, 32);
-      const IR = bytes2.slice(32);
+      const bytes3 = arrayify(computeHmac2("sha512", chainCode, data));
+      const IL = bytes3.slice(0, 32);
+      const IR = bytes3.slice(32);
       if (privateKey) {
         const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
         const ki = bn(IL).add(privateKey).mod(N).toBytes(32);
@@ -50034,26 +50435,26 @@ Supported fuel-core version: ${supportedVersion}.`
     }
     static fromExtendedKey(extendedKey) {
       const decoded = hexlify(toBytes2(decodeBase58(extendedKey)));
-      const bytes2 = arrayify(decoded);
-      const validChecksum = base58check(bytes2.slice(0, 78)) === extendedKey;
-      if (bytes2.length !== 82 || !isValidExtendedKey(bytes2)) {
+      const bytes3 = arrayify(decoded);
+      const validChecksum = base58check(bytes3.slice(0, 78)) === extendedKey;
+      if (bytes3.length !== 82 || !isValidExtendedKey(bytes3)) {
         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 = 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);
+      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);
       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(bytes2)) {
+      if (isPublicExtendedKey(bytes3)) {
         if (key[0] !== 3) {
           throw new FuelError(ErrorCode.HD_WALLET_ERROR, "Invalid public extended key.");
         }
@@ -50235,7 +50636,7 @@ Supported fuel-core version: ${supportedVersion}.`
   var seedTestWallet = async (wallet, quantities, utxosAmount = 1) => {
     const accountsToBeFunded = Array.isArray(wallet) ? wallet : [wallet];
     const [{ provider }] = accountsToBeFunded;
-    const genesisWallet = new WalletUnlocked(process.env.GENESIS_SECRET || randomBytes22(32), provider);
+    const genesisWallet = new WalletUnlocked(process.env.GENESIS_SECRET || randomBytes2(32), provider);
     const request = new ScriptTransactionRequest();
     quantities.map(coinQuantityfy).forEach(
       ({ amount, assetId }) => accountsToBeFunded.forEach(({ address }) => {
@@ -50315,7 +50716,7 @@ Supported fuel-core version: ${supportedVersion}.`
       const signer = new Signer(pk);
       process.env.GENESIS_SECRET = hexlify(pk);
       coins.push({
-        tx_id: hexlify(randomBytes22(BYTES_32)),
+        tx_id: hexlify(randomBytes2(BYTES_32)),
         owner: signer.address.toHexString(),
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         amount: "18446744073709551615",
@@ -50480,7 +50881,7 @@ Supported fuel-core version: ${supportedVersion}.`
     static random(count = 1) {
       const assetIds = [];
       for (let i = 0; i < count; i++) {
-        assetIds.push(new _AssetId(hexlify(randomBytes22(32))));
+        assetIds.push(new _AssetId(hexlify(randomBytes2(32))));
       }
       return assetIds;
     }
@@ -50501,7 +50902,7 @@ Supported fuel-core version: ${supportedVersion}.`
     generateWallets = () => {
       const generatedWallets = [];
       for (let index = 1; index <= this.options.count; index++) {
-        generatedWallets.push(new WalletUnlocked(randomBytes22(32)));
+        generatedWallets.push(new WalletUnlocked(randomBytes2(32)));
       }
       return generatedWallets;
     };
@@ -50558,7 +50959,7 @@ Supported fuel-core version: ${supportedVersion}.`
               tx_pointer_block_height: 0,
               tx_pointer_tx_idx: 0,
               output_index: 0,
-              tx_id: hexlify(randomBytes22(32))
+              tx_id: hexlify(randomBytes2(32))
             });
           }
         });
@@ -50664,7 +51065,7 @@ Supported fuel-core version: ${supportedVersion}.`
     constructor({
       sender = Address.fromRandom(),
       recipient = Address.fromRandom(),
-      nonce = hexlify(randomBytes22(32)),
+      nonce = hexlify(randomBytes2(32)),
       amount = 1e6,
       data = "02",
       da_height = 0
@@ -50712,6 +51113,9 @@ 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) *)