@fuel-ts/account 0.0.0-pr-2143-20240510170046 → 0.0.0-pr-2143-20240513112950

package/dist/test-utils.global.js

@@ -59,178 +59,12 @@
     return method;
   };
 
-  // ../../node_modules/.pnpm/bech32@2.0.0/node_modules/bech32/dist/index.js
-  var require_dist = __commonJS({
-    "../../node_modules/.pnpm/bech32@2.0.0/node_modules/bech32/dist/index.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.bech32m = exports.bech32 = void 0;
-      var ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
-      var ALPHABET_MAP = {};
-      for (let z = 0; z < ALPHABET.length; z++) {
-        const x = ALPHABET.charAt(z);
-        ALPHABET_MAP[x] = z;
-      }
-      function polymodStep(pre) {
-        const b = pre >> 25;
-        return (pre & 33554431) << 5 ^ -(b >> 0 & 1) & 996825010 ^ -(b >> 1 & 1) & 642813549 ^ -(b >> 2 & 1) & 513874426 ^ -(b >> 3 & 1) & 1027748829 ^ -(b >> 4 & 1) & 705979059;
-      }
-      function prefixChk(prefix) {
-        let chk = 1;
-        for (let i = 0; i < prefix.length; ++i) {
-          const c = prefix.charCodeAt(i);
-          if (c < 33 || c > 126)
-            return "Invalid prefix (" + prefix + ")";
-          chk = polymodStep(chk) ^ c >> 5;
-        }
-        chk = polymodStep(chk);
-        for (let i = 0; i < prefix.length; ++i) {
-          const v = prefix.charCodeAt(i);
-          chk = polymodStep(chk) ^ v & 31;
-        }
-        return chk;
-      }
-      function convert2(data, inBits, outBits, pad3) {
-        let value = 0;
-        let bits = 0;
-        const maxV = (1 << outBits) - 1;
-        const result = [];
-        for (let i = 0; i < data.length; ++i) {
-          value = value << inBits | data[i];
-          bits += inBits;
-          while (bits >= outBits) {
-            bits -= outBits;
-            result.push(value >> bits & maxV);
-          }
-        }
-        if (pad3) {
-          if (bits > 0) {
-            result.push(value << outBits - bits & maxV);
-          }
-        } else {
-          if (bits >= inBits)
-            return "Excess padding";
-          if (value << outBits - bits & maxV)
-            return "Non-zero padding";
-        }
-        return result;
-      }
-      function toWords(bytes3) {
-        return convert2(bytes3, 8, 5, true);
-      }
-      function fromWordsUnsafe(words) {
-        const res = convert2(words, 5, 8, false);
-        if (Array.isArray(res))
-          return res;
-      }
-      function fromWords(words) {
-        const res = convert2(words, 5, 8, false);
-        if (Array.isArray(res))
-          return res;
-        throw new Error(res);
-      }
-      function getLibraryFromEncoding(encoding) {
-        let ENCODING_CONST;
-        if (encoding === "bech32") {
-          ENCODING_CONST = 1;
-        } else {
-          ENCODING_CONST = 734539939;
-        }
-        function encode(prefix, words, LIMIT) {
-          LIMIT = LIMIT || 90;
-          if (prefix.length + 7 + words.length > LIMIT)
-            throw new TypeError("Exceeds length limit");
-          prefix = prefix.toLowerCase();
-          let chk = prefixChk(prefix);
-          if (typeof chk === "string")
-            throw new Error(chk);
-          let result = prefix + "1";
-          for (let i = 0; i < words.length; ++i) {
-            const x = words[i];
-            if (x >> 5 !== 0)
-              throw new Error("Non 5-bit word");
-            chk = polymodStep(chk) ^ x;
-            result += ALPHABET.charAt(x);
-          }
-          for (let i = 0; i < 6; ++i) {
-            chk = polymodStep(chk);
-          }
-          chk ^= ENCODING_CONST;
-          for (let i = 0; i < 6; ++i) {
-            const v = chk >> (5 - i) * 5 & 31;
-            result += ALPHABET.charAt(v);
-          }
-          return result;
-        }
-        function __decode(str, LIMIT) {
-          LIMIT = LIMIT || 90;
-          if (str.length < 8)
-            return str + " too short";
-          if (str.length > LIMIT)
-            return "Exceeds length limit";
-          const lowered = str.toLowerCase();
-          const uppered = str.toUpperCase();
-          if (str !== lowered && str !== uppered)
-            return "Mixed-case string " + str;
-          str = lowered;
-          const split2 = str.lastIndexOf("1");
-          if (split2 === -1)
-            return "No separator character for " + str;
-          if (split2 === 0)
-            return "Missing prefix for " + str;
-          const prefix = str.slice(0, split2);
-          const wordChars = str.slice(split2 + 1);
-          if (wordChars.length < 6)
-            return "Data too short";
-          let chk = prefixChk(prefix);
-          if (typeof chk === "string")
-            return chk;
-          const words = [];
-          for (let i = 0; i < wordChars.length; ++i) {
-            const c = wordChars.charAt(i);
-            const v = ALPHABET_MAP[c];
-            if (v === void 0)
-              return "Unknown character " + c;
-            chk = polymodStep(chk) ^ v;
-            if (i + 6 >= wordChars.length)
-              continue;
-            words.push(v);
-          }
-          if (chk !== ENCODING_CONST)
-            return "Invalid checksum for " + str;
-          return { prefix, words };
-        }
-        function decodeUnsafe(str, LIMIT) {
-          const res = __decode(str, LIMIT);
-          if (typeof res === "object")
-            return res;
-        }
-        function decode(str, LIMIT) {
-          const res = __decode(str, LIMIT);
-          if (typeof res === "object")
-            return res;
-          throw new Error(res);
-        }
-        return {
-          decodeUnsafe,
-          decode,
-          encode,
-          toWords,
-          fromWordsUnsafe,
-          fromWords
-        };
-      }
-      exports.bech32 = getLibraryFromEncoding("bech32");
-      exports.bech32m = getLibraryFromEncoding("bech32m");
-    }
-  });
-
   // ../../node_modules/.pnpm/bn.js@5.2.1/node_modules/bn.js/lib/bn.js
   var require_bn = __commonJS({
     "../../node_modules/.pnpm/bn.js@5.2.1/node_modules/bn.js/lib/bn.js"(exports, module) {
       (function(module2, exports2) {
         "use strict";
-        function assert3(val, msg) {
+        function assert2(val, msg) {
           if (!val)
             throw new Error(msg || "Assertion failed");
         }
@@ -242,20 +76,20 @@
           ctor.prototype = new TempCtor();
           ctor.prototype.constructor = ctor;
         }
-        function BN2(number3, base, endian) {
-          if (BN2.isBN(number3)) {
-            return number3;
+        function BN2(number2, base, endian) {
+          if (BN2.isBN(number2)) {
+            return number2;
           }
           this.negative = 0;
           this.words = null;
           this.length = 0;
           this.red = null;
-          if (number3 !== null) {
+          if (number2 !== null) {
             if (base === "le" || base === "be") {
               endian = base;
               base = 10;
             }
-            this._init(number3 || 0, base || 10, endian || "be");
+            this._init(number2 || 0, base || 10, endian || "be");
           }
         }
         if (typeof module2 === "object") {
@@ -290,53 +124,53 @@
             return left;
           return right;
         };
-        BN2.prototype._init = function init(number3, base, endian) {
-          if (typeof number3 === "number") {
-            return this._initNumber(number3, base, endian);
+        BN2.prototype._init = function init(number2, base, endian) {
+          if (typeof number2 === "number") {
+            return this._initNumber(number2, base, endian);
           }
-          if (typeof number3 === "object") {
-            return this._initArray(number3, base, endian);
+          if (typeof number2 === "object") {
+            return this._initArray(number2, base, endian);
           }
           if (base === "hex") {
             base = 16;
           }
-          assert3(base === (base | 0) && base >= 2 && base <= 36);
-          number3 = number3.toString().replace(/\s+/g, "");
+          assert2(base === (base | 0) && base >= 2 && base <= 36);
+          number2 = number2.toString().replace(/\s+/g, "");
           var start = 0;
-          if (number3[0] === "-") {
+          if (number2[0] === "-") {
             start++;
             this.negative = 1;
           }
-          if (start < number3.length) {
+          if (start < number2.length) {
             if (base === 16) {
-              this._parseHex(number3, start, endian);
+              this._parseHex(number2, start, endian);
             } else {
-              this._parseBase(number3, base, start);
+              this._parseBase(number2, base, start);
               if (endian === "le") {
                 this._initArray(this.toArray(), base, endian);
               }
             }
           }
         };
-        BN2.prototype._initNumber = function _initNumber(number3, base, endian) {
-          if (number3 < 0) {
+        BN2.prototype._initNumber = function _initNumber(number2, base, endian) {
+          if (number2 < 0) {
             this.negative = 1;
-            number3 = -number3;
+            number2 = -number2;
           }
-          if (number3 < 67108864) {
-            this.words = [number3 & 67108863];
+          if (number2 < 67108864) {
+            this.words = [number2 & 67108863];
             this.length = 1;
-          } else if (number3 < 4503599627370496) {
+          } else if (number2 < 4503599627370496) {
             this.words = [
-              number3 & 67108863,
-              number3 / 67108864 & 67108863
+              number2 & 67108863,
+              number2 / 67108864 & 67108863
             ];
             this.length = 2;
           } else {
-            assert3(number3 < 9007199254740992);
+            assert2(number2 < 9007199254740992);
             this.words = [
-              number3 & 67108863,
-              number3 / 67108864 & 67108863,
+              number2 & 67108863,
+              number2 / 67108864 & 67108863,
               1
             ];
             this.length = 3;
@@ -345,14 +179,14 @@
             return;
           this._initArray(this.toArray(), base, endian);
         };
-        BN2.prototype._initArray = function _initArray(number3, base, endian) {
-          assert3(typeof number3.length === "number");
-          if (number3.length <= 0) {
+        BN2.prototype._initArray = function _initArray(number2, base, endian) {
+          assert2(typeof number2.length === "number");
+          if (number2.length <= 0) {
             this.words = [0];
             this.length = 1;
             return this;
           }
-          this.length = Math.ceil(number3.length / 3);
+          this.length = Math.ceil(number2.length / 3);
           this.words = new Array(this.length);
           for (var i = 0; i < this.length; i++) {
             this.words[i] = 0;
@@ -360,8 +194,8 @@
           var j, w;
           var off = 0;
           if (endian === "be") {
-            for (i = number3.length - 1, j = 0; i >= 0; i -= 3) {
-              w = number3[i] | number3[i - 1] << 8 | number3[i - 2] << 16;
+            for (i = number2.length - 1, j = 0; i >= 0; i -= 3) {
+              w = number2[i] | number2[i - 1] << 8 | number2[i - 2] << 16;
               this.words[j] |= w << off & 67108863;
               this.words[j + 1] = w >>> 26 - off & 67108863;
               off += 24;
@@ -371,8 +205,8 @@
               }
             }
           } else if (endian === "le") {
-            for (i = 0, j = 0; i < number3.length; i += 3) {
-              w = number3[i] | number3[i + 1] << 8 | number3[i + 2] << 16;
+            for (i = 0, j = 0; i < number2.length; i += 3) {
+              w = number2[i] | number2[i + 1] << 8 | number2[i + 2] << 16;
               this.words[j] |= w << off & 67108863;
               this.words[j + 1] = w >>> 26 - off & 67108863;
               off += 24;
@@ -393,7 +227,7 @@
           } else if (c >= 97 && c <= 102) {
             return c - 87;
           } else {
-            assert3(false, "Invalid character in " + string);
+            assert2(false, "Invalid character in " + string);
           }
         }
         function parseHexByte(string, lowerBound, index) {
@@ -403,8 +237,8 @@
           }
           return r;
         }
-        BN2.prototype._parseHex = function _parseHex(number3, start, endian) {
-          this.length = Math.ceil((number3.length - start) / 6);
+        BN2.prototype._parseHex = function _parseHex(number2, start, endian) {
+          this.length = Math.ceil((number2.length - start) / 6);
           this.words = new Array(this.length);
           for (var i = 0; i < this.length; i++) {
             this.words[i] = 0;
@@ -413,8 +247,8 @@
           var j = 0;
           var w;
           if (endian === "be") {
-            for (i = number3.length - 1; i >= start; i -= 2) {
-              w = parseHexByte(number3, start, i) << off;
+            for (i = number2.length - 1; i >= start; i -= 2) {
+              w = parseHexByte(number2, start, i) << off;
               this.words[j] |= w & 67108863;
               if (off >= 18) {
                 off -= 18;
@@ -425,9 +259,9 @@
               }
             }
           } else {
-            var parseLength = number3.length - start;
-            for (i = parseLength % 2 === 0 ? start + 1 : start; i < number3.length; i += 2) {
-              w = parseHexByte(number3, start, i) << off;
+            var parseLength = number2.length - start;
+            for (i = parseLength % 2 === 0 ? start + 1 : start; i < number2.length; i += 2) {
+              w = parseHexByte(number2, start, i) << off;
               this.words[j] |= w & 67108863;
               if (off >= 18) {
                 off -= 18;
@@ -454,12 +288,12 @@
             } else {
               b = c;
             }
-            assert3(c >= 0 && b < mul, "Invalid character");
+            assert2(c >= 0 && b < mul, "Invalid character");
             r += b;
           }
           return r;
         }
-        BN2.prototype._parseBase = function _parseBase(number3, base, start) {
+        BN2.prototype._parseBase = function _parseBase(number2, base, start) {
           this.words = [0];
           this.length = 1;
           for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
@@ -467,12 +301,12 @@
           }
           limbLen--;
           limbPow = limbPow / base | 0;
-          var total = number3.length - start;
+          var total = number2.length - start;
           var mod2 = total % limbLen;
           var end = Math.min(total, total - mod2) + start;
           var word = 0;
           for (var i = start; i < end; i += limbLen) {
-            word = parseBase(number3, i, i + limbLen, base);
+            word = parseBase(number2, i, i + limbLen, base);
             this.imuln(limbPow);
             if (this.words[0] + word < 67108864) {
               this.words[0] += word;
@@ -482,7 +316,7 @@
           }
           if (mod2 !== 0) {
             var pow3 = 1;
-            word = parseBase(number3, i, number3.length, base);
+            word = parseBase(number2, i, number2.length, base);
             for (i = 0; i < mod2; i++) {
               pow3 *= base;
             }
@@ -714,7 +548,7 @@
             }
             return out;
           }
-          assert3(false, "Base should be between 2 and 36");
+          assert2(false, "Base should be between 2 and 36");
         };
         BN2.prototype.toNumber = function toNumber3() {
           var ret2 = this.words[0];
@@ -723,7 +557,7 @@
           } else if (this.length === 3 && this.words[2] === 1) {
             ret2 += 4503599627370496 + this.words[1] * 67108864;
           } else if (this.length > 2) {
-            assert3(false, "Number can only safely store up to 53 bits");
+            assert2(false, "Number can only safely store up to 53 bits");
           }
           return this.negative !== 0 ? -ret2 : ret2;
         };
@@ -748,8 +582,8 @@
           this._strip();
           var byteLength = this.byteLength();
           var reqLength = length || Math.max(1, byteLength);
-          assert3(byteLength <= reqLength, "byte array longer than desired length");
-          assert3(reqLength > 0, "Requested array length <= 0");
+          assert2(byteLength <= reqLength, "byte array longer than desired length");
+          assert2(reqLength > 0, "Requested array length <= 0");
           var res = allocate(ArrayType, reqLength);
           var postfix = endian === "le" ? "LE" : "BE";
           this["_toArrayLike" + postfix](res, byteLength);
@@ -931,7 +765,7 @@
           return this._strip();
         };
         BN2.prototype.ior = function ior(num) {
-          assert3((this.negative | num.negative) === 0);
+          assert2((this.negative | num.negative) === 0);
           return this.iuor(num);
         };
         BN2.prototype.or = function or(num) {
@@ -958,7 +792,7 @@
           return this._strip();
         };
         BN2.prototype.iand = function iand(num) {
-          assert3((this.negative | num.negative) === 0);
+          assert2((this.negative | num.negative) === 0);
           return this.iuand(num);
         };
         BN2.prototype.and = function and(num) {
@@ -993,7 +827,7 @@
           return this._strip();
         };
         BN2.prototype.ixor = function ixor(num) {
-          assert3((this.negative | num.negative) === 0);
+          assert2((this.negative | num.negative) === 0);
           return this.iuxor(num);
         };
         BN2.prototype.xor = function xor(num) {
@@ -1007,7 +841,7 @@
           return num.clone().iuxor(this);
         };
         BN2.prototype.inotn = function inotn(width) {
-          assert3(typeof width === "number" && width >= 0);
+          assert2(typeof width === "number" && width >= 0);
           var bytesNeeded = Math.ceil(width / 26) | 0;
           var bitsLeft = width % 26;
           this._expand(bytesNeeded);
@@ -1026,7 +860,7 @@
           return this.clone().inotn(width);
         };
         BN2.prototype.setn = function setn(bit, val) {
-          assert3(typeof bit === "number" && bit >= 0);
+          assert2(typeof bit === "number" && bit >= 0);
           var off = bit / 26 | 0;
           var wbit = bit % 26;
           this._expand(off + 1);
@@ -1892,8 +1726,8 @@
           for (i = 2 * len; i < N; ++i) {
             rws[i] = 0;
           }
-          assert3(carry === 0);
-          assert3((carry & ~8191) === 0);
+          assert2(carry === 0);
+          assert2((carry & ~8191) === 0);
         };
         FFTM.prototype.stub = function stub(N) {
           var ph = new Array(N);
@@ -1948,8 +1782,8 @@
           var isNegNum = num < 0;
           if (isNegNum)
             num = -num;
-          assert3(typeof num === "number");
-          assert3(num < 67108864);
+          assert2(typeof num === "number");
+          assert2(num < 67108864);
           var carry = 0;
           for (var i = 0; i < this.length; i++) {
             var w = (this.words[i] | 0) * num;
@@ -1993,7 +1827,7 @@
           return res;
         };
         BN2.prototype.iushln = function iushln(bits) {
-          assert3(typeof bits === "number" && bits >= 0);
+          assert2(typeof bits === "number" && bits >= 0);
           var r = bits % 26;
           var s = (bits - r) / 26;
           var carryMask = 67108863 >>> 26 - r << 26 - r;
@@ -2023,11 +1857,11 @@
           return this._strip();
         };
         BN2.prototype.ishln = function ishln(bits) {
-          assert3(this.negative === 0);
+          assert2(this.negative === 0);
           return this.iushln(bits);
         };
         BN2.prototype.iushrn = function iushrn(bits, hint, extended) {
-          assert3(typeof bits === "number" && bits >= 0);
+          assert2(typeof bits === "number" && bits >= 0);
           var h;
           if (hint) {
             h = (hint - hint % 26) / 26;
@@ -2072,7 +1906,7 @@
           return this._strip();
         };
         BN2.prototype.ishrn = function ishrn(bits, hint, extended) {
-          assert3(this.negative === 0);
+          assert2(this.negative === 0);
           return this.iushrn(bits, hint, extended);
         };
         BN2.prototype.shln = function shln(bits) {
@@ -2088,7 +1922,7 @@
           return this.clone().iushrn(bits);
         };
         BN2.prototype.testn = function testn(bit) {
-          assert3(typeof bit === "number" && bit >= 0);
+          assert2(typeof bit === "number" && bit >= 0);
           var r = bit % 26;
           var s = (bit - r) / 26;
           var q = 1 << r;
@@ -2098,10 +1932,10 @@
           return !!(w & q);
         };
         BN2.prototype.imaskn = function imaskn(bits) {
-          assert3(typeof bits === "number" && bits >= 0);
+          assert2(typeof bits === "number" && bits >= 0);
           var r = bits % 26;
           var s = (bits - r) / 26;
-          assert3(this.negative === 0, "imaskn works only with positive numbers");
+          assert2(this.negative === 0, "imaskn works only with positive numbers");
           if (this.length <= s) {
             return this;
           }
@@ -2119,8 +1953,8 @@
           return this.clone().imaskn(bits);
         };
         BN2.prototype.iaddn = function iaddn(num) {
-          assert3(typeof num === "number");
-          assert3(num < 67108864);
+          assert2(typeof num === "number");
+          assert2(num < 67108864);
           if (num < 0)
             return this.isubn(-num);
           if (this.negative !== 0) {
@@ -2150,8 +1984,8 @@
           return this;
         };
         BN2.prototype.isubn = function isubn(num) {
-          assert3(typeof num === "number");
-          assert3(num < 67108864);
+          assert2(typeof num === "number");
+          assert2(num < 67108864);
           if (num < 0)
             return this.iaddn(-num);
           if (this.negative !== 0) {
@@ -2205,7 +2039,7 @@
           }
           if (carry === 0)
             return this._strip();
-          assert3(carry === -1);
+          assert2(carry === -1);
           carry = 0;
           for (i = 0; i < this.length; i++) {
             w = -(this.words[i] | 0) + carry;
@@ -2273,7 +2107,7 @@
           };
         };
         BN2.prototype.divmod = function divmod(num, mode, positive) {
-          assert3(!num.isZero());
+          assert2(!num.isZero());
           if (this.isZero()) {
             return {
               div: new BN2(0),
@@ -2371,7 +2205,7 @@
           var isNegNum = num < 0;
           if (isNegNum)
             num = -num;
-          assert3(num <= 67108863);
+          assert2(num <= 67108863);
           var p = (1 << 26) % num;
           var acc = 0;
           for (var i = this.length - 1; i >= 0; i--) {
@@ -2386,7 +2220,7 @@
           var isNegNum = num < 0;
           if (isNegNum)
             num = -num;
-          assert3(num <= 67108863);
+          assert2(num <= 67108863);
           var carry = 0;
           for (var i = this.length - 1; i >= 0; i--) {
             var w = (this.words[i] | 0) + carry * 67108864;
@@ -2400,8 +2234,8 @@
           return this.clone().idivn(num);
         };
         BN2.prototype.egcd = function egcd(p) {
-          assert3(p.negative === 0);
-          assert3(!p.isZero());
+          assert2(p.negative === 0);
+          assert2(!p.isZero());
           var x = this;
           var y = p.clone();
           if (x.negative !== 0) {
@@ -2465,8 +2299,8 @@
           };
         };
         BN2.prototype._invmp = function _invmp(p) {
-          assert3(p.negative === 0);
-          assert3(!p.isZero());
+          assert2(p.negative === 0);
+          assert2(!p.isZero());
           var a = this;
           var b = p.clone();
           if (a.negative !== 0) {
@@ -2564,7 +2398,7 @@
           return this.words[0] & num;
         };
         BN2.prototype.bincn = function bincn(bit) {
-          assert3(typeof bit === "number");
+          assert2(typeof bit === "number");
           var r = bit % 26;
           var s = (bit - r) / 26;
           var q = 1 << r;
@@ -2604,7 +2438,7 @@
             if (negative) {
               num = -num;
             }
-            assert3(num <= 67108863, "Number is too big");
+            assert2(num <= 67108863, "Number is too big");
             var w = this.words[0] | 0;
             res = w === num ? 0 : w < num ? -1 : 1;
           }
@@ -2676,12 +2510,12 @@
           return new Red(num);
         };
         BN2.prototype.toRed = function toRed(ctx) {
-          assert3(!this.red, "Already a number in reduction context");
-          assert3(this.negative === 0, "red works only with positives");
+          assert2(!this.red, "Already a number in reduction context");
+          assert2(this.negative === 0, "red works only with positives");
           return ctx.convertTo(this)._forceRed(ctx);
         };
         BN2.prototype.fromRed = function fromRed() {
-          assert3(this.red, "fromRed works only with numbers in reduction context");
+          assert2(this.red, "fromRed works only with numbers in reduction context");
           return this.red.convertFrom(this);
         };
         BN2.prototype._forceRed = function _forceRed(ctx) {
@@ -2689,66 +2523,66 @@
           return this;
         };
         BN2.prototype.forceRed = function forceRed(ctx) {
-          assert3(!this.red, "Already a number in reduction context");
+          assert2(!this.red, "Already a number in reduction context");
           return this._forceRed(ctx);
         };
         BN2.prototype.redAdd = function redAdd(num) {
-          assert3(this.red, "redAdd works only with red numbers");
+          assert2(this.red, "redAdd works only with red numbers");
           return this.red.add(this, num);
         };
         BN2.prototype.redIAdd = function redIAdd(num) {
-          assert3(this.red, "redIAdd works only with red numbers");
+          assert2(this.red, "redIAdd works only with red numbers");
           return this.red.iadd(this, num);
         };
         BN2.prototype.redSub = function redSub(num) {
-          assert3(this.red, "redSub works only with red numbers");
+          assert2(this.red, "redSub works only with red numbers");
           return this.red.sub(this, num);
         };
         BN2.prototype.redISub = function redISub(num) {
-          assert3(this.red, "redISub works only with red numbers");
+          assert2(this.red, "redISub works only with red numbers");
           return this.red.isub(this, num);
         };
         BN2.prototype.redShl = function redShl(num) {
-          assert3(this.red, "redShl works only with red numbers");
+          assert2(this.red, "redShl works only with red numbers");
           return this.red.shl(this, num);
         };
         BN2.prototype.redMul = function redMul(num) {
-          assert3(this.red, "redMul works only with red numbers");
+          assert2(this.red, "redMul works only with red numbers");
           this.red._verify2(this, num);
           return this.red.mul(this, num);
         };
         BN2.prototype.redIMul = function redIMul(num) {
-          assert3(this.red, "redMul works only with red numbers");
+          assert2(this.red, "redMul works only with red numbers");
           this.red._verify2(this, num);
           return this.red.imul(this, num);
         };
         BN2.prototype.redSqr = function redSqr() {
-          assert3(this.red, "redSqr works only with red numbers");
+          assert2(this.red, "redSqr works only with red numbers");
           this.red._verify1(this);
           return this.red.sqr(this);
         };
         BN2.prototype.redISqr = function redISqr() {
-          assert3(this.red, "redISqr works only with red numbers");
+          assert2(this.red, "redISqr works only with red numbers");
           this.red._verify1(this);
           return this.red.isqr(this);
         };
         BN2.prototype.redSqrt = function redSqrt() {
-          assert3(this.red, "redSqrt works only with red numbers");
+          assert2(this.red, "redSqrt works only with red numbers");
           this.red._verify1(this);
           return this.red.sqrt(this);
         };
         BN2.prototype.redInvm = function redInvm() {
-          assert3(this.red, "redInvm works only with red numbers");
+          assert2(this.red, "redInvm works only with red numbers");
           this.red._verify1(this);
           return this.red.invm(this);
         };
         BN2.prototype.redNeg = function redNeg() {
-          assert3(this.red, "redNeg works only with red numbers");
+          assert2(this.red, "redNeg works only with red numbers");
           this.red._verify1(this);
           return this.red.neg(this);
         };
         BN2.prototype.redPow = function redPow(num) {
-          assert3(this.red && !num.red, "redPow(normalNum)");
+          assert2(this.red && !num.red, "redPow(normalNum)");
           this.red._verify1(this);
           return this.red.pow(this, num);
         };
@@ -2808,20 +2642,20 @@
           );
         }
         inherits(K256, MPrime);
-        K256.prototype.split = function split2(input, output3) {
+        K256.prototype.split = function split2(input, output2) {
           var mask2 = 4194303;
           var outLen = Math.min(input.length, 9);
           for (var i = 0; i < outLen; i++) {
-            output3.words[i] = input.words[i];
+            output2.words[i] = input.words[i];
           }
-          output3.length = outLen;
+          output2.length = outLen;
           if (input.length <= 9) {
             input.words[0] = 0;
             input.length = 1;
             return;
           }
           var prev = input.words[9];
-          output3.words[output3.length++] = prev & mask2;
+          output2.words[output2.length++] = prev & mask2;
           for (i = 10; i < input.length; i++) {
             var next = input.words[i] | 0;
             input.words[i - 10] = (next & mask2) << 4 | prev >>> 22;
@@ -2916,18 +2750,18 @@
             this.m = prime.p;
             this.prime = prime;
           } else {
-            assert3(m.gtn(1), "modulus must be greater than 1");
+            assert2(m.gtn(1), "modulus must be greater than 1");
             this.m = m;
             this.prime = null;
           }
         }
         Red.prototype._verify1 = function _verify1(a) {
-          assert3(a.negative === 0, "red works only with positives");
-          assert3(a.red, "red works only with red numbers");
+          assert2(a.negative === 0, "red works only with positives");
+          assert2(a.red, "red works only with red numbers");
         };
         Red.prototype._verify2 = function _verify2(a, b) {
-          assert3((a.negative | b.negative) === 0, "red works only with positives");
-          assert3(
+          assert2((a.negative | b.negative) === 0, "red works only with positives");
+          assert2(
             a.red && a.red === b.red,
             "red works only with red numbers"
           );
@@ -2998,7 +2832,7 @@
           if (a.isZero())
             return a.clone();
           var mod3 = this.m.andln(3);
-          assert3(mod3 % 2 === 1);
+          assert2(mod3 % 2 === 1);
           if (mod3 === 3) {
             var pow3 = this.m.add(new BN2(1)).iushrn(2);
             return this.pow(a, pow3);
@@ -3009,7 +2843,7 @@
             s++;
             q.iushrn(1);
           }
-          assert3(!q.isZero());
+          assert2(!q.isZero());
           var one = new BN2(1).toRed(this);
           var nOne = one.redNeg();
           var lpow = this.m.subn(1).iushrn(1);
@@ -3027,7 +2861,7 @@
             for (var i = 0; tmp.cmp(one) !== 0; i++) {
               tmp = tmp.redSqr();
             }
-            assert3(i < m);
+            assert2(i < m);
             var b = this.pow(c, new BN2(1).iushln(m - i - 1));
             r = r.redMul(b);
             c = b.redSqr();
@@ -3161,6 +2995,172 @@
     }
   });
 
+  // ../../node_modules/.pnpm/bech32@2.0.0/node_modules/bech32/dist/index.js
+  var require_dist = __commonJS({
+    "../../node_modules/.pnpm/bech32@2.0.0/node_modules/bech32/dist/index.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.bech32m = exports.bech32 = void 0;
+      var ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+      var ALPHABET_MAP = {};
+      for (let z = 0; z < ALPHABET.length; z++) {
+        const x = ALPHABET.charAt(z);
+        ALPHABET_MAP[x] = z;
+      }
+      function polymodStep(pre) {
+        const b = pre >> 25;
+        return (pre & 33554431) << 5 ^ -(b >> 0 & 1) & 996825010 ^ -(b >> 1 & 1) & 642813549 ^ -(b >> 2 & 1) & 513874426 ^ -(b >> 3 & 1) & 1027748829 ^ -(b >> 4 & 1) & 705979059;
+      }
+      function prefixChk(prefix) {
+        let chk = 1;
+        for (let i = 0; i < prefix.length; ++i) {
+          const c = prefix.charCodeAt(i);
+          if (c < 33 || c > 126)
+            return "Invalid prefix (" + prefix + ")";
+          chk = polymodStep(chk) ^ c >> 5;
+        }
+        chk = polymodStep(chk);
+        for (let i = 0; i < prefix.length; ++i) {
+          const v = prefix.charCodeAt(i);
+          chk = polymodStep(chk) ^ v & 31;
+        }
+        return chk;
+      }
+      function convert2(data, inBits, outBits, pad3) {
+        let value = 0;
+        let bits = 0;
+        const maxV = (1 << outBits) - 1;
+        const result = [];
+        for (let i = 0; i < data.length; ++i) {
+          value = value << inBits | data[i];
+          bits += inBits;
+          while (bits >= outBits) {
+            bits -= outBits;
+            result.push(value >> bits & maxV);
+          }
+        }
+        if (pad3) {
+          if (bits > 0) {
+            result.push(value << outBits - bits & maxV);
+          }
+        } else {
+          if (bits >= inBits)
+            return "Excess padding";
+          if (value << outBits - bits & maxV)
+            return "Non-zero padding";
+        }
+        return result;
+      }
+      function toWords(bytes2) {
+        return convert2(bytes2, 8, 5, true);
+      }
+      function fromWordsUnsafe(words) {
+        const res = convert2(words, 5, 8, false);
+        if (Array.isArray(res))
+          return res;
+      }
+      function fromWords(words) {
+        const res = convert2(words, 5, 8, false);
+        if (Array.isArray(res))
+          return res;
+        throw new Error(res);
+      }
+      function getLibraryFromEncoding(encoding) {
+        let ENCODING_CONST;
+        if (encoding === "bech32") {
+          ENCODING_CONST = 1;
+        } else {
+          ENCODING_CONST = 734539939;
+        }
+        function encode(prefix, words, LIMIT) {
+          LIMIT = LIMIT || 90;
+          if (prefix.length + 7 + words.length > LIMIT)
+            throw new TypeError("Exceeds length limit");
+          prefix = prefix.toLowerCase();
+          let chk = prefixChk(prefix);
+          if (typeof chk === "string")
+            throw new Error(chk);
+          let result = prefix + "1";
+          for (let i = 0; i < words.length; ++i) {
+            const x = words[i];
+            if (x >> 5 !== 0)
+              throw new Error("Non 5-bit word");
+            chk = polymodStep(chk) ^ x;
+            result += ALPHABET.charAt(x);
+          }
+          for (let i = 0; i < 6; ++i) {
+            chk = polymodStep(chk);
+          }
+          chk ^= ENCODING_CONST;
+          for (let i = 0; i < 6; ++i) {
+            const v = chk >> (5 - i) * 5 & 31;
+            result += ALPHABET.charAt(v);
+          }
+          return result;
+        }
+        function __decode(str, LIMIT) {
+          LIMIT = LIMIT || 90;
+          if (str.length < 8)
+            return str + " too short";
+          if (str.length > LIMIT)
+            return "Exceeds length limit";
+          const lowered = str.toLowerCase();
+          const uppered = str.toUpperCase();
+          if (str !== lowered && str !== uppered)
+            return "Mixed-case string " + str;
+          str = lowered;
+          const split2 = str.lastIndexOf("1");
+          if (split2 === -1)
+            return "No separator character for " + str;
+          if (split2 === 0)
+            return "Missing prefix for " + str;
+          const prefix = str.slice(0, split2);
+          const wordChars = str.slice(split2 + 1);
+          if (wordChars.length < 6)
+            return "Data too short";
+          let chk = prefixChk(prefix);
+          if (typeof chk === "string")
+            return chk;
+          const words = [];
+          for (let i = 0; i < wordChars.length; ++i) {
+            const c = wordChars.charAt(i);
+            const v = ALPHABET_MAP[c];
+            if (v === void 0)
+              return "Unknown character " + c;
+            chk = polymodStep(chk) ^ v;
+            if (i + 6 >= wordChars.length)
+              continue;
+            words.push(v);
+          }
+          if (chk !== ENCODING_CONST)
+            return "Invalid checksum for " + str;
+          return { prefix, words };
+        }
+        function decodeUnsafe(str, LIMIT) {
+          const res = __decode(str, LIMIT);
+          if (typeof res === "object")
+            return res;
+        }
+        function decode(str, LIMIT) {
+          const res = __decode(str, LIMIT);
+          if (typeof res === "object")
+            return res;
+          throw new Error(res);
+        }
+        return {
+          decodeUnsafe,
+          decode,
+          encode,
+          toWords,
+          fromWordsUnsafe,
+          fromWords
+        };
+      }
+      exports.bech32 = getLibraryFromEncoding("bech32");
+      exports.bech32m = getLibraryFromEncoding("bech32m");
+    }
+  });
+
   // ../../node_modules/.pnpm/webidl-conversions@3.0.1/node_modules/webidl-conversions/lib/index.js
   var require_lib = __commonJS({
     "../../node_modules/.pnpm/webidl-conversions@3.0.1/node_modules/webidl-conversions/lib/index.js"(exports, module) {
@@ -3591,18 +3591,18 @@
       }
       function utf8PercentDecode(str) {
         const input = new Buffer(str);
-        const output3 = [];
+        const output2 = [];
         for (let i = 0; i < input.length; ++i) {
           if (input[i] !== 37) {
-            output3.push(input[i]);
+            output2.push(input[i]);
           } else if (input[i] === 37 && isASCIIHex(input[i + 1]) && isASCIIHex(input[i + 2])) {
-            output3.push(parseInt(input.slice(i + 1, i + 3).toString(), 16));
+            output2.push(parseInt(input.slice(i + 1, i + 3).toString(), 16));
             i += 2;
           } else {
-            output3.push(input[i]);
+            output2.push(input[i]);
           }
         }
-        return new Buffer(output3).toString();
+        return new Buffer(output2).toString();
       }
       function isC0ControlPercentEncode(c) {
         return c <= 31 || c > 126;
@@ -3678,16 +3678,16 @@
         return ipv4;
       }
       function serializeIPv4(address) {
-        let output3 = "";
+        let output2 = "";
         let n = address;
         for (let i = 1; i <= 4; ++i) {
-          output3 = String(n % 256) + output3;
+          output2 = String(n % 256) + output2;
           if (i !== 4) {
-            output3 = "." + output3;
+            output2 = "." + output2;
           }
           n = Math.floor(n / 256);
         }
-        return output3;
+        return output2;
       }
       function parseIPv6(input) {
         const address = [0, 0, 0, 0, 0, 0, 0, 0];
@@ -3745,13 +3745,13 @@
                 return failure;
               }
               while (isASCIIDigit(input[pointer])) {
-                const number3 = parseInt(at(input, pointer));
+                const number2 = parseInt(at(input, pointer));
                 if (ipv4Piece === null) {
-                  ipv4Piece = number3;
+                  ipv4Piece = number2;
                 } else if (ipv4Piece === 0) {
                   return failure;
                 } else {
-                  ipv4Piece = ipv4Piece * 10 + number3;
+                  ipv4Piece = ipv4Piece * 10 + number2;
                 }
                 if (ipv4Piece > 255) {
                   return failure;
@@ -3795,7 +3795,7 @@
         return address;
       }
       function serializeIPv6(address) {
-        let output3 = "";
+        let output2 = "";
         const seqResult = findLongestZeroSequence(address);
         const compress = seqResult.idx;
         let ignore0 = false;
@@ -3807,16 +3807,16 @@
           }
           if (compress === pieceIndex) {
             const separator = pieceIndex === 0 ? "::" : ":";
-            output3 += separator;
+            output2 += separator;
             ignore0 = true;
             continue;
           }
-          output3 += address[pieceIndex].toString(16);
+          output2 += address[pieceIndex].toString(16);
           if (pieceIndex !== 7) {
-            output3 += ":";
+            output2 += ":";
           }
         }
-        return output3;
+        return output2;
       }
       function parseHost(input, isSpecialArg) {
         if (input[0] === "[") {
@@ -3846,12 +3846,12 @@
         if (containsForbiddenHostCodePointExcludingPercent(input)) {
           return failure;
         }
-        let output3 = "";
+        let output2 = "";
         const decoded = punycode.ucs2.decode(input);
         for (let i = 0; i < decoded.length; ++i) {
-          output3 += percentEncodeChar(decoded[i], isC0ControlPercentEncode);
+          output2 += percentEncodeChar(decoded[i], isC0ControlPercentEncode);
         }
-        return output3;
+        return output2;
       }
       function findLongestZeroSequence(arr) {
         let maxIdx = null;
@@ -4476,37 +4476,37 @@
         return true;
       };
       function serializeURL(url, excludeFragment) {
-        let output3 = url.scheme + ":";
+        let output2 = url.scheme + ":";
         if (url.host !== null) {
-          output3 += "//";
+          output2 += "//";
           if (url.username !== "" || url.password !== "") {
-            output3 += url.username;
+            output2 += url.username;
             if (url.password !== "") {
-              output3 += ":" + url.password;
+              output2 += ":" + url.password;
             }
-            output3 += "@";
+            output2 += "@";
           }
-          output3 += serializeHost(url.host);
+          output2 += serializeHost(url.host);
           if (url.port !== null) {
-            output3 += ":" + url.port;
+            output2 += ":" + url.port;
           }
         } else if (url.host === null && url.scheme === "file") {
-          output3 += "//";
+          output2 += "//";
         }
         if (url.cannotBeABaseURL) {
-          output3 += url.path[0];
+          output2 += url.path[0];
         } else {
           for (const string of url.path) {
-            output3 += "/" + string;
+            output2 += "/" + string;
           }
         }
         if (url.query !== null) {
-          output3 += "?" + url.query;
+          output2 += "?" + url.query;
         }
         if (!excludeFragment && url.fragment !== null) {
-          output3 += "#" + url.fragment;
+          output2 += "#" + url.fragment;
         }
-        return output3;
+        return output2;
       }
       function serializeOrigin(tuple) {
         let result = tuple.scheme + "://";
@@ -6450,19 +6450,19 @@
           return "GraphQLError";
         }
         toString() {
-          let output3 = this.message;
+          let output2 = this.message;
           if (this.nodes) {
             for (const node of this.nodes) {
               if (node.loc) {
-                output3 += "\n\n" + (0, _printLocation.printLocation)(node.loc);
+                output2 += "\n\n" + (0, _printLocation.printLocation)(node.loc);
               }
             }
           } else if (this.source && this.locations) {
             for (const location of this.locations) {
-              output3 += "\n\n" + (0, _printLocation.printSourceLocation)(this.source, location);
+              output2 += "\n\n" + (0, _printLocation.printSourceLocation)(this.source, location);
             }
           }
-          return output3;
+          return output2;
         }
         toJSON() {
           const formattedError = {
@@ -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, output3) {
+        state.jobs[key] = runJob(iterator, key, list[key], function(error, output2) {
           if (!(key in state.jobs)) {
             return;
           }
@@ -18785,7 +18785,7 @@ spurious results.`);
           if (error) {
             abort(state);
           } else {
-            state.results[key] = output3;
+            state.results[key] = output2;
           }
           callback(error, state.results);
         });
@@ -20547,8 +20547,8 @@ spurious results.`);
         const ret3 = wasm$1.retd(addr, len);
         return Instruction.__wrap(ret3);
       }
-      function aloc(bytes3) {
-        const ret3 = wasm$1.aloc(bytes3);
+      function aloc(bytes2) {
+        const ret3 = wasm$1.aloc(bytes2);
         return Instruction.__wrap(ret3);
       }
       function mcl(dst_addr, len) {
@@ -21762,9 +21762,9 @@ spurious results.`);
         * Construct the instruction from its parts.
         * @param {RegId} bytes
         */
-        constructor(bytes3) {
-          _assertClass(bytes3, RegId);
-          var ptr0 = bytes3.__destroy_into_raw();
+        constructor(bytes2) {
+          _assertClass(bytes2, RegId);
+          var ptr0 = bytes2.__destroy_into_raw();
           const ret3 = wasm$1.aloc_new_typescript(ptr0);
           this.__wbg_ptr = ret3 >>> 0;
           return this;
@@ -28301,8 +28301,8 @@ spurious results.`);
               }
             }
           }
-          const bytes3 = await module2.arrayBuffer();
-          return await WebAssembly.instantiate(bytes3, imports);
+          const bytes2 = await module2.arrayBuffer();
+          return await WebAssembly.instantiate(bytes2, imports);
         } else {
           const instance = await WebAssembly.instantiate(module2, imports);
           if (instance instanceof WebAssembly.Instance) {
@@ -29920,9 +29920,9 @@ spurious results.`);
         const chunks = arguments_.trim().split(/\s*,\s*/g);
         let matches;
         for (const chunk of chunks) {
-          const number3 = Number(chunk);
-          if (!Number.isNaN(number3)) {
-            results.push(number3);
+          const number2 = Number(chunk);
+          if (!Number.isNaN(number2)) {
+            results.push(number2);
           } else if (matches = chunk.match(STRING_REGEX)) {
             results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
           } else {
@@ -30434,11 +30434,11 @@ spurious results.`);
           return r;
         }
         function is_char(character) {
-          var bool2 = false;
+          var bool = false;
           all.filter(function(i) {
-            bool2 = i === character;
+            bool = i === character;
           });
-          return bool2;
+          return bool;
         }
         function heComes(text2, options2) {
           var result = "", counts, l;
@@ -33040,12 +33040,12 @@ spurious results.`);
         createDebug.skips = [];
         createDebug.formatters = {};
         function selectColor(namespace) {
-          var hash4 = 0;
+          var hash3 = 0;
           for (var i = 0; i < namespace.length; i++) {
-            hash4 = (hash4 << 5) - hash4 + namespace.charCodeAt(i);
-            hash4 |= 0;
+            hash3 = (hash3 << 5) - hash3 + namespace.charCodeAt(i);
+            hash3 |= 0;
           }
-          return createDebug.colors[Math.abs(hash4) % createDebug.colors.length];
+          return createDebug.colors[Math.abs(hash3) % createDebug.colors.length];
         }
         createDebug.selectColor = selectColor;
         function createDebug(namespace) {
@@ -33832,11 +33832,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(hash4) {
-    if (typeof hash4 !== "function" || typeof hash4.create !== "function")
+  function hash(hash3) {
+    if (typeof hash3 !== "function" || typeof hash3.create !== "function")
       throw new Error("Hash should be wrapped by utils.wrapConstructor");
-    number(hash4.outputLen);
-    number(hash4.blockLen);
+    number(hash3.outputLen);
+    number(hash3.blockLen);
   }
   function exists(instance, checkFinished = true) {
     if (instance.destroyed)
@@ -33931,25 +33931,25 @@ spurious results.`);
   }
 
   // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/_sha2.js
-  function setBigUint64(view, byteOffset, value, isLE3) {
+  function setBigUint64(view, byteOffset, value, isLE2) {
     if (typeof view.setBigUint64 === "function")
-      return view.setBigUint64(byteOffset, value, isLE3);
+      return view.setBigUint64(byteOffset, value, isLE2);
     const _32n2 = BigInt(32);
     const _u32_max = BigInt(4294967295);
     const wh = Number(value >> _32n2 & _u32_max);
     const wl = Number(value & _u32_max);
-    const h = isLE3 ? 4 : 0;
-    const l = isLE3 ? 0 : 4;
-    view.setUint32(byteOffset + h, wh, isLE3);
-    view.setUint32(byteOffset + l, wl, isLE3);
+    const h = isLE2 ? 4 : 0;
+    const l = isLE2 ? 0 : 4;
+    view.setUint32(byteOffset + h, wh, isLE2);
+    view.setUint32(byteOffset + l, wl, isLE2);
   }
   var SHA2 = class extends Hash {
-    constructor(blockLen, outputLen, padOffset, isLE3) {
+    constructor(blockLen, outputLen, padOffset, isLE2) {
       super();
       this.blockLen = blockLen;
       this.outputLen = outputLen;
       this.padOffset = padOffset;
-      this.isLE = isLE3;
+      this.isLE = isLE2;
       this.finished = false;
       this.length = 0;
       this.pos = 0;
@@ -33986,7 +33986,7 @@ spurious results.`);
       exists(this);
       output(out, this);
       this.finished = true;
-      const { buffer, view, blockLen, isLE: isLE3 } = this;
+      const { buffer, view, blockLen, isLE: isLE2 } = this;
       let { pos } = this;
       buffer[pos++] = 128;
       this.buffer.subarray(pos).fill(0);
@@ -33996,7 +33996,7 @@ spurious results.`);
       }
       for (let i = pos; i < blockLen; i++)
         buffer[i] = 0;
-      setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE3);
+      setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
       this.process(view, 0);
       const oview = createView(out);
       const len = this.outputLen;
@@ -34007,7 +34007,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], isLE3);
+        oview.setUint32(4 * i, state[i], isLE2);
     }
     digest() {
       const { buffer, outputLen } = this;
@@ -34184,24 +34184,24 @@ spurious results.`);
 
   // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/hmac.js
   var HMAC = class extends Hash {
-    constructor(hash4, _key) {
+    constructor(hash3, _key) {
       super();
       this.finished = false;
       this.destroyed = false;
-      hash(hash4);
+      hash(hash3);
       const key = toBytes(_key);
-      this.iHash = hash4.create();
+      this.iHash = hash3.create();
       if (typeof this.iHash.update !== "function")
         throw new Error("Expected instance of class which extends utils.Hash");
       this.blockLen = this.iHash.blockLen;
       this.outputLen = this.iHash.outputLen;
       const blockLen = this.blockLen;
       const pad3 = new Uint8Array(blockLen);
-      pad3.set(key.length > blockLen ? hash4.create().update(key).digest() : key);
+      pad3.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
       for (let i = 0; i < pad3.length; i++)
         pad3[i] ^= 54;
       this.iHash.update(pad3);
-      this.oHash = hash4.create();
+      this.oHash = hash3.create();
       for (let i = 0; i < pad3.length; i++)
         pad3[i] ^= 54 ^ 92;
       this.oHash.update(pad3);
@@ -34244,12 +34244,12 @@ spurious results.`);
       this.iHash.destroy();
     }
   };
-  var hmac = (hash4, key, message) => new HMAC(hash4, key).update(message).digest();
-  hmac.create = (hash4, key) => new HMAC(hash4, key);
+  var hmac = (hash3, key, message) => new HMAC(hash3, key).update(message).digest();
+  hmac.create = (hash3, key) => new HMAC(hash3, key);
 
   // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/pbkdf2.js
-  function pbkdf2Init(hash4, _password, _salt, _opts) {
-    hash(hash4);
+  function pbkdf2Init(hash3, _password, _salt, _opts) {
+    hash(hash3);
     const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
     const { c, dkLen, asyncTick } = opts;
     number(c);
@@ -34260,7 +34260,7 @@ spurious results.`);
     const password = toBytes(_password);
     const salt = toBytes(_salt);
     const DK = new Uint8Array(dkLen);
-    const PRF = hmac.create(hash4, password);
+    const PRF = hmac.create(hash3, password);
     const PRFSalt = PRF._cloneInto().update(salt);
     return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
   }
@@ -34272,8 +34272,8 @@ spurious results.`);
     u.fill(0);
     return DK;
   }
-  function pbkdf2(hash4, password, salt, opts) {
-    const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash4, password, salt, opts);
+  function pbkdf2(hash3, password, salt, opts) {
+    const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash3, password, salt, opts);
     let prfW;
     const arr = new Uint8Array(4);
     const view = createView(arr);
@@ -34600,9 +34600,9 @@ spurious results.`);
         throw new Error("XOF is not possible for this instance");
       return this.writeInto(out);
     }
-    xof(bytes3) {
-      number(bytes3);
-      return this.xofInto(new Uint8Array(bytes3));
+    xof(bytes2) {
+      number(bytes2);
+      return this.xofInto(new Uint8Array(bytes2));
     }
     digestInto(out) {
       output(out, this);
@@ -34738,7 +34738,6 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["PARSE_FAILED"] = "parse-failed";
     ErrorCode2["ENCODE_ERROR"] = "encode-error";
     ErrorCode2["DECODE_ERROR"] = "decode-error";
-    ErrorCode2["INVALID_CREDENTIALS"] = "invalid-credentials";
     ErrorCode2["ENV_DEPENDENCY_MISSING"] = "env-dependency-missing";
     ErrorCode2["INVALID_TTL"] = "invalid-ttl";
     ErrorCode2["INVALID_INPUT_PARAMETERS"] = "invalid-input-parameters";
@@ -34749,6 +34748,8 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["MISSING_REQUIRED_PARAMETER"] = "missing-required-parameter";
     ErrorCode2["INVALID_REQUEST"] = "invalid-request";
     ErrorCode2["INVALID_TRANSFER_AMOUNT"] = "invalid-transfer-amount";
+    ErrorCode2["INVALID_CREDENTIALS"] = "invalid-credentials";
+    ErrorCode2["HASHER_LOCKED"] = "hasher-locked";
     ErrorCode2["GAS_PRICE_TOO_LOW"] = "gas-price-too-low";
     ErrorCode2["GAS_LIMIT_TOO_LOW"] = "gas-limit-too-low";
     ErrorCode2["MAX_FEE_TOO_LOW"] = "max-fee-too-low";
@@ -34816,6 +34817,226 @@ This unreleased fuel-core build may include features and updates not yet support
   var FuelError = _FuelError;
   __publicField2(FuelError, "CODES", ErrorCode);
 
+  // ../math/dist/index.mjs
+  var import_bn = __toESM(require_bn(), 1);
+  var DEFAULT_PRECISION = 9;
+  var DEFAULT_MIN_PRECISION = 3;
+  var DEFAULT_DECIMAL_UNITS = 9;
+  function toFixed(value, options) {
+    const { precision = DEFAULT_PRECISION, minPrecision = DEFAULT_MIN_PRECISION } = options || {};
+    const [valueUnits = "0", valueDecimals = "0"] = String(value || "0.0").split(".");
+    const groupRegex = /(\d)(?=(\d{3})+\b)/g;
+    const units = valueUnits.replace(groupRegex, "$1,");
+    let decimals = valueDecimals.slice(0, precision);
+    if (minPrecision < precision) {
+      const trimmedDecimal = decimals.match(/.*[1-9]{1}/);
+      const lastNonZeroIndex = trimmedDecimal?.[0].length || 0;
+      const keepChars = Math.max(minPrecision, lastNonZeroIndex);
+      decimals = decimals.slice(0, keepChars);
+    }
+    const decimalPortion = decimals ? `.${decimals}` : "";
+    return `${units}${decimalPortion}`;
+  }
+  var BN = class extends import_bn.default {
+    MAX_U64 = "0xFFFFFFFFFFFFFFFF";
+    constructor(value, base, endian) {
+      let bnValue = value;
+      let bnBase = base;
+      if (BN.isBN(value)) {
+        bnValue = value.toArray();
+      } else if (typeof value === "string" && value.slice(0, 2) === "0x") {
+        bnValue = value.substring(2);
+        bnBase = base || "hex";
+      }
+      super(bnValue == null ? 0 : bnValue, bnBase, endian);
+    }
+    // ANCHOR: HELPERS
+    // make sure we always include `0x` in hex strings
+    toString(base, length) {
+      const output2 = super.toString(base, length);
+      if (base === 16 || base === "hex") {
+        return `0x${output2}`;
+      }
+      return output2;
+    }
+    toHex(bytesPadding) {
+      const bytes2 = bytesPadding || 0;
+      const bytesLength = bytes2 * 2;
+      if (this.isNeg()) {
+        throw new FuelError(ErrorCode.CONVERTING_FAILED, "Cannot convert negative value to hex.");
+      }
+      if (bytesPadding && this.byteLength() > bytesPadding) {
+        throw new FuelError(
+          ErrorCode.CONVERTING_FAILED,
+          `Provided value ${this} is too large. It should fit within ${bytesPadding} bytes.`
+        );
+      }
+      return this.toString(16, bytesLength);
+    }
+    toBytes(bytesPadding) {
+      if (this.isNeg()) {
+        throw new FuelError(ErrorCode.CONVERTING_FAILED, "Cannot convert negative value to bytes.");
+      }
+      return Uint8Array.from(this.toArray(void 0, bytesPadding));
+    }
+    toJSON() {
+      return this.toString(16);
+    }
+    valueOf() {
+      return this.toString();
+    }
+    format(options) {
+      const {
+        units = DEFAULT_DECIMAL_UNITS,
+        precision = DEFAULT_PRECISION,
+        minPrecision = DEFAULT_MIN_PRECISION
+      } = options || {};
+      const formattedUnits = this.formatUnits(units);
+      const formattedFixed = toFixed(formattedUnits, { precision, minPrecision });
+      if (!parseFloat(formattedFixed)) {
+        const [, originalDecimals = "0"] = formattedUnits.split(".");
+        const firstNonZero = originalDecimals.match(/[1-9]/);
+        if (firstNonZero && firstNonZero.index && firstNonZero.index + 1 > precision) {
+          const [valueUnits = "0"] = formattedFixed.split(".");
+          return `${valueUnits}.${originalDecimals.slice(0, firstNonZero.index + 1)}`;
+        }
+      }
+      return formattedFixed;
+    }
+    formatUnits(units = DEFAULT_DECIMAL_UNITS) {
+      const valueUnits = this.toString().slice(0, units * -1);
+      const valueDecimals = this.toString().slice(units * -1);
+      const length = valueDecimals.length;
+      const defaultDecimals = Array.from({ length: units - length }).fill("0").join("");
+      const integerPortion = valueUnits ? `${valueUnits}.` : "0.";
+      return `${integerPortion}${defaultDecimals}${valueDecimals}`;
+    }
+    // END ANCHOR: HELPERS
+    // ANCHOR: OVERRIDES to accept better inputs
+    add(v) {
+      return this.caller(v, "add");
+    }
+    pow(v) {
+      return this.caller(v, "pow");
+    }
+    sub(v) {
+      return this.caller(v, "sub");
+    }
+    div(v) {
+      return this.caller(v, "div");
+    }
+    mul(v) {
+      return this.caller(v, "mul");
+    }
+    mod(v) {
+      return this.caller(v, "mod");
+    }
+    divRound(v) {
+      return this.caller(v, "divRound");
+    }
+    lt(v) {
+      return this.caller(v, "lt");
+    }
+    lte(v) {
+      return this.caller(v, "lte");
+    }
+    gt(v) {
+      return this.caller(v, "gt");
+    }
+    gte(v) {
+      return this.caller(v, "gte");
+    }
+    eq(v) {
+      return this.caller(v, "eq");
+    }
+    cmp(v) {
+      return this.caller(v, "cmp");
+    }
+    // END ANCHOR: OVERRIDES to accept better inputs
+    // ANCHOR: OVERRIDES to output our BN type
+    sqr() {
+      return new BN(super.sqr().toArray());
+    }
+    neg() {
+      return new BN(super.neg().toArray());
+    }
+    abs() {
+      return new BN(super.abs().toArray());
+    }
+    toTwos(width) {
+      return new BN(super.toTwos(width).toArray());
+    }
+    fromTwos(width) {
+      return new BN(super.fromTwos(width).toArray());
+    }
+    // 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());
+      }
+      if (typeof output2 === "boolean") {
+        return output2;
+      }
+      return output2;
+    }
+    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());
+    }
+    egcd(p) {
+      const { a, b, gcd } = new import_bn.default(this.toArray()).egcd(p);
+      return {
+        a: new BN(a.toArray()),
+        b: new BN(b.toArray()),
+        gcd: new BN(gcd.toArray())
+      };
+    }
+    divmod(num, mode, positive) {
+      const { div, mod: mod2 } = new import_bn.default(this.toArray()).divmod(new BN(num), mode, positive);
+      return {
+        div: new BN(div?.toArray()),
+        mod: new BN(mod2?.toArray())
+      };
+    }
+    maxU64() {
+      return this.gte(this.MAX_U64) ? new BN(this.MAX_U64) : this;
+    }
+    normalizeZeroToOne() {
+      return this.isZero() ? new BN(1) : this;
+    }
+    // END ANCHOR: OVERRIDES to avoid losing references
+  };
+  var bn = (value, base, endian) => new BN(value, base, endian);
+  bn.parseUnits = (value, units = DEFAULT_DECIMAL_UNITS) => {
+    const valueToParse = value === "." ? "0." : value;
+    const [valueUnits = "0", valueDecimals = "0"] = valueToParse.split(".");
+    const length = valueDecimals.length;
+    if (length > units) {
+      throw new FuelError(
+        ErrorCode.CONVERTING_FAILED,
+        `Decimal can't have more than ${units} digits.`
+      );
+    }
+    const decimals = Array.from({ length: units }).fill("0");
+    decimals.splice(0, length, valueDecimals);
+    const amount = `${valueUnits.replaceAll(",", "")}${decimals.join("")}`;
+    return bn(amount);
+  };
+  function toNumber(value) {
+    return bn(value).toNumber();
+  }
+  function toHex(value, bytesPadding) {
+    return bn(value).toHex(bytesPadding);
+  }
+  function toBytes2(value, bytesPadding) {
+    return bn(value).toBytes(bytesPadding);
+  }
+
   // ../utils/dist/index.mjs
   var __defProp3 = Object.defineProperty;
   var __defNormalProp3 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -34823,9 +35044,12 @@ This unreleased fuel-core build may include features and updates not yet support
     __defNormalProp3(obj, typeof key !== "symbol" ? key + "" : key, value);
     return value;
   };
-  var arrayify = (value) => {
+  var arrayify = (value, name, copy = true) => {
     if (value instanceof Uint8Array) {
-      return new Uint8Array(value);
+      if (copy) {
+        return new Uint8Array(value);
+      }
+      return value;
     }
     if (typeof value === "string" && value.match(/^0x([0-9a-f][0-9a-f])*$/i)) {
       const result = new Uint8Array((value.length - 2) / 2);
@@ -34836,7 +35060,7 @@ This unreleased fuel-core build may include features and updates not yet support
       }
       return result;
     }
-    throw new FuelError(ErrorCode.PARSE_FAILED, "invalid BytesLike value");
+    throw new FuelError(ErrorCode.INVALID_DATA, `invalid data - ${name || ""}`);
   };
   var concatBytes2 = (arrays) => {
     const byteArrays = arrays.map((array) => {
@@ -34854,15 +35078,15 @@ This unreleased fuel-core build may include features and updates not yet support
     return concatenated;
   };
   var concat = (arrays) => {
-    const bytes3 = arrays.map((v) => arrayify(v));
-    return concatBytes2(bytes3);
+    const bytes2 = arrays.map((v) => arrayify(v));
+    return concatBytes2(bytes2);
   };
   var HexCharacters = "0123456789abcdef";
   function hexlify(data) {
-    const bytes3 = arrayify(data);
+    const bytes2 = arrayify(data);
     let result = "0x";
-    for (let i = 0; i < bytes3.length; i++) {
-      const v = bytes3[i];
+    for (let i = 0; i < bytes2.length; i++) {
+      const v = bytes2[i];
       result += HexCharacters[(v & 240) >> 4] + HexCharacters[v & 15];
     }
     return result;
@@ -35689,681 +35913,87 @@ This unreleased fuel-core build may include features and updates not yet support
   function isDefined(value) {
     return value !== void 0;
   }
-
-  // ../crypto/dist/index.mjs
-  var import_crypto7 = __toESM(__require("crypto"), 1);
-
-  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/_version.js
-  var version = "6.7.1";
-
-  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/utils/properties.js
-  function checkType(value, type3, name) {
-    const types = type3.split("|").map((t) => t.trim());
-    for (let i = 0; i < types.length; i++) {
-      switch (type3) {
-        case "any":
-          return;
-        case "bigint":
-        case "boolean":
-        case "number":
-        case "string":
-          if (typeof value === type3) {
-            return;
-          }
-      }
-    }
-    const error = new Error(`invalid value for type ${type3}`);
-    error.code = "INVALID_ARGUMENT";
-    error.argument = `value.${name}`;
-    error.value = value;
-    throw error;
-  }
-  function defineProperties(target, values, types) {
-    for (let key in values) {
-      let value = values[key];
-      const type3 = types ? types[key] : null;
-      if (type3) {
-        checkType(value, type3, key);
-      }
-      Object.defineProperty(target, key, { enumerable: true, value, writable: false });
-    }
-  }
-
-  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/utils/errors.js
-  function stringify(value) {
-    if (value == null) {
-      return "null";
-    }
-    if (Array.isArray(value)) {
-      return "[ " + value.map(stringify).join(", ") + " ]";
-    }
-    if (value instanceof Uint8Array) {
-      const HEX = "0123456789abcdef";
-      let result = "0x";
-      for (let i = 0; i < value.length; i++) {
-        result += HEX[value[i] >> 4];
-        result += HEX[value[i] & 15];
-      }
-      return result;
-    }
-    if (typeof value === "object" && typeof value.toJSON === "function") {
-      return stringify(value.toJSON());
-    }
-    switch (typeof value) {
-      case "boolean":
-      case "symbol":
-        return value.toString();
-      case "bigint":
-        return BigInt(value).toString();
-      case "number":
-        return value.toString();
-      case "string":
-        return JSON.stringify(value);
-      case "object": {
-        const keys = Object.keys(value);
-        keys.sort();
-        return "{ " + keys.map((k) => `${stringify(k)}: ${stringify(value[k])}`).join(", ") + " }";
-      }
-    }
-    return `[ COULD NOT SERIALIZE ]`;
-  }
-  function makeError(message, code, info) {
-    {
-      const details = [];
-      if (info) {
-        if ("message" in info || "code" in info || "name" in info) {
-          throw new Error(`value will overwrite populated values: ${stringify(info)}`);
-        }
-        for (const key in info) {
-          const value = info[key];
-          details.push(key + "=" + stringify(value));
-        }
-      }
-      details.push(`code=${code}`);
-      details.push(`version=${version}`);
-      if (details.length) {
-        message += " (" + details.join(", ") + ")";
-      }
-    }
-    let error;
-    switch (code) {
-      case "INVALID_ARGUMENT":
-        error = new TypeError(message);
-        break;
-      case "NUMERIC_FAULT":
-      case "BUFFER_OVERRUN":
-        error = new RangeError(message);
-        break;
-      default:
-        error = new Error(message);
-    }
-    defineProperties(error, { code });
-    if (info) {
-      Object.assign(error, info);
-    }
-    return error;
-  }
-  function assert(check, message, code, info) {
-    if (!check) {
-      throw makeError(message, code, info);
-    }
-  }
-  function assertArgument(check, message, name, value) {
-    assert(check, message, "INVALID_ARGUMENT", { argument: name, value });
-  }
-  var _normalizeForms = ["NFD", "NFC", "NFKD", "NFKC"].reduce((accum, form) => {
-    try {
-      if ("test".normalize(form) !== "test") {
-        throw new Error("bad");
-      }
-      ;
-      if (form === "NFD") {
-        const check = String.fromCharCode(233).normalize("NFD");
-        const expected = String.fromCharCode(101, 769);
-        if (check !== expected) {
-          throw new Error("broken");
-        }
-      }
-      accum.push(form);
-    } catch (error) {
-    }
-    return accum;
-  }, []);
-  function assertNormalize(form) {
-    assert(_normalizeForms.indexOf(form) >= 0, "platform missing String.prototype.normalize", "UNSUPPORTED_OPERATION", {
-      operation: "String.prototype.normalize",
-      info: { form }
-    });
-  }
-
-  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/utils/data.js
-  function _getBytes(value, name, copy) {
-    if (value instanceof Uint8Array) {
-      if (copy) {
-        return new Uint8Array(value);
-      }
-      return value;
-    }
-    if (typeof value === "string" && value.match(/^0x([0-9a-f][0-9a-f])*$/i)) {
-      const result = new Uint8Array((value.length - 2) / 2);
-      let offset = 2;
-      for (let i = 0; i < result.length; i++) {
-        result[i] = parseInt(value.substring(offset, offset + 2), 16);
-        offset += 2;
-      }
-      return result;
-    }
-    assertArgument(false, "invalid BytesLike value", name || "value", value);
-  }
-  function getBytes(value, name) {
-    return _getBytes(value, name, false);
-  }
-  var HexCharacters2 = "0123456789abcdef";
-  function hexlify2(data) {
-    const bytes3 = getBytes(data);
-    let result = "0x";
-    for (let i = 0; i < bytes3.length; i++) {
-      const v = bytes3[i];
-      result += HexCharacters2[(v & 240) >> 4] + HexCharacters2[v & 15];
-    }
-    return result;
-  }
-  function dataSlice(data, start, end) {
-    const bytes3 = getBytes(data);
-    if (end != null && end > bytes3.length) {
-      assert(false, "cannot slice beyond data bounds", "BUFFER_OVERRUN", {
-        buffer: bytes3,
-        length: bytes3.length,
-        offset: end
-      });
-    }
-    return hexlify2(bytes3.slice(start == null ? 0 : start, end == null ? bytes3.length : end));
-  }
-
-  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/utils/maths.js
-  var BN_0 = BigInt(0);
-  var BN_1 = BigInt(1);
-  var maxValue = 9007199254740991;
-  function getBigInt(value, name) {
-    switch (typeof value) {
-      case "bigint":
-        return value;
-      case "number":
-        assertArgument(Number.isInteger(value), "underflow", name || "value", value);
-        assertArgument(value >= -maxValue && value <= maxValue, "overflow", name || "value", value);
-        return BigInt(value);
-      case "string":
-        try {
-          if (value === "") {
-            throw new Error("empty string");
-          }
-          if (value[0] === "-" && value[1] !== "-") {
-            return -BigInt(value.substring(1));
-          }
-          return BigInt(value);
-        } catch (e) {
-          assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || "value", value);
-        }
-    }
-    assertArgument(false, "invalid BigNumberish value", name || "value", value);
-  }
-  function getUint(value, name) {
-    const result = getBigInt(value, name);
-    assert(result >= BN_0, "unsigned value cannot be negative", "NUMERIC_FAULT", {
-      fault: "overflow",
-      operation: "getUint",
-      value
-    });
-    return result;
-  }
-  var Nibbles = "0123456789abcdef";
-  function toBigInt(value) {
-    if (value instanceof Uint8Array) {
-      let result = "0x0";
-      for (const v of value) {
-        result += Nibbles[v >> 4];
-        result += Nibbles[v & 15];
-      }
-      return BigInt(result);
-    }
-    return getBigInt(value);
-  }
-  function getNumber(value, name) {
-    switch (typeof value) {
-      case "bigint":
-        assertArgument(value >= -maxValue && value <= maxValue, "overflow", name || "value", value);
-        return Number(value);
-      case "number":
-        assertArgument(Number.isInteger(value), "underflow", name || "value", value);
-        assertArgument(value >= -maxValue && value <= maxValue, "overflow", name || "value", value);
-        return value;
-      case "string":
-        try {
-          if (value === "") {
-            throw new Error("empty string");
-          }
-          return getNumber(BigInt(value), name);
-        } catch (e) {
-          assertArgument(false, `invalid numeric string: ${e.message}`, name || "value", value);
-        }
-    }
-    assertArgument(false, "invalid numeric value", name || "value", value);
-  }
-  function toBeHex(_value, _width) {
-    const value = getUint(_value, "value");
-    let result = value.toString(16);
-    if (_width == null) {
-      if (result.length % 2) {
-        result = "0" + result;
-      }
-    } else {
-      const width = getNumber(_width, "width");
-      assert(width * 2 >= result.length, `value exceeds width (${width} bits)`, "NUMERIC_FAULT", {
-        operation: "toBeHex",
-        fault: "overflow",
-        value: _value
-      });
-      while (result.length < width * 2) {
-        result = "0" + result;
-      }
-    }
-    return "0x" + result;
-  }
-
-  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/utils/base58.js
+  var BN_0 = bn(0);
+  var BN_58 = bn(58);
   var Alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
   var Lookup = null;
   function getAlpha(letter) {
     if (Lookup == null) {
       Lookup = {};
       for (let i = 0; i < Alphabet.length; i++) {
-        Lookup[Alphabet[i]] = BigInt(i);
+        Lookup[Alphabet[i]] = bn(i);
       }
     }
     const result = Lookup[letter];
-    assertArgument(result != null, `invalid base58 value`, "letter", letter);
-    return result;
+    if (result == null) {
+      throw new FuelError(ErrorCode.INVALID_DATA, `invalid base58 value ${letter}`);
+    }
+    return bn(result);
   }
-  var BN_02 = BigInt(0);
-  var BN_58 = BigInt(58);
   function encodeBase58(_value) {
-    let value = toBigInt(getBytes(_value));
+    const bytes2 = arrayify(_value);
+    let value = bn(bytes2);
     let result = "";
-    while (value) {
-      result = Alphabet[Number(value % BN_58)] + result;
-      value /= BN_58;
+    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]) {
+        break;
+      }
+      result = Alphabet[0] + result;
     }
     return result;
   }
   function decodeBase58(value) {
-    let result = BN_02;
+    let result = BN_0;
     for (let i = 0; i < value.length; i++) {
-      result *= BN_58;
-      result += getAlpha(value[i]);
-    }
-    return result;
-  }
-
-  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/utils/utf8.js
-  function errorFunc(reason, offset, bytes3, output3, badCodepoint) {
-    assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes3);
-  }
-  function ignoreFunc(reason, offset, bytes3, output3, badCodepoint) {
-    if (reason === "BAD_PREFIX" || reason === "UNEXPECTED_CONTINUE") {
-      let i = 0;
-      for (let o = offset + 1; o < bytes3.length; o++) {
-        if (bytes3[o] >> 6 !== 2) {
-          break;
-        }
-        i++;
-      }
-      return i;
-    }
-    if (reason === "OVERRUN") {
-      return bytes3.length - offset - 1;
-    }
-    return 0;
-  }
-  function replaceFunc(reason, offset, bytes3, output3, badCodepoint) {
-    if (reason === "OVERLONG") {
-      assertArgument(typeof badCodepoint === "number", "invalid bad code point for replacement", "badCodepoint", badCodepoint);
-      output3.push(badCodepoint);
-      return 0;
-    }
-    output3.push(65533);
-    return ignoreFunc(reason, offset, bytes3, output3, badCodepoint);
-  }
-  var Utf8ErrorFuncs = Object.freeze({
-    error: errorFunc,
-    ignore: ignoreFunc,
-    replace: replaceFunc
-  });
-  function getUtf8CodePoints(_bytes, onError) {
-    if (onError == null) {
-      onError = Utf8ErrorFuncs.error;
-    }
-    const bytes3 = getBytes(_bytes, "bytes");
-    const result = [];
-    let i = 0;
-    while (i < bytes3.length) {
-      const c = bytes3[i++];
-      if (c >> 7 === 0) {
-        result.push(c);
-        continue;
-      }
-      let extraLength = null;
-      let overlongMask = null;
-      if ((c & 224) === 192) {
-        extraLength = 1;
-        overlongMask = 127;
-      } else if ((c & 240) === 224) {
-        extraLength = 2;
-        overlongMask = 2047;
-      } else if ((c & 248) === 240) {
-        extraLength = 3;
-        overlongMask = 65535;
-      } else {
-        if ((c & 192) === 128) {
-          i += onError("UNEXPECTED_CONTINUE", i - 1, bytes3, result);
-        } else {
-          i += onError("BAD_PREFIX", i - 1, bytes3, result);
-        }
-        continue;
-      }
-      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++) {
-        let nextChar = bytes3[i];
-        if ((nextChar & 192) != 128) {
-          i += onError("MISSING_CONTINUE", i, bytes3, result);
-          res = null;
-          break;
-        }
-        ;
-        res = res << 6 | nextChar & 63;
-        i++;
-      }
-      if (res === null) {
-        continue;
-      }
-      if (res > 1114111) {
-        i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes3, result, res);
-        continue;
-      }
-      if (res >= 55296 && res <= 57343) {
-        i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes3, result, res);
-        continue;
-      }
-      if (res <= overlongMask) {
-        i += onError("OVERLONG", i - 1 - extraLength, bytes3, result, res);
-        continue;
-      }
-      result.push(res);
+      result = result.mul(BN_58);
+      result = result.add(getAlpha(value[i].toString()));
     }
     return result;
   }
-  function toUtf8Bytes(str, form) {
-    if (form != null) {
-      assertNormalize(form);
-      str = str.normalize(form);
-    }
-    let result = [];
-    for (let i = 0; i < str.length; i++) {
-      const c = str.charCodeAt(i);
-      if (c < 128) {
-        result.push(c);
-      } else if (c < 2048) {
-        result.push(c >> 6 | 192);
-        result.push(c & 63 | 128);
-      } else if ((c & 64512) == 55296) {
-        i++;
-        const c2 = str.charCodeAt(i);
-        assertArgument(i < str.length && (c2 & 64512) === 56320, "invalid surrogate pair", "str", str);
-        const pair = 65536 + ((c & 1023) << 10) + (c2 & 1023);
-        result.push(pair >> 18 | 240);
-        result.push(pair >> 12 & 63 | 128);
-        result.push(pair >> 6 & 63 | 128);
-        result.push(pair & 63 | 128);
-      } else {
-        result.push(c >> 12 | 224);
-        result.push(c >> 6 & 63 | 128);
-        result.push(c & 63 | 128);
-      }
-    }
-    return new Uint8Array(result);
-  }
-  function _toUtf8String(codePoints) {
-    return codePoints.map((codePoint) => {
-      if (codePoint <= 65535) {
-        return String.fromCharCode(codePoint);
-      }
-      codePoint -= 65536;
-      return String.fromCharCode((codePoint >> 10 & 1023) + 55296, (codePoint & 1023) + 56320);
-    }).join("");
-  }
-  function toUtf8String(bytes3, onError) {
-    return _toUtf8String(getUtf8CodePoints(bytes3, onError));
-  }
-
-  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/crypto/crypto.js
-  var import_crypto2 = __require("crypto");
-
-  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/crypto/hmac.js
-  var locked = false;
-  var _computeHmac = function(algorithm, key, data) {
-    return (0, import_crypto2.createHmac)(algorithm, key).update(data).digest();
-  };
-  var __computeHmac = _computeHmac;
-  function computeHmac(algorithm, _key, _data) {
-    const key = getBytes(_key, "key");
-    const data = getBytes(_data, "data");
-    return hexlify2(__computeHmac(algorithm, key, data));
-  }
-  computeHmac._ = _computeHmac;
-  computeHmac.lock = function() {
-    locked = true;
-  };
-  computeHmac.register = function(func) {
-    if (locked) {
-      throw new Error("computeHmac is locked");
-    }
-    __computeHmac = func;
-  };
-  Object.freeze(computeHmac);
-
-  // ../../node_modules/.pnpm/@noble+hashes@1.1.2/node_modules/@noble/hashes/esm/_assert.js
-  function number2(n) {
-    if (!Number.isSafeInteger(n) || n < 0)
-      throw new Error(`Wrong positive integer: ${n}`);
-  }
-  function bool(b) {
-    if (typeof b !== "boolean")
-      throw new Error(`Expected boolean, not ${b}`);
-  }
-  function bytes2(b, ...lengths) {
-    if (!(b instanceof Uint8Array))
-      throw new TypeError("Expected Uint8Array");
-    if (lengths.length > 0 && !lengths.includes(b.length))
-      throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
-  }
-  function hash2(hash4) {
-    if (typeof hash4 !== "function" || typeof hash4.create !== "function")
-      throw new Error("Hash should be wrapped by utils.wrapConstructor");
-    number2(hash4.outputLen);
-    number2(hash4.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}`);
-    }
-  }
-  var assert2 = {
-    number: number2,
-    bool,
-    bytes: bytes2,
-    hash: hash2,
-    exists: exists2,
-    output: output2
-  };
-  var assert_default = assert2;
-
-  // ../../node_modules/.pnpm/@noble+hashes@1.1.2/node_modules/@noble/hashes/esm/utils.js
-  var createView2 = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-  var isLE2 = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-  if (!isLE2)
-    throw new Error("Non little-endian hardware is not supported");
-  var hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
-  function utf8ToBytes2(str) {
-    if (typeof str !== "string") {
-      throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);
-    }
-    return new TextEncoder().encode(str);
-  }
-  function toBytes2(data) {
-    if (typeof data === "string")
-      data = utf8ToBytes2(data);
-    if (!(data instanceof Uint8Array))
-      throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);
-    return data;
-  }
-  var Hash2 = class {
-    // Safe version that clones internal state
-    clone() {
-      return this._cloneInto();
+  function dataSlice(data, start, end) {
+    const bytes2 = arrayify(data);
+    if (end != null && end > bytes2.length) {
+      throw new FuelError(ErrorCode.INVALID_DATA, "cannot slice beyond data bounds");
     }
-  };
-  function wrapConstructor2(hashConstructor) {
-    const hashC = (message) => hashConstructor().update(toBytes2(message)).digest();
-    const tmp = hashConstructor();
-    hashC.outputLen = tmp.outputLen;
-    hashC.blockLen = tmp.blockLen;
-    hashC.create = () => hashConstructor();
-    return hashC;
+    return hexlify(bytes2.slice(start == null ? 0 : start, end == null ? bytes2.length : end));
   }
 
-  // ../../node_modules/.pnpm/@noble+hashes@1.1.2/node_modules/@noble/hashes/esm/_sha2.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 SHA22 = 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) {
-      assert_default.exists(this);
-      const { view, buffer, blockLen } = this;
-      data = toBytes2(data);
-      const len = data.length;
-      for (let pos = 0; pos < len; ) {
-        const take = Math.min(blockLen - this.pos, len - pos);
-        if (take === blockLen) {
-          const dataView = createView2(data);
-          for (; blockLen <= len - pos; pos += blockLen)
-            this.process(dataView, pos);
-          continue;
-        }
-        buffer.set(data.subarray(pos, pos + take), this.pos);
-        this.pos += take;
-        pos += take;
-        if (this.pos === blockLen) {
-          this.process(view, 0);
-          this.pos = 0;
-        }
-      }
-      this.length += data.length;
-      this.roundClean();
-      return this;
-    }
-    digestInto(out) {
-      assert_default.exists(this);
-      assert_default.output(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);
-      this.get().forEach((v, i) => oview.setUint32(4 * i, v, 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.1.2/node_modules/@noble/hashes/esm/ripemd160.js
-  var Rho = new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
-  var Id = Uint8Array.from({ length: 16 }, (_, i) => i);
-  var Pi = Id.map((i) => (9 * i + 5) % 16);
+  // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/ripemd160.js
+  var Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
+  var Id = /* @__PURE__ */ Uint8Array.from({ length: 16 }, (_, i) => i);
+  var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
   var idxL = [Id];
   var idxR = [Pi];
   for (let i = 0; i < 4; i++)
     for (let j of [idxL, idxR])
       j.push(j[i].map((k) => Rho[k]));
-  var shifts = [
+  var shifts = /* @__PURE__ */ [
     [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
     [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
     [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
     [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
     [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
   ].map((i) => new Uint8Array(i));
-  var shiftsL = idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
-  var shiftsR = idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
-  var Kl = new Uint32Array([0, 1518500249, 1859775393, 2400959708, 2840853838]);
-  var Kr = new Uint32Array([1352829926, 1548603684, 1836072691, 2053994217, 0]);
+  var shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
+  var shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
+  var Kl = /* @__PURE__ */ new Uint32Array([
+    0,
+    1518500249,
+    1859775393,
+    2400959708,
+    2840853838
+  ]);
+  var Kr = /* @__PURE__ */ new Uint32Array([
+    1352829926,
+    1548603684,
+    1836072691,
+    2053994217,
+    0
+  ]);
   var rotl2 = (word, shift) => word << shift | word >>> 32 - shift;
   function f(group, x, y, z) {
     if (group === 0)
@@ -36377,8 +36007,8 @@ This unreleased fuel-core build may include features and updates not yet support
     else
       return x ^ (y | ~z);
   }
-  var BUF = new Uint32Array(16);
-  var RIPEMD160 = class extends SHA22 {
+  var BUF = /* @__PURE__ */ new Uint32Array(16);
+  var RIPEMD160 = class extends SHA2 {
     constructor() {
       super(64, 20, 8, true);
       this.h0 = 1732584193 | 0;
@@ -36427,65 +36057,60 @@ This unreleased fuel-core build may include features and updates not yet support
       this.set(0, 0, 0, 0, 0);
     }
   };
-  var ripemd160 = wrapConstructor2(() => new RIPEMD160());
+  var ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());
 
-  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/crypto/ripemd160.js
-  var locked2 = false;
-  var _ripemd160 = function(data) {
-    return ripemd160(data);
+  // ../crypto/dist/index.mjs
+  var import_crypto2 = __toESM(__require("crypto"), 1);
+  var import_crypto3 = __require("crypto");
+  var import_crypto4 = __toESM(__require("crypto"), 1);
+  var import_crypto5 = __toESM(__require("crypto"), 1);
+  var import_crypto6 = __require("crypto");
+  var scrypt2 = (params) => {
+    const { password, salt, n, p, r, dklen } = params;
+    const derivedKey = scrypt(password, salt, { N: n, r, p, dkLen: dklen });
+    return derivedKey;
   };
-  var __ripemd160 = _ripemd160;
+  var keccak256 = (data) => keccak_256(data);
+  var locked = false;
+  var helper = (data) => ripemd160(data);
+  var ripemd = helper;
   function ripemd1602(_data) {
-    const data = getBytes(_data, "data");
-    return hexlify2(__ripemd160(data));
+    const data = arrayify(_data, "data");
+    return ripemd(data);
   }
-  ripemd1602._ = _ripemd160;
-  ripemd1602.lock = function() {
-    locked2 = true;
+  ripemd1602._ = helper;
+  ripemd1602.lock = () => {
+    locked = true;
   };
-  ripemd1602.register = function(func) {
-    if (locked2) {
-      throw new TypeError("ripemd160 is locked");
+  ripemd1602.register = (func) => {
+    if (locked) {
+      throw new FuelError(ErrorCode.HASHER_LOCKED, "ripemd160 is locked");
     }
-    __ripemd160 = func;
+    ripemd = func;
   };
   Object.freeze(ripemd1602);
-
-  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/crypto/pbkdf2.js
-  var locked3 = false;
-  var _pbkdf2 = function(password, salt, iterations, keylen, algo) {
-    return (0, import_crypto2.pbkdf2Sync)(password, salt, iterations, keylen, algo);
-  };
-  var __pbkdf2 = _pbkdf2;
+  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 = PBKDF2;
   function pbkdf22(_password, _salt, iterations, keylen, algo) {
-    const password = getBytes(_password, "password");
-    const salt = getBytes(_salt, "salt");
-    return hexlify2(__pbkdf2(password, salt, iterations, keylen, algo));
+    const password = arrayify(_password, "password");
+    const salt = arrayify(_salt, "salt");
+    return hexlify(pBkdf2(password, salt, iterations, keylen, algo));
   }
-  pbkdf22._ = _pbkdf2;
-  pbkdf22.lock = function() {
-    locked3 = true;
+  pbkdf22._ = PBKDF2;
+  pbkdf22.lock = () => {
+    locked2 = true;
   };
-  pbkdf22.register = function(func) {
-    if (locked3) {
-      throw new Error("pbkdf2 is locked");
+  pbkdf22.register = (func) => {
+    if (locked2) {
+      throw new FuelError(ErrorCode.HASHER_LOCKED, "pbkdf2 is locked");
     }
-    __pbkdf2 = func;
+    pBkdf2 = func;
   };
   Object.freeze(pbkdf22);
-
-  // ../crypto/dist/index.mjs
-  var import_crypto8 = __toESM(__require("crypto"), 1);
-  var import_crypto9 = __toESM(__require("crypto"), 1);
-  var scrypt3 = (params) => {
-    const { password, salt, n, p, r, dklen } = params;
-    const derivedKey = scrypt(password, salt, { N: n, r, p, dkLen: dklen });
-    return derivedKey;
-  };
-  var keccak2562 = (data) => keccak_256(data);
-  var bufferFromString = (string, encoding = "base64") => Uint8Array.from(Buffer.from(string, encoding));
-  var randomBytes4 = (length) => {
-    const randomValues = Uint8Array.from(import_crypto8.default.randomBytes(length));
+  var randomBytes2 = (length) => {
+    const randomValues = Uint8Array.from(import_crypto4.default.randomBytes(length));
     return randomValues;
   };
   var stringFromBuffer = (buffer, encoding = "base64") => Buffer.from(buffer).toString(encoding);
@@ -36496,11 +36121,11 @@ This unreleased fuel-core build may include features and updates not yet support
     return arrayify(key);
   };
   var encrypt = async (password, data) => {
-    const iv = randomBytes4(16);
-    const salt = randomBytes4(32);
+    const iv = randomBytes2(16);
+    const salt = randomBytes2(32);
     const secret = keyFromPassword(password, salt);
     const dataBuffer = Uint8Array.from(Buffer.from(JSON.stringify(data), "utf-8"));
-    const cipher = await import_crypto7.default.createCipheriv(ALGORITHM, secret, iv);
+    const cipher = await import_crypto2.default.createCipheriv(ALGORITHM, secret, iv);
     let cipherData = cipher.update(dataBuffer);
     cipherData = Buffer.concat([cipherData, cipher.final()]);
     return {
@@ -36514,7 +36139,7 @@ This unreleased fuel-core build may include features and updates not yet support
     const salt = bufferFromString(keystore.salt);
     const secret = keyFromPassword(password, salt);
     const encryptedText = bufferFromString(keystore.data);
-    const decipher = await import_crypto7.default.createDecipheriv(ALGORITHM, secret, iv);
+    const decipher = await import_crypto2.default.createDecipheriv(ALGORITHM, secret, iv);
     const decrypted = decipher.update(encryptedText);
     const deBuff = Buffer.concat([decrypted, decipher.final()]);
     const decryptedData = Buffer.from(deBuff).toString("utf-8");
@@ -36525,26 +36150,48 @@ This unreleased fuel-core build may include features and updates not yet support
     }
   };
   async function encryptJsonWalletData(data, key, iv) {
-    const cipher = await import_crypto9.default.createCipheriv("aes-128-ctr", key.subarray(0, 16), iv);
+    const cipher = await import_crypto5.default.createCipheriv("aes-128-ctr", key.subarray(0, 16), iv);
     const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
     return new Uint8Array(encrypted);
   }
   async function decryptJsonWalletData(data, key, iv) {
-    const decipher = import_crypto9.default.createDecipheriv("aes-128-ctr", key.subarray(0, 16), iv);
+    const decipher = import_crypto5.default.createDecipheriv("aes-128-ctr", key.subarray(0, 16), iv);
     const decrypted = await Buffer.concat([decipher.update(data), decipher.final()]);
     return new Uint8Array(decrypted);
   }
+  var locked3 = false;
+  var COMPUTEHMAC = (algorithm, key, data) => (0, import_crypto6.createHmac)(algorithm, key).update(data).digest();
+  var computeHMAC = COMPUTEHMAC;
+  function computeHmac(algorithm, _key, _data) {
+    const key = arrayify(_key, "key");
+    const data = arrayify(_data, "data");
+    return hexlify(computeHMAC(algorithm, key, data));
+  }
+  computeHmac._ = COMPUTEHMAC;
+  computeHmac.lock = () => {
+    locked3 = true;
+  };
+  computeHmac.register = (func) => {
+    if (locked3) {
+      throw new FuelError(ErrorCode.HASHER_LOCKED, "computeHmac is locked");
+    }
+    computeHMAC = func;
+  };
+  Object.freeze(computeHmac);
   var api = {
     bufferFromString,
     stringFromBuffer,
     decrypt,
     encrypt,
     keyFromPassword,
-    randomBytes: randomBytes4,
-    scrypt: scrypt3,
-    keccak256: keccak2562,
+    randomBytes: randomBytes2,
+    scrypt: scrypt2,
+    keccak256,
     decryptJsonWalletData,
-    encryptJsonWalletData
+    encryptJsonWalletData,
+    computeHmac,
+    pbkdf2: pbkdf22,
+    ripemd160: ripemd1602
   };
   var node_default = api;
   var {
@@ -36555,17 +36202,20 @@ This unreleased fuel-core build may include features and updates not yet support
     randomBytes: randomBytes22,
     stringFromBuffer: stringFromBuffer2,
     scrypt: scrypt22,
-    keccak256: keccak25622,
+    keccak256: keccak2562,
     decryptJsonWalletData: decryptJsonWalletData2,
-    encryptJsonWalletData: encryptJsonWalletData2
+    encryptJsonWalletData: encryptJsonWalletData2,
+    computeHmac: computeHmac2,
+    pbkdf2: pbkdf222,
+    ripemd160: ripemd16022
   } = node_default;
 
   // ../hasher/dist/index.mjs
-  function sha2563(data) {
+  function sha2562(data) {
     return hexlify(sha256(arrayify(data)));
   }
-  function hash3(data) {
-    return sha2563(data);
+  function hash2(data) {
+    return sha2562(data);
   }
   function uint64ToBytesBE(value) {
     const bigIntValue = BigInt(value);
@@ -36575,7 +36225,7 @@ This unreleased fuel-core build may include features and updates not yet support
     return new Uint8Array(dataView.buffer);
   }
   function hashMessage(msg) {
-    return hash3(bufferFromString2(msg, "utf-8"));
+    return hash2(bufferFromString2(msg, "utf-8"));
   }
 
   // ../interfaces/dist/index.mjs
@@ -36639,7 +36289,7 @@ This unreleased fuel-core build may include features and updates not yet support
   };
   var getRandomB256 = () => hexlify(randomBytes22(32));
   var clearFirst12BytesFromB256 = (b256) => {
-    let bytes3;
+    let bytes2;
     try {
       if (!isB256(b256)) {
         throw new FuelError(
@@ -36647,15 +36297,15 @@ This unreleased fuel-core build may include features and updates not yet support
           `Invalid Bech32 Address: ${b256}.`
         );
       }
-      bytes3 = getBytesFromBech32(toBech32(b256));
-      bytes3 = hexlify(bytes3.fill(0, 0, 12));
+      bytes2 = getBytesFromBech32(toBech32(b256));
+      bytes2 = hexlify(bytes2.fill(0, 0, 12));
     } catch (error) {
       throw new FuelError(
         FuelError.CODES.PARSE_FAILED,
         `Cannot generate EVM Address B256 from: ${b256}.`
       );
     }
-    return bytes3;
+    return bytes2;
   };
   var padFirst12BytesOfEvmAddress = (address) => {
     if (!isEvmAddress(address)) {
@@ -36864,226 +36514,6 @@ This unreleased fuel-core build may include features and updates not yet support
     }
   };
 
-  // ../math/dist/index.mjs
-  var import_bn = __toESM(require_bn(), 1);
-  var DEFAULT_PRECISION = 9;
-  var DEFAULT_MIN_PRECISION = 3;
-  var DEFAULT_DECIMAL_UNITS = 9;
-  function toFixed(value, options) {
-    const { precision = DEFAULT_PRECISION, minPrecision = DEFAULT_MIN_PRECISION } = options || {};
-    const [valueUnits = "0", valueDecimals = "0"] = String(value || "0.0").split(".");
-    const groupRegex = /(\d)(?=(\d{3})+\b)/g;
-    const units = valueUnits.replace(groupRegex, "$1,");
-    let decimals = valueDecimals.slice(0, precision);
-    if (minPrecision < precision) {
-      const trimmedDecimal = decimals.match(/.*[1-9]{1}/);
-      const lastNonZeroIndex = trimmedDecimal?.[0].length || 0;
-      const keepChars = Math.max(minPrecision, lastNonZeroIndex);
-      decimals = decimals.slice(0, keepChars);
-    }
-    const decimalPortion = decimals ? `.${decimals}` : "";
-    return `${units}${decimalPortion}`;
-  }
-  var BN = class extends import_bn.default {
-    MAX_U64 = "0xFFFFFFFFFFFFFFFF";
-    constructor(value, base, endian) {
-      let bnValue = value;
-      let bnBase = base;
-      if (BN.isBN(value)) {
-        bnValue = value.toArray();
-      } else if (typeof value === "string" && value.slice(0, 2) === "0x") {
-        bnValue = value.substring(2);
-        bnBase = base || "hex";
-      }
-      super(bnValue == null ? 0 : bnValue, bnBase, endian);
-    }
-    // ANCHOR: HELPERS
-    // make sure we always include `0x` in hex strings
-    toString(base, length) {
-      const output3 = super.toString(base, length);
-      if (base === 16 || base === "hex") {
-        return `0x${output3}`;
-      }
-      return output3;
-    }
-    toHex(bytesPadding) {
-      const bytes3 = bytesPadding || 0;
-      const bytesLength = bytes3 * 2;
-      if (this.isNeg()) {
-        throw new FuelError(ErrorCode.CONVERTING_FAILED, "Cannot convert negative value to hex.");
-      }
-      if (bytesPadding && this.byteLength() > bytesPadding) {
-        throw new FuelError(
-          ErrorCode.CONVERTING_FAILED,
-          `Provided value ${this} is too large. It should fit within ${bytesPadding} bytes.`
-        );
-      }
-      return this.toString(16, bytesLength);
-    }
-    toBytes(bytesPadding) {
-      if (this.isNeg()) {
-        throw new FuelError(ErrorCode.CONVERTING_FAILED, "Cannot convert negative value to bytes.");
-      }
-      return Uint8Array.from(this.toArray(void 0, bytesPadding));
-    }
-    toJSON() {
-      return this.toString(16);
-    }
-    valueOf() {
-      return this.toString();
-    }
-    format(options) {
-      const {
-        units = DEFAULT_DECIMAL_UNITS,
-        precision = DEFAULT_PRECISION,
-        minPrecision = DEFAULT_MIN_PRECISION
-      } = options || {};
-      const formattedUnits = this.formatUnits(units);
-      const formattedFixed = toFixed(formattedUnits, { precision, minPrecision });
-      if (!parseFloat(formattedFixed)) {
-        const [, originalDecimals = "0"] = formattedUnits.split(".");
-        const firstNonZero = originalDecimals.match(/[1-9]/);
-        if (firstNonZero && firstNonZero.index && firstNonZero.index + 1 > precision) {
-          const [valueUnits = "0"] = formattedFixed.split(".");
-          return `${valueUnits}.${originalDecimals.slice(0, firstNonZero.index + 1)}`;
-        }
-      }
-      return formattedFixed;
-    }
-    formatUnits(units = DEFAULT_DECIMAL_UNITS) {
-      const valueUnits = this.toString().slice(0, units * -1);
-      const valueDecimals = this.toString().slice(units * -1);
-      const length = valueDecimals.length;
-      const defaultDecimals = Array.from({ length: units - length }).fill("0").join("");
-      const integerPortion = valueUnits ? `${valueUnits}.` : "0.";
-      return `${integerPortion}${defaultDecimals}${valueDecimals}`;
-    }
-    // END ANCHOR: HELPERS
-    // ANCHOR: OVERRIDES to accept better inputs
-    add(v) {
-      return this.caller(v, "add");
-    }
-    pow(v) {
-      return this.caller(v, "pow");
-    }
-    sub(v) {
-      return this.caller(v, "sub");
-    }
-    div(v) {
-      return this.caller(v, "div");
-    }
-    mul(v) {
-      return this.caller(v, "mul");
-    }
-    mod(v) {
-      return this.caller(v, "mod");
-    }
-    divRound(v) {
-      return this.caller(v, "divRound");
-    }
-    lt(v) {
-      return this.caller(v, "lt");
-    }
-    lte(v) {
-      return this.caller(v, "lte");
-    }
-    gt(v) {
-      return this.caller(v, "gt");
-    }
-    gte(v) {
-      return this.caller(v, "gte");
-    }
-    eq(v) {
-      return this.caller(v, "eq");
-    }
-    cmp(v) {
-      return this.caller(v, "cmp");
-    }
-    // END ANCHOR: OVERRIDES to accept better inputs
-    // ANCHOR: OVERRIDES to output our BN type
-    sqr() {
-      return new BN(super.sqr().toArray());
-    }
-    neg() {
-      return new BN(super.neg().toArray());
-    }
-    abs() {
-      return new BN(super.abs().toArray());
-    }
-    toTwos(width) {
-      return new BN(super.toTwos(width).toArray());
-    }
-    fromTwos(width) {
-      return new BN(super.fromTwos(width).toArray());
-    }
-    // END ANCHOR: OVERRIDES to output our BN type
-    // ANCHOR: OVERRIDES to avoid losing references
-    caller(v, methodName) {
-      const output3 = super[methodName](new BN(v));
-      if (BN.isBN(output3)) {
-        return new BN(output3.toArray());
-      }
-      if (typeof output3 === "boolean") {
-        return output3;
-      }
-      return output3;
-    }
-    clone() {
-      return new BN(this.toArray());
-    }
-    mulTo(num, out) {
-      const output3 = new import_bn.default(this.toArray()).mulTo(num, out);
-      return new BN(output3.toArray());
-    }
-    egcd(p) {
-      const { a, b, gcd } = new import_bn.default(this.toArray()).egcd(p);
-      return {
-        a: new BN(a.toArray()),
-        b: new BN(b.toArray()),
-        gcd: new BN(gcd.toArray())
-      };
-    }
-    divmod(num, mode, positive) {
-      const { div, mod: mod2 } = new import_bn.default(this.toArray()).divmod(new BN(num), mode, positive);
-      return {
-        div: new BN(div?.toArray()),
-        mod: new BN(mod2?.toArray())
-      };
-    }
-    maxU64() {
-      return this.gte(this.MAX_U64) ? new BN(this.MAX_U64) : this;
-    }
-    normalizeZeroToOne() {
-      return this.isZero() ? new BN(1) : this;
-    }
-    // END ANCHOR: OVERRIDES to avoid losing references
-  };
-  var bn = (value, base, endian) => new BN(value, base, endian);
-  bn.parseUnits = (value, units = DEFAULT_DECIMAL_UNITS) => {
-    const valueToParse = value === "." ? "0." : value;
-    const [valueUnits = "0", valueDecimals = "0"] = valueToParse.split(".");
-    const length = valueDecimals.length;
-    if (length > units) {
-      throw new FuelError(
-        ErrorCode.CONVERTING_FAILED,
-        `Decimal can't have more than ${units} digits.`
-      );
-    }
-    const decimals = Array.from({ length: units }).fill("0");
-    decimals.splice(0, length, valueDecimals);
-    const amount = `${valueUnits.replaceAll(",", "")}${decimals.join("")}`;
-    return bn(amount);
-  };
-  function toNumber2(value) {
-    return bn(value).toNumber();
-  }
-  function toHex(value, bytesPadding) {
-    return bn(value).toHex(bytesPadding);
-  }
-  function toBytes3(value, bytesPadding) {
-    return bn(value).toBytes(bytesPadding);
-  }
-
   // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_isPlaceholder.js
   function _isPlaceholder(a) {
     return a != null && typeof a === "object" && a["@@functional/placeholder"] === true;
@@ -37270,6 +36700,316 @@ This unreleased fuel-core build may include features and updates not yet support
     return coinQuantities;
   };
 
+  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/_version.js
+  var version = "6.7.1";
+
+  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/utils/properties.js
+  function checkType(value, type3, name) {
+    const types = type3.split("|").map((t) => t.trim());
+    for (let i = 0; i < types.length; i++) {
+      switch (type3) {
+        case "any":
+          return;
+        case "bigint":
+        case "boolean":
+        case "number":
+        case "string":
+          if (typeof value === type3) {
+            return;
+          }
+      }
+    }
+    const error = new Error(`invalid value for type ${type3}`);
+    error.code = "INVALID_ARGUMENT";
+    error.argument = `value.${name}`;
+    error.value = value;
+    throw error;
+  }
+  function defineProperties(target, values, types) {
+    for (let key in values) {
+      let value = values[key];
+      const type3 = types ? types[key] : null;
+      if (type3) {
+        checkType(value, type3, key);
+      }
+      Object.defineProperty(target, key, { enumerable: true, value, writable: false });
+    }
+  }
+
+  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/utils/errors.js
+  function stringify(value) {
+    if (value == null) {
+      return "null";
+    }
+    if (Array.isArray(value)) {
+      return "[ " + value.map(stringify).join(", ") + " ]";
+    }
+    if (value instanceof Uint8Array) {
+      const HEX = "0123456789abcdef";
+      let result = "0x";
+      for (let i = 0; i < value.length; i++) {
+        result += HEX[value[i] >> 4];
+        result += HEX[value[i] & 15];
+      }
+      return result;
+    }
+    if (typeof value === "object" && typeof value.toJSON === "function") {
+      return stringify(value.toJSON());
+    }
+    switch (typeof value) {
+      case "boolean":
+      case "symbol":
+        return value.toString();
+      case "bigint":
+        return BigInt(value).toString();
+      case "number":
+        return value.toString();
+      case "string":
+        return JSON.stringify(value);
+      case "object": {
+        const keys = Object.keys(value);
+        keys.sort();
+        return "{ " + keys.map((k) => `${stringify(k)}: ${stringify(value[k])}`).join(", ") + " }";
+      }
+    }
+    return `[ COULD NOT SERIALIZE ]`;
+  }
+  function makeError(message, code, info) {
+    {
+      const details = [];
+      if (info) {
+        if ("message" in info || "code" in info || "name" in info) {
+          throw new Error(`value will overwrite populated values: ${stringify(info)}`);
+        }
+        for (const key in info) {
+          const value = info[key];
+          details.push(key + "=" + stringify(value));
+        }
+      }
+      details.push(`code=${code}`);
+      details.push(`version=${version}`);
+      if (details.length) {
+        message += " (" + details.join(", ") + ")";
+      }
+    }
+    let error;
+    switch (code) {
+      case "INVALID_ARGUMENT":
+        error = new TypeError(message);
+        break;
+      case "NUMERIC_FAULT":
+      case "BUFFER_OVERRUN":
+        error = new RangeError(message);
+        break;
+      default:
+        error = new Error(message);
+    }
+    defineProperties(error, { code });
+    if (info) {
+      Object.assign(error, info);
+    }
+    return error;
+  }
+  function assert(check, message, code, info) {
+    if (!check) {
+      throw makeError(message, code, info);
+    }
+  }
+  function assertArgument(check, message, name, value) {
+    assert(check, message, "INVALID_ARGUMENT", { argument: name, value });
+  }
+  var _normalizeForms = ["NFD", "NFC", "NFKD", "NFKC"].reduce((accum, form) => {
+    try {
+      if ("test".normalize(form) !== "test") {
+        throw new Error("bad");
+      }
+      ;
+      if (form === "NFD") {
+        const check = String.fromCharCode(233).normalize("NFD");
+        const expected = String.fromCharCode(101, 769);
+        if (check !== expected) {
+          throw new Error("broken");
+        }
+      }
+      accum.push(form);
+    } catch (error) {
+    }
+    return accum;
+  }, []);
+  function assertNormalize(form) {
+    assert(_normalizeForms.indexOf(form) >= 0, "platform missing String.prototype.normalize", "UNSUPPORTED_OPERATION", {
+      operation: "String.prototype.normalize",
+      info: { form }
+    });
+  }
+
+  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/utils/data.js
+  function _getBytes(value, name, copy) {
+    if (value instanceof Uint8Array) {
+      if (copy) {
+        return new Uint8Array(value);
+      }
+      return value;
+    }
+    if (typeof value === "string" && value.match(/^0x([0-9a-f][0-9a-f])*$/i)) {
+      const result = new Uint8Array((value.length - 2) / 2);
+      let offset = 2;
+      for (let i = 0; i < result.length; i++) {
+        result[i] = parseInt(value.substring(offset, offset + 2), 16);
+        offset += 2;
+      }
+      return result;
+    }
+    assertArgument(false, "invalid BytesLike value", name || "value", value);
+  }
+  function getBytes(value, name) {
+    return _getBytes(value, name, false);
+  }
+
+  // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/utils/utf8.js
+  function errorFunc(reason, offset, bytes2, output2, badCodepoint) {
+    assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes2);
+  }
+  function ignoreFunc(reason, offset, bytes2, output2, badCodepoint) {
+    if (reason === "BAD_PREFIX" || reason === "UNEXPECTED_CONTINUE") {
+      let i = 0;
+      for (let o = offset + 1; o < bytes2.length; o++) {
+        if (bytes2[o] >> 6 !== 2) {
+          break;
+        }
+        i++;
+      }
+      return i;
+    }
+    if (reason === "OVERRUN") {
+      return bytes2.length - offset - 1;
+    }
+    return 0;
+  }
+  function replaceFunc(reason, offset, bytes2, output2, badCodepoint) {
+    if (reason === "OVERLONG") {
+      assertArgument(typeof badCodepoint === "number", "invalid bad code point for replacement", "badCodepoint", badCodepoint);
+      output2.push(badCodepoint);
+      return 0;
+    }
+    output2.push(65533);
+    return ignoreFunc(reason, offset, bytes2, output2, badCodepoint);
+  }
+  var Utf8ErrorFuncs = Object.freeze({
+    error: errorFunc,
+    ignore: ignoreFunc,
+    replace: replaceFunc
+  });
+  function getUtf8CodePoints(_bytes, onError) {
+    if (onError == null) {
+      onError = Utf8ErrorFuncs.error;
+    }
+    const bytes2 = getBytes(_bytes, "bytes");
+    const result = [];
+    let i = 0;
+    while (i < bytes2.length) {
+      const c = bytes2[i++];
+      if (c >> 7 === 0) {
+        result.push(c);
+        continue;
+      }
+      let extraLength = null;
+      let overlongMask = null;
+      if ((c & 224) === 192) {
+        extraLength = 1;
+        overlongMask = 127;
+      } else if ((c & 240) === 224) {
+        extraLength = 2;
+        overlongMask = 2047;
+      } else if ((c & 248) === 240) {
+        extraLength = 3;
+        overlongMask = 65535;
+      } else {
+        if ((c & 192) === 128) {
+          i += onError("UNEXPECTED_CONTINUE", i - 1, bytes2, result);
+        } else {
+          i += onError("BAD_PREFIX", i - 1, bytes2, result);
+        }
+        continue;
+      }
+      if (i - 1 + extraLength >= bytes2.length) {
+        i += onError("OVERRUN", i - 1, bytes2, result);
+        continue;
+      }
+      let res = c & (1 << 8 - extraLength - 1) - 1;
+      for (let j = 0; j < extraLength; j++) {
+        let nextChar = bytes2[i];
+        if ((nextChar & 192) != 128) {
+          i += onError("MISSING_CONTINUE", i, bytes2, result);
+          res = null;
+          break;
+        }
+        ;
+        res = res << 6 | nextChar & 63;
+        i++;
+      }
+      if (res === null) {
+        continue;
+      }
+      if (res > 1114111) {
+        i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes2, result, res);
+        continue;
+      }
+      if (res >= 55296 && res <= 57343) {
+        i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes2, result, res);
+        continue;
+      }
+      if (res <= overlongMask) {
+        i += onError("OVERLONG", i - 1 - extraLength, bytes2, result, res);
+        continue;
+      }
+      result.push(res);
+    }
+    return result;
+  }
+  function toUtf8Bytes(str, form) {
+    if (form != null) {
+      assertNormalize(form);
+      str = str.normalize(form);
+    }
+    let result = [];
+    for (let i = 0; i < str.length; i++) {
+      const c = str.charCodeAt(i);
+      if (c < 128) {
+        result.push(c);
+      } else if (c < 2048) {
+        result.push(c >> 6 | 192);
+        result.push(c & 63 | 128);
+      } else if ((c & 64512) == 55296) {
+        i++;
+        const c2 = str.charCodeAt(i);
+        assertArgument(i < str.length && (c2 & 64512) === 56320, "invalid surrogate pair", "str", str);
+        const pair = 65536 + ((c & 1023) << 10) + (c2 & 1023);
+        result.push(pair >> 18 | 240);
+        result.push(pair >> 12 & 63 | 128);
+        result.push(pair >> 6 & 63 | 128);
+        result.push(pair & 63 | 128);
+      } else {
+        result.push(c >> 12 | 224);
+        result.push(c >> 6 & 63 | 128);
+        result.push(c & 63 | 128);
+      }
+    }
+    return new Uint8Array(result);
+  }
+  function _toUtf8String(codePoints) {
+    return codePoints.map((codePoint) => {
+      if (codePoint <= 65535) {
+        return String.fromCharCode(codePoint);
+      }
+      codePoint -= 65536;
+      return String.fromCharCode((codePoint >> 10 & 1023) + 55296, (codePoint & 1023) + 56320);
+    }).join("");
+  }
+  function toUtf8String(bytes2, onError) {
+    return _toUtf8String(getUtf8CodePoints(bytes2, onError));
+  }
+
   // ../abi-coder/dist/index.mjs
   var __defProp4 = Object.defineProperty;
   var __defNormalProp4 = (obj, key, value) => key in obj ? __defProp4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -37375,24 +37115,24 @@ This unreleased fuel-core build may include features and updates not yet support
       super("bigNumber", baseType, encodedLengths[baseType]);
     }
     encode(value) {
-      let bytes3;
+      let bytes2;
       try {
-        bytes3 = toBytes3(value, this.encodedLength);
+        bytes2 = toBytes2(value, this.encodedLength);
       } catch (error) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.type}.`);
       }
-      return bytes3;
+      return bytes2;
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} data size.`);
       }
-      let bytes3 = data.slice(offset, offset + this.encodedLength);
-      bytes3 = bytes3.slice(0, this.encodedLength);
-      if (bytes3.length !== this.encodedLength) {
+      let bytes2 = data.slice(offset, offset + this.encodedLength);
+      bytes2 = bytes2.slice(0, this.encodedLength);
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} byte data size.`);
       }
-      return [bn(bytes3), offset + this.encodedLength];
+      return [bn(bytes2), offset + this.encodedLength];
     }
   };
   var VEC_PROPERTY_SPACE = 3;
@@ -37535,15 +37275,15 @@ This unreleased fuel-core build may include features and updates not yet support
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid b256 data size.`);
       }
-      let bytes3 = data.slice(offset, offset + this.encodedLength);
-      const decoded = bn(bytes3);
+      let bytes2 = data.slice(offset, offset + this.encodedLength);
+      const decoded = bn(bytes2);
       if (decoded.isZero()) {
-        bytes3 = new Uint8Array(32);
+        bytes2 = new Uint8Array(32);
       }
-      if (bytes3.length !== this.encodedLength) {
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid b256 byte data size.`);
       }
-      return [toHex(bytes3, 32), offset + 32];
+      return [toHex(bytes2, 32), offset + 32];
     }
   };
   var B512Coder = class extends Coder {
@@ -37566,15 +37306,15 @@ This unreleased fuel-core build may include features and updates not yet support
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid b512 data size.`);
       }
-      let bytes3 = data.slice(offset, offset + this.encodedLength);
-      const decoded = bn(bytes3);
+      let bytes2 = data.slice(offset, offset + this.encodedLength);
+      const decoded = bn(bytes2);
       if (decoded.isZero()) {
-        bytes3 = new Uint8Array(64);
+        bytes2 = new Uint8Array(64);
       }
-      if (bytes3.length !== this.encodedLength) {
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid b512 byte data size.`);
       }
-      return [toHex(bytes3, this.encodedLength), offset + this.encodedLength];
+      return [toHex(bytes2, this.encodedLength), offset + this.encodedLength];
     }
   };
   var BooleanCoder = class extends Coder {
@@ -37594,23 +37334,23 @@ This unreleased fuel-core build may include features and updates not yet support
       if (!isTrueBool) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid boolean value.`);
       }
-      const output3 = toBytes3(value ? 1 : 0, this.paddingLength);
+      const output2 = toBytes2(value ? 1 : 0, this.paddingLength);
       if (this.options.isRightPadded) {
-        return output3.reverse();
+        return output2.reverse();
       }
-      return output3;
+      return output2;
     }
     decode(data, offset) {
       if (data.length < this.paddingLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean data size.`);
       }
-      let bytes3;
+      let bytes2;
       if (this.options.isRightPadded) {
-        bytes3 = data.slice(offset, offset + 1);
+        bytes2 = data.slice(offset, offset + 1);
       } else {
-        bytes3 = data.slice(offset, offset + this.paddingLength);
+        bytes2 = data.slice(offset, offset + this.paddingLength);
       }
-      const decodedValue = bn(bytes3);
+      const decodedValue = bn(bytes2);
       if (decodedValue.isZero()) {
         return [false, offset + this.paddingLength];
       }
@@ -37717,7 +37457,7 @@ This unreleased fuel-core build may include features and updates not yet support
       let newOffset = offset;
       let decoded;
       [decoded, newOffset] = new BigNumberCoder("u64").decode(data, newOffset);
-      const caseIndex = toNumber2(decoded);
+      const caseIndex = toNumber(decoded);
       const caseKey = Object.keys(this.coders)[caseIndex];
       if (!caseKey) {
         throw new FuelError(
@@ -37753,9 +37493,9 @@ This unreleased fuel-core build may include features and updates not yet support
       const [decoded, newOffset] = super.decode(data, offset);
       return [this.toOption(decoded), newOffset];
     }
-    toOption(output3) {
-      if (output3 && "Some" in output3) {
-        return output3.Some;
+    toOption(output2) {
+      if (output2 && "Some" in output2) {
+        return output2.Some;
       }
       return void 0;
     }
@@ -37790,30 +37530,30 @@ This unreleased fuel-core build may include features and updates not yet support
       this.options = options;
     }
     encode(value) {
-      let bytes3;
+      let bytes2;
       try {
-        bytes3 = toBytes3(value);
+        bytes2 = toBytes2(value);
       } catch (error) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}.`);
       }
-      if (bytes3.length > this.length) {
+      if (bytes2.length > this.length) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}, too many bytes.`);
       }
-      const output3 = toBytes3(bytes3, this.paddingLength);
+      const output2 = toBytes2(bytes2, this.paddingLength);
       if (this.baseType !== "u8") {
-        return output3;
+        return output2;
       }
-      return this.options.isRightPadded ? output3.reverse() : output3;
+      return this.options.isRightPadded ? output2.reverse() : output2;
     }
     decodeU8(data, offset) {
-      let bytes3;
+      let bytes2;
       if (this.options.isRightPadded) {
-        bytes3 = data.slice(offset, offset + 1);
+        bytes2 = data.slice(offset, offset + 1);
       } else {
-        bytes3 = data.slice(offset, offset + this.paddingLength);
-        bytes3 = bytes3.slice(this.paddingLength - this.length, this.paddingLength);
+        bytes2 = data.slice(offset, offset + this.paddingLength);
+        bytes2 = bytes2.slice(this.paddingLength - this.length, this.paddingLength);
       }
-      return [toNumber2(bytes3), offset + this.paddingLength];
+      return [toNumber(bytes2), offset + this.paddingLength];
     }
     decode(data, offset) {
       if (data.length < this.paddingLength) {
@@ -37822,12 +37562,12 @@ This unreleased fuel-core build may include features and updates not yet support
       if (this.baseType === "u8") {
         return this.decodeU8(data, offset);
       }
-      let bytes3 = data.slice(offset, offset + this.paddingLength);
-      bytes3 = bytes3.slice(8 - this.length, 8);
-      if (bytes3.length !== this.paddingLength - (this.paddingLength - this.length)) {
+      let bytes2 = data.slice(offset, offset + this.paddingLength);
+      bytes2 = bytes2.slice(8 - this.length, 8);
+      if (bytes2.length !== this.paddingLength - (this.paddingLength - this.length)) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number byte data size.`);
       }
-      return [toNumber2(bytes3), offset + 8];
+      return [toNumber(bytes2), offset + 8];
     }
   };
   var RawSliceCoder = class extends Coder {
@@ -37925,11 +37665,11 @@ This unreleased fuel-core build may include features and updates not yet support
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string data size.`);
       }
-      const bytes3 = data.slice(offset, offset + this.length);
-      if (bytes3.length !== this.length) {
+      const bytes2 = data.slice(offset, offset + this.length);
+      if (bytes2.length !== this.length) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string byte data size.`);
       }
-      const value = toUtf8String(bytes3);
+      const value = toUtf8String(bytes2);
       const padding = this.#paddingLength;
       return [value, offset + this.length + padding];
     }
@@ -38340,17 +38080,17 @@ This unreleased fuel-core build may include features and updates not yet support
       if (!isTrueBool) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid boolean value.`);
       }
-      return toBytes3(value ? 1 : 0, this.encodedLength);
+      return toBytes2(value ? 1 : 0, this.encodedLength);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean data size.`);
       }
-      const bytes3 = bn(data.slice(offset, offset + this.encodedLength));
-      if (bytes3.isZero()) {
+      const bytes2 = bn(data.slice(offset, offset + this.encodedLength));
+      if (bytes2.isZero()) {
         return [false, offset + this.encodedLength];
       }
-      if (!bytes3.eq(bn(1))) {
+      if (!bytes2.eq(bn(1))) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean value.`);
       }
       return [true, offset + this.encodedLength];
@@ -38361,9 +38101,9 @@ This unreleased fuel-core build may include features and updates not yet support
       super("struct", "struct Bytes", WORD_SIZE);
     }
     encode(value) {
-      const bytes3 = value instanceof Uint8Array ? value : new Uint8Array(value);
-      const lengthBytes = new BigNumberCoder("u64").encode(bytes3.length);
-      return new Uint8Array([...lengthBytes, ...bytes3]);
+      const bytes2 = value instanceof Uint8Array ? value : new Uint8Array(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
     }
     decode(data, offset) {
       if (data.length < WORD_SIZE) {
@@ -38432,7 +38172,7 @@ This unreleased fuel-core build may include features and updates not yet support
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid enum data size.`);
       }
       const caseBytes = new BigNumberCoder("u64").decode(data, offset)[0];
-      const caseIndex = toNumber2(caseBytes);
+      const caseIndex = toNumber(caseBytes);
       const caseKey = Object.keys(this.coders)[caseIndex];
       if (!caseKey) {
         throw new FuelError(
@@ -38471,26 +38211,26 @@ This unreleased fuel-core build may include features and updates not yet support
       this.length = length;
     }
     encode(value) {
-      let bytes3;
+      let bytes2;
       try {
-        bytes3 = toBytes3(value);
+        bytes2 = toBytes2(value);
       } catch (error) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}.`);
       }
-      if (bytes3.length > this.length) {
+      if (bytes2.length > this.length) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}, too many bytes.`);
       }
-      return toBytes3(bytes3, this.length);
+      return toBytes2(bytes2, this.length);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number data size.`);
       }
-      const bytes3 = data.slice(offset, offset + this.length);
-      if (bytes3.length !== this.encodedLength) {
+      const bytes2 = data.slice(offset, offset + this.length);
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number byte data size.`);
       }
-      return [toNumber2(bytes3), offset + this.length];
+      return [toNumber(bytes2), offset + this.length];
     }
   };
   var OptionCoder2 = class extends EnumCoder2 {
@@ -38508,9 +38248,9 @@ This unreleased fuel-core build may include features and updates not yet support
       const [decoded, newOffset] = super.decode(data, offset);
       return [this.toOption(decoded), newOffset];
     }
-    toOption(output3) {
-      if (output3 && "Some" in output3) {
-        return output3.Some;
+    toOption(output2) {
+      if (output2 && "Some" in output2) {
+        return output2.Some;
       }
       return void 0;
     }
@@ -38524,9 +38264,9 @@ This unreleased fuel-core build may include features and updates not yet support
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
       }
       const internalCoder = new ArrayCoder(new NumberCoder2("u8"), value.length);
-      const bytes3 = internalCoder.encode(value);
-      const lengthBytes = new BigNumberCoder("u64").encode(bytes3.length);
-      return new Uint8Array([...lengthBytes, ...bytes3]);
+      const bytes2 = internalCoder.encode(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -38549,9 +38289,9 @@ This unreleased fuel-core build may include features and updates not yet support
       super("struct", "struct String", WORD_SIZE);
     }
     encode(value) {
-      const bytes3 = toUtf8Bytes(value);
+      const bytes2 = toUtf8Bytes(value);
       const lengthBytes = new BigNumberCoder("u64").encode(value.length);
-      return new Uint8Array([...lengthBytes, ...bytes3]);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -38573,9 +38313,9 @@ This unreleased fuel-core build may include features and updates not yet support
       super("strSlice", "str", WORD_SIZE);
     }
     encode(value) {
-      const bytes3 = toUtf8Bytes(value);
+      const bytes2 = toUtf8Bytes(value);
       const lengthBytes = new BigNumberCoder("u64").encode(value.length);
-      return new Uint8Array([...lengthBytes, ...bytes3]);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -38584,11 +38324,11 @@ This unreleased fuel-core build may include features and updates not yet support
       const offsetAndLength = offset + WORD_SIZE;
       const lengthBytes = data.slice(offset, offsetAndLength);
       const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
-      const bytes3 = data.slice(offsetAndLength, offsetAndLength + length);
-      if (bytes3.length !== length) {
+      const bytes2 = data.slice(offsetAndLength, offsetAndLength + length);
+      if (bytes2.length !== length) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string slice byte data size.`);
       }
-      return [toUtf8String(bytes3), offsetAndLength + length];
+      return [toUtf8String(bytes2), offsetAndLength + length];
     }
   };
   __publicField4(StrSliceCoder, "memorySize", 1);
@@ -38606,11 +38346,11 @@ This unreleased fuel-core build may include features and updates not yet support
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string data size.`);
       }
-      const bytes3 = data.slice(offset, offset + this.encodedLength);
-      if (bytes3.length !== this.encodedLength) {
+      const bytes2 = data.slice(offset, offset + this.encodedLength);
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string byte data size.`);
       }
-      return [toUtf8String(bytes3), offset + this.encodedLength];
+      return [toUtf8String(bytes2), offset + this.encodedLength];
     }
   };
   var StructCoder2 = class extends Coder {
@@ -38690,12 +38430,19 @@ This unreleased fuel-core build may include features and updates not yet support
       this.#isOptionVec = this.coder instanceof OptionCoder2;
     }
     encode(value) {
-      if (!Array.isArray(value)) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+      if (!Array.isArray(value) && !isUint8Array(value)) {
+        throw new FuelError(
+          ErrorCode.ENCODE_ERROR,
+          `Expected array value, or a Uint8Array. You can use arrayify to convert a value to a Uint8Array.`
+        );
       }
-      const bytes3 = value.map((v) => this.coder.encode(v));
-      const lengthBytes = new BigNumberCoder("u64").encode(value.length);
-      return new Uint8Array([...lengthBytes, ...concatBytes2(bytes3)]);
+      const lengthCoder = new BigNumberCoder("u64");
+      if (isUint8Array(value)) {
+        return new Uint8Array([...lengthCoder.encode(value.length), ...value]);
+      }
+      const bytes2 = value.map((v) => this.coder.encode(v));
+      const lengthBytes = lengthCoder.encode(value.length);
+      return new Uint8Array([...lengthBytes, ...concatBytes2(bytes2)]);
     }
     decode(data, offset) {
       if (!this.#isOptionVec && (data.length < this.encodedLength || data.length > MAX_BYTES)) {
@@ -38858,7 +38605,7 @@ This unreleased fuel-core build may include features and updates not yet support
       return `${fn.name}(${inputsSignatures.join(",")})`;
     }
     static getFunctionSelector(functionSignature) {
-      const hashedFunctionSignature = sha2563(bufferFromString2(functionSignature, "utf-8"));
+      const hashedFunctionSignature = sha2562(bufferFromString2(functionSignature, "utf-8"));
       return bn(hashedFunctionSignature.slice(0, 10)).toHex(8);
     }
     #isInputDataPointer() {
@@ -38921,10 +38668,10 @@ This unreleased fuel-core build may include features and updates not yet support
       throw new FuelError(ErrorCode.ABI_TYPES_AND_VALUES_MISMATCH, errorMsg);
     }
     decodeArguments(data) {
-      const bytes3 = arrayify(data);
+      const bytes2 = arrayify(data);
       const nonEmptyInputs = findNonEmptyInputs(this.jsonAbi, this.jsonFn.inputs);
       if (nonEmptyInputs.length === 0) {
-        if (bytes3.length === 0) {
+        if (bytes2.length === 0) {
           return void 0;
         }
         throw new FuelError(
@@ -38933,12 +38680,12 @@ This unreleased fuel-core build may include features and updates not yet support
             count: {
               types: this.jsonFn.inputs.length,
               nonEmptyInputs: nonEmptyInputs.length,
-              values: bytes3.length
+              values: bytes2.length
             },
             value: {
               args: this.jsonFn.inputs,
               nonEmptyInputs,
-              values: bytes3
+              values: bytes2
             }
           })}`
         );
@@ -38946,7 +38693,7 @@ This unreleased fuel-core build may include features and updates not yet support
       const result = nonEmptyInputs.reduce(
         (obj, input) => {
           const coder = AbiCoder.getCoder(this.jsonAbi, input, { encoding: this.encoding });
-          const [decodedValue, decodedValueByteSize] = coder.decode(bytes3, obj.offset);
+          const [decodedValue, decodedValueByteSize] = coder.decode(bytes2, obj.offset);
           return {
             decoded: [...obj.decoded, decodedValue],
             offset: obj.offset + decodedValueByteSize
@@ -38961,11 +38708,11 @@ This unreleased fuel-core build may include features and updates not yet support
       if (outputAbiType.type === "()") {
         return [void 0, 0];
       }
-      const bytes3 = arrayify(data);
+      const bytes2 = arrayify(data);
       const coder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output, {
         encoding: this.encoding
       });
-      return coder.decode(bytes3, 0);
+      return coder.decode(bytes2, 0);
     }
     /**
      * Checks if the function is read-only i.e. it only reads from storage, does not write to it.
@@ -39226,12 +38973,12 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new ByteArrayCoder(32).encode(value.nonce));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(arrayify(value.data || "0x"));
-      return sha2563(concat(parts));
+      return sha2562(concat(parts));
     }
     static encodeData(messageData) {
-      const bytes3 = arrayify(messageData || "0x");
-      const dataLength2 = bytes3.length;
-      return new ByteArrayCoder(dataLength2).encode(bytes3);
+      const bytes2 = arrayify(messageData || "0x");
+      const dataLength2 = bytes2.length;
+      return new ByteArrayCoder(dataLength2).encode(bytes2);
     }
     encode(value) {
       const parts = [];
@@ -39253,9 +39000,9 @@ This unreleased fuel-core build may include features and updates not yet support
       return concat(parts);
     }
     static decodeData(messageData) {
-      const bytes3 = arrayify(messageData);
-      const dataLength2 = bytes3.length;
-      const [data] = new ByteArrayCoder(dataLength2).decode(bytes3, 0);
+      const bytes2 = arrayify(messageData);
+      const dataLength2 = bytes2.length;
+      const [data] = new ByteArrayCoder(dataLength2).decode(bytes2, 0);
       return arrayify(data);
     }
     decode(data, offset) {
@@ -39692,7 +39439,7 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new ByteArrayCoder(32).encode(value.nonce));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(arrayify(value.data || "0x"));
-      return sha2563(concat(parts));
+      return sha2562(concat(parts));
     }
     encode(value) {
       const parts = [];
@@ -39739,7 +39486,7 @@ This unreleased fuel-core build may include features and updates not yet support
   var getMintedAssetId = (contractId, subId) => {
     const contractIdBytes = arrayify(contractId);
     const subIdBytes = arrayify(subId);
-    return sha2563(concat([contractIdBytes, subIdBytes]));
+    return sha2562(concat([contractIdBytes, subIdBytes]));
   };
   var ReceiptMintCoder = class extends Coder {
     constructor() {
@@ -40353,7 +40100,7 @@ This unreleased fuel-core build may include features and updates not yet support
     numberToBytesLE: () => numberToBytesLE,
     numberToHexUnpadded: () => numberToHexUnpadded,
     numberToVarBytesBE: () => numberToVarBytesBE,
-    utf8ToBytes: () => utf8ToBytes3,
+    utf8ToBytes: () => utf8ToBytes2,
     validateObject: () => validateObject
   });
   var _0n2 = BigInt(0);
@@ -40362,13 +40109,13 @@ This unreleased fuel-core build may include features and updates not yet support
   function isBytes3(a) {
     return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
   }
-  var hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-  function bytesToHex(bytes3) {
-    if (!isBytes3(bytes3))
+  var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+  function bytesToHex(bytes2) {
+    if (!isBytes3(bytes2))
       throw new Error("Uint8Array expected");
     let hex = "";
-    for (let i = 0; i < bytes3.length; i++) {
-      hex += hexes2[bytes3[i]];
+    for (let i = 0; i < bytes2.length; i++) {
+      hex += hexes[bytes2[i]];
     }
     return hex;
   }
@@ -40410,13 +40157,13 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     return array;
   }
-  function bytesToNumberBE(bytes3) {
-    return hexToNumber(bytesToHex(bytes3));
+  function bytesToNumberBE(bytes2) {
+    return hexToNumber(bytesToHex(bytes2));
   }
-  function bytesToNumberLE(bytes3) {
-    if (!isBytes3(bytes3))
+  function bytesToNumberLE(bytes2) {
+    if (!isBytes3(bytes2))
       throw new Error("Uint8Array expected");
-    return hexToNumber(bytesToHex(Uint8Array.from(bytes3).reverse()));
+    return hexToNumber(bytesToHex(Uint8Array.from(bytes2).reverse()));
   }
   function numberToBytesBE(n, len) {
     return hexToBytes(n.toString(16).padStart(len * 2, "0"));
@@ -40470,7 +40217,7 @@ This unreleased fuel-core build may include features and updates not yet support
       diff |= a[i] ^ b[i];
     return diff === 0;
   }
-  function utf8ToBytes3(str) {
+  function utf8ToBytes2(str) {
     if (typeof str !== "string")
       throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
     return new Uint8Array(new TextEncoder().encode(str));
@@ -40789,19 +40536,19 @@ This unreleased fuel-core build may include features and updates not yet support
       return "GraphQLError";
     }
     toString() {
-      let output3 = this.message;
+      let output2 = this.message;
       if (this.nodes) {
         for (const node of this.nodes) {
           if (node.loc) {
-            output3 += "\n\n" + printLocation(node.loc);
+            output2 += "\n\n" + printLocation(node.loc);
           }
         }
       } else if (this.source && this.locations) {
         for (const location of this.locations) {
-          output3 += "\n\n" + printSourceLocation(this.source, location);
+          output2 += "\n\n" + printSourceLocation(this.source, location);
         }
       }
-      return output3;
+      return output2;
     }
     toJSON() {
       const formattedError = {
@@ -44815,13 +44562,13 @@ ${MessageCoinFragmentDoc}`;
         return {
           type: InputType.Coin,
           txID: hexlify(arrayify(value.id).slice(0, BYTES_32)),
-          outputIndex: toNumber2(arrayify(value.id).slice(BYTES_32, UTXO_ID_LEN)),
+          outputIndex: toNumber(arrayify(value.id).slice(BYTES_32, UTXO_ID_LEN)),
           owner: hexlify(value.owner),
           amount: bn(value.amount),
           assetId: hexlify(value.assetId),
           txPointer: {
-            blockHeight: toNumber2(arrayify(value.txPointer).slice(0, 8)),
-            txIndex: toNumber2(arrayify(value.txPointer).slice(8, 16))
+            blockHeight: toNumber(arrayify(value.txPointer).slice(0, 8)),
+            txIndex: toNumber(arrayify(value.txPointer).slice(8, 16))
           },
           witnessIndex: value.witnessIndex,
           predicateGasUsed: bn(value.predicateGasUsed),
@@ -44839,8 +44586,8 @@ ${MessageCoinFragmentDoc}`;
           balanceRoot: ZeroBytes32,
           stateRoot: ZeroBytes32,
           txPointer: {
-            blockHeight: toNumber2(arrayify(value.txPointer).slice(0, 8)),
-            txIndex: toNumber2(arrayify(value.txPointer).slice(8, 16))
+            blockHeight: toNumber(arrayify(value.txPointer).slice(0, 8)),
+            txIndex: toNumber(arrayify(value.txPointer).slice(8, 16))
           },
           contractID: hexlify(value.contractId)
         };
@@ -45399,6 +45146,34 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     name = "NoWitnessAtIndexError";
   };
 
+  // src/providers/transaction-request/helpers.ts
+  var isRequestInputCoin = (input) => input.type === InputType.Coin;
+  var isRequestInputMessage = (input) => input.type === InputType.Message;
+  var isRequestInputResource = (input) => isRequestInputCoin(input) || isRequestInputMessage(input);
+  var getAssetAmountInRequestInputs = (inputs, assetId, baseAsset) => inputs.filter(isRequestInputResource).reduce((acc, input) => {
+    if (isRequestInputCoin(input) && input.assetId === assetId) {
+      return acc.add(input.amount);
+    }
+    if (isRequestInputMessage(input) && assetId === baseAsset) {
+      return acc.add(input.amount);
+    }
+    return acc;
+  }, bn(0));
+  var cacheRequestInputsResourcesFromOwner = (inputs, owner) => inputs.reduce(
+    (acc, input) => {
+      if (isRequestInputCoin(input) && input.owner === owner.toB256()) {
+        acc.utxos.push(input.id);
+      } else if (isRequestInputMessage(input) && input.recipient === owner.toB256()) {
+        acc.messages.push(input.nonce);
+      }
+      return acc;
+    },
+    {
+      utxos: [],
+      messages: []
+    }
+  );
+
   // src/providers/transaction-request/witness.ts
   var witnessify = (value) => {
     const data = arrayify(value);
@@ -45512,8 +45287,8 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      *
      * Pushes an output to the list without any side effects and returns the index
      */
-    pushOutput(output3) {
-      this.outputs.push(output3);
+    pushOutput(output2) {
+      this.outputs.push(output2);
       return this.outputs.length - 1;
     }
     /**
@@ -45597,7 +45372,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      */
     getCoinOutputs() {
       return this.outputs.filter(
-        (output3) => output3.type === OutputType.Coin
+        (output2) => output2.type === OutputType.Coin
       );
     }
     /**
@@ -45607,7 +45382,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      */
     getChangeOutputs() {
       return this.outputs.filter(
-        (output3) => output3.type === OutputType.Change
+        (output2) => output2.type === OutputType.Change
       );
     }
     /**
@@ -45636,7 +45411,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @param coin - Coin resource.
      */
     addCoinInput(coin) {
-      const { assetId, owner, amount } = coin;
+      const { assetId, owner, amount, id, predicate } = coin;
       let witnessIndex;
       if (coin.predicate) {
         witnessIndex = 0;
@@ -45647,13 +45422,14 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         }
       }
       const input = {
-        ...coin,
+        id,
         type: InputType.Coin,
         owner: owner.toB256(),
         amount,
         assetId,
         txPointer: "0x00000000000000000000000000000000",
-        witnessIndex
+        witnessIndex,
+        predicate
       };
       this.pushInput(input);
       this.addChangeOutput(owner, assetId);
@@ -45665,7 +45441,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      * @param message - Message resource.
      */
     addMessageInput(message) {
-      const { recipient, sender, amount, assetId } = message;
+      const { recipient, sender, amount, predicate, nonce, assetId } = message;
       let witnessIndex;
       if (message.predicate) {
         witnessIndex = 0;
@@ -45676,12 +45452,13 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         }
       }
       const input = {
-        ...message,
+        nonce,
         type: InputType.Message,
         sender: sender.toB256(),
         recipient: recipient.toB256(),
         amount,
-        witnessIndex
+        witnessIndex,
+        predicate
       };
       this.pushInput(input);
       this.addChangeOutput(recipient, assetId);
@@ -45753,7 +45530,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      */
     addChangeOutput(to, assetId) {
       const changeOutput = this.getChangeOutputs().find(
-        (output3) => hexlify(output3.assetId) === assetId
+        (output2) => hexlify(output2.assetId) === assetId
       );
       if (!changeOutput) {
         this.pushOutput({
@@ -45871,6 +45648,17 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     toJSON() {
       return normalizeJSON(this);
     }
+    removeWitness(index) {
+      this.witnesses.splice(index, 1);
+      this.adjustWitnessIndexes(index);
+    }
+    adjustWitnessIndexes(removedIndex) {
+      this.inputs.filter(isRequestInputResource).forEach((input) => {
+        if (input.witnessIndex > removedIndex) {
+          input.witnessIndex -= 1;
+        }
+      });
+    }
     updatePredicateGasUsed(inputs) {
       this.inputs.forEach((i) => {
         let correspondingInput;
@@ -45940,8 +45728,8 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
           return inputClone;
       }
     });
-    transaction.outputs = transaction.outputs.map((output3) => {
-      const outputClone = clone_default(output3);
+    transaction.outputs = transaction.outputs.map((output2) => {
+      const outputClone = clone_default(output2);
       switch (outputClone.type) {
         case OutputType.Contract: {
           outputClone.balanceRoot = ZeroBytes32;
@@ -45966,7 +45754,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     transaction.witnesses = [];
     const chainIdBytes = uint64ToBytesBE(chainId);
     const concatenatedData = concat([chainIdBytes, new TransactionCoder().encode(transaction)]);
-    return sha2563(concatenatedData);
+    return sha2562(concatenatedData);
   }
 
   // src/providers/transaction-request/storage-slot.ts
@@ -46043,7 +45831,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      */
     getContractCreatedOutputs() {
       return this.outputs.filter(
-        (output3) => output3.type === OutputType.ContractCreated
+        (output2) => output2.type === OutputType.ContractCreated
       );
     }
     /**
@@ -46169,7 +45957,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      */
     getContractOutputs() {
       return this.outputs.filter(
-        (output3) => output3.type === OutputType.Contract
+        (output2) => output2.type === OutputType.Contract
       );
     }
     /**
@@ -46179,7 +45967,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
      */
     getVariableOutputs() {
       return this.outputs.filter(
-        (output3) => output3.type === OutputType.Variable
+        (output2) => output2.type === OutputType.Variable
       );
     }
     /**
@@ -46297,21 +46085,6 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       }
     }
   };
-  var cacheTxInputsFromOwner = (inputs, owner) => inputs.reduce(
-    (acc, input) => {
-      if (input.type === InputType.Coin && input.owner === owner.toB256()) {
-        acc.utxos.push(input.id);
-      }
-      if (input.type === InputType.Message && input.recipient === owner.toB256()) {
-        acc.messages.push(input.nonce);
-      }
-      return acc;
-    },
-    {
-      utxos: [],
-      messages: []
-    }
-  );
 
   // src/providers/transaction-summary/calculate-tx-fee-for-summary.ts
   var calculateTXFeeForSummary = (params) => {
@@ -46620,8 +46393,8 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   }) {
     const contractCallReceipts = getReceiptsCall(receipts);
     const contractOutputs = getOutputsContract(outputs);
-    const contractCallOperations = contractOutputs.reduce((prevOutputCallOps, output3) => {
-      const contractInput = getInputContractFromIndex(inputs, output3.inputIndex);
+    const contractCallOperations = contractOutputs.reduce((prevOutputCallOps, output2) => {
+      const contractInput = getInputContractFromIndex(inputs, output2.inputIndex);
       if (contractInput) {
         const newCallOps = contractCallReceipts.reduce((prevContractCallOps, receipt) => {
           if (receipt.to === contractInput.contractID) {
@@ -46675,7 +46448,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     let { from: fromAddress } = receipt;
     const toType = contractInputs.some((input) => input.contractID === toAddress) ? 0 /* contract */ : 1 /* account */;
     if (ZeroBytes32 === fromAddress) {
-      const change = changeOutputs.find((output3) => output3.assetId === assetId);
+      const change = changeOutputs.find((output2) => output2.assetId === assetId);
       fromAddress = change?.to || fromAddress;
     }
     const fromType = contractInputs.some((input) => input.contractID === fromAddress) ? 0 /* contract */ : 1 /* account */;
@@ -46706,8 +46479,8 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     const coinOutputs = getOutputsCoin(outputs);
     const contractInputs = getInputsContract(inputs);
     const changeOutputs = getOutputsChange(outputs);
-    coinOutputs.forEach((output3) => {
-      const { amount, assetId, to } = output3;
+    coinOutputs.forEach((output2) => {
+      const { amount, assetId, to } = output2;
       const changeOutput = changeOutputs.find((change) => change.assetId === assetId);
       if (changeOutput) {
         operations = addOperation(operations, {
@@ -46745,7 +46518,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   }
   function getPayProducerOperations(outputs) {
     const coinOutputs = getOutputsCoin(outputs);
-    const payProducerOperations = coinOutputs.reduce((prev, output3) => {
+    const payProducerOperations = coinOutputs.reduce((prev, output2) => {
       const operations = addOperation(prev, {
         name: "Pay network fee to block producer" /* payBlockProducer */,
         from: {
@@ -46754,12 +46527,12 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         },
         to: {
           type: 1 /* account */,
-          address: output3.to.toString()
+          address: output2.to.toString()
         },
         assetsSent: [
           {
-            assetId: output3.assetId.toString(),
-            amount: output3.amount
+            assetId: output2.assetId.toString(),
+            amount: output2.amount
           }
         ]
       });
@@ -48451,20 +48224,6 @@ Supported fuel-core version: ${supportedVersion}.`
   ];
   var assets = resolveIconPaths(rawAssets, fuelAssetsBaseUrl);
 
-  // src/providers/transaction-request/helpers.ts
-  var isRequestInputCoin = (input) => input.type === InputType.Coin;
-  var isRequestInputMessage = (input) => input.type === InputType.Message;
-  var isRequestInputResource = (input) => isRequestInputCoin(input) || isRequestInputMessage(input);
-  var getAssetAmountInRequestInputs = (inputs, assetId, baseAsset) => inputs.filter(isRequestInputResource).reduce((acc, input) => {
-    if (isRequestInputCoin(input) && input.assetId === assetId) {
-      return acc.add(input.amount);
-    }
-    if (isRequestInputMessage(input) && assetId === baseAsset) {
-      return acc.add(input.amount);
-    }
-    return acc;
-  }, bn(0));
-
   // src/utils/formatTransferToContractScriptData.ts
   var asm = __toESM(require_node());
   var formatTransferToContractScriptData = (params) => {
@@ -48699,7 +48458,7 @@ Supported fuel-core version: ${supportedVersion}.`
       while (needsToBeFunded && fundingAttempts < MAX_FUNDING_ATTEMPTS) {
         const resources = await this.getResourcesToSpend(
           missingQuantities,
-          cacheTxInputsFromOwner(request.inputs, this.address)
+          cacheRequestInputsResourcesFromOwner(request.inputs, this.address)
         );
         request.addResources(resources);
         request.shiftPredicateData();
@@ -48990,11 +48749,11 @@ Supported fuel-core version: ${supportedVersion}.`
     }
     return res;
   }
-  function invert(number3, modulo) {
-    if (number3 === _0n3 || modulo <= _0n3) {
-      throw new Error(`invert: expected positive integers, got n=${number3} mod=${modulo}`);
+  function invert(number2, modulo) {
+    if (number2 === _0n3 || modulo <= _0n3) {
+      throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
     }
-    let a = mod(number3, modulo);
+    let a = mod(number2, modulo);
     let b = modulo;
     let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
     while (a !== _0n3) {
@@ -49149,7 +48908,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const nByteLength = Math.ceil(_nBitLength / 8);
     return { nBitLength: _nBitLength, nByteLength };
   }
-  function Field(ORDER, bitLen2, isLE3 = false, redef = {}) {
+  function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
     if (ORDER <= _0n3)
       throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
     const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
@@ -49190,11 +48949,11 @@ Supported fuel-core version: ${supportedVersion}.`
       // TODO: do we really need constant cmov?
       // We don't have const-time bigints anyway, so probably will be not very useful
       cmov: (a, b, c) => c ? b : a,
-      toBytes: (num) => isLE3 ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES),
-      fromBytes: (bytes3) => {
-        if (bytes3.length !== BYTES)
-          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes3.length}`);
-        return isLE3 ? bytesToNumberLE(bytes3) : bytesToNumberBE(bytes3);
+      toBytes: (num) => isLE2 ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES),
+      fromBytes: (bytes2) => {
+        if (bytes2.length !== BYTES)
+          throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
+        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
       }
     });
     return Object.freeze(f2);
@@ -49209,15 +48968,15 @@ Supported fuel-core version: ${supportedVersion}.`
     const length = getFieldBytesLength(fieldOrder);
     return length + Math.ceil(length / 2);
   }
-  function mapHashToField(key, fieldOrder, isLE3 = false) {
+  function mapHashToField(key, fieldOrder, isLE2 = false) {
     const len = key.length;
     const fieldLen = getFieldBytesLength(fieldOrder);
     const minLen = getMinHashLength(fieldOrder);
     if (len < 16 || len < minLen || len > 1024)
       throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
-    const num = isLE3 ? bytesToNumberBE(key) : bytesToNumberLE(key);
+    const num = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
     const reduced = mod(num, fieldOrder - _1n3) + _1n3;
-    return isLE3 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
+    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
   }
 
   // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/curve.js
@@ -49425,12 +49184,12 @@ Supported fuel-core version: ${supportedVersion}.`
   function weierstrassPoints(opts) {
     const CURVE = validatePointOpts(opts);
     const { Fp: Fp2 } = CURVE;
-    const toBytes4 = CURVE.toBytes || ((_c, point, _isCompressed) => {
+    const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
       const a = point.toAffine();
       return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
     });
-    const fromBytes = CURVE.fromBytes || ((bytes3) => {
-      const tail = bytes3.subarray(1);
+    const fromBytes = CURVE.fromBytes || ((bytes2) => {
+      const tail = bytes2.subarray(1);
       const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES));
       const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES));
       return { x, y };
@@ -49793,7 +49552,7 @@ Supported fuel-core version: ${supportedVersion}.`
       }
       toRawBytes(isCompressed = true) {
         this.assertValidity();
-        return toBytes4(Point2, this, isCompressed);
+        return toBytes3(Point2, this, isCompressed);
       }
       toHex(isCompressed = true) {
         return bytesToHex(this.toRawBytes(isCompressed));
@@ -49850,10 +49609,10 @@ Supported fuel-core version: ${supportedVersion}.`
           return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y));
         }
       },
-      fromBytes(bytes3) {
-        const len = bytes3.length;
-        const head = bytes3[0];
-        const tail = bytes3.subarray(1);
+      fromBytes(bytes2) {
+        const len = bytes2.length;
+        const head = bytes2[0];
+        const tail = bytes2.subarray(1);
         if (len === compressedLen && (head === 2 || head === 3)) {
           const x = bytesToNumberBE(tail);
           if (!isValidFieldElement(x))
@@ -49875,15 +49634,15 @@ Supported fuel-core version: ${supportedVersion}.`
       }
     });
     const numToNByteStr = (num) => bytesToHex(numberToBytesBE(num, CURVE.nByteLength));
-    function isBiggerThanHalfOrder(number3) {
+    function isBiggerThanHalfOrder(number2) {
       const HALF = CURVE_ORDER >> _1n5;
-      return number3 > HALF;
+      return number2 > HALF;
     }
     function normalizeS(s) {
       return isBiggerThanHalfOrder(s) ? modN(-s) : s;
     }
     const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
-    class Signature2 {
+    class Signature {
       constructor(r, s, recovery) {
         this.r = r;
         this.s = s;
@@ -49894,13 +49653,13 @@ Supported fuel-core version: ${supportedVersion}.`
       static fromCompact(hex) {
         const l = CURVE.nByteLength;
         hex = ensureBytes("compactSignature", hex, l * 2);
-        return new Signature2(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
+        return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
       }
       // DER encoded ECDSA signature
       // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
       static fromDER(hex) {
         const { r, s } = DER.toSig(ensureBytes("DER", hex));
-        return new Signature2(r, s);
+        return new Signature(r, s);
       }
       assertValidity() {
         if (!isWithinCurveOrder(this.r))
@@ -49909,7 +49668,7 @@ Supported fuel-core version: ${supportedVersion}.`
           throw new Error("s must be 0 < s < CURVE.n");
       }
       addRecoveryBit(recovery) {
-        return new Signature2(this.r, this.s, recovery);
+        return new Signature(this.r, this.s, recovery);
       }
       recoverPublicKey(msgHash) {
         const { r, s, recovery: rec } = this;
@@ -49935,7 +49694,7 @@ Supported fuel-core version: ${supportedVersion}.`
         return isBiggerThanHalfOrder(this.s);
       }
       normalizeS() {
-        return this.hasHighS() ? new Signature2(this.r, modN(-this.s), this.recovery) : this;
+        return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;
       }
       // DER-encoded
       toDERRawBytes() {
@@ -50007,13 +49766,13 @@ Supported fuel-core version: ${supportedVersion}.`
       const b = Point2.fromHex(publicB);
       return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
     }
-    const bits2int = CURVE.bits2int || function(bytes3) {
-      const num = bytesToNumberBE(bytes3);
-      const delta = bytes3.length * 8 - CURVE.nBitLength;
+    const bits2int = CURVE.bits2int || function(bytes2) {
+      const num = bytesToNumberBE(bytes2);
+      const delta = bytes2.length * 8 - CURVE.nBitLength;
       return delta > 0 ? num >> BigInt(delta) : num;
     };
-    const bits2int_modN = CURVE.bits2int_modN || function(bytes3) {
-      return modN(bits2int(bytes3));
+    const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
+      return modN(bits2int(bytes2));
     };
     const ORDER_MASK = bitMask(CURVE.nBitLength);
     function int2octets(num) {
@@ -50026,18 +49785,18 @@ 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: hash4, randomBytes: randomBytes5 } = CURVE;
+      const { hash: hash3, randomBytes: randomBytes3 } = CURVE;
       let { lowS, prehash, extraEntropy: ent } = opts;
       if (lowS == null)
         lowS = true;
       msgHash = ensureBytes("msgHash", msgHash);
       if (prehash)
-        msgHash = ensureBytes("prehashed msgHash", hash4(msgHash));
+        msgHash = ensureBytes("prehashed msgHash", hash3(msgHash));
       const h1int = bits2int_modN(msgHash);
       const d = normPrivateKeyToScalar(privateKey);
       const seedArgs = [int2octets(d), int2octets(h1int)];
       if (ent != null) {
-        const e = ent === true ? randomBytes5(Fp2.BYTES) : ent;
+        const e = ent === true ? randomBytes3(Fp2.BYTES) : ent;
         seedArgs.push(ensureBytes("extraEntropy", e));
       }
       const seed = concatBytes3(...seedArgs);
@@ -50060,7 +49819,7 @@ Supported fuel-core version: ${supportedVersion}.`
           normS = normalizeS(s);
           recovery ^= 1;
         }
-        return new Signature2(r, normS, recovery);
+        return new Signature(r, normS, recovery);
       }
       return { seed, k2sig };
     }
@@ -50085,15 +49844,15 @@ Supported fuel-core version: ${supportedVersion}.`
       try {
         if (typeof sg === "string" || isBytes3(sg)) {
           try {
-            _sig = Signature2.fromDER(sg);
+            _sig = Signature.fromDER(sg);
           } catch (derError) {
             if (!(derError instanceof DER.Err))
               throw derError;
-            _sig = Signature2.fromCompact(sg);
+            _sig = Signature.fromCompact(sg);
           }
         } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
           const { r: r2, s: s2 } = sg;
-          _sig = new Signature2(r2, s2);
+          _sig = new Signature(r2, s2);
         } else {
           throw new Error("PARSE");
         }
@@ -50125,21 +49884,21 @@ Supported fuel-core version: ${supportedVersion}.`
       sign,
       verify,
       ProjectivePoint: Point2,
-      Signature: Signature2,
+      Signature,
       utils
     };
   }
 
   // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/_shortw_utils.js
-  function getHash(hash4) {
+  function getHash(hash3) {
     return {
-      hash: hash4,
-      hmac: (key, ...msgs) => hmac(hash4, key, concatBytes(...msgs)),
+      hash: hash3,
+      hmac: (key, ...msgs) => hmac(hash3, key, concatBytes(...msgs)),
       randomBytes
     };
   }
   function createCurve(curveDef, defHash) {
-    const create = (hash4) => weierstrass({ ...curveDef, ...getHash(hash4) });
+    const create = (hash3) => weierstrass({ ...curveDef, ...getHash(hash3) });
     return Object.freeze({ ...create(defHash), create });
   }
 
@@ -50241,7 +50000,7 @@ Supported fuel-core version: ${supportedVersion}.`
           privateKey = `0x${privateKey}`;
         }
       }
-      const privateKeyBytes = toBytes3(privateKey, 32);
+      const privateKeyBytes = toBytes2(privateKey, 32);
       this.privateKey = hexlify(privateKeyBytes);
       this.publicKey = hexlify(secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
       this.compressedPublicKey = hexlify(secp256k1.getPublicKey(privateKeyBytes, true));
@@ -50259,8 +50018,8 @@ Supported fuel-core version: ${supportedVersion}.`
      */
     sign(data) {
       const signature = secp256k1.sign(arrayify(data), arrayify(this.privateKey));
-      const r = toBytes3(`0x${signature.r.toString(16)}`, 32);
-      const s = toBytes3(`0x${signature.s.toString(16)}`, 32);
+      const r = toBytes2(`0x${signature.r.toString(16)}`, 32);
+      const s = toBytes2(`0x${signature.s.toString(16)}`, 32);
       s[0] |= (signature.recovery || 0) << 7;
       return hexlify(concat([r, s]));
     }
@@ -50312,7 +50071,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns random 32-byte hashed
      */
     static generatePrivateKey(entropy) {
-      return entropy ? hash3(concat([randomBytes22(32), arrayify(entropy)])) : randomBytes22(32);
+      return entropy ? hash2(concat([randomBytes22(32), arrayify(entropy)])) : randomBytes22(32);
     }
     /**
      * Extended publicKey from a compact publicKey
@@ -50327,12 +50086,12 @@ Supported fuel-core version: ${supportedVersion}.`
   };
 
   // ../../node_modules/.pnpm/uuid@9.0.0/node_modules/uuid/dist/esm-node/rng.js
-  var import_crypto15 = __toESM(__require("crypto"));
+  var import_crypto12 = __toESM(__require("crypto"));
   var rnds8Pool = new Uint8Array(256);
   var poolPtr = rnds8Pool.length;
   function rng() {
     if (poolPtr > rnds8Pool.length - 16) {
-      import_crypto15.default.randomFillSync(rnds8Pool);
+      import_crypto12.default.randomFillSync(rnds8Pool);
       poolPtr = 0;
     }
     return rnds8Pool.slice(poolPtr, poolPtr += 16);
@@ -50348,9 +50107,9 @@ Supported fuel-core version: ${supportedVersion}.`
   }
 
   // ../../node_modules/.pnpm/uuid@9.0.0/node_modules/uuid/dist/esm-node/native.js
-  var import_crypto16 = __toESM(__require("crypto"));
+  var import_crypto13 = __toESM(__require("crypto"));
   var native_default = {
-    randomUUID: import_crypto16.default.randomUUID
+    randomUUID: import_crypto13.default.randomUUID
   };
 
   // ../../node_modules/.pnpm/uuid@9.0.0/node_modules/uuid/dist/esm-node/v4.js
@@ -50400,7 +50159,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const iv = randomBytes22(DEFAULT_IV_SIZE);
     const ciphertext = await encryptJsonWalletData2(privateKeyBuffer, key, iv);
     const data = Uint8Array.from([...key.subarray(16, 32), ...ciphertext]);
-    const macHashUint8Array = keccak25622(data);
+    const macHashUint8Array = keccak2562(data);
     const mac = stringFromBuffer2(macHashUint8Array, "hex");
     const keystore = {
       id: v4_default(),
@@ -50446,7 +50205,7 @@ Supported fuel-core version: ${supportedVersion}.`
       dklen
     });
     const data = Uint8Array.from([...key.subarray(16, 32), ...ciphertextBuffer]);
-    const macHashUint8Array = keccak25622(data);
+    const macHashUint8Array = keccak2562(data);
     const macHash = stringFromBuffer2(macHashUint8Array, "hex");
     if (mac !== macHash) {
       throw new FuelError(
@@ -52690,7 +52449,7 @@ Supported fuel-core version: ${supportedVersion}.`
       }
     }
     const checksumBits = entropy.length / 4;
-    const checksum = arrayify(sha2563(entropy))[0] & getUpperMask(checksumBits);
+    const checksum = arrayify(sha2562(entropy))[0] & getUpperMask(checksumBits);
     indices[indices.length - 1] <<= checksumBits;
     indices[indices.length - 1] |= checksum >> 8 - checksumBits;
     return indices;
@@ -52717,7 +52476,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const entropyBits = 32 * words.length / 3;
     const checksumBits = words.length / 3;
     const checksumMask = getUpperMask(checksumBits);
-    const checksum = arrayify(sha2563(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
+    const checksum = arrayify(sha2562(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
     if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
       throw new FuelError(
         ErrorCode.INVALID_CHECKSUM,
@@ -52814,7 +52573,7 @@ Supported fuel-core version: ${supportedVersion}.`
       assertMnemonic(getWords(phrase));
       const phraseBytes = toUtf8Bytes2(getPhrase(phrase));
       const salt = toUtf8Bytes2(`mnemonic${passphrase}`);
-      return pbkdf22(phraseBytes, salt, 2048, 64, "sha512");
+      return pbkdf222(phraseBytes, salt, 2048, 64, "sha512");
     }
     /**
      * @param phrase - Mnemonic phrase composed by words from the provided wordlist
@@ -52876,7 +52635,7 @@ Supported fuel-core version: ${supportedVersion}.`
           `Seed length should be between 16 and 64 bytes, but received ${seedArray.length} bytes.`
         );
       }
-      return arrayify(computeHmac("sha512", MasterSecret, seedArray));
+      return arrayify(computeHmac2("sha512", MasterSecret, seedArray));
     }
     /**
      * Get the extendKey as defined on BIP-32 from the provided seed
@@ -52901,7 +52660,7 @@ Supported fuel-core version: ${supportedVersion}.`
         chainCode,
         concat(["0x00", privateKey])
       ]);
-      const checksum = dataSlice(sha2563(sha2563(extendedKey)), 0, 4);
+      const checksum = dataSlice(sha2562(sha2562(extendedKey)), 0, 4);
       return encodeBase58(concat([extendedKey, checksum]));
     }
     /**
@@ -52917,7 +52676,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * @returns A randomly generated mnemonic
      */
     static generate(size = 32, extraEntropy = "") {
-      const entropy = extraEntropy ? sha2563(concat([randomBytes22(size), arrayify(extraEntropy)])) : randomBytes22(size);
+      const entropy = extraEntropy ? sha2562(concat([randomBytes22(size), arrayify(extraEntropy)])) : randomBytes22(size);
       return Mnemonic.entropyToMnemonic(entropy);
     }
   };
@@ -52930,7 +52689,7 @@ Supported fuel-core version: ${supportedVersion}.`
   var TestnetPRV2 = hexlify("0x04358394");
   var TestnetPUB = hexlify("0x043587cf");
   function base58check(data) {
-    return encodeBase58(concat([data, dataSlice(sha2563(sha2563(data)), 0, 4)]));
+    return encodeBase58(concat([data, dataSlice(sha2562(sha2562(data)), 0, 4)]));
   }
   function getExtendedKeyPrefix(isPublic = false, testnet = false) {
     if (isPublic) {
@@ -52986,7 +52745,7 @@ Supported fuel-core version: ${supportedVersion}.`
         this.publicKey = hexlify(config.publicKey);
       }
       this.parentFingerprint = config.parentFingerprint || this.parentFingerprint;
-      this.fingerprint = dataSlice(ripemd1602(sha2563(this.publicKey)), 0, 4);
+      this.fingerprint = dataSlice(ripemd16022(sha2562(this.publicKey)), 0, 4);
       this.depth = config.depth || this.depth;
       this.index = config.index || this.index;
       this.chainCode = config.chainCode;
@@ -53017,10 +52776,10 @@ Supported fuel-core version: ${supportedVersion}.`
       } else {
         data.set(arrayify(this.publicKey));
       }
-      data.set(toBytes3(index, 4), 33);
-      const bytes3 = arrayify(computeHmac("sha512", chainCode, data));
-      const IL = bytes3.slice(0, 32);
-      const IR = bytes3.slice(32);
+      data.set(toBytes2(index, 4), 33);
+      const bytes2 = arrayify(computeHmac2("sha512", chainCode, data));
+      const IL = bytes2.slice(0, 32);
+      const IR = bytes2.slice(32);
       if (privateKey) {
         const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
         const ki = bn(IL).add(privateKey).mod(N).toBytes(32);
@@ -53089,27 +52848,27 @@ Supported fuel-core version: ${supportedVersion}.`
       });
     }
     static fromExtendedKey(extendedKey) {
-      const decoded = toBeHex(decodeBase58(extendedKey));
-      const bytes3 = arrayify(decoded);
-      const validChecksum = base58check(bytes3.slice(0, 78)) === extendedKey;
-      if (bytes3.length !== 82 || !isValidExtendedKey(bytes3)) {
+      const decoded = hexlify(toBytes2(decodeBase58(extendedKey)));
+      const bytes2 = arrayify(decoded);
+      const validChecksum = base58check(bytes2.slice(0, 78)) === extendedKey;
+      if (bytes2.length !== 82 || !isValidExtendedKey(bytes2)) {
         throw new FuelError(ErrorCode.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
       }
       if (!validChecksum) {
         throw new FuelError(ErrorCode.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
       }
-      const depth = bytes3[4];
-      const parentFingerprint = hexlify(bytes3.slice(5, 9));
-      const index = parseInt(hexlify(bytes3.slice(9, 13)).substring(2), 16);
-      const chainCode = hexlify(bytes3.slice(13, 45));
-      const key = bytes3.slice(45, 78);
+      const depth = bytes2[4];
+      const parentFingerprint = hexlify(bytes2.slice(5, 9));
+      const index = parseInt(hexlify(bytes2.slice(9, 13)).substring(2), 16);
+      const chainCode = hexlify(bytes2.slice(13, 45));
+      const key = bytes2.slice(45, 78);
       if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
         throw new FuelError(
           ErrorCode.HD_WALLET_ERROR,
           "Inconsistency detected: Depth is zero but fingerprint/index is non-zero."
         );
       }
-      if (isPublicExtendedKey(bytes3)) {
+      if (isPublicExtendedKey(bytes2)) {
         if (key[0] !== 3) {
           throw new FuelError(ErrorCode.HD_WALLET_ERROR, "Invalid public extended key.");
         }
@@ -53288,16 +53047,18 @@ Supported fuel-core version: ${supportedVersion}.`
   __publicField(Wallet, "fromEncryptedJson", WalletUnlocked.fromEncryptedJson);
 
   // src/test-utils/seedTestWallet.ts
-  var seedTestWallet = async (wallet, quantities) => {
-    const genesisWallet = new WalletUnlocked(
-      process.env.GENESIS_SECRET || randomBytes22(32),
-      wallet.provider
-    );
+  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 request = new ScriptTransactionRequest();
-    quantities.forEach((quantity) => {
-      const { amount, assetId } = coinQuantityfy(quantity);
-      request.addCoinOutput(wallet.address, amount, assetId);
-    });
+    quantities.map(coinQuantityfy).forEach(
+      ({ amount, assetId }) => accountsToBeFunded.forEach(({ address }) => {
+        for (let i = 0; i < utxosAmount; i++) {
+          request.addCoinOutput(address, amount.div(utxosAmount), assetId);
+        }
+      })
+    );
     const txCost = await genesisWallet.provider.getTransactionCost(request);
     request.gasLimit = txCost.gasUsed;
     request.maxFee = txCost.maxFee;
@@ -53338,7 +53099,7 @@ Supported fuel-core version: ${supportedVersion}.`
 
   // src/test-utils/launchNode.ts
   var import_child_process = __require("child_process");
-  var import_crypto21 = __require("crypto");
+  var import_crypto19 = __require("crypto");
   var import_fs2 = __require("fs");
   var import_os = __toESM(__require("os"));
   var import_path8 = __toESM(__require("path"));
@@ -53411,7 +53172,7 @@ Supported fuel-core version: ${supportedVersion}.`
       })).toString();
       let snapshotDirToUse;
       const prefix = basePath || import_os.default.tmpdir();
-      const suffix = basePath ? "" : (0, import_crypto21.randomUUID)();
+      const suffix = basePath ? "" : (0, import_crypto19.randomUUID)();
       const tempDirPath = import_path8.default.join(prefix, ".fuels", suffix, "snapshotDir");
       if (snapshotDir) {
         snapshotDirToUse = snapshotDir;
@@ -53562,9 +53323,6 @@ mime-types/index.js:
 @noble/hashes/esm/utils.js:
   (*! noble-hashes - 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/utils.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)