@fuel-ts/account 0.0.0-rc-2238-20240514192918 → 0.0.0-rc-2143-20240514211533

package/dist/index.global.js

@@ -73,7 +73,7 @@
     "../../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");
         }
@@ -143,7 +143,7 @@
           if (base === "hex") {
             base = 16;
           }
-          assert3(base === (base | 0) && base >= 2 && base <= 36);
+          assert2(base === (base | 0) && base >= 2 && base <= 36);
           number2 = number2.toString().replace(/\s+/g, "");
           var start = 0;
           if (number2[0] === "-") {
@@ -176,7 +176,7 @@
             ];
             this.length = 2;
           } else {
-            assert3(number2 < 9007199254740992);
+            assert2(number2 < 9007199254740992);
             this.words = [
               number2 & 67108863,
               number2 / 67108864 & 67108863,
@@ -189,7 +189,7 @@
           this._initArray(this.toArray(), base, endian);
         };
         BN2.prototype._initArray = function _initArray(number2, base, endian) {
-          assert3(typeof number2.length === "number");
+          assert2(typeof number2.length === "number");
           if (number2.length <= 0) {
             this.words = [0];
             this.length = 1;
@@ -236,7 +236,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) {
@@ -297,7 +297,7 @@
             } else {
               b = c;
             }
-            assert3(c >= 0 && b < mul, "Invalid character");
+            assert2(c >= 0 && b < mul, "Invalid character");
             r += b;
           }
           return r;
@@ -557,16 +557,16 @@
             }
             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() {
+        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) {
-            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;
         };
@@ -591,8 +591,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);
@@ -740,13 +740,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();
           }
@@ -774,7 +774,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) {
@@ -801,7 +801,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) {
@@ -836,7 +836,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) {
@@ -850,7 +850,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);
@@ -869,7 +869,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);
@@ -1735,8 +1735,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);
@@ -1791,8 +1791,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;
@@ -1836,7 +1836,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;
@@ -1866,11 +1866,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;
@@ -1879,7 +1879,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);
@@ -1903,7 +1903,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;
@@ -1915,7 +1915,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) {
@@ -1931,7 +1931,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;
@@ -1941,10 +1941,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;
           }
@@ -1953,8 +1953,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();
         };
@@ -1962,8 +1962,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) {
@@ -1993,8 +1993,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) {
@@ -2048,7 +2048,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;
@@ -2116,7 +2116,7 @@
           };
         };
         BN2.prototype.divmod = function divmod(num, mode, positive) {
-          assert3(!num.isZero());
+          assert2(!num.isZero());
           if (this.isZero()) {
             return {
               div: new BN2(0),
@@ -2214,7 +2214,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--) {
@@ -2229,7 +2229,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;
@@ -2243,8 +2243,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) {
@@ -2308,8 +2308,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) {
@@ -2407,7 +2407,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;
@@ -2447,7 +2447,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;
           }
@@ -2519,12 +2519,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) {
@@ -2532,66 +2532,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);
         };
@@ -2652,7 +2652,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];
@@ -2664,10 +2664,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;
@@ -2759,18 +2759,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"
           );
@@ -2841,7 +2841,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);
@@ -2852,7 +2852,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);
@@ -2870,7 +2870,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();
@@ -29470,13 +29470,13 @@ spurious results.`);
   // ../versions/dist/index.mjs
   function getBuiltinVersions() {
     return {
-      FORC: "0.58.0",
+      FORC: "0.56.1",
       FUEL_CORE: "0.26.0",
       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) {
@@ -30036,6 +30036,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]);
@@ -30147,13 +30264,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;
   };
@@ -30757,316 +30874,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));
-  }
-
   // ../hasher/dist/index.mjs
   function sha2562(data) {
     return hexlify(sha256(arrayify(data)));
@@ -31092,6 +30899,19 @@ This unreleased fuel-core build may include features and updates not yet support
     __defNormalProp4(obj, typeof key !== "symbol" ? key + "" : key, value);
     return value;
   };
+  var __accessCheck2 = (obj, member, msg) => {
+    if (!member.has(obj))
+      throw TypeError("Cannot " + msg);
+  };
+  var __privateAdd2 = (obj, member, value) => {
+    if (member.has(obj))
+      throw TypeError("Cannot add the same private member more than once");
+    member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  };
+  var __privateMethod2 = (obj, member, method) => {
+    __accessCheck2(obj, member, "access private method");
+    return method;
+  };
   var Coder = class {
     name;
     type;
@@ -31123,6 +30943,7 @@ This unreleased fuel-core build may include features and updates not yet support
   var enumRegEx = /^enum (?<name>\w+)$/;
   var tupleRegEx = /^\((?<items>.*)\)$/;
   var genericRegEx = /^generic (?<name>\w+)$/;
+  var ENCODING_V0 = "0";
   var ENCODING_V1 = "1";
   var WORD_SIZE = 8;
   var BYTES_32 = 32;
@@ -31133,6 +30954,10 @@ This unreleased fuel-core build may include features and updates not yet support
   var TX_LEN = WORD_SIZE * 4;
   var TX_POINTER_LEN = WORD_SIZE * 2;
   var MAX_BYTES = 2 ** 32 - 1;
+  var calculateVmTxMemory = ({ maxInputs }) => BYTES_32 + // Tx ID
+  ASSET_ID_LEN + // Base asset ID
+  // Asset ID/Balance coin input pairs
+  maxInputs * (ASSET_ID_LEN + WORD_SIZE) + WORD_SIZE;
   var SCRIPT_FIXED_SIZE = WORD_SIZE + // Identifier
   WORD_SIZE + // Gas limit
   WORD_SIZE + // Script size
@@ -31163,6 +30988,125 @@ This unreleased fuel-core build may include features and updates not yet support
   WORD_SIZE + // Predicate size
   WORD_SIZE + // Predicate data size
   WORD_SIZE;
+  var encodedLengths = {
+    u64: WORD_SIZE,
+    u256: WORD_SIZE * 4
+  };
+  var BigNumberCoder = class extends Coder {
+    constructor(baseType) {
+      super("bigNumber", baseType, encodedLengths[baseType]);
+    }
+    encode(value) {
+      let bytes2;
+      try {
+        bytes2 = toBytes2(value, this.encodedLength);
+      } catch (error) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.type}.`);
+      }
+      return bytes2;
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} data size.`);
+      }
+      let bytes2 = data.slice(offset, offset + this.encodedLength);
+      bytes2 = bytes2.slice(0, this.encodedLength);
+      if (bytes2.length !== this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} byte data size.`);
+      }
+      return [bn(bytes2), offset + this.encodedLength];
+    }
+  };
+  var VEC_PROPERTY_SPACE = 3;
+  var BASE_VECTOR_OFFSET = VEC_PROPERTY_SPACE * WORD_SIZE;
+  var RAW_SLICE_PROPERTY_SPACE = 2;
+  var BASE_RAW_SLICE_OFFSET = RAW_SLICE_PROPERTY_SPACE * WORD_SIZE;
+  function concatWithDynamicData(items) {
+    const topLevelData = {};
+    let totalIndex = 0;
+    const objects = items.map((item) => {
+      const dynamicData = item.dynamicData;
+      if (dynamicData) {
+        Object.entries(dynamicData).forEach(([pointerIndex, vData]) => {
+          topLevelData[parseInt(pointerIndex, 10) + totalIndex] = vData;
+        });
+      }
+      const byteArray = arrayify(item);
+      totalIndex += byteArray.byteLength / WORD_SIZE;
+      return byteArray;
+    });
+    const length = objects.reduce((accum, item) => accum + item.length, 0);
+    const result = new Uint8Array(length);
+    objects.reduce((offset, object) => {
+      result.set(object, offset);
+      return offset + object.length;
+    }, 0);
+    if (Object.keys(topLevelData).length) {
+      result.dynamicData = topLevelData;
+    }
+    return result;
+  }
+  function unpackDynamicData(results, baseOffset, dataOffset) {
+    if (!results.dynamicData) {
+      return concat([results]);
+    }
+    let cumulativeDynamicByteLength = 0;
+    let updatedResults = results;
+    Object.entries(results.dynamicData).forEach(([pointerIndex, vData]) => {
+      const pointerOffset = parseInt(pointerIndex, 10) * WORD_SIZE;
+      const adjustedValue = new BigNumberCoder("u64").encode(
+        dataOffset + baseOffset + cumulativeDynamicByteLength
+      );
+      updatedResults.set(adjustedValue, pointerOffset);
+      const dataToAppend = vData.dynamicData ? (
+        // unpack child dynamic data
+        unpackDynamicData(
+          vData,
+          baseOffset,
+          dataOffset + vData.byteLength + cumulativeDynamicByteLength
+        )
+      ) : vData;
+      updatedResults = concat([updatedResults, dataToAppend]);
+      cumulativeDynamicByteLength += dataToAppend.byteLength;
+    });
+    return updatedResults;
+  }
+  var chunkByLength = (data, length = WORD_SIZE) => {
+    const chunks = [];
+    let offset = 0;
+    let chunk = data.slice(offset, offset + length);
+    while (chunk.length) {
+      chunks.push(chunk);
+      offset += length;
+      chunk = data.slice(offset, offset + length);
+    }
+    return chunks;
+  };
+  var isPointerType = (type3) => {
+    switch (type3) {
+      case "u8":
+      case "u16":
+      case "u32":
+      case "u64":
+      case "bool": {
+        return false;
+      }
+      default: {
+        return true;
+      }
+    }
+  };
+  var isHeapType = (type3) => type3 === VEC_CODER_TYPE || type3 === BYTES_CODER_TYPE || type3 === STD_STRING_CODER_TYPE;
+  var isMultipleOfWordSize = (length) => length % WORD_SIZE === 0;
+  var getWordSizePadding = (length) => WORD_SIZE - length % WORD_SIZE;
+  var rightPadToWordSize = (encoded) => {
+    if (isMultipleOfWordSize(encoded.length)) {
+      return encoded;
+    }
+    const padding = new Uint8Array(WORD_SIZE - encoded.length % WORD_SIZE);
+    return concatBytes2([encoded, padding]);
+  };
+  var isUint8Array = (value) => value instanceof Uint8Array;
   var ArrayCoder = class extends Coder {
     coder;
     length;
@@ -31178,7 +31122,7 @@ This unreleased fuel-core build may include features and updates not yet support
       if (this.length !== value.length) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Types/values length mismatch.`);
       }
-      return concat(Array.from(value).map((v) => this.coder.encode(v)));
+      return concatWithDynamicData(Array.from(value).map((v) => this.coder.encode(v)));
     }
     decode(data, offset) {
       if (data.length < this.encodedLength || data.length > MAX_BYTES) {
@@ -31255,44 +31199,764 @@ This unreleased fuel-core build may include features and updates not yet support
       return [toHex(bytes2, this.encodedLength), offset + this.encodedLength];
     }
   };
-  var encodedLengths = {
-    u64: WORD_SIZE,
-    u256: WORD_SIZE * 4
-  };
-  var BigNumberCoder = class extends Coder {
-    constructor(baseType) {
-      super("bigNumber", baseType, encodedLengths[baseType]);
+  var BooleanCoder = class extends Coder {
+    paddingLength;
+    options;
+    constructor(options = {
+      isSmallBytes: false,
+      isRightPadded: false
+    }) {
+      const paddingLength = options.isSmallBytes ? 1 : 8;
+      super("boolean", "boolean", paddingLength);
+      this.paddingLength = paddingLength;
+      this.options = options;
     }
     encode(value) {
+      const isTrueBool = value === true || value === false;
+      if (!isTrueBool) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid boolean value.`);
+      }
+      const output2 = toBytes2(value ? 1 : 0, this.paddingLength);
+      if (this.options.isRightPadded) {
+        return output2.reverse();
+      }
+      return output2;
+    }
+    decode(data, offset) {
+      if (data.length < this.paddingLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean data size.`);
+      }
       let bytes2;
-      try {
-        bytes2 = toBytes2(value, this.encodedLength);
-      } catch (error) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.type}.`);
+      if (this.options.isRightPadded) {
+        bytes2 = data.slice(offset, offset + 1);
+      } else {
+        bytes2 = data.slice(offset, offset + this.paddingLength);
       }
-      return bytes2;
+      const decodedValue = bn(bytes2);
+      if (decodedValue.isZero()) {
+        return [false, offset + this.paddingLength];
+      }
+      if (!decodedValue.eq(bn(1))) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean value.`);
+      }
+      return [true, offset + this.paddingLength];
+    }
+  };
+  var _getPaddedData;
+  var getPaddedData_fn;
+  var ByteCoder = class extends Coder {
+    constructor() {
+      super("struct", "struct Bytes", BASE_VECTOR_OFFSET);
+      __privateAdd2(this, _getPaddedData);
+    }
+    encode(value) {
+      const parts = [];
+      const pointer = new BigNumberCoder("u64").encode(BASE_VECTOR_OFFSET);
+      const data = __privateMethod2(this, _getPaddedData, getPaddedData_fn).call(this, value);
+      pointer.dynamicData = {
+        0: concatWithDynamicData([data])
+      };
+      parts.push(pointer);
+      parts.push(new BigNumberCoder("u64").encode(data.byteLength));
+      parts.push(new BigNumberCoder("u64").encode(value.length));
+      return concatWithDynamicData(parts);
+    }
+    decode(data, offset) {
+      if (data.length < BASE_VECTOR_OFFSET) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid byte data size.`);
+      }
+      const len = data.slice(16, 24);
+      const encodedLength = bn(new BigNumberCoder("u64").decode(len, 0)[0]).toNumber();
+      const byteData = data.slice(BASE_VECTOR_OFFSET, BASE_VECTOR_OFFSET + encodedLength);
+      if (byteData.length !== encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid bytes byte data size.`);
+      }
+      return [byteData, offset + BASE_VECTOR_OFFSET];
+    }
+  };
+  _getPaddedData = /* @__PURE__ */ new WeakSet();
+  getPaddedData_fn = function(value) {
+    const data = value instanceof Uint8Array ? [value] : [new Uint8Array(value)];
+    const paddingLength = (WORD_SIZE - value.length % WORD_SIZE) % WORD_SIZE;
+    if (paddingLength) {
+      data.push(new Uint8Array(paddingLength));
+    }
+    return concat(data);
+  };
+  __publicField4(ByteCoder, "memorySize", 1);
+  var isFullyNativeEnum = (enumCoders) => Object.values(enumCoders).every(
+    // @ts-expect-error complicated types
+    ({ type: type3, coders }) => type3 === "()" && JSON.stringify(coders) === JSON.stringify([])
+  );
+  var EnumCoder = class extends Coder {
+    name;
+    coders;
+    #caseIndexCoder;
+    #encodedValueSize;
+    constructor(name, coders) {
+      const caseIndexCoder = new BigNumberCoder("u64");
+      const encodedValueSize = Object.values(coders).reduce(
+        (max, coder) => Math.max(max, coder.encodedLength),
+        0
+      );
+      super(`enum ${name}`, `enum ${name}`, caseIndexCoder.encodedLength + encodedValueSize);
+      this.name = name;
+      this.coders = coders;
+      this.#caseIndexCoder = caseIndexCoder;
+      this.#encodedValueSize = encodedValueSize;
+    }
+    #encodeNativeEnum(value) {
+      const valueCoder = this.coders[value];
+      const encodedValue = valueCoder.encode([]);
+      const caseIndex = Object.keys(this.coders).indexOf(value);
+      const padding = new Uint8Array(this.#encodedValueSize - valueCoder.encodedLength);
+      return concat([this.#caseIndexCoder.encode(caseIndex), padding, encodedValue]);
+    }
+    encode(value) {
+      if (typeof value === "string" && this.coders[value]) {
+        return this.#encodeNativeEnum(value);
+      }
+      const [caseKey, ...empty] = Object.keys(value);
+      if (!caseKey) {
+        throw new FuelError(ErrorCode.INVALID_DECODE_VALUE, "A field for the case must be provided.");
+      }
+      if (empty.length !== 0) {
+        throw new FuelError(ErrorCode.INVALID_DECODE_VALUE, "Only one field must be provided.");
+      }
+      const valueCoder = this.coders[caseKey];
+      const caseIndex = Object.keys(this.coders).indexOf(caseKey);
+      const encodedValue = valueCoder.encode(value[caseKey]);
+      const padding = new Uint8Array(this.#encodedValueSize - valueCoder.encodedLength);
+      return concatWithDynamicData([this.#caseIndexCoder.encode(caseIndex), padding, encodedValue]);
+    }
+    #decodeNativeEnum(caseKey, newOffset) {
+      return [caseKey, newOffset];
+    }
+    decode(data, offset) {
+      if (data.length < this.#encodedValueSize) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid enum data size.`);
+      }
+      let newOffset = offset;
+      let decoded;
+      [decoded, newOffset] = new BigNumberCoder("u64").decode(data, newOffset);
+      const caseIndex = toNumber(decoded);
+      const caseKey = Object.keys(this.coders)[caseIndex];
+      if (!caseKey) {
+        throw new FuelError(
+          ErrorCode.INVALID_DECODE_VALUE,
+          `Invalid caseIndex "${caseIndex}". Valid cases: ${Object.keys(this.coders)}.`
+        );
+      }
+      const valueCoder = this.coders[caseKey];
+      const padding = this.#encodedValueSize - valueCoder.encodedLength;
+      newOffset += padding;
+      [decoded, newOffset] = valueCoder.decode(data, newOffset);
+      if (isFullyNativeEnum(this.coders)) {
+        return this.#decodeNativeEnum(caseKey, newOffset);
+      }
+      return [{ [caseKey]: decoded }, newOffset];
+    }
+  };
+  var OptionCoder = class extends EnumCoder {
+    encode(value) {
+      const result = super.encode(this.toSwayOption(value));
+      return result;
+    }
+    toSwayOption(input) {
+      if (input !== void 0) {
+        return { Some: input };
+      }
+      return { None: [] };
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} data size.`);
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid option data size.`);
       }
-      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.`);
+      const [decoded, newOffset] = super.decode(data, offset);
+      return [this.toOption(decoded), newOffset];
+    }
+    toOption(output2) {
+      if (output2 && "Some" in output2) {
+        return output2.Some;
       }
-      return [bn(bytes2), offset + this.encodedLength];
+      return void 0;
     }
   };
-  var BooleanCoder = class extends Coder {
+  var NumberCoder = class extends Coder {
+    // This is to align the bits to the total bytes
+    // See https://github.com/FuelLabs/fuel-specs/blob/master/specs/protocol/abi.md#unsigned-integers
+    length;
+    paddingLength;
+    baseType;
     options;
-    constructor(options = {
-      padToWordSize: false
+    constructor(baseType, options = {
+      isSmallBytes: false,
+      isRightPadded: false
     }) {
-      const encodedLength = options.padToWordSize ? WORD_SIZE : 1;
-      super("boolean", "boolean", encodedLength);
+      const paddingLength = options.isSmallBytes && baseType === "u8" ? 1 : 8;
+      super("number", baseType, paddingLength);
+      this.baseType = baseType;
+      switch (baseType) {
+        case "u8":
+          this.length = 1;
+          break;
+        case "u16":
+          this.length = 2;
+          break;
+        case "u32":
+        default:
+          this.length = 4;
+          break;
+      }
+      this.paddingLength = paddingLength;
       this.options = options;
     }
+    encode(value) {
+      let bytes2;
+      try {
+        bytes2 = toBytes2(value);
+      } catch (error) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}.`);
+      }
+      if (bytes2.length > this.length) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}, too many bytes.`);
+      }
+      const output2 = toBytes2(bytes2, this.paddingLength);
+      if (this.baseType !== "u8") {
+        return output2;
+      }
+      return this.options.isRightPadded ? output2.reverse() : output2;
+    }
+    decodeU8(data, offset) {
+      let bytes2;
+      if (this.options.isRightPadded) {
+        bytes2 = data.slice(offset, offset + 1);
+      } else {
+        bytes2 = data.slice(offset, offset + this.paddingLength);
+        bytes2 = bytes2.slice(this.paddingLength - this.length, this.paddingLength);
+      }
+      return [toNumber(bytes2), offset + this.paddingLength];
+    }
+    decode(data, offset) {
+      if (data.length < this.paddingLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number data size.`);
+      }
+      if (this.baseType === "u8") {
+        return this.decodeU8(data, offset);
+      }
+      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 [toNumber(bytes2), offset + 8];
+    }
+  };
+  var RawSliceCoder = class extends Coder {
+    constructor() {
+      super("raw untyped slice", "raw untyped slice", BASE_RAW_SLICE_OFFSET);
+    }
+    encode(value) {
+      if (!Array.isArray(value)) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+      }
+      const parts = [];
+      const coder = new NumberCoder("u8", { isSmallBytes: true });
+      const pointer = new BigNumberCoder("u64").encode(
+        BASE_RAW_SLICE_OFFSET
+      );
+      pointer.dynamicData = {
+        0: concatWithDynamicData(value.map((v) => coder.encode(v)))
+      };
+      parts.push(pointer);
+      parts.push(new BigNumberCoder("u64").encode(value.length));
+      return concatWithDynamicData(parts);
+    }
+    decode(data, offset) {
+      const dataBytes = data.slice(offset);
+      const internalCoder = new ArrayCoder(
+        new NumberCoder("u8", { isSmallBytes: true }),
+        dataBytes.length
+      );
+      const [decodedValue] = internalCoder.decode(dataBytes, 0);
+      return [decodedValue, offset + dataBytes.length];
+    }
+  };
+  var _getPaddedData2;
+  var getPaddedData_fn2;
+  var StdStringCoder = class extends Coder {
+    constructor() {
+      super("struct", "struct String", 1);
+      __privateAdd2(this, _getPaddedData2);
+    }
+    encode(value) {
+      const parts = [];
+      const pointer = new BigNumberCoder("u64").encode(BASE_VECTOR_OFFSET);
+      const data = __privateMethod2(this, _getPaddedData2, getPaddedData_fn2).call(this, value);
+      pointer.dynamicData = {
+        0: concatWithDynamicData([data])
+      };
+      parts.push(pointer);
+      parts.push(new BigNumberCoder("u64").encode(data.byteLength));
+      parts.push(new BigNumberCoder("u64").encode(value.length));
+      return concatWithDynamicData(parts);
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid std string data size.`);
+      }
+      const len = data.slice(16, 24);
+      const encodedLength = bn(new BigNumberCoder("u64").decode(len, 0)[0]).toNumber();
+      const byteData = data.slice(BASE_VECTOR_OFFSET, BASE_VECTOR_OFFSET + encodedLength);
+      if (byteData.length !== encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid std string byte data size.`);
+      }
+      const value = toUtf8String(byteData);
+      return [value, offset + BASE_VECTOR_OFFSET];
+    }
+  };
+  _getPaddedData2 = /* @__PURE__ */ new WeakSet();
+  getPaddedData_fn2 = function(value) {
+    const data = [toUtf8Bytes(value)];
+    const paddingLength = (WORD_SIZE - value.length % WORD_SIZE) % WORD_SIZE;
+    if (paddingLength) {
+      data.push(new Uint8Array(paddingLength));
+    }
+    return concat(data);
+  };
+  __publicField4(StdStringCoder, "memorySize", 1);
+  var StringCoder = class extends Coder {
+    length;
+    #paddingLength;
+    constructor(length) {
+      let paddingLength = (8 - length) % 8;
+      paddingLength = paddingLength < 0 ? paddingLength + 8 : paddingLength;
+      super("string", `str[${length}]`, length + paddingLength);
+      this.length = length;
+      this.#paddingLength = paddingLength;
+    }
+    encode(value) {
+      if (this.length !== value.length) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Value length mismatch during encode.`);
+      }
+      const encoded = toUtf8Bytes(value);
+      const padding = new Uint8Array(this.#paddingLength);
+      return concat([encoded, padding]);
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string data size.`);
+      }
+      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(bytes2);
+      const padding = this.#paddingLength;
+      return [value, offset + this.length + padding];
+    }
+  };
+  var StructCoder = class extends Coder {
+    name;
+    coders;
+    constructor(name, coders) {
+      const encodedLength = Object.values(coders).reduce(
+        (acc, coder) => acc + coder.encodedLength,
+        0
+      );
+      super("struct", `struct ${name}`, encodedLength);
+      this.name = name;
+      this.coders = coders;
+    }
+    encode(value) {
+      const encodedFields = Object.keys(this.coders).map((fieldName) => {
+        const fieldCoder = this.coders[fieldName];
+        const fieldValue = value[fieldName];
+        if (!(fieldCoder instanceof OptionCoder) && fieldValue == null) {
+          throw new FuelError(
+            ErrorCode.ENCODE_ERROR,
+            `Invalid ${this.type}. Field "${fieldName}" not present.`
+          );
+        }
+        const encoded = fieldCoder.encode(fieldValue);
+        if (!isMultipleOfWordSize(encoded.length)) {
+          return rightPadToWordSize(encoded);
+        }
+        return encoded;
+      });
+      return concatWithDynamicData([concatWithDynamicData(encodedFields)]);
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid struct data size.`);
+      }
+      let newOffset = offset;
+      const decodedValue = Object.keys(this.coders).reduce((obj, fieldName) => {
+        const fieldCoder = this.coders[fieldName];
+        let decoded;
+        [decoded, newOffset] = fieldCoder.decode(data, newOffset);
+        if (!isMultipleOfWordSize(newOffset)) {
+          newOffset += getWordSizePadding(newOffset);
+        }
+        obj[fieldName] = decoded;
+        return obj;
+      }, {});
+      return [decodedValue, newOffset];
+    }
+  };
+  var TupleCoder = class extends Coder {
+    coders;
+    constructor(coders) {
+      const encodedLength = coders.reduce((acc, coder) => acc + coder.encodedLength, 0);
+      super("tuple", `(${coders.map((coder) => coder.type).join(", ")})`, encodedLength);
+      this.coders = coders;
+    }
+    encode(value) {
+      if (this.coders.length !== value.length) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Types/values length mismatch.`);
+      }
+      return concatWithDynamicData(
+        this.coders.map((coder, i) => {
+          const encoded = coder.encode(value[i]);
+          if (!isMultipleOfWordSize(encoded.length)) {
+            return rightPadToWordSize(encoded);
+          }
+          return encoded;
+        })
+      );
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid tuple data size.`);
+      }
+      let newOffset = offset;
+      const decodedValue = this.coders.map((coder) => {
+        let decoded;
+        [decoded, newOffset] = coder.decode(data, newOffset);
+        if (!isMultipleOfWordSize(newOffset)) {
+          newOffset += getWordSizePadding(newOffset);
+        }
+        return decoded;
+      });
+      return [decodedValue, newOffset];
+    }
+  };
+  var VecCoder = class extends Coder {
+    coder;
+    constructor(coder) {
+      super("struct", `struct Vec`, coder.encodedLength + BASE_VECTOR_OFFSET);
+      this.coder = coder;
+    }
+    encode(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 parts = [];
+      const pointer = new BigNumberCoder("u64").encode(BASE_VECTOR_OFFSET);
+      pointer.dynamicData = {
+        0: concatWithDynamicData(Array.from(value).map((v) => this.coder.encode(v)))
+      };
+      parts.push(pointer);
+      parts.push(new BigNumberCoder("u64").encode(value.length));
+      parts.push(new BigNumberCoder("u64").encode(value.length));
+      return concatWithDynamicData(parts);
+    }
+    decode(data, offset) {
+      if (data.length < BASE_VECTOR_OFFSET || data.length > MAX_BYTES) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec data size.`);
+      }
+      const len = data.slice(16, 24);
+      const encodedLength = bn(new BigNumberCoder("u64").decode(len, 0)[0]).toNumber();
+      const vectorRawDataLength = encodedLength * this.coder.encodedLength;
+      const vectorRawData = data.slice(BASE_VECTOR_OFFSET, BASE_VECTOR_OFFSET + vectorRawDataLength);
+      if (vectorRawData.length !== vectorRawDataLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec byte data size.`);
+      }
+      return [
+        chunkByLength(vectorRawData, this.coder.encodedLength).map(
+          (chunk) => this.coder.decode(chunk, 0)[0]
+        ),
+        offset + BASE_VECTOR_OFFSET
+      ];
+    }
+  };
+  var getEncodingVersion = (encoding) => {
+    switch (encoding) {
+      case void 0:
+      case ENCODING_V0:
+        return ENCODING_V0;
+      case ENCODING_V1:
+        return ENCODING_V1;
+      default:
+        throw new FuelError(
+          ErrorCode.UNSUPPORTED_ENCODING_VERSION,
+          `Encoding version '${encoding}' is unsupported.`
+        );
+    }
+  };
+  var findFunctionByName = (abi, name) => {
+    const fn = abi.functions.find((f2) => f2.name === name);
+    if (!fn) {
+      throw new FuelError(
+        ErrorCode.FUNCTION_NOT_FOUND,
+        `Function with name '${name}' doesn't exist in the ABI`
+      );
+    }
+    return fn;
+  };
+  var findTypeById = (abi, typeId) => {
+    const type3 = abi.types.find((t) => t.typeId === typeId);
+    if (!type3) {
+      throw new FuelError(
+        ErrorCode.TYPE_NOT_FOUND,
+        `Type with typeId '${typeId}' doesn't exist in the ABI.`
+      );
+    }
+    return type3;
+  };
+  var findNonEmptyInputs = (abi, inputs) => inputs.filter((input) => findTypeById(abi, input.type).type !== "()");
+  var findVectorBufferArgument = (components) => {
+    const bufferComponent = components.find((c) => c.name === "buf");
+    const bufferTypeArgument = bufferComponent?.originalTypeArguments?.[0];
+    if (!bufferComponent || !bufferTypeArgument) {
+      throw new FuelError(
+        ErrorCode.INVALID_COMPONENT,
+        `The Vec type provided is missing or has a malformed 'buf' component.`
+      );
+    }
+    return bufferTypeArgument;
+  };
+  var ResolvedAbiType = class {
+    abi;
+    name;
+    type;
+    originalTypeArguments;
+    components;
+    constructor(abi, argument) {
+      this.abi = abi;
+      this.name = argument.name;
+      const type3 = findTypeById(abi, argument.type);
+      this.type = type3.type;
+      this.originalTypeArguments = argument.typeArguments;
+      this.components = ResolvedAbiType.getResolvedGenericComponents(
+        abi,
+        argument,
+        type3.components,
+        type3.typeParameters ?? ResolvedAbiType.getImplicitGenericTypeParameters(abi, type3.components)
+      );
+    }
+    static getResolvedGenericComponents(abi, arg, components, typeParameters) {
+      if (components === null) {
+        return null;
+      }
+      if (typeParameters === null || typeParameters.length === 0) {
+        return components.map((c) => new ResolvedAbiType(abi, c));
+      }
+      const typeParametersAndArgsMap = typeParameters.reduce(
+        (obj, typeParameter, typeParameterIndex) => {
+          const o = { ...obj };
+          o[typeParameter] = structuredClone(
+            arg.typeArguments?.[typeParameterIndex]
+          );
+          return o;
+        },
+        {}
+      );
+      const resolvedComponents = this.resolveGenericArgTypes(
+        abi,
+        components,
+        typeParametersAndArgsMap
+      );
+      return resolvedComponents.map((c) => new ResolvedAbiType(abi, c));
+    }
+    static resolveGenericArgTypes(abi, args, typeParametersAndArgsMap) {
+      return args.map((arg) => {
+        if (typeParametersAndArgsMap[arg.type] !== void 0) {
+          return {
+            ...typeParametersAndArgsMap[arg.type],
+            name: arg.name
+          };
+        }
+        if (arg.typeArguments) {
+          return {
+            ...structuredClone(arg),
+            typeArguments: this.resolveGenericArgTypes(
+              abi,
+              arg.typeArguments,
+              typeParametersAndArgsMap
+            )
+          };
+        }
+        const argType = findTypeById(abi, arg.type);
+        const implicitTypeParameters = this.getImplicitGenericTypeParameters(abi, argType.components);
+        if (implicitTypeParameters && implicitTypeParameters.length > 0) {
+          return {
+            ...structuredClone(arg),
+            typeArguments: implicitTypeParameters.map((itp) => typeParametersAndArgsMap[itp])
+          };
+        }
+        return arg;
+      });
+    }
+    static getImplicitGenericTypeParameters(abi, args, implicitGenericParametersParam) {
+      if (!Array.isArray(args)) {
+        return null;
+      }
+      const implicitGenericParameters = implicitGenericParametersParam ?? [];
+      args.forEach((a) => {
+        const argType = findTypeById(abi, a.type);
+        if (genericRegEx.test(argType.type)) {
+          implicitGenericParameters.push(argType.typeId);
+          return;
+        }
+        if (!Array.isArray(a.typeArguments)) {
+          return;
+        }
+        this.getImplicitGenericTypeParameters(abi, a.typeArguments, implicitGenericParameters);
+      });
+      return implicitGenericParameters.length > 0 ? implicitGenericParameters : null;
+    }
+    getSignature() {
+      const prefix = this.getArgSignaturePrefix();
+      const content = this.getArgSignatureContent();
+      return `${prefix}${content}`;
+    }
+    getArgSignaturePrefix() {
+      const structMatch = structRegEx.test(this.type);
+      if (structMatch) {
+        return "s";
+      }
+      const arrayMatch = arrayRegEx.test(this.type);
+      if (arrayMatch) {
+        return "a";
+      }
+      const enumMatch = enumRegEx.test(this.type);
+      if (enumMatch) {
+        return "e";
+      }
+      return "";
+    }
+    getArgSignatureContent() {
+      if (this.type === "raw untyped ptr") {
+        return "rawptr";
+      }
+      if (this.type === "raw untyped slice") {
+        return "rawslice";
+      }
+      const strMatch = stringRegEx.exec(this.type)?.groups;
+      if (strMatch) {
+        return `str[${strMatch.length}]`;
+      }
+      if (this.components === null) {
+        return this.type;
+      }
+      const arrayMatch = arrayRegEx.exec(this.type)?.groups;
+      if (arrayMatch) {
+        return `[${this.components[0].getSignature()};${arrayMatch.length}]`;
+      }
+      const typeArgumentsSignature = this.originalTypeArguments !== null ? `<${this.originalTypeArguments.map((a) => new ResolvedAbiType(this.abi, a).getSignature()).join(",")}>` : "";
+      const componentsSignature = `(${this.components.map((c) => c.getSignature()).join(",")})`;
+      return `${typeArgumentsSignature}${componentsSignature}`;
+    }
+  };
+  function getCoders(components, options) {
+    const { getCoder: getCoder3 } = options;
+    return components.reduce((obj, component) => {
+      const o = obj;
+      o[component.name] = getCoder3(component, options);
+      return o;
+    }, {});
+  }
+  var getCoder = (resolvedAbiType, options) => {
+    switch (resolvedAbiType.type) {
+      case U8_CODER_TYPE:
+      case U16_CODER_TYPE:
+      case U32_CODER_TYPE:
+        return new NumberCoder(resolvedAbiType.type, options);
+      case U64_CODER_TYPE:
+      case RAW_PTR_CODER_TYPE:
+        return new BigNumberCoder("u64");
+      case U256_CODER_TYPE:
+        return new BigNumberCoder("u256");
+      case RAW_SLICE_CODER_TYPE:
+        return new RawSliceCoder();
+      case BOOL_CODER_TYPE:
+        return new BooleanCoder(options);
+      case B256_CODER_TYPE:
+        return new B256Coder();
+      case B512_CODER_TYPE:
+        return new B512Coder();
+      case BYTES_CODER_TYPE:
+        return new ByteCoder();
+      case STD_STRING_CODER_TYPE:
+        return new StdStringCoder();
+      default:
+        break;
+    }
+    const stringMatch = stringRegEx.exec(resolvedAbiType.type)?.groups;
+    if (stringMatch) {
+      const length = parseInt(stringMatch.length, 10);
+      return new StringCoder(length);
+    }
+    const components = resolvedAbiType.components;
+    const arrayMatch = arrayRegEx.exec(resolvedAbiType.type)?.groups;
+    if (arrayMatch) {
+      const length = parseInt(arrayMatch.length, 10);
+      const arg = components[0];
+      if (!arg) {
+        throw new FuelError(
+          ErrorCode.INVALID_COMPONENT,
+          `The provided Array type is missing an item of 'component'.`
+        );
+      }
+      const arrayElementCoder = getCoder(arg, { isSmallBytes: true });
+      return new ArrayCoder(arrayElementCoder, length);
+    }
+    if (resolvedAbiType.type === VEC_CODER_TYPE) {
+      const arg = findVectorBufferArgument(components);
+      const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
+      const itemCoder = getCoder(argType, { isSmallBytes: true, encoding: ENCODING_V0 });
+      return new VecCoder(itemCoder);
+    }
+    const structMatch = structRegEx.exec(resolvedAbiType.type)?.groups;
+    if (structMatch) {
+      const coders = getCoders(components, { isRightPadded: true, getCoder });
+      return new StructCoder(structMatch.name, coders);
+    }
+    const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
+    if (enumMatch) {
+      const coders = getCoders(components, { getCoder });
+      const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
+      if (isOptionEnum) {
+        return new OptionCoder(enumMatch.name, coders);
+      }
+      return new EnumCoder(enumMatch.name, coders);
+    }
+    const tupleMatch = tupleRegEx.exec(resolvedAbiType.type)?.groups;
+    if (tupleMatch) {
+      const coders = components.map(
+        (component) => getCoder(component, { isRightPadded: true, encoding: ENCODING_V0 })
+      );
+      return new TupleCoder(coders);
+    }
+    if (resolvedAbiType.type === STR_SLICE_CODER_TYPE) {
+      throw new FuelError(
+        ErrorCode.INVALID_DATA,
+        "String slices can not be decoded from logs. Convert the slice to `str[N]` with `__to_str_array`"
+      );
+    }
+    throw new FuelError(
+      ErrorCode.CODER_NOT_FOUND,
+      `Coder not found: ${JSON.stringify(resolvedAbiType)}.`
+    );
+  };
+  var BooleanCoder2 = class extends Coder {
+    constructor() {
+      super("boolean", "boolean", 1);
+    }
     encode(value) {
       const isTrueBool = value === true || value === false;
       if (!isTrueBool) {
@@ -31314,7 +31978,7 @@ This unreleased fuel-core build may include features and updates not yet support
       return [true, offset + this.encodedLength];
     }
   };
-  var ByteCoder = class extends Coder {
+  var ByteCoder2 = class extends Coder {
     constructor() {
       super("struct", "struct Bytes", WORD_SIZE);
     }
@@ -31337,12 +32001,12 @@ This unreleased fuel-core build may include features and updates not yet support
       return [dataBytes, offsetAndLength + length];
     }
   };
-  __publicField4(ByteCoder, "memorySize", 1);
-  var isFullyNativeEnum = (enumCoders) => Object.values(enumCoders).every(
+  __publicField4(ByteCoder2, "memorySize", 1);
+  var isFullyNativeEnum2 = (enumCoders) => Object.values(enumCoders).every(
     // @ts-expect-error complicated types
     ({ type: type3, coders }) => type3 === "()" && JSON.stringify(coders) === JSON.stringify([])
   );
-  var EnumCoder = class extends Coder {
+  var EnumCoder2 = class extends Coder {
     name;
     coders;
     #caseIndexCoder;
@@ -31401,7 +32065,7 @@ This unreleased fuel-core build may include features and updates not yet support
       const valueCoder = this.coders[caseKey];
       const offsetAndCase = offset + WORD_SIZE;
       const [decoded, newOffset] = valueCoder.decode(data, offsetAndCase);
-      if (isFullyNativeEnum(this.coders)) {
+      if (isFullyNativeEnum2(this.coders)) {
         return this.#decodeNativeEnum(caseKey, newOffset);
       }
       return [{ [caseKey]: decoded }, newOffset];
@@ -31419,16 +32083,14 @@ This unreleased fuel-core build may include features and updates not yet support
         throw new FuelError(ErrorCode.TYPE_NOT_SUPPORTED, `Invalid number type: ${baseType}`);
     }
   };
-  var NumberCoder = class extends Coder {
+  var NumberCoder2 = class extends Coder {
+    length;
     baseType;
-    options;
-    constructor(baseType, options = {
-      padToWordSize: false
-    }) {
-      const length = options.padToWordSize ? WORD_SIZE : getLength(baseType);
+    constructor(baseType) {
+      const length = getLength(baseType);
       super("number", baseType, length);
       this.baseType = baseType;
-      this.options = options;
+      this.length = length;
     }
     encode(value) {
       let bytes2;
@@ -31437,23 +32099,23 @@ This unreleased fuel-core build may include features and updates not yet support
       } catch (error) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}.`);
       }
-      if (bytes2.length > this.encodedLength) {
+      if (bytes2.length > this.length) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}, too many bytes.`);
       }
-      return toBytes2(bytes2, this.encodedLength);
+      return toBytes2(bytes2, this.length);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number data size.`);
       }
-      const bytes2 = data.slice(offset, offset + this.encodedLength);
+      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 [toNumber(bytes2), offset + this.encodedLength];
+      return [toNumber(bytes2), offset + this.length];
     }
   };
-  var OptionCoder = class extends EnumCoder {
+  var OptionCoder2 = class extends EnumCoder2 {
     encode(value) {
       const result = super.encode(this.toSwayOption(value));
       return result;
@@ -31475,7 +32137,7 @@ This unreleased fuel-core build may include features and updates not yet support
       return void 0;
     }
   };
-  var RawSliceCoder = class extends Coder {
+  var RawSliceCoder2 = class extends Coder {
     constructor() {
       super("raw untyped slice", "raw untyped slice", WORD_SIZE);
     }
@@ -31483,7 +32145,7 @@ This unreleased fuel-core build may include features and updates not yet support
       if (!Array.isArray(value)) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
       }
-      const internalCoder = new ArrayCoder(new NumberCoder("u8"), value.length);
+      const internalCoder = new ArrayCoder(new NumberCoder2("u8"), value.length);
       const bytes2 = internalCoder.encode(value);
       const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
       return new Uint8Array([...lengthBytes, ...bytes2]);
@@ -31499,12 +32161,12 @@ This unreleased fuel-core build may include features and updates not yet support
       if (dataBytes.length !== length) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid raw slice byte data size.`);
       }
-      const internalCoder = new ArrayCoder(new NumberCoder("u8"), length);
+      const internalCoder = new ArrayCoder(new NumberCoder2("u8"), length);
       const [decodedValue] = internalCoder.decode(dataBytes, 0);
       return [decodedValue, offsetAndLength + length];
     }
   };
-  var StdStringCoder = class extends Coder {
+  var StdStringCoder2 = class extends Coder {
     constructor() {
       super("struct", "struct String", WORD_SIZE);
     }
@@ -31527,7 +32189,7 @@ This unreleased fuel-core build may include features and updates not yet support
       return [toUtf8String(dataBytes), offsetAndLength + length];
     }
   };
-  __publicField4(StdStringCoder, "memorySize", 1);
+  __publicField4(StdStringCoder2, "memorySize", 1);
   var StrSliceCoder = class extends Coder {
     constructor() {
       super("strSlice", "str", WORD_SIZE);
@@ -31552,7 +32214,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
   };
   __publicField4(StrSliceCoder, "memorySize", 1);
-  var StringCoder = class extends Coder {
+  var StringCoder2 = class extends Coder {
     constructor(length) {
       super("string", `str[${length}]`, length);
     }
@@ -31573,7 +32235,7 @@ This unreleased fuel-core build may include features and updates not yet support
       return [toUtf8String(bytes2), offset + this.encodedLength];
     }
   };
-  var StructCoder = class extends Coder {
+  var StructCoder2 = class extends Coder {
     name;
     coders;
     constructor(name, coders) {
@@ -31590,7 +32252,7 @@ This unreleased fuel-core build may include features and updates not yet support
         Object.keys(this.coders).map((fieldName) => {
           const fieldCoder = this.coders[fieldName];
           const fieldValue = value[fieldName];
-          if (!(fieldCoder instanceof OptionCoder) && fieldValue == null) {
+          if (!(fieldCoder instanceof OptionCoder2) && fieldValue == null) {
             throw new FuelError(
               ErrorCode.ENCODE_ERROR,
               `Invalid ${this.type}. Field "${fieldName}" not present.`
@@ -31615,7 +32277,7 @@ This unreleased fuel-core build may include features and updates not yet support
       return [decodedValue, newOffset];
     }
   };
-  var TupleCoder = class extends Coder {
+  var TupleCoder2 = class extends Coder {
     coders;
     constructor(coders) {
       const encodedLength = coders.reduce((acc, coder) => acc + coder.encodedLength, 0);
@@ -31641,14 +32303,13 @@ This unreleased fuel-core build may include features and updates not yet support
       return [decodedValue, newOffset];
     }
   };
-  var isUint8Array = (value) => value instanceof Uint8Array;
-  var VecCoder = class extends Coder {
+  var VecCoder2 = class extends Coder {
     coder;
     #isOptionVec;
     constructor(coder) {
       super("struct", `struct Vec`, coder.encodedLength + WORD_SIZE);
       this.coder = coder;
-      this.#isOptionVec = this.coder instanceof OptionCoder;
+      this.#isOptionVec = this.coder instanceof OptionCoder2;
     }
     encode(value) {
       if (!Array.isArray(value) && !isUint8Array(value)) {
@@ -31672,9 +32333,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;
@@ -31687,214 +32348,29 @@ This unreleased fuel-core build may include features and updates not yet support
       return [chunks, newOffset];
     }
   };
-  var getEncodingVersion = (encoding) => {
-    switch (encoding) {
-      case void 0:
-      case ENCODING_V1:
-        return ENCODING_V1;
-      default:
-        throw new FuelError(
-          ErrorCode.UNSUPPORTED_ENCODING_VERSION,
-          `Encoding version '${encoding}' is unsupported.`
-        );
-    }
-  };
-  var findFunctionByName = (abi, name) => {
-    const fn = abi.functions.find((f2) => f2.name === name);
-    if (!fn) {
-      throw new FuelError(
-        ErrorCode.FUNCTION_NOT_FOUND,
-        `Function with name '${name}' doesn't exist in the ABI`
-      );
-    }
-    return fn;
-  };
-  var findTypeById = (abi, typeId) => {
-    const type3 = abi.types.find((t) => t.typeId === typeId);
-    if (!type3) {
-      throw new FuelError(
-        ErrorCode.TYPE_NOT_FOUND,
-        `Type with typeId '${typeId}' doesn't exist in the ABI.`
-      );
-    }
-    return type3;
-  };
-  var findNonEmptyInputs = (abi, inputs) => inputs.filter((input) => findTypeById(abi, input.type).type !== "()");
-  var findVectorBufferArgument = (components) => {
-    const bufferComponent = components.find((c) => c.name === "buf");
-    const bufferTypeArgument = bufferComponent?.originalTypeArguments?.[0];
-    if (!bufferComponent || !bufferTypeArgument) {
-      throw new FuelError(
-        ErrorCode.INVALID_COMPONENT,
-        `The Vec type provided is missing or has a malformed 'buf' component.`
-      );
-    }
-    return bufferTypeArgument;
-  };
-  var ResolvedAbiType = class {
-    abi;
-    name;
-    type;
-    originalTypeArguments;
-    components;
-    constructor(abi, argument) {
-      this.abi = abi;
-      this.name = argument.name;
-      const type3 = findTypeById(abi, argument.type);
-      this.type = type3.type;
-      this.originalTypeArguments = argument.typeArguments;
-      this.components = ResolvedAbiType.getResolvedGenericComponents(
-        abi,
-        argument,
-        type3.components,
-        type3.typeParameters ?? ResolvedAbiType.getImplicitGenericTypeParameters(abi, type3.components)
-      );
-    }
-    static getResolvedGenericComponents(abi, arg, components, typeParameters) {
-      if (components === null) {
-        return null;
-      }
-      if (typeParameters === null || typeParameters.length === 0) {
-        return components.map((c) => new ResolvedAbiType(abi, c));
-      }
-      const typeParametersAndArgsMap = typeParameters.reduce(
-        (obj, typeParameter, typeParameterIndex) => {
-          const o = { ...obj };
-          o[typeParameter] = structuredClone(
-            arg.typeArguments?.[typeParameterIndex]
-          );
-          return o;
-        },
-        {}
-      );
-      const resolvedComponents = this.resolveGenericArgTypes(
-        abi,
-        components,
-        typeParametersAndArgsMap
-      );
-      return resolvedComponents.map((c) => new ResolvedAbiType(abi, c));
-    }
-    static resolveGenericArgTypes(abi, args, typeParametersAndArgsMap) {
-      return args.map((arg) => {
-        if (typeParametersAndArgsMap[arg.type] !== void 0) {
-          return {
-            ...typeParametersAndArgsMap[arg.type],
-            name: arg.name
-          };
-        }
-        if (arg.typeArguments) {
-          return {
-            ...structuredClone(arg),
-            typeArguments: this.resolveGenericArgTypes(
-              abi,
-              arg.typeArguments,
-              typeParametersAndArgsMap
-            )
-          };
-        }
-        const argType = findTypeById(abi, arg.type);
-        const implicitTypeParameters = this.getImplicitGenericTypeParameters(abi, argType.components);
-        if (implicitTypeParameters && implicitTypeParameters.length > 0) {
-          return {
-            ...structuredClone(arg),
-            typeArguments: implicitTypeParameters.map((itp) => typeParametersAndArgsMap[itp])
-          };
-        }
-        return arg;
-      });
-    }
-    static getImplicitGenericTypeParameters(abi, args, implicitGenericParametersParam) {
-      if (!Array.isArray(args)) {
-        return null;
-      }
-      const implicitGenericParameters = implicitGenericParametersParam ?? [];
-      args.forEach((a) => {
-        const argType = findTypeById(abi, a.type);
-        if (genericRegEx.test(argType.type)) {
-          implicitGenericParameters.push(argType.typeId);
-          return;
-        }
-        if (!Array.isArray(a.typeArguments)) {
-          return;
-        }
-        this.getImplicitGenericTypeParameters(abi, a.typeArguments, implicitGenericParameters);
-      });
-      return implicitGenericParameters.length > 0 ? implicitGenericParameters : null;
-    }
-    getSignature() {
-      const prefix = this.getArgSignaturePrefix();
-      const content = this.getArgSignatureContent();
-      return `${prefix}${content}`;
-    }
-    getArgSignaturePrefix() {
-      const structMatch = structRegEx.test(this.type);
-      if (structMatch) {
-        return "s";
-      }
-      const arrayMatch = arrayRegEx.test(this.type);
-      if (arrayMatch) {
-        return "a";
-      }
-      const enumMatch = enumRegEx.test(this.type);
-      if (enumMatch) {
-        return "e";
-      }
-      return "";
-    }
-    getArgSignatureContent() {
-      if (this.type === "raw untyped ptr") {
-        return "rawptr";
-      }
-      if (this.type === "raw untyped slice") {
-        return "rawslice";
-      }
-      const strMatch = stringRegEx.exec(this.type)?.groups;
-      if (strMatch) {
-        return `str[${strMatch.length}]`;
-      }
-      if (this.components === null) {
-        return this.type;
-      }
-      const arrayMatch = arrayRegEx.exec(this.type)?.groups;
-      if (arrayMatch) {
-        return `[${this.components[0].getSignature()};${arrayMatch.length}]`;
-      }
-      const typeArgumentsSignature = this.originalTypeArguments !== null ? `<${this.originalTypeArguments.map((a) => new ResolvedAbiType(this.abi, a).getSignature()).join(",")}>` : "";
-      const componentsSignature = `(${this.components.map((c) => c.getSignature()).join(",")})`;
-      return `${typeArgumentsSignature}${componentsSignature}`;
-    }
-  };
-  function getCoders(components, options) {
-    const { getCoder: getCoder2 } = options;
-    return components.reduce((obj, component) => {
-      const o = obj;
-      o[component.name] = getCoder2(component, options);
-      return o;
-    }, {});
-  }
-  var getCoder = (resolvedAbiType, _options) => {
+  var getCoder2 = (resolvedAbiType, _options) => {
     switch (resolvedAbiType.type) {
       case U8_CODER_TYPE:
       case U16_CODER_TYPE:
       case U32_CODER_TYPE:
-        return new NumberCoder(resolvedAbiType.type);
+        return new NumberCoder2(resolvedAbiType.type);
       case U64_CODER_TYPE:
       case RAW_PTR_CODER_TYPE:
         return new BigNumberCoder("u64");
       case U256_CODER_TYPE:
         return new BigNumberCoder("u256");
       case RAW_SLICE_CODER_TYPE:
-        return new RawSliceCoder();
+        return new RawSliceCoder2();
       case BOOL_CODER_TYPE:
-        return new BooleanCoder();
+        return new BooleanCoder2();
       case B256_CODER_TYPE:
         return new B256Coder();
       case B512_CODER_TYPE:
         return new B512Coder();
       case BYTES_CODER_TYPE:
-        return new ByteCoder();
+        return new ByteCoder2();
       case STD_STRING_CODER_TYPE:
-        return new StdStringCoder();
+        return new StdStringCoder2();
       case STR_SLICE_CODER_TYPE:
         return new StrSliceCoder();
       default:
@@ -31903,7 +32379,7 @@ This unreleased fuel-core build may include features and updates not yet support
     const stringMatch = stringRegEx.exec(resolvedAbiType.type)?.groups;
     if (stringMatch) {
       const length = parseInt(stringMatch.length, 10);
-      return new StringCoder(length);
+      return new StringCoder2(length);
     }
     const components = resolvedAbiType.components;
     const arrayMatch = arrayRegEx.exec(resolvedAbiType.type)?.groups;
@@ -31916,42 +32392,46 @@ This unreleased fuel-core build may include features and updates not yet support
           `The provided Array type is missing an item of 'component'.`
         );
       }
-      const arrayElementCoder = getCoder(arg);
+      const arrayElementCoder = getCoder2(arg, { isSmallBytes: true });
       return new ArrayCoder(arrayElementCoder, length);
     }
     if (resolvedAbiType.type === VEC_CODER_TYPE) {
       const arg = findVectorBufferArgument(components);
       const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
-      const itemCoder = getCoder(argType, { encoding: ENCODING_V1 });
-      return new VecCoder(itemCoder);
+      const itemCoder = getCoder2(argType, { isSmallBytes: true, encoding: ENCODING_V0 });
+      return new VecCoder2(itemCoder);
     }
     const structMatch = structRegEx.exec(resolvedAbiType.type)?.groups;
     if (structMatch) {
-      const coders = getCoders(components, { getCoder });
-      return new StructCoder(structMatch.name, coders);
+      const coders = getCoders(components, { isRightPadded: true, getCoder: getCoder2 });
+      return new StructCoder2(structMatch.name, coders);
     }
     const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
     if (enumMatch) {
-      const coders = getCoders(components, { getCoder });
+      const coders = getCoders(components, { getCoder: getCoder2 });
       const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
       if (isOptionEnum) {
-        return new OptionCoder(enumMatch.name, coders);
+        return new OptionCoder2(enumMatch.name, coders);
       }
-      return new EnumCoder(enumMatch.name, coders);
+      return new EnumCoder2(enumMatch.name, coders);
     }
     const tupleMatch = tupleRegEx.exec(resolvedAbiType.type)?.groups;
     if (tupleMatch) {
-      const coders = components.map((component) => getCoder(component, { encoding: ENCODING_V1 }));
-      return new TupleCoder(coders);
+      const coders = components.map(
+        (component) => getCoder2(component, { isRightPadded: true, encoding: ENCODING_V0 })
+      );
+      return new TupleCoder2(coders);
     }
     throw new FuelError(
       ErrorCode.CODER_NOT_FOUND,
       `Coder not found: ${JSON.stringify(resolvedAbiType)}.`
     );
   };
-  function getCoderForEncoding(encoding = ENCODING_V1) {
+  function getCoderForEncoding(encoding = ENCODING_V0) {
     switch (encoding) {
       case ENCODING_V1:
+        return getCoder2;
+      case ENCODING_V0:
         return getCoder;
       default:
         throw new FuelError(
@@ -31962,7 +32442,7 @@ This unreleased fuel-core build may include features and updates not yet support
   }
   var AbiCoder = class {
     static getCoder(abi, argument, options = {
-      padToWordSize: false
+      isSmallBytes: false
     }) {
       const resolvedAbiType = new ResolvedAbiType(abi, argument);
       return getCoderForEncoding(options.encoding)(resolvedAbiType, options);
@@ -31982,6 +32462,8 @@ This unreleased fuel-core build may include features and updates not yet support
     name;
     jsonFn;
     attributes;
+    isInputDataPointer;
+    outputMetadata;
     jsonAbi;
     constructor(jsonAbi, name) {
       this.jsonAbi = jsonAbi;
@@ -31989,8 +32471,13 @@ This unreleased fuel-core build may include features and updates not yet support
       this.name = name;
       this.signature = FunctionFragment.getSignature(this.jsonAbi, this.jsonFn);
       this.selector = FunctionFragment.getFunctionSelector(this.signature);
-      this.selectorBytes = new StdStringCoder().encode(name);
+      this.selectorBytes = new StdStringCoder2().encode(name);
       this.encoding = getEncodingVersion(jsonAbi.encoding);
+      this.isInputDataPointer = this.#isInputDataPointer();
+      this.outputMetadata = {
+        isHeapType: this.#isOutputDataHeap(),
+        encodedLength: this.#getOutputEncodedLength()
+      };
       this.attributes = this.jsonFn.attributes ?? [];
     }
     static getSignature(abi, fn) {
@@ -32003,7 +32490,29 @@ This unreleased fuel-core build may include features and updates not yet support
       const hashedFunctionSignature = sha2562(bufferFromString2(functionSignature, "utf-8"));
       return bn(hashedFunctionSignature.slice(0, 10)).toHex(8);
     }
-    encodeArguments(values) {
+    #isInputDataPointer() {
+      const inputTypes = this.jsonFn.inputs.map((i) => findTypeById(this.jsonAbi, i.type));
+      return this.jsonFn.inputs.length > 1 || isPointerType(inputTypes[0]?.type || "");
+    }
+    #isOutputDataHeap() {
+      const outputType = findTypeById(this.jsonAbi, this.jsonFn.output.type);
+      return isHeapType(outputType?.type || "");
+    }
+    #getOutputEncodedLength() {
+      try {
+        const heapCoder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output);
+        if (heapCoder instanceof VecCoder) {
+          return heapCoder.coder.encodedLength;
+        }
+        if (heapCoder instanceof ByteCoder) {
+          return ByteCoder.memorySize;
+        }
+        return heapCoder.encodedLength;
+      } catch (e) {
+        return 0;
+      }
+    }
+    encodeArguments(values, offset = 0) {
       FunctionFragment.verifyArgsAndInputsAlign(values, this.jsonFn.inputs, this.jsonAbi);
       const shallowCopyValues = values.slice();
       const nonEmptyInputs = findNonEmptyInputs(this.jsonAbi, this.jsonFn.inputs);
@@ -32013,10 +32522,15 @@ This unreleased fuel-core build may include features and updates not yet support
       }
       const coders = nonEmptyInputs.map(
         (t) => AbiCoder.getCoder(this.jsonAbi, t, {
+          isRightPadded: nonEmptyInputs.length > 1,
           encoding: this.encoding
         })
       );
-      return new TupleCoder(coders).encode(shallowCopyValues);
+      if (this.encoding === ENCODING_V1) {
+        return new TupleCoder2(coders).encode(shallowCopyValues);
+      }
+      const results = new TupleCoder(coders).encode(shallowCopyValues);
+      return unpackDynamicData(results, offset, results.byteLength);
     }
     static verifyArgsAndInputsAlign(args, inputs, abi) {
       if (args.length === inputs.length) {
@@ -32125,9 +32639,9 @@ This unreleased fuel-core build may include features and updates not yet support
       const fragment = typeof functionFragment === "string" ? this.getFunction(functionFragment) : functionFragment;
       return fragment.decodeArguments(data);
     }
-    encodeFunctionData(functionFragment, values) {
+    encodeFunctionData(functionFragment, values, offset = 0) {
       const fragment = typeof functionFragment === "string" ? this.getFunction(functionFragment) : functionFragment;
-      return fragment.encodeArguments(values);
+      return fragment.encodeArguments(values, offset);
     }
     // Decode the result of a function call
     decodeFunctionResult(functionFragment, data) {
@@ -32155,7 +32669,9 @@ This unreleased fuel-core build may include features and updates not yet support
         );
       }
       return AbiCoder.encode(this.jsonAbi, configurable.configurableType, value, {
-        encoding: this.encoding
+        isRightPadded: true,
+        // TODO: Review support for configurables in v1 encoding when it becomes available
+        encoding: ENCODING_V0
       });
     }
     getTypeById(typeId) {
@@ -32205,8 +32721,8 @@ This unreleased fuel-core build may include features and updates not yet support
   var TxPointerCoder = class extends StructCoder {
     constructor() {
       super("TxPointer", {
-        blockHeight: new NumberCoder("u32", { padToWordSize: true }),
-        txIndex: new NumberCoder("u16", { padToWordSize: true })
+        blockHeight: new NumberCoder("u32"),
+        txIndex: new NumberCoder("u16")
       });
     }
   };
@@ -32223,12 +32739,12 @@ This unreleased fuel-core build may include features and updates not yet support
     encode(value) {
       const parts = [];
       parts.push(new B256Coder().encode(value.txID));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputIndex));
+      parts.push(new NumberCoder("u16").encode(value.outputIndex));
       parts.push(new B256Coder().encode(value.owner));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(new B256Coder().encode(value.assetId));
       parts.push(new TxPointerCoder().encode(value.txPointer));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessIndex));
+      parts.push(new NumberCoder("u16").encode(value.witnessIndex));
       parts.push(new BigNumberCoder("u64").encode(value.predicateGasUsed));
       parts.push(new BigNumberCoder("u64").encode(value.predicateLength));
       parts.push(new BigNumberCoder("u64").encode(value.predicateDataLength));
@@ -32243,7 +32759,7 @@ This unreleased fuel-core build may include features and updates not yet support
       let o = offset;
       [decoded, o] = new B256Coder().decode(data, o);
       const txID = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const outputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const owner = decoded;
@@ -32253,7 +32769,7 @@ This unreleased fuel-core build may include features and updates not yet support
       const assetId = decoded;
       [decoded, o] = new TxPointerCoder().decode(data, o);
       const txPointer = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const witnessIndex = Number(decoded);
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateGasUsed = decoded;
@@ -32292,7 +32808,7 @@ This unreleased fuel-core build may include features and updates not yet support
     encode(value) {
       const parts = [];
       parts.push(new B256Coder().encode(value.txID));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputIndex));
+      parts.push(new NumberCoder("u16").encode(value.outputIndex));
       parts.push(new B256Coder().encode(value.balanceRoot));
       parts.push(new B256Coder().encode(value.stateRoot));
       parts.push(new TxPointerCoder().encode(value.txPointer));
@@ -32304,7 +32820,7 @@ This unreleased fuel-core build may include features and updates not yet support
       let o = offset;
       [decoded, o] = new B256Coder().decode(data, o);
       const txID = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const outputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const balanceRoot = decoded;
@@ -32343,8 +32859,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 = [];
@@ -32353,7 +32869,7 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new ByteArrayCoder(32).encode(value.recipient));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(new ByteArrayCoder(32).encode(value.nonce));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessIndex));
+      parts.push(new NumberCoder("u16").encode(value.witnessIndex));
       parts.push(new BigNumberCoder("u64").encode(value.predicateGasUsed));
       parts.push(new BigNumberCoder("u64").encode(data.length));
       parts.push(new BigNumberCoder("u64").encode(value.predicateLength));
@@ -32367,8 +32883,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) {
@@ -32382,17 +32898,17 @@ This unreleased fuel-core build may include features and updates not yet support
       const amount = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const nonce = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const witnessIndex = Number(decoded);
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateGasUsed = decoded;
-      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
-      const dataLength2 = decoded;
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      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;
@@ -32407,7 +32923,7 @@ This unreleased fuel-core build may include features and updates not yet support
           witnessIndex,
           nonce,
           predicateGasUsed,
-          dataLength: dataLength2,
+          dataLength,
           predicateLength,
           predicateDataLength,
           data: messageData,
@@ -32424,7 +32940,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.type));
+      parts.push(new NumberCoder("u8").encode(value.type));
       const { type: type3 } = value;
       switch (type3) {
         case 0: {
@@ -32451,7 +32967,7 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u8").decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
@@ -32520,7 +33036,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.inputIndex));
+      parts.push(new NumberCoder("u8").encode(value.inputIndex));
       parts.push(new B256Coder().encode(value.balanceRoot));
       parts.push(new B256Coder().encode(value.stateRoot));
       return concat(parts);
@@ -32528,7 +33044,7 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u8").decode(data, o);
       const inputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const balanceRoot = decoded;
@@ -32640,7 +33156,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.type));
+      parts.push(new NumberCoder("u8").encode(value.type));
       const { type: type3 } = value;
       switch (type3) {
         case 0: {
@@ -32675,7 +33191,7 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u8").decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
@@ -32743,7 +33259,7 @@ This unreleased fuel-core build may include features and updates not yet support
             parts.push(new BigNumberCoder("u64").encode(data));
             break;
           case 4:
-            parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(data));
+            parts.push(new NumberCoder("u32").encode(data));
             break;
           default: {
             throw new FuelError(ErrorCode.INVALID_POLICY_TYPE, `Invalid policy type: ${type3}`);
@@ -32766,10 +33282,7 @@ This unreleased fuel-core build may include features and updates not yet support
         policies.push({ type: 2, data: witnessLimit });
       }
       if (policyTypes & 4) {
-        const [maturity, nextOffset] = new NumberCoder("u32", { padToWordSize: true }).decode(
-          data,
-          o
-        );
+        const [maturity, nextOffset] = new NumberCoder("u32").decode(data, o);
         o = nextOffset;
         policies.push({ type: 4, data: maturity });
       }
@@ -32816,7 +33329,7 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new B256Coder().encode(value.recipient));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(new B256Coder().encode(value.nonce));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.data.length));
+      parts.push(new NumberCoder("u16").encode(value.data.length));
       parts.push(new B256Coder().encode(value.digest));
       parts.push(new ByteArrayCoder(value.data.length).encode(value.data));
       return concat(parts);
@@ -32832,7 +33345,7 @@ This unreleased fuel-core build may include features and updates not yet support
       const amount = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const nonce = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const len = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const digest = decoded;
@@ -32956,11 +33469,11 @@ This unreleased fuel-core build may include features and updates not yet support
     encode(upgradePurposeType) {
       const parts = [];
       const { type: type3 } = upgradePurposeType;
-      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(type3));
+      parts.push(new NumberCoder("u8").encode(type3));
       switch (type3) {
         case 0: {
           const data = upgradePurposeType.data;
-          parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(data.witnessIndex));
+          parts.push(new NumberCoder("u16").encode(data.witnessIndex));
           parts.push(new B256Coder().encode(data.checksum));
           break;
         }
@@ -32981,11 +33494,11 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let o = offset;
       let decoded;
-      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u8").decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
-          [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+          [decoded, o] = new NumberCoder("u16").decode(data, o);
           const witnessIndex = decoded;
           [decoded, o] = new B256Coder().decode(data, o);
           const checksum = decoded;
@@ -33016,20 +33529,20 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(value.dataLength));
+      parts.push(new NumberCoder("u32").encode(value.dataLength));
       parts.push(new ByteArrayCoder(value.dataLength).encode(value.data));
       return concat(parts);
     }
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
-      const dataLength2 = decoded;
-      [decoded, o] = new ByteArrayCoder(dataLength2).decode(data, o);
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      const dataLength = decoded;
+      [decoded, o] = new ByteArrayCoder(dataLength).decode(data, o);
       const witnessData = decoded;
       return [
         {
-          dataLength: dataLength2,
+          dataLength,
           data: witnessData
         },
         o
@@ -33054,10 +33567,10 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new B256Coder().encode(value.receiptsRoot));
       parts.push(new BigNumberCoder("u64").encode(value.scriptLength));
       parts.push(new BigNumberCoder("u64").encode(value.scriptDataLength));
-      parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(value.policyTypes));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.inputsCount));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputsCount));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessesCount));
+      parts.push(new NumberCoder("u32").encode(value.policyTypes));
+      parts.push(new NumberCoder("u16").encode(value.inputsCount));
+      parts.push(new NumberCoder("u16").encode(value.outputsCount));
+      parts.push(new NumberCoder("u16").encode(value.witnessesCount));
       parts.push(new ByteArrayCoder(value.scriptLength.toNumber()).encode(value.script));
       parts.push(new ByteArrayCoder(value.scriptDataLength.toNumber()).encode(value.scriptData));
       parts.push(new PoliciesCoder().encode(value.policies));
@@ -33077,13 +33590,13 @@ This unreleased fuel-core build may include features and updates not yet support
       const scriptLength = decoded;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const scriptDataLength = decoded;
-      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
       const policyTypes = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const inputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const outputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const witnessesCount = decoded;
       [decoded, o] = new ByteArrayCoder(scriptLength.toNumber()).decode(data, o);
       const script = decoded;
@@ -33125,13 +33638,13 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.bytecodeWitnessIndex));
+      parts.push(new NumberCoder("u16").encode(value.bytecodeWitnessIndex));
       parts.push(new B256Coder().encode(value.salt));
       parts.push(new BigNumberCoder("u64").encode(value.storageSlotsCount));
-      parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(value.policyTypes));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.inputsCount));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputsCount));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessesCount));
+      parts.push(new NumberCoder("u32").encode(value.policyTypes));
+      parts.push(new NumberCoder("u16").encode(value.inputsCount));
+      parts.push(new NumberCoder("u16").encode(value.outputsCount));
+      parts.push(new NumberCoder("u16").encode(value.witnessesCount));
       parts.push(
         new ArrayCoder(new StorageSlotCoder(), value.storageSlotsCount.toNumber()).encode(
           value.storageSlots
@@ -33146,19 +33659,19 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const bytecodeWitnessIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const salt = decoded;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const storageSlotsCount = decoded;
-      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
       const policyTypes = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const inputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const outputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const witnessesCount = decoded;
       [decoded, o] = new ArrayCoder(new StorageSlotCoder(), storageSlotsCount.toNumber()).decode(
         data,
@@ -33372,7 +33885,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.type));
+      parts.push(new NumberCoder("u8").encode(value.type));
       const { type: type3 } = value;
       switch (value.type) {
         case 0: {
@@ -33415,7 +33928,7 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u8").decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
@@ -38514,7 +39027,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);
@@ -38524,17 +39037,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;
@@ -39142,6 +39655,15 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         }
       });
     }
+    shiftPredicateData() {
+      this.inputs.forEach((input) => {
+        if ("predicateData" in input && "padPredicateData" in input && typeof input.padPredicateData === "function") {
+          input.predicateData = input.padPredicateData(
+            BaseTransactionRequest.getPolicyMeta(this).policies.length
+          );
+        }
+      });
+    }
   };
 
   // src/providers/transaction-request/hash-transaction.ts
@@ -39606,27 +40128,37 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   };
 
   // src/providers/transaction-summary/call.ts
-  var getFunctionCall = ({ abi, receipt }) => {
+  var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
     const abiInterface = new Interface(abi);
     const callFunctionSelector = receipt.param1.toHex(8);
     const functionFragment = abiInterface.getFunction(callFunctionSelector);
     const inputs = functionFragment.jsonFn.inputs;
-    const encodedArgs = receipt.param2.toHex();
+    let encodedArgs;
+    if (functionFragment.isInputDataPointer) {
+      if (rawPayload) {
+        const argsOffset = bn(receipt.param2).sub(calculateVmTxMemory({ maxInputs: maxInputs.toNumber() })).toNumber();
+        encodedArgs = `0x${rawPayload.slice(2).slice(argsOffset * 2)}`;
+      }
+    } else {
+      encodedArgs = receipt.param2.toHex();
+    }
     let argumentsProvided;
-    const data = functionFragment.decodeArguments(encodedArgs);
-    if (data) {
-      argumentsProvided = inputs.reduce((prev, input, index) => {
-        const value = data[index];
-        const name = input.name;
-        if (name) {
-          return {
-            ...prev,
-            // reparse to remove bn
-            [name]: JSON.parse(JSON.stringify(value))
-          };
-        }
-        return prev;
-      }, {});
+    if (encodedArgs) {
+      const data = functionFragment.decodeArguments(encodedArgs);
+      if (data) {
+        argumentsProvided = inputs.reduce((prev, input, index) => {
+          const value = data[index];
+          const name = input.name;
+          if (name) {
+            return {
+              ...prev,
+              // reparse to remove bn
+              [name]: JSON.parse(JSON.stringify(value))
+            };
+          }
+          return prev;
+        }, {});
+      }
     }
     const call = {
       functionSignature: functionFragment.signature,
@@ -40523,13 +41055,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: {
@@ -42123,6 +42655,7 @@ Supported fuel-core version: ${supportedVersion}.`
           cacheRequestInputsResourcesFromOwner(request.inputs, this.address)
         );
         request.addResources(resources);
+        request.shiftPredicateData();
         request.updatePredicateGasUsed(estimatedPredicates);
         const requestToReestimate2 = clone_default(request);
         if (addedSignatures) {
@@ -42154,6 +42687,7 @@ Supported fuel-core version: ${supportedVersion}.`
         }
         fundingAttempts += 1;
       }
+      request.shiftPredicateData();
       request.updatePredicateGasUsed(estimatedPredicates);
       const requestToReestimate = clone_default(request);
       if (addedSignatures) {
@@ -42703,12 +43237,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;
@@ -46049,38 +46583,6 @@ Supported fuel-core version: ${supportedVersion}.`
   })(Language || {});
 
   // 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;
   }
@@ -46153,7 +46655,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];
@@ -46237,8 +46739,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");
     }
     /**
@@ -46866,7 +47368,7 @@ Supported fuel-core version: ${supportedVersion}.`
     wallet_not_unlocked: "The wallet is currently locked.",
     passphrase_not_match: "The provided passphrase did not match the expected value."
   };
-  function assert2(condition, message) {
+  function assert(condition, message) {
     if (!condition) {
       throw new FuelError(ErrorCode.WALLET_MANAGER_ERROR, message);
     }
@@ -46909,9 +47411,9 @@ Supported fuel-core version: ${supportedVersion}.`
      * the format of the return depends on the Vault type.
      */
     exportVault(vaultId) {
-      assert2(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
+      assert(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
       const vaultState = __privateGet(this, _vaults).find((_, idx) => idx === vaultId);
-      assert2(vaultState, ERROR_MESSAGES.vault_not_found);
+      assert(vaultState, ERROR_MESSAGES.vault_not_found);
       return vaultState.vault.serialize();
     }
     /**
@@ -46940,7 +47442,7 @@ Supported fuel-core version: ${supportedVersion}.`
       const vaultState = __privateGet(this, _vaults).find(
         (vs) => vs.vault.getAccounts().find((a) => a.address.equals(ownerAddress))
       );
-      assert2(vaultState, ERROR_MESSAGES.address_not_found);
+      assert(vaultState, ERROR_MESSAGES.address_not_found);
       return vaultState.vault.getWallet(ownerAddress);
     }
     /**
@@ -46948,11 +47450,11 @@ Supported fuel-core version: ${supportedVersion}.`
      */
     exportPrivateKey(address) {
       const ownerAddress = Address.fromAddressOrString(address);
-      assert2(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
+      assert(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
       const vaultState = __privateGet(this, _vaults).find(
         (vs) => vs.vault.getAccounts().find((a) => a.address.equals(ownerAddress))
       );
-      assert2(vaultState, ERROR_MESSAGES.address_not_found);
+      assert(vaultState, ERROR_MESSAGES.address_not_found);
       return vaultState.vault.exportAccount(ownerAddress);
     }
     /**
@@ -46962,7 +47464,7 @@ Supported fuel-core version: ${supportedVersion}.`
     async addAccount(options) {
       await this.loadState();
       const vaultState = __privateGet(this, _vaults)[options?.vaultId || 0];
-      await assert2(vaultState, ERROR_MESSAGES.vault_not_found);
+      await assert(vaultState, ERROR_MESSAGES.vault_not_found);
       const account = vaultState.vault.addAccount();
       await this.saveState();
       return account;
@@ -47032,7 +47534,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * Retrieve and decrypt WalletManager state from storage
      */
     async loadState() {
-      await assert2(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
+      await assert(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
       const data = await this.storage.getItem(this.STORAGE_KEY);
       if (data) {
         const state = await decrypt2(__privateGet(this, _passphrase), JSON.parse(data));
@@ -47043,7 +47545,7 @@ Supported fuel-core version: ${supportedVersion}.`
      * Store encrypted WalletManager state on storage
      */
     async saveState() {
-      await assert2(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
+      await assert(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
       const encryptedData = await encrypt2(__privateGet(this, _passphrase), {
         vaults: __privateMethod(this, _serializeVaults, serializeVaults_fn).call(this, __privateGet(this, _vaults))
       });
@@ -47055,7 +47557,7 @@ Supported fuel-core version: ${supportedVersion}.`
      */
     getVaultClass(type3) {
       const VaultClass = _WalletManager.Vaults.find((v) => v.type === type3);
-      assert2(VaultClass, ERROR_MESSAGES.invalid_vault_type);
+      assert(VaultClass, ERROR_MESSAGES.invalid_vault_type);
       return VaultClass;
     }
   };
@@ -47227,6 +47729,7 @@ Supported fuel-core version: ${supportedVersion}.`
      */
     populateTransactionPredicateData(transactionRequestLike) {
       const request = transactionRequestify(transactionRequestLike);
+      const { policies } = BaseTransactionRequest.getPolicyMeta(request);
       const placeholderIndex = this.getIndexFromPlaceholderWitness(request);
       if (placeholderIndex !== -1) {
         request.removeWitness(placeholderIndex);
@@ -47234,7 +47737,7 @@ Supported fuel-core version: ${supportedVersion}.`
       request.inputs.filter(isRequestInputResource).forEach((input) => {
         if (isRequestInputResourceFromOwner(input, this.address)) {
           input.predicate = hexlify(this.bytes);
-          input.predicateData = hexlify(this.getPredicateData());
+          input.predicateData = hexlify(this.getPredicateData(policies.length));
           input.witnessIndex = 0;
         }
       });
@@ -47260,12 +47763,17 @@ Supported fuel-core version: ${supportedVersion}.`
       const transactionRequest = transactionRequestify(transactionRequestLike);
       return super.simulateTransaction(transactionRequest, { estimateTxDependencies: false });
     }
-    getPredicateData() {
+    getPredicateData(policiesLength) {
       if (!this.predicateData.length) {
         return new Uint8Array();
       }
       const mainFn = this.interface?.functions.main;
-      return mainFn?.encodeArguments(this.predicateData) || new Uint8Array();
+      const paddedCode = new ByteArrayCoder(this.bytes.length).encode(this.bytes);
+      const VM_TX_MEMORY = calculateVmTxMemory({
+        maxInputs: this.provider.getChain().consensusParameters.txParameters.maxInputs.toNumber()
+      });
+      const OFFSET = VM_TX_MEMORY + SCRIPT_FIXED_SIZE + INPUT_COIN_FIXED_SIZE + WORD_SIZE + paddedCode.byteLength + policiesLength * WORD_SIZE;
+      return mainFn?.encodeArguments(this.predicateData, OFFSET) || new Uint8Array();
     }
     /**
      * Processes the predicate data and returns the altered bytecode and interface.
@@ -47314,7 +47822,8 @@ Supported fuel-core version: ${supportedVersion}.`
       );
       return resources.map((resource) => ({
         ...resource,
-        predicate: hexlify(this.bytes)
+        predicate: hexlify(this.bytes),
+        padPredicateData: (policiesLength) => hexlify(this.getPredicateData(policiesLength))
       }));
     }
     /**