@fuel-ts/account 0.0.0-rc-2143-20240514195947 → 0.0.0-rc-2143-20240514211533

package/dist/test-utils.global.js

@@ -64,7 +64,7 @@
     "../../node_modules/.pnpm/bn.js@5.2.1/node_modules/bn.js/lib/bn.js"(exports, module) {
       (function(module2, exports2) {
         "use strict";
-        function assert2(val, msg) {
+        function assert(val, msg) {
           if (!val)
             throw new Error(msg || "Assertion failed");
         }
@@ -134,7 +134,7 @@
           if (base === "hex") {
             base = 16;
           }
-          assert2(base === (base | 0) && base >= 2 && base <= 36);
+          assert(base === (base | 0) && base >= 2 && base <= 36);
           number2 = number2.toString().replace(/\s+/g, "");
           var start = 0;
           if (number2[0] === "-") {
@@ -167,7 +167,7 @@
             ];
             this.length = 2;
           } else {
-            assert2(number2 < 9007199254740992);
+            assert(number2 < 9007199254740992);
             this.words = [
               number2 & 67108863,
               number2 / 67108864 & 67108863,
@@ -180,7 +180,7 @@
           this._initArray(this.toArray(), base, endian);
         };
         BN2.prototype._initArray = function _initArray(number2, base, endian) {
-          assert2(typeof number2.length === "number");
+          assert(typeof number2.length === "number");
           if (number2.length <= 0) {
             this.words = [0];
             this.length = 1;
@@ -227,7 +227,7 @@
           } else if (c >= 97 && c <= 102) {
             return c - 87;
           } else {
-            assert2(false, "Invalid character in " + string);
+            assert(false, "Invalid character in " + string);
           }
         }
         function parseHexByte(string, lowerBound, index) {
@@ -288,7 +288,7 @@
             } else {
               b = c;
             }
-            assert2(c >= 0 && b < mul, "Invalid character");
+            assert(c >= 0 && b < mul, "Invalid character");
             r += b;
           }
           return r;
@@ -548,16 +548,16 @@
             }
             return out;
           }
-          assert2(false, "Base should be between 2 and 36");
+          assert(false, "Base should be between 2 and 36");
         };
-        BN2.prototype.toNumber = function toNumber3() {
+        BN2.prototype.toNumber = function toNumber2() {
           var ret2 = this.words[0];
           if (this.length === 2) {
             ret2 += this.words[1] * 67108864;
           } else if (this.length === 3 && this.words[2] === 1) {
             ret2 += 4503599627370496 + this.words[1] * 67108864;
           } else if (this.length > 2) {
-            assert2(false, "Number can only safely store up to 53 bits");
+            assert(false, "Number can only safely store up to 53 bits");
           }
           return this.negative !== 0 ? -ret2 : ret2;
         };
@@ -582,8 +582,8 @@
           this._strip();
           var byteLength = this.byteLength();
           var reqLength = length || Math.max(1, byteLength);
-          assert2(byteLength <= reqLength, "byte array longer than desired length");
-          assert2(reqLength > 0, "Requested array length <= 0");
+          assert(byteLength <= reqLength, "byte array longer than desired length");
+          assert(reqLength > 0, "Requested array length <= 0");
           var res = allocate(ArrayType, reqLength);
           var postfix = endian === "le" ? "LE" : "BE";
           this["_toArrayLike" + postfix](res, byteLength);
@@ -731,13 +731,13 @@
         BN2.prototype.byteLength = function byteLength() {
           return Math.ceil(this.bitLength() / 8);
         };
-        BN2.prototype.toTwos = function toTwos2(width) {
+        BN2.prototype.toTwos = function toTwos(width) {
           if (this.negative !== 0) {
             return this.abs().inotn(width).iaddn(1);
           }
           return this.clone();
         };
-        BN2.prototype.fromTwos = function fromTwos2(width) {
+        BN2.prototype.fromTwos = function fromTwos(width) {
           if (this.testn(width - 1)) {
             return this.notn(width).iaddn(1).ineg();
           }
@@ -765,7 +765,7 @@
           return this._strip();
         };
         BN2.prototype.ior = function ior(num) {
-          assert2((this.negative | num.negative) === 0);
+          assert((this.negative | num.negative) === 0);
           return this.iuor(num);
         };
         BN2.prototype.or = function or(num) {
@@ -792,7 +792,7 @@
           return this._strip();
         };
         BN2.prototype.iand = function iand(num) {
-          assert2((this.negative | num.negative) === 0);
+          assert((this.negative | num.negative) === 0);
           return this.iuand(num);
         };
         BN2.prototype.and = function and(num) {
@@ -827,7 +827,7 @@
           return this._strip();
         };
         BN2.prototype.ixor = function ixor(num) {
-          assert2((this.negative | num.negative) === 0);
+          assert((this.negative | num.negative) === 0);
           return this.iuxor(num);
         };
         BN2.prototype.xor = function xor(num) {
@@ -841,7 +841,7 @@
           return num.clone().iuxor(this);
         };
         BN2.prototype.inotn = function inotn(width) {
-          assert2(typeof width === "number" && width >= 0);
+          assert(typeof width === "number" && width >= 0);
           var bytesNeeded = Math.ceil(width / 26) | 0;
           var bitsLeft = width % 26;
           this._expand(bytesNeeded);
@@ -860,7 +860,7 @@
           return this.clone().inotn(width);
         };
         BN2.prototype.setn = function setn(bit, val) {
-          assert2(typeof bit === "number" && bit >= 0);
+          assert(typeof bit === "number" && bit >= 0);
           var off = bit / 26 | 0;
           var wbit = bit % 26;
           this._expand(off + 1);
@@ -1726,8 +1726,8 @@
           for (i = 2 * len; i < N; ++i) {
             rws[i] = 0;
           }
-          assert2(carry === 0);
-          assert2((carry & ~8191) === 0);
+          assert(carry === 0);
+          assert((carry & ~8191) === 0);
         };
         FFTM.prototype.stub = function stub(N) {
           var ph = new Array(N);
@@ -1782,8 +1782,8 @@
           var isNegNum = num < 0;
           if (isNegNum)
             num = -num;
-          assert2(typeof num === "number");
-          assert2(num < 67108864);
+          assert(typeof num === "number");
+          assert(num < 67108864);
           var carry = 0;
           for (var i = 0; i < this.length; i++) {
             var w = (this.words[i] | 0) * num;
@@ -1827,7 +1827,7 @@
           return res;
         };
         BN2.prototype.iushln = function iushln(bits) {
-          assert2(typeof bits === "number" && bits >= 0);
+          assert(typeof bits === "number" && bits >= 0);
           var r = bits % 26;
           var s = (bits - r) / 26;
           var carryMask = 67108863 >>> 26 - r << 26 - r;
@@ -1857,11 +1857,11 @@
           return this._strip();
         };
         BN2.prototype.ishln = function ishln(bits) {
-          assert2(this.negative === 0);
+          assert(this.negative === 0);
           return this.iushln(bits);
         };
         BN2.prototype.iushrn = function iushrn(bits, hint, extended) {
-          assert2(typeof bits === "number" && bits >= 0);
+          assert(typeof bits === "number" && bits >= 0);
           var h;
           if (hint) {
             h = (hint - hint % 26) / 26;
@@ -1870,7 +1870,7 @@
           }
           var r = bits % 26;
           var s = Math.min((bits - r) / 26, this.length);
-          var mask2 = 67108863 ^ 67108863 >>> r << r;
+          var mask = 67108863 ^ 67108863 >>> r << r;
           var maskedWords = extended;
           h -= s;
           h = Math.max(0, h);
@@ -1894,7 +1894,7 @@
           for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
             var word = this.words[i] | 0;
             this.words[i] = carry << 26 - r | word >>> r;
-            carry = word & mask2;
+            carry = word & mask;
           }
           if (maskedWords && carry !== 0) {
             maskedWords.words[maskedWords.length++] = carry;
@@ -1906,7 +1906,7 @@
           return this._strip();
         };
         BN2.prototype.ishrn = function ishrn(bits, hint, extended) {
-          assert2(this.negative === 0);
+          assert(this.negative === 0);
           return this.iushrn(bits, hint, extended);
         };
         BN2.prototype.shln = function shln(bits) {
@@ -1922,7 +1922,7 @@
           return this.clone().iushrn(bits);
         };
         BN2.prototype.testn = function testn(bit) {
-          assert2(typeof bit === "number" && bit >= 0);
+          assert(typeof bit === "number" && bit >= 0);
           var r = bit % 26;
           var s = (bit - r) / 26;
           var q = 1 << r;
@@ -1932,10 +1932,10 @@
           return !!(w & q);
         };
         BN2.prototype.imaskn = function imaskn(bits) {
-          assert2(typeof bits === "number" && bits >= 0);
+          assert(typeof bits === "number" && bits >= 0);
           var r = bits % 26;
           var s = (bits - r) / 26;
-          assert2(this.negative === 0, "imaskn works only with positive numbers");
+          assert(this.negative === 0, "imaskn works only with positive numbers");
           if (this.length <= s) {
             return this;
           }
@@ -1944,8 +1944,8 @@
           }
           this.length = Math.min(s, this.length);
           if (r !== 0) {
-            var mask2 = 67108863 ^ 67108863 >>> r << r;
-            this.words[this.length - 1] &= mask2;
+            var mask = 67108863 ^ 67108863 >>> r << r;
+            this.words[this.length - 1] &= mask;
           }
           return this._strip();
         };
@@ -1953,8 +1953,8 @@
           return this.clone().imaskn(bits);
         };
         BN2.prototype.iaddn = function iaddn(num) {
-          assert2(typeof num === "number");
-          assert2(num < 67108864);
+          assert(typeof num === "number");
+          assert(num < 67108864);
           if (num < 0)
             return this.isubn(-num);
           if (this.negative !== 0) {
@@ -1984,8 +1984,8 @@
           return this;
         };
         BN2.prototype.isubn = function isubn(num) {
-          assert2(typeof num === "number");
-          assert2(num < 67108864);
+          assert(typeof num === "number");
+          assert(num < 67108864);
           if (num < 0)
             return this.iaddn(-num);
           if (this.negative !== 0) {
@@ -2039,7 +2039,7 @@
           }
           if (carry === 0)
             return this._strip();
-          assert2(carry === -1);
+          assert(carry === -1);
           carry = 0;
           for (i = 0; i < this.length; i++) {
             w = -(this.words[i] | 0) + carry;
@@ -2107,7 +2107,7 @@
           };
         };
         BN2.prototype.divmod = function divmod(num, mode, positive) {
-          assert2(!num.isZero());
+          assert(!num.isZero());
           if (this.isZero()) {
             return {
               div: new BN2(0),
@@ -2205,7 +2205,7 @@
           var isNegNum = num < 0;
           if (isNegNum)
             num = -num;
-          assert2(num <= 67108863);
+          assert(num <= 67108863);
           var p = (1 << 26) % num;
           var acc = 0;
           for (var i = this.length - 1; i >= 0; i--) {
@@ -2220,7 +2220,7 @@
           var isNegNum = num < 0;
           if (isNegNum)
             num = -num;
-          assert2(num <= 67108863);
+          assert(num <= 67108863);
           var carry = 0;
           for (var i = this.length - 1; i >= 0; i--) {
             var w = (this.words[i] | 0) + carry * 67108864;
@@ -2234,8 +2234,8 @@
           return this.clone().idivn(num);
         };
         BN2.prototype.egcd = function egcd(p) {
-          assert2(p.negative === 0);
-          assert2(!p.isZero());
+          assert(p.negative === 0);
+          assert(!p.isZero());
           var x = this;
           var y = p.clone();
           if (x.negative !== 0) {
@@ -2299,8 +2299,8 @@
           };
         };
         BN2.prototype._invmp = function _invmp(p) {
-          assert2(p.negative === 0);
-          assert2(!p.isZero());
+          assert(p.negative === 0);
+          assert(!p.isZero());
           var a = this;
           var b = p.clone();
           if (a.negative !== 0) {
@@ -2398,7 +2398,7 @@
           return this.words[0] & num;
         };
         BN2.prototype.bincn = function bincn(bit) {
-          assert2(typeof bit === "number");
+          assert(typeof bit === "number");
           var r = bit % 26;
           var s = (bit - r) / 26;
           var q = 1 << r;
@@ -2438,7 +2438,7 @@
             if (negative) {
               num = -num;
             }
-            assert2(num <= 67108863, "Number is too big");
+            assert(num <= 67108863, "Number is too big");
             var w = this.words[0] | 0;
             res = w === num ? 0 : w < num ? -1 : 1;
           }
@@ -2510,12 +2510,12 @@
           return new Red(num);
         };
         BN2.prototype.toRed = function toRed(ctx) {
-          assert2(!this.red, "Already a number in reduction context");
-          assert2(this.negative === 0, "red works only with positives");
+          assert(!this.red, "Already a number in reduction context");
+          assert(this.negative === 0, "red works only with positives");
           return ctx.convertTo(this)._forceRed(ctx);
         };
         BN2.prototype.fromRed = function fromRed() {
-          assert2(this.red, "fromRed works only with numbers in reduction context");
+          assert(this.red, "fromRed works only with numbers in reduction context");
           return this.red.convertFrom(this);
         };
         BN2.prototype._forceRed = function _forceRed(ctx) {
@@ -2523,66 +2523,66 @@
           return this;
         };
         BN2.prototype.forceRed = function forceRed(ctx) {
-          assert2(!this.red, "Already a number in reduction context");
+          assert(!this.red, "Already a number in reduction context");
           return this._forceRed(ctx);
         };
         BN2.prototype.redAdd = function redAdd(num) {
-          assert2(this.red, "redAdd works only with red numbers");
+          assert(this.red, "redAdd works only with red numbers");
           return this.red.add(this, num);
         };
         BN2.prototype.redIAdd = function redIAdd(num) {
-          assert2(this.red, "redIAdd works only with red numbers");
+          assert(this.red, "redIAdd works only with red numbers");
           return this.red.iadd(this, num);
         };
         BN2.prototype.redSub = function redSub(num) {
-          assert2(this.red, "redSub works only with red numbers");
+          assert(this.red, "redSub works only with red numbers");
           return this.red.sub(this, num);
         };
         BN2.prototype.redISub = function redISub(num) {
-          assert2(this.red, "redISub works only with red numbers");
+          assert(this.red, "redISub works only with red numbers");
           return this.red.isub(this, num);
         };
         BN2.prototype.redShl = function redShl(num) {
-          assert2(this.red, "redShl works only with red numbers");
+          assert(this.red, "redShl works only with red numbers");
           return this.red.shl(this, num);
         };
         BN2.prototype.redMul = function redMul(num) {
-          assert2(this.red, "redMul works only with red numbers");
+          assert(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) {
-          assert2(this.red, "redMul works only with red numbers");
+          assert(this.red, "redMul works only with red numbers");
           this.red._verify2(this, num);
           return this.red.imul(this, num);
         };
         BN2.prototype.redSqr = function redSqr() {
-          assert2(this.red, "redSqr works only with red numbers");
+          assert(this.red, "redSqr works only with red numbers");
           this.red._verify1(this);
           return this.red.sqr(this);
         };
         BN2.prototype.redISqr = function redISqr() {
-          assert2(this.red, "redISqr works only with red numbers");
+          assert(this.red, "redISqr works only with red numbers");
           this.red._verify1(this);
           return this.red.isqr(this);
         };
         BN2.prototype.redSqrt = function redSqrt() {
-          assert2(this.red, "redSqrt works only with red numbers");
+          assert(this.red, "redSqrt works only with red numbers");
           this.red._verify1(this);
           return this.red.sqrt(this);
         };
         BN2.prototype.redInvm = function redInvm() {
-          assert2(this.red, "redInvm works only with red numbers");
+          assert(this.red, "redInvm works only with red numbers");
           this.red._verify1(this);
           return this.red.invm(this);
         };
         BN2.prototype.redNeg = function redNeg() {
-          assert2(this.red, "redNeg works only with red numbers");
+          assert(this.red, "redNeg works only with red numbers");
           this.red._verify1(this);
           return this.red.neg(this);
         };
         BN2.prototype.redPow = function redPow(num) {
-          assert2(this.red && !num.red, "redPow(normalNum)");
+          assert(this.red && !num.red, "redPow(normalNum)");
           this.red._verify1(this);
           return this.red.pow(this, num);
         };
@@ -2643,7 +2643,7 @@
         }
         inherits(K256, MPrime);
         K256.prototype.split = function split2(input, output2) {
-          var mask2 = 4194303;
+          var mask = 4194303;
           var outLen = Math.min(input.length, 9);
           for (var i = 0; i < outLen; i++) {
             output2.words[i] = input.words[i];
@@ -2655,10 +2655,10 @@
             return;
           }
           var prev = input.words[9];
-          output2.words[output2.length++] = prev & mask2;
+          output2.words[output2.length++] = prev & mask;
           for (i = 10; i < input.length; i++) {
             var next = input.words[i] | 0;
-            input.words[i - 10] = (next & mask2) << 4 | prev >>> 22;
+            input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
             prev = next;
           }
           prev >>>= 22;
@@ -2750,18 +2750,18 @@
             this.m = prime.p;
             this.prime = prime;
           } else {
-            assert2(m.gtn(1), "modulus must be greater than 1");
+            assert(m.gtn(1), "modulus must be greater than 1");
             this.m = m;
             this.prime = null;
           }
         }
         Red.prototype._verify1 = function _verify1(a) {
-          assert2(a.negative === 0, "red works only with positives");
-          assert2(a.red, "red works only with red numbers");
+          assert(a.negative === 0, "red works only with positives");
+          assert(a.red, "red works only with red numbers");
         };
         Red.prototype._verify2 = function _verify2(a, b) {
-          assert2((a.negative | b.negative) === 0, "red works only with positives");
-          assert2(
+          assert((a.negative | b.negative) === 0, "red works only with positives");
+          assert(
             a.red && a.red === b.red,
             "red works only with red numbers"
           );
@@ -2832,7 +2832,7 @@
           if (a.isZero())
             return a.clone();
           var mod3 = this.m.andln(3);
-          assert2(mod3 % 2 === 1);
+          assert(mod3 % 2 === 1);
           if (mod3 === 3) {
             var pow3 = this.m.add(new BN2(1)).iushrn(2);
             return this.pow(a, pow3);
@@ -2843,7 +2843,7 @@
             s++;
             q.iushrn(1);
           }
-          assert2(!q.isZero());
+          assert(!q.isZero());
           var one = new BN2(1).toRed(this);
           var nOne = one.redNeg();
           var lpow = this.m.subn(1).iushrn(1);
@@ -2861,7 +2861,7 @@
             for (var i = 0; tmp.cmp(one) !== 0; i++) {
               tmp = tmp.redSqr();
             }
-            assert2(i < m);
+            assert(i < m);
             var b = this.pow(c, new BN2(1).iushln(m - i - 1));
             r = r.redMul(b);
             c = b.redSqr();
@@ -29814,10 +29814,10 @@ spurious results.`);
           return 3;
         }
         if ("TERM_PROGRAM" in env) {
-          const version2 = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+          const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
           switch (env.TERM_PROGRAM) {
             case "iTerm.app":
-              return version2 >= 3 ? 3 : 2;
+              return version >= 3 ? 3 : 2;
             case "Apple_Terminal":
               return 2;
           }
@@ -32062,7 +32062,7 @@ spurious results.`);
             return callback(err, result);
           });
         };
-        var concat3 = doLimit(concatLimit, Infinity);
+        var concat2 = doLimit(concatLimit, Infinity);
         var concatSeries = doLimit(concatLimit, 1);
         var constant = function() {
           var values = slice(arguments);
@@ -32706,7 +32706,7 @@ spurious results.`);
           autoInject,
           cargo,
           compose: compose2,
-          concat: concat3,
+          concat: concat2,
           concatLimit,
           concatSeries,
           constant,
@@ -32808,7 +32808,7 @@ spurious results.`);
         exports2.autoInject = autoInject;
         exports2.cargo = cargo;
         exports2.compose = compose2;
-        exports2.concat = concat3;
+        exports2.concat = concat2;
         exports2.concatLimit = concatLimit;
         exports2.concatSeries = concatSeries;
         exports2.constant = constant;
@@ -33489,11 +33489,11 @@ spurious results.`);
         debugTestPort("entered testPort(): trying", options.host, "port", options.port);
         function onListen() {
           debugTestPort("done w/ testPort(): OK", options.host, "port", options.port);
-          options.server.removeListener("error", onError);
+          options.server.removeListener("error", onError2);
           options.server.close();
           callback(null, options.port);
         }
-        function onError(err) {
+        function onError2(err) {
           debugTestPort("done w/ testPort(): failed", options.host, "w/ port", options.port, "with error", err.code);
           options.server.removeListener("listening", onListen);
           if (!(err.code == "EADDRINUSE" || err.code == "EACCES")) {
@@ -33509,7 +33509,7 @@ spurious results.`);
             server: options.server
           }, callback);
         }
-        options.server.once("error", onError);
+        options.server.once("error", onError2);
         options.server.once("listening", onListen);
         if (options.host) {
           options.server.listen(options.port, options.host);
@@ -34655,8 +34655,8 @@ spurious results.`);
       FUELS: "0.85.0"
     };
   }
-  function parseVersion(version2) {
-    const [major, minor, patch] = version2.split(".").map((v) => parseInt(v, 10));
+  function parseVersion(version) {
+    const [major, minor, patch] = version.split(".").map((v) => parseInt(v, 10));
     return { major, minor, patch };
   }
   function versionDiffs(version1, version2) {
@@ -35961,6 +35961,123 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     return hexlify(bytes2.slice(start == null ? 0 : start, end == null ? bytes2.length : end));
   }
+  function toUtf8Bytes(stri, form = true) {
+    let str = stri;
+    if (form) {
+      str = stri.normalize("NFC");
+    }
+    const result = [];
+    for (let i = 0; i < str.length; i += 1) {
+      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 += 1;
+        const c2 = str.charCodeAt(i);
+        if (i >= str.length || (c2 & 64512) !== 56320) {
+          throw new FuelError(
+            ErrorCode.INVALID_INPUT_PARAMETERS,
+            "Invalid UTF-8 in the input string."
+          );
+        }
+        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 onError(reason, offset, bytes2, output2, badCodepoint) {
+    console.log(`invalid codepoint at offset ${offset}; ${reason}, bytes: ${bytes2}`);
+    return offset;
+  }
+  function helper(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 getUtf8CodePoints(_bytes) {
+    const bytes2 = arrayify(_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++) {
+        const 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 toUtf8String(bytes2) {
+    return helper(getUtf8CodePoints(bytes2));
+  }
 
   // ../../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]);
@@ -36072,13 +36189,13 @@ This unreleased fuel-core build may include features and updates not yet support
   };
   var keccak256 = (data) => keccak_256(data);
   var locked = false;
-  var helper = (data) => ripemd160(data);
-  var ripemd = helper;
+  var helper2 = (data) => ripemd160(data);
+  var ripemd = helper2;
   function ripemd1602(_data) {
     const data = arrayify(_data, "data");
     return ripemd(data);
   }
-  ripemd1602._ = helper;
+  ripemd1602._ = helper2;
   ripemd1602.lock = () => {
     locked = true;
   };
@@ -36700,316 +36817,6 @@ 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;
@@ -38451,9 +38258,9 @@ 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 dataLength2 = length * this.coder.encodedLength;
-      const dataBytes = data.slice(offsetAndLength, offsetAndLength + dataLength2);
-      if (!this.#isOptionVec && dataBytes.length !== dataLength2) {
+      const dataLength = length * this.coder.encodedLength;
+      const dataBytes = data.slice(offsetAndLength, offsetAndLength + dataLength);
+      if (!this.#isOptionVec && dataBytes.length !== dataLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec byte data size.`);
       }
       let newOffset = offsetAndLength;
@@ -38977,8 +38784,8 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     static encodeData(messageData) {
       const bytes2 = arrayify(messageData || "0x");
-      const dataLength2 = bytes2.length;
-      return new ByteArrayCoder(dataLength2).encode(bytes2);
+      const dataLength = bytes2.length;
+      return new ByteArrayCoder(dataLength).encode(bytes2);
     }
     encode(value) {
       const parts = [];
@@ -39001,8 +38808,8 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     static decodeData(messageData) {
       const bytes2 = arrayify(messageData);
-      const dataLength2 = bytes2.length;
-      const [data] = new ByteArrayCoder(dataLength2).decode(bytes2, 0);
+      const dataLength = bytes2.length;
+      const [data] = new ByteArrayCoder(dataLength).decode(bytes2, 0);
       return arrayify(data);
     }
     decode(data, offset) {
@@ -39021,12 +38828,12 @@ This unreleased fuel-core build may include features and updates not yet support
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateGasUsed = decoded;
       [decoded, o] = new NumberCoder("u32").decode(data, o);
-      const dataLength2 = decoded;
+      const dataLength = decoded;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateLength = decoded;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateDataLength = decoded;
-      [decoded, o] = new ByteArrayCoder(dataLength2).decode(data, o);
+      [decoded, o] = new ByteArrayCoder(dataLength).decode(data, o);
       const messageData = decoded;
       [decoded, o] = new ByteArrayCoder(predicateLength.toNumber()).decode(data, o);
       const predicate = decoded;
@@ -39041,7 +38848,7 @@ This unreleased fuel-core build may include features and updates not yet support
           witnessIndex,
           nonce,
           predicateGasUsed,
-          dataLength: dataLength2,
+          dataLength,
           predicateLength,
           predicateDataLength,
           data: messageData,
@@ -39655,12 +39462,12 @@ This unreleased fuel-core build may include features and updates not yet support
       let decoded;
       let o = offset;
       [decoded, o] = new NumberCoder("u32").decode(data, o);
-      const dataLength2 = decoded;
-      [decoded, o] = new ByteArrayCoder(dataLength2).decode(data, o);
+      const dataLength = decoded;
+      [decoded, o] = new ByteArrayCoder(dataLength).decode(data, o);
       const witnessData = decoded;
       return [
         {
-          dataLength: dataLength2,
+          dataLength,
           data: witnessData
         },
         o
@@ -45081,7 +44888,7 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
     }
     return { errorMessage, reason };
   };
-  var stringify2 = (obj) => JSON.stringify(obj, null, 2);
+  var stringify = (obj) => JSON.stringify(obj, null, 2);
   var assembleRevertError = (receipts, logs) => {
     let errorMessage = "The transaction reverted with an unknown reason.";
     const revertReceipt = receipts.find(({ type: type3 }) => type3 === ReceiptType.Revert);
@@ -45091,17 +44898,17 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       switch (reasonHex) {
         case FAILED_REQUIRE_SIGNAL: {
           reason = "require";
-          errorMessage = `The transaction reverted because a "require" statement has thrown ${logs.length ? stringify2(logs[0]) : "an error."}.`;
+          errorMessage = `The transaction reverted because a "require" statement has thrown ${logs.length ? stringify(logs[0]) : "an error."}.`;
           break;
         }
         case FAILED_ASSERT_EQ_SIGNAL: {
-          const sufix = logs.length >= 2 ? ` comparing ${stringify2(logs[1])} and ${stringify2(logs[0])}.` : ".";
+          const sufix = logs.length >= 2 ? ` comparing ${stringify(logs[1])} and ${stringify(logs[0])}.` : ".";
           reason = "assert_eq";
           errorMessage = `The transaction reverted because of an "assert_eq" statement${sufix}`;
           break;
         }
         case FAILED_ASSERT_NE_SIGNAL: {
-          const sufix = logs.length >= 2 ? ` comparing ${stringify2(logs[1])} and ${stringify2(logs[0])}.` : ".";
+          const sufix = logs.length >= 2 ? ` comparing ${stringify(logs[1])} and ${stringify(logs[0])}.` : ".";
           reason = "assert_ne";
           errorMessage = `The transaction reverted because of an "assert_ne" statement${sufix}`;
           break;
@@ -47032,13 +46839,13 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
       gasCosts,
       baseAssetId,
       chainId,
-      version: version2
+      version
     } = consensusParameters;
     return {
       name,
       baseChainHeight: bn(daHeight),
       consensusParameters: {
-        version: version2,
+        version,
         chainId: bn(chainId),
         baseAssetId,
         feeParameters: {
@@ -49043,12 +48850,12 @@ Supported fuel-core version: ${supportedVersion}.`
         const { windows, windowSize } = opts(W);
         let p = c.ZERO;
         let f2 = c.BASE;
-        const mask2 = BigInt(2 ** W - 1);
+        const mask = BigInt(2 ** W - 1);
         const maxNumber = 2 ** W;
         const shiftBy = BigInt(W);
         for (let window2 = 0; window2 < windows; window2++) {
           const offset = window2 * windowSize;
-          let wbits = Number(n & mask2);
+          let wbits = Number(n & mask);
           n >>= shiftBy;
           if (wbits > windowSize) {
             wbits -= maxNumber;
@@ -52383,38 +52190,6 @@ Supported fuel-core version: ${supportedVersion}.`
   ];
 
   // src/mnemonic/utils.ts
-  function toUtf8Bytes2(stri) {
-    const str = stri.normalize("NFKD");
-    const result = [];
-    for (let i = 0; i < str.length; i += 1) {
-      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 += 1;
-        const c2 = str.charCodeAt(i);
-        if (i >= str.length || (c2 & 64512) !== 56320) {
-          throw new FuelError(
-            ErrorCode.INVALID_INPUT_PARAMETERS,
-            "Invalid UTF-8 in the input string."
-          );
-        }
-        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 Uint8Array.from(result);
-  }
   function getLowerMask(bits) {
     return (1 << bits) - 1;
   }
@@ -52487,7 +52262,7 @@ Supported fuel-core version: ${supportedVersion}.`
   }
 
   // src/mnemonic/mnemonic.ts
-  var MasterSecret = toUtf8Bytes2("Bitcoin seed");
+  var MasterSecret = toUtf8Bytes("Bitcoin seed");
   var MainnetPRV = "0x0488ade4";
   var TestnetPRV = "0x04358394";
   var MNEMONIC_SIZES = [12, 15, 18, 21, 24];
@@ -52571,8 +52346,8 @@ Supported fuel-core version: ${supportedVersion}.`
      */
     static mnemonicToSeed(phrase, passphrase = "") {
       assertMnemonic(getWords(phrase));
-      const phraseBytes = toUtf8Bytes2(getPhrase(phrase));
-      const salt = toUtf8Bytes2(`mnemonic${passphrase}`);
+      const phraseBytes = toUtf8Bytes(getPhrase(phrase));
+      const salt = toUtf8Bytes(`mnemonic${passphrase}`);
       return pbkdf222(phraseBytes, salt, 2048, 64, "sha512");
     }
     /**