@fuel-ts/account 0.0.0-rc-1356-20240514125020 → 0.0.0-rc-2238-20240514153703

package/dist/test-utils.global.js

@@ -32432,7 +32432,7 @@ spurious results.`);
   // ../versions/dist/index.mjs
   function getBuiltinVersions() {
     return {
-      FORC: "0.56.1",
+      FORC: "0.58.0",
       FUEL_CORE: "0.26.0",
       FUELS: "0.85.0"
     };
@@ -32933,13 +32933,6 @@ This unreleased fuel-core build may include features and updates not yet support
   };
   var DateTime = _DateTime;
   __publicField3(DateTime, "TAI64_NULL", "");
-  function sleep(time) {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve(true);
-      }, time);
-    });
-  }
   var chainConfig_default = {
     chain_name: "local_testnet",
     consensus_parameters: {
@@ -33694,9 +33687,9 @@ This unreleased fuel-core build may include features and updates not yet support
     da_block_height: 0
   };
   var defaultSnapshotConfigs = {
-    chainConfig: chainConfig_default,
-    metadata: metadata_default,
-    stateConfig: stateConfig_default
+    chainConfigJson: chainConfig_default,
+    metadataJson: metadata_default,
+    stateConfigJson: stateConfig_default
   };
   var defaultConsensusKey = "0xa449b1ffee0e2205fa924c6740cc48b3b473aa28587df6dab12abc245d1f5298";
   function isDefined(value) {
@@ -34319,72 +34312,11 @@ This unreleased fuel-core build may include features and updates not yet support
     };
   }
 
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_curry2.js
-  function _curry2(fn) {
-    return function f2(a, b) {
-      switch (arguments.length) {
-        case 0:
-          return f2;
-        case 1:
-          return _isPlaceholder(a) ? f2 : _curry1(function(_b) {
-            return fn(a, _b);
-          });
-        default:
-          return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function(_a) {
-            return fn(_a, b);
-          }) : _isPlaceholder(b) ? _curry1(function(_b) {
-            return fn(a, _b);
-          }) : fn(a, b);
-      }
-    };
-  }
-
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_curry3.js
-  function _curry3(fn) {
-    return function f3(a, b, c) {
-      switch (arguments.length) {
-        case 0:
-          return f3;
-        case 1:
-          return _isPlaceholder(a) ? f3 : _curry2(function(_b, _c) {
-            return fn(a, _b, _c);
-          });
-        case 2:
-          return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function(_a, _c) {
-            return fn(_a, b, _c);
-          }) : _isPlaceholder(b) ? _curry2(function(_b, _c) {
-            return fn(a, _b, _c);
-          }) : _curry1(function(_c) {
-            return fn(a, b, _c);
-          });
-        default:
-          return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function(_a, _b) {
-            return fn(_a, _b, c);
-          }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function(_a, _c) {
-            return fn(_a, b, _c);
-          }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function(_b, _c) {
-            return fn(a, _b, _c);
-          }) : _isPlaceholder(a) ? _curry1(function(_a) {
-            return fn(_a, b, c);
-          }) : _isPlaceholder(b) ? _curry1(function(_b) {
-            return fn(a, _b, c);
-          }) : _isPlaceholder(c) ? _curry1(function(_c) {
-            return fn(a, b, _c);
-          }) : fn(a, b, c);
-      }
-    };
-  }
-
   // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_isArray.js
   var isArray_default = Array.isArray || function _isArray(val) {
     return val != null && val.length >= 0 && Object.prototype.toString.call(val) === "[object Array]";
   };
 
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_has.js
-  function _has(prop, obj) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
-  }
-
   // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/type.js
   var type = /* @__PURE__ */ _curry1(function type2(val) {
     return val === null ? "Null" : val === void 0 ? "Undefined" : Object.prototype.toString.call(val).slice(8, -1);
@@ -34401,11 +34333,6 @@ This unreleased fuel-core build may include features and updates not yet support
     return d.getUTCFullYear() + "-" + pad(d.getUTCMonth() + 1) + "-" + pad(d.getUTCDate()) + "T" + pad(d.getUTCHours()) + ":" + pad(d.getUTCMinutes()) + ":" + pad(d.getUTCSeconds()) + "." + (d.getUTCMilliseconds() / 1e3).toFixed(3).slice(2, 5) + "Z";
   };
 
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_isObject.js
-  function _isObject(x) {
-    return Object.prototype.toString.call(x) === "[object Object]";
-  }
-
   // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/internal/_isInteger.js
   var isInteger_default = Number.isInteger || function _isInteger(n) {
     return n << 0 === n;
@@ -34519,46 +34446,6 @@ This unreleased fuel-core build may include features and updates not yet support
   });
   var clone_default = clone;
 
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/mergeWithKey.js
-  var mergeWithKey = /* @__PURE__ */ _curry3(function mergeWithKey2(fn, l, r) {
-    var result = {};
-    var k;
-    l = l || {};
-    r = r || {};
-    for (k in l) {
-      if (_has(k, l)) {
-        result[k] = _has(k, r) ? fn(k, l[k], r[k]) : l[k];
-      }
-    }
-    for (k in r) {
-      if (_has(k, r) && !_has(k, result)) {
-        result[k] = r[k];
-      }
-    }
-    return result;
-  });
-  var mergeWithKey_default = mergeWithKey;
-
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/mergeDeepWithKey.js
-  var mergeDeepWithKey = /* @__PURE__ */ _curry3(function mergeDeepWithKey2(fn, lObj, rObj) {
-    return mergeWithKey_default(function(k, lVal, rVal) {
-      if (_isObject(lVal) && _isObject(rVal)) {
-        return mergeDeepWithKey2(fn, lVal, rVal);
-      } else {
-        return fn(k, lVal, rVal);
-      }
-    }, lObj, rObj);
-  });
-  var mergeDeepWithKey_default = mergeDeepWithKey;
-
-  // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/mergeDeepRight.js
-  var mergeDeepRight = /* @__PURE__ */ _curry2(function mergeDeepRight2(lObj, rObj) {
-    return mergeDeepWithKey_default(function(k, lVal, rVal) {
-      return rVal;
-    }, lObj, rObj);
-  });
-  var mergeDeepRight_default = mergeDeepRight;
-
   // ../../node_modules/.pnpm/ramda@0.29.0/node_modules/ramda/es/trim.js
   var hasProtoTrim = typeof String.prototype.trim === "function";
 
@@ -34912,19 +34799,6 @@ 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;
@@ -34956,7 +34830,6 @@ 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;
@@ -34967,10 +34840,6 @@ 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
@@ -35001,125 +34870,6 @@ 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;
@@ -35135,7 +34885,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 concatWithDynamicData(Array.from(value).map((v) => this.coder.encode(v)));
+      return concat(Array.from(value).map((v) => this.coder.encode(v)));
     }
     decode(data, offset) {
       if (data.length < this.encodedLength || data.length > MAX_BYTES) {
@@ -35212,16 +34962,42 @@ 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]);
+    }
+    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 BooleanCoder = class extends Coder {
-    paddingLength;
     options;
     constructor(options = {
-      isSmallBytes: false,
-      isRightPadded: false
+      padToWordSize: false
     }) {
-      const paddingLength = options.isSmallBytes ? 1 : 8;
-      super("boolean", "boolean", paddingLength);
-      this.paddingLength = paddingLength;
+      const encodedLength = options.padToWordSize ? WORD_SIZE : 1;
+      super("boolean", "boolean", encodedLength);
       this.options = options;
     }
     encode(value) {
@@ -35229,73 +35005,45 @@ This unreleased fuel-core build may include features and updates not yet support
       if (!isTrueBool) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid boolean value.`);
       }
-      const output2 = toBytes2(value ? 1 : 0, this.paddingLength);
-      if (this.options.isRightPadded) {
-        return output2.reverse();
-      }
-      return output2;
+      return toBytes2(value ? 1 : 0, this.encodedLength);
     }
     decode(data, offset) {
-      if (data.length < this.paddingLength) {
+      if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean data size.`);
       }
-      let bytes2;
-      if (this.options.isRightPadded) {
-        bytes2 = data.slice(offset, offset + 1);
-      } else {
-        bytes2 = data.slice(offset, offset + this.paddingLength);
-      }
-      const decodedValue = bn(bytes2);
-      if (decodedValue.isZero()) {
-        return [false, offset + this.paddingLength];
+      const bytes2 = bn(data.slice(offset, offset + this.encodedLength));
+      if (bytes2.isZero()) {
+        return [false, offset + this.encodedLength];
       }
-      if (!decodedValue.eq(bn(1))) {
+      if (!bytes2.eq(bn(1))) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean value.`);
       }
-      return [true, offset + this.paddingLength];
+      return [true, offset + this.encodedLength];
     }
   };
-  var _getPaddedData;
-  var getPaddedData_fn;
   var ByteCoder = class extends Coder {
     constructor() {
-      super("struct", "struct Bytes", BASE_VECTOR_OFFSET);
-      __privateAdd2(this, _getPaddedData);
+      super("struct", "struct Bytes", WORD_SIZE);
     }
     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);
+      const bytes2 = value instanceof Uint8Array ? value : new Uint8Array(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
     }
     decode(data, offset) {
-      if (data.length < BASE_VECTOR_OFFSET) {
+      if (data.length < WORD_SIZE) {
         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) {
+      const offsetAndLength = offset + WORD_SIZE;
+      const lengthBytes = data.slice(offset, offsetAndLength);
+      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
+      const dataBytes = data.slice(offsetAndLength, offsetAndLength + length);
+      if (dataBytes.length !== length) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid bytes byte data size.`);
       }
-      return [byteData, offset + BASE_VECTOR_OFFSET];
+      return [dataBytes, offsetAndLength + length];
     }
   };
-  _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
@@ -35339,8 +35087,7 @@ This unreleased fuel-core build may include features and updates not yet support
       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]);
+      return new Uint8Array([...this.#caseIndexCoder.encode(caseIndex), ...encodedValue]);
     }
     #decodeNativeEnum(caseKey, newOffset) {
       return [caseKey, newOffset];
@@ -35349,10 +35096,8 @@ This unreleased fuel-core build may include features and updates not yet support
       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 caseBytes = new BigNumberCoder("u64").decode(data, offset)[0];
+      const caseIndex = toNumber(caseBytes);
       const caseKey = Object.keys(this.coders)[caseIndex];
       if (!caseKey) {
         throw new FuelError(
@@ -35361,67 +35106,35 @@ This unreleased fuel-core build may include features and updates not yet support
         );
       }
       const valueCoder = this.coders[caseKey];
-      const padding = this.#encodedValueSize - valueCoder.encodedLength;
-      newOffset += padding;
-      [decoded, newOffset] = valueCoder.decode(data, newOffset);
+      const offsetAndCase = offset + WORD_SIZE;
+      const [decoded, newOffset] = valueCoder.decode(data, offsetAndCase);
       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 option 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 void 0;
+  var getLength = (baseType) => {
+    switch (baseType) {
+      case "u8":
+        return 1;
+      case "u16":
+        return 2;
+      case "u32":
+        return 4;
+      default:
+        throw new FuelError(ErrorCode.TYPE_NOT_SUPPORTED, `Invalid number type: ${baseType}`);
     }
   };
   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(baseType, options = {
-      isSmallBytes: false,
-      isRightPadded: false
+      padToWordSize: false
     }) {
-      const paddingLength = options.isSmallBytes && baseType === "u8" ? 1 : 8;
-      super("number", baseType, paddingLength);
+      const length = options.padToWordSize ? WORD_SIZE : getLength(baseType);
+      super("number", baseType, length);
       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) {
@@ -35431,142 +35144,140 @@ 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.length) {
+      if (bytes2.length > this.encodedLength) {
         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];
+      return toBytes2(bytes2, this.encodedLength);
     }
     decode(data, offset) {
-      if (data.length < this.paddingLength) {
+      if (data.length < this.encodedLength) {
         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)) {
+      const bytes2 = data.slice(offset, offset + this.encodedLength);
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number byte data size.`);
       }
-      return [toNumber(bytes2), offset + 8];
+      return [toNumber(bytes2), offset + this.encodedLength];
     }
   };
-  var RawSliceCoder = class extends Coder {
-    constructor() {
-      super("raw untyped slice", "raw untyped slice", BASE_RAW_SLICE_OFFSET);
-    }
+  var OptionCoder = class extends EnumCoder {
     encode(value) {
-      if (!Array.isArray(value)) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+      const result = super.encode(this.toSwayOption(value));
+      return result;
+    }
+    toSwayOption(input) {
+      if (input !== void 0) {
+        return { Some: input };
       }
-      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);
+      return { None: [] };
     }
     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];
+      const [decoded, newOffset] = super.decode(data, offset);
+      return [this.toOption(decoded), newOffset];
+    }
+    toOption(output2) {
+      if (output2 && "Some" in output2) {
+        return output2.Some;
+      }
+      return void 0;
     }
   };
-  var _getPaddedData2;
-  var getPaddedData_fn2;
-  var StdStringCoder = class extends Coder {
+  var RawSliceCoder = class extends Coder {
     constructor() {
-      super("struct", "struct String", 1);
-      __privateAdd2(this, _getPaddedData2);
+      super("raw untyped slice", "raw untyped slice", WORD_SIZE);
     }
     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);
+      if (!Array.isArray(value)) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+      }
+      const internalCoder = new ArrayCoder(new NumberCoder("u8"), value.length);
+      const bytes2 = internalCoder.encode(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid std string data size.`);
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid raw slice 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 offsetAndLength = offset + WORD_SIZE;
+      const lengthBytes = data.slice(offset, offsetAndLength);
+      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
+      const dataBytes = data.slice(offsetAndLength, offsetAndLength + length);
+      if (dataBytes.length !== length) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid raw slice byte data size.`);
       }
-      const value = toUtf8String(byteData);
-      return [value, offset + BASE_VECTOR_OFFSET];
+      const internalCoder = new ArrayCoder(new NumberCoder("u8"), length);
+      const [decodedValue] = internalCoder.decode(dataBytes, 0);
+      return [decodedValue, offsetAndLength + length];
     }
   };
-  _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);
+  var StdStringCoder = class extends Coder {
+    constructor() {
+      super("struct", "struct String", WORD_SIZE);
+    }
+    encode(value) {
+      const bytes2 = toUtf8Bytes(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(value.length);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid std string data size.`);
+      }
+      const offsetAndLength = offset + WORD_SIZE;
+      const lengthBytes = data.slice(offset, offsetAndLength);
+      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
+      const dataBytes = data.slice(offsetAndLength, offsetAndLength + length);
+      if (dataBytes.length !== length) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid std string byte data size.`);
+      }
+      return [toUtf8String(dataBytes), offsetAndLength + length];
+    }
   };
   __publicField4(StdStringCoder, "memorySize", 1);
+  var StrSliceCoder = class extends Coder {
+    constructor() {
+      super("strSlice", "str", WORD_SIZE);
+    }
+    encode(value) {
+      const bytes2 = toUtf8Bytes(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(value.length);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string slice data size.`);
+      }
+      const offsetAndLength = offset + WORD_SIZE;
+      const lengthBytes = data.slice(offset, offsetAndLength);
+      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
+      const bytes2 = data.slice(offsetAndLength, offsetAndLength + length);
+      if (bytes2.length !== length) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string slice byte data size.`);
+      }
+      return [toUtf8String(bytes2), offsetAndLength + length];
+    }
+  };
+  __publicField4(StrSliceCoder, "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;
+      super("string", `str[${length}]`, length);
     }
     encode(value) {
-      if (this.length !== value.length) {
+      if (value.length !== this.encodedLength) {
         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]);
+      return toUtf8Bytes(value);
     }
     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) {
+      const bytes2 = data.slice(offset, offset + this.encodedLength);
+      if (bytes2.length !== this.encodedLength) {
         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];
+      return [toUtf8String(bytes2), offset + this.encodedLength];
     }
   };
   var StructCoder = class extends Coder {
@@ -35582,22 +35293,19 @@ This unreleased fuel-core build may include features and updates not yet support
       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)]);
+      return concatBytes2(
+        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.`
+            );
+          }
+          return fieldCoder.encode(fieldValue);
+        })
+      );
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -35608,9 +35316,6 @@ This unreleased fuel-core build may include features and updates not yet support
         const fieldCoder = this.coders[fieldName];
         let decoded;
         [decoded, newOffset] = fieldCoder.decode(data, newOffset);
-        if (!isMultipleOfWordSize(newOffset)) {
-          newOffset += getWordSizePadding(newOffset);
-        }
         obj[fieldName] = decoded;
         return obj;
       }, {});
@@ -35628,15 +35333,7 @@ This unreleased fuel-core build may include features and updates not yet support
       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;
-        })
-      );
+      return concatBytes2(this.coders.map((coder, i) => coder.encode(value[i])));
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -35646,19 +35343,19 @@ This unreleased fuel-core build may include features and updates not yet support
       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 isUint8Array = (value) => value instanceof Uint8Array;
   var VecCoder = class extends Coder {
     coder;
+    #isOptionVec;
     constructor(coder) {
-      super("struct", `struct Vec`, coder.encodedLength + BASE_VECTOR_OFFSET);
+      super("struct", `struct Vec`, coder.encodedLength + WORD_SIZE);
       this.coder = coder;
+      this.#isOptionVec = this.coder instanceof OptionCoder;
     }
     encode(value) {
       if (!Array.isArray(value) && !isUint8Array(value)) {
@@ -35667,40 +35364,39 @@ This unreleased fuel-core build may include features and updates not yet support
           `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);
+      const lengthCoder = new BigNumberCoder("u64");
+      if (isUint8Array(value)) {
+        return new Uint8Array([...lengthCoder.encode(value.length), ...value]);
+      }
+      const bytes2 = value.map((v) => this.coder.encode(v));
+      const lengthBytes = lengthCoder.encode(value.length);
+      return new Uint8Array([...lengthBytes, ...concatBytes2(bytes2)]);
     }
     decode(data, offset) {
-      if (data.length < BASE_VECTOR_OFFSET || data.length > MAX_BYTES) {
+      if (!this.#isOptionVec && (data.length < this.encodedLength || 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) {
+      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) {
         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
-      ];
+      let newOffset = offsetAndLength;
+      const chunks = [];
+      for (let i = 0; i < length; i++) {
+        const [decoded, optionOffset] = this.coder.decode(data, newOffset);
+        chunks.push(decoded);
+        newOffset = optionOffset;
+      }
+      return [chunks, newOffset];
     }
   };
   var getEncodingVersion = (encoding) => {
     switch (encoding) {
       case void 0:
-      case ENCODING_V0:
-        return ENCODING_V0;
       case ENCODING_V1:
         return ENCODING_V1;
       default:
@@ -35803,587 +35499,109 @@ This unreleased fuel-core build may include features and updates not yet support
             )
           };
         }
-        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) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid boolean value.`);
-      }
-      return toBytes2(value ? 1 : 0, this.encodedLength);
-    }
-    decode(data, offset) {
-      if (data.length < this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean data size.`);
-      }
-      const bytes2 = bn(data.slice(offset, offset + this.encodedLength));
-      if (bytes2.isZero()) {
-        return [false, offset + this.encodedLength];
-      }
-      if (!bytes2.eq(bn(1))) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean value.`);
-      }
-      return [true, offset + this.encodedLength];
-    }
-  };
-  var ByteCoder2 = class extends Coder {
-    constructor() {
-      super("struct", "struct Bytes", WORD_SIZE);
-    }
-    encode(value) {
-      const bytes2 = value instanceof Uint8Array ? value : new Uint8Array(value);
-      const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
-      return new Uint8Array([...lengthBytes, ...bytes2]);
-    }
-    decode(data, offset) {
-      if (data.length < WORD_SIZE) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid byte data size.`);
-      }
-      const offsetAndLength = offset + WORD_SIZE;
-      const lengthBytes = data.slice(offset, offsetAndLength);
-      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
-      const dataBytes = data.slice(offsetAndLength, offsetAndLength + length);
-      if (dataBytes.length !== length) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid bytes byte data size.`);
-      }
-      return [dataBytes, offsetAndLength + length];
-    }
-  };
-  __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 EnumCoder2 = 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]);
-      return new Uint8Array([...this.#caseIndexCoder.encode(caseIndex), ...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.`);
-      }
-      const caseBytes = new BigNumberCoder("u64").decode(data, offset)[0];
-      const caseIndex = toNumber(caseBytes);
-      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 offsetAndCase = offset + WORD_SIZE;
-      const [decoded, newOffset] = valueCoder.decode(data, offsetAndCase);
-      if (isFullyNativeEnum2(this.coders)) {
-        return this.#decodeNativeEnum(caseKey, newOffset);
-      }
-      return [{ [caseKey]: decoded }, newOffset];
-    }
-  };
-  var getLength = (baseType) => {
-    switch (baseType) {
-      case "u8":
-        return 1;
-      case "u16":
-        return 2;
-      case "u32":
-        return 4;
-      default:
-        throw new FuelError(ErrorCode.TYPE_NOT_SUPPORTED, `Invalid number type: ${baseType}`);
-    }
-  };
-  var NumberCoder2 = class extends Coder {
-    length;
-    baseType;
-    constructor(baseType) {
-      const length = getLength(baseType);
-      super("number", baseType, length);
-      this.baseType = baseType;
-      this.length = length;
-    }
-    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.`);
-      }
-      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.length);
-      if (bytes2.length !== this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number byte data size.`);
-      }
-      return [toNumber(bytes2), offset + this.length];
-    }
-  };
-  var OptionCoder2 = class extends EnumCoder2 {
-    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) {
-      const [decoded, newOffset] = super.decode(data, offset);
-      return [this.toOption(decoded), newOffset];
-    }
-    toOption(output2) {
-      if (output2 && "Some" in output2) {
-        return output2.Some;
-      }
-      return void 0;
-    }
-  };
-  var RawSliceCoder2 = class extends Coder {
-    constructor() {
-      super("raw untyped slice", "raw untyped slice", WORD_SIZE);
-    }
-    encode(value) {
-      if (!Array.isArray(value)) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
-      }
-      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]);
-    }
-    decode(data, offset) {
-      if (data.length < this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid raw slice data size.`);
-      }
-      const offsetAndLength = offset + WORD_SIZE;
-      const lengthBytes = data.slice(offset, offsetAndLength);
-      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
-      const dataBytes = data.slice(offsetAndLength, offsetAndLength + length);
-      if (dataBytes.length !== length) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid raw slice byte data size.`);
-      }
-      const internalCoder = new ArrayCoder(new NumberCoder2("u8"), length);
-      const [decodedValue] = internalCoder.decode(dataBytes, 0);
-      return [decodedValue, offsetAndLength + length];
-    }
-  };
-  var StdStringCoder2 = class extends Coder {
-    constructor() {
-      super("struct", "struct String", WORD_SIZE);
-    }
-    encode(value) {
-      const bytes2 = toUtf8Bytes(value);
-      const lengthBytes = new BigNumberCoder("u64").encode(value.length);
-      return new Uint8Array([...lengthBytes, ...bytes2]);
-    }
-    decode(data, offset) {
-      if (data.length < this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid std string data size.`);
-      }
-      const offsetAndLength = offset + WORD_SIZE;
-      const lengthBytes = data.slice(offset, offsetAndLength);
-      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
-      const dataBytes = data.slice(offsetAndLength, offsetAndLength + length);
-      if (dataBytes.length !== length) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid std string byte data size.`);
-      }
-      return [toUtf8String(dataBytes), offsetAndLength + length];
-    }
-  };
-  __publicField4(StdStringCoder2, "memorySize", 1);
-  var StrSliceCoder = class extends Coder {
-    constructor() {
-      super("strSlice", "str", WORD_SIZE);
-    }
-    encode(value) {
-      const bytes2 = toUtf8Bytes(value);
-      const lengthBytes = new BigNumberCoder("u64").encode(value.length);
-      return new Uint8Array([...lengthBytes, ...bytes2]);
-    }
-    decode(data, offset) {
-      if (data.length < this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string slice data size.`);
-      }
-      const offsetAndLength = offset + WORD_SIZE;
-      const lengthBytes = data.slice(offset, offsetAndLength);
-      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
-      const bytes2 = data.slice(offsetAndLength, offsetAndLength + length);
-      if (bytes2.length !== length) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string slice byte data size.`);
-      }
-      return [toUtf8String(bytes2), offsetAndLength + length];
-    }
-  };
-  __publicField4(StrSliceCoder, "memorySize", 1);
-  var StringCoder2 = class extends Coder {
-    constructor(length) {
-      super("string", `str[${length}]`, length);
-    }
-    encode(value) {
-      if (value.length !== this.encodedLength) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Value length mismatch during encode.`);
-      }
-      return toUtf8Bytes(value);
-    }
-    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.encodedLength);
-      if (bytes2.length !== this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string byte data size.`);
-      }
-      return [toUtf8String(bytes2), offset + this.encodedLength];
-    }
-  };
-  var StructCoder2 = 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) {
-      return concatBytes2(
-        Object.keys(this.coders).map((fieldName) => {
-          const fieldCoder = this.coders[fieldName];
-          const fieldValue = value[fieldName];
-          if (!(fieldCoder instanceof OptionCoder2) && fieldValue == null) {
-            throw new FuelError(
-              ErrorCode.ENCODE_ERROR,
-              `Invalid ${this.type}. Field "${fieldName}" not present.`
-            );
-          }
-          return fieldCoder.encode(fieldValue);
-        })
-      );
-    }
-    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);
-        obj[fieldName] = decoded;
-        return obj;
-      }, {});
-      return [decodedValue, newOffset];
-    }
-  };
-  var TupleCoder2 = 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 concatBytes2(this.coders.map((coder, i) => coder.encode(value[i])));
+        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;
+      });
     }
-    decode(data, offset) {
-      if (data.length < this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid tuple data size.`);
+    static getImplicitGenericTypeParameters(abi, args, implicitGenericParametersParam) {
+      if (!Array.isArray(args)) {
+        return null;
       }
-      let newOffset = offset;
-      const decodedValue = this.coders.map((coder) => {
-        let decoded;
-        [decoded, newOffset] = coder.decode(data, newOffset);
-        return decoded;
+      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 [decodedValue, newOffset];
+      return implicitGenericParameters.length > 0 ? implicitGenericParameters : null;
     }
-  };
-  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 OptionCoder2;
+    getSignature() {
+      const prefix = this.getArgSignaturePrefix();
+      const content = this.getArgSignatureContent();
+      return `${prefix}${content}`;
     }
-    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.`
-        );
+    getArgSignaturePrefix() {
+      const structMatch = structRegEx.test(this.type);
+      if (structMatch) {
+        return "s";
       }
-      const lengthCoder = new BigNumberCoder("u64");
-      if (isUint8Array(value)) {
-        return new Uint8Array([...lengthCoder.encode(value.length), ...value]);
+      const arrayMatch = arrayRegEx.test(this.type);
+      if (arrayMatch) {
+        return "a";
       }
-      const bytes2 = value.map((v) => this.coder.encode(v));
-      const lengthBytes = lengthCoder.encode(value.length);
-      return new Uint8Array([...lengthBytes, ...concatBytes2(bytes2)]);
+      const enumMatch = enumRegEx.test(this.type);
+      if (enumMatch) {
+        return "e";
+      }
+      return "";
     }
-    decode(data, offset) {
-      if (!this.#isOptionVec && (data.length < this.encodedLength || data.length > MAX_BYTES)) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec data size.`);
+    getArgSignatureContent() {
+      if (this.type === "raw untyped ptr") {
+        return "rawptr";
       }
-      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) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec byte data size.`);
+      if (this.type === "raw untyped slice") {
+        return "rawslice";
       }
-      let newOffset = offsetAndLength;
-      const chunks = [];
-      for (let i = 0; i < length; i++) {
-        const [decoded, optionOffset] = this.coder.decode(data, newOffset);
-        chunks.push(decoded);
-        newOffset = optionOffset;
+      const strMatch = stringRegEx.exec(this.type)?.groups;
+      if (strMatch) {
+        return `str[${strMatch.length}]`;
       }
-      return [chunks, newOffset];
+      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}`;
     }
   };
-  var getCoder2 = (resolvedAbiType, _options) => {
+  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) => {
     switch (resolvedAbiType.type) {
       case U8_CODER_TYPE:
       case U16_CODER_TYPE:
       case U32_CODER_TYPE:
-        return new NumberCoder2(resolvedAbiType.type);
+        return new NumberCoder(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 RawSliceCoder2();
+        return new RawSliceCoder();
       case BOOL_CODER_TYPE:
-        return new BooleanCoder2();
+        return new BooleanCoder();
       case B256_CODER_TYPE:
         return new B256Coder();
       case B512_CODER_TYPE:
         return new B512Coder();
       case BYTES_CODER_TYPE:
-        return new ByteCoder2();
+        return new ByteCoder();
       case STD_STRING_CODER_TYPE:
-        return new StdStringCoder2();
+        return new StdStringCoder();
       case STR_SLICE_CODER_TYPE:
         return new StrSliceCoder();
       default:
@@ -36392,7 +35610,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 StringCoder2(length);
+      return new StringCoder(length);
     }
     const components = resolvedAbiType.components;
     const arrayMatch = arrayRegEx.exec(resolvedAbiType.type)?.groups;
@@ -36405,46 +35623,42 @@ 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 = getCoder2(arg, { isSmallBytes: true });
+      const arrayElementCoder = getCoder(arg);
       return new ArrayCoder(arrayElementCoder, length);
     }
     if (resolvedAbiType.type === VEC_CODER_TYPE) {
       const arg = findVectorBufferArgument(components);
       const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
-      const itemCoder = getCoder2(argType, { isSmallBytes: true, encoding: ENCODING_V0 });
-      return new VecCoder2(itemCoder);
+      const itemCoder = getCoder(argType, { encoding: ENCODING_V1 });
+      return new VecCoder(itemCoder);
     }
     const structMatch = structRegEx.exec(resolvedAbiType.type)?.groups;
     if (structMatch) {
-      const coders = getCoders(components, { isRightPadded: true, getCoder: getCoder2 });
-      return new StructCoder2(structMatch.name, coders);
+      const coders = getCoders(components, { getCoder });
+      return new StructCoder(structMatch.name, coders);
     }
     const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
     if (enumMatch) {
-      const coders = getCoders(components, { getCoder: getCoder2 });
+      const coders = getCoders(components, { getCoder });
       const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
       if (isOptionEnum) {
-        return new OptionCoder2(enumMatch.name, coders);
+        return new OptionCoder(enumMatch.name, coders);
       }
-      return new EnumCoder2(enumMatch.name, coders);
+      return new EnumCoder(enumMatch.name, coders);
     }
     const tupleMatch = tupleRegEx.exec(resolvedAbiType.type)?.groups;
     if (tupleMatch) {
-      const coders = components.map(
-        (component) => getCoder2(component, { isRightPadded: true, encoding: ENCODING_V0 })
-      );
-      return new TupleCoder2(coders);
+      const coders = components.map((component) => getCoder(component, { encoding: ENCODING_V1 }));
+      return new TupleCoder(coders);
     }
     throw new FuelError(
       ErrorCode.CODER_NOT_FOUND,
       `Coder not found: ${JSON.stringify(resolvedAbiType)}.`
     );
   };
-  function getCoderForEncoding(encoding = ENCODING_V0) {
+  function getCoderForEncoding(encoding = ENCODING_V1) {
     switch (encoding) {
       case ENCODING_V1:
-        return getCoder2;
-      case ENCODING_V0:
         return getCoder;
       default:
         throw new FuelError(
@@ -36455,7 +35669,7 @@ This unreleased fuel-core build may include features and updates not yet support
   }
   var AbiCoder = class {
     static getCoder(abi, argument, options = {
-      isSmallBytes: false
+      padToWordSize: false
     }) {
       const resolvedAbiType = new ResolvedAbiType(abi, argument);
       return getCoderForEncoding(options.encoding)(resolvedAbiType, options);
@@ -36475,8 +35689,6 @@ 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;
@@ -36484,13 +35696,8 @@ 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 StdStringCoder2().encode(name);
+      this.selectorBytes = new StdStringCoder().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) {
@@ -36503,29 +35710,7 @@ 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);
     }
-    #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) {
+    encodeArguments(values) {
       FunctionFragment.verifyArgsAndInputsAlign(values, this.jsonFn.inputs, this.jsonAbi);
       const shallowCopyValues = values.slice();
       const nonEmptyInputs = findNonEmptyInputs(this.jsonAbi, this.jsonFn.inputs);
@@ -36535,15 +35720,10 @@ 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
         })
       );
-      if (this.encoding === ENCODING_V1) {
-        return new TupleCoder2(coders).encode(shallowCopyValues);
-      }
-      const results = new TupleCoder(coders).encode(shallowCopyValues);
-      return unpackDynamicData(results, offset, results.byteLength);
+      return new TupleCoder(coders).encode(shallowCopyValues);
     }
     static verifyArgsAndInputsAlign(args, inputs, abi) {
       if (args.length === inputs.length) {
@@ -36652,9 +35832,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, offset = 0) {
+    encodeFunctionData(functionFragment, values) {
       const fragment = typeof functionFragment === "string" ? this.getFunction(functionFragment) : functionFragment;
-      return fragment.encodeArguments(values, offset);
+      return fragment.encodeArguments(values);
     }
     // Decode the result of a function call
     decodeFunctionResult(functionFragment, data) {
@@ -36682,9 +35862,7 @@ This unreleased fuel-core build may include features and updates not yet support
         );
       }
       return AbiCoder.encode(this.jsonAbi, configurable.configurableType, value, {
-        isRightPadded: true,
-        // TODO: Review support for configurables in v1 encoding when it becomes available
-        encoding: ENCODING_V0
+        encoding: this.encoding
       });
     }
     getTypeById(typeId) {
@@ -36734,8 +35912,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"),
-        txIndex: new NumberCoder("u16")
+        blockHeight: new NumberCoder("u32", { padToWordSize: true }),
+        txIndex: new NumberCoder("u16", { padToWordSize: true })
       });
     }
   };
@@ -36752,12 +35930,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").encode(value.outputIndex));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).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").encode(value.witnessIndex));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).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));
@@ -36772,7 +35950,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").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const outputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const owner = decoded;
@@ -36782,7 +35960,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").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const witnessIndex = Number(decoded);
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateGasUsed = decoded;
@@ -36821,7 +35999,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").encode(value.outputIndex));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputIndex));
       parts.push(new B256Coder().encode(value.balanceRoot));
       parts.push(new B256Coder().encode(value.stateRoot));
       parts.push(new TxPointerCoder().encode(value.txPointer));
@@ -36833,7 +36011,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").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const outputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const balanceRoot = decoded;
@@ -36882,7 +36060,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").encode(value.witnessIndex));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).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));
@@ -36911,11 +36089,11 @@ 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").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const witnessIndex = Number(decoded);
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateGasUsed = decoded;
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
       const dataLength2 = decoded;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateLength = decoded;
@@ -36953,7 +36131,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8").encode(value.type));
+      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.type));
       const { type: type3 } = value;
       switch (type3) {
         case 0: {
@@ -36980,7 +36158,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").decode(data, o);
+      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
@@ -37049,7 +36227,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8").encode(value.inputIndex));
+      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.inputIndex));
       parts.push(new B256Coder().encode(value.balanceRoot));
       parts.push(new B256Coder().encode(value.stateRoot));
       return concat(parts);
@@ -37057,7 +36235,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").decode(data, o);
+      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
       const inputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const balanceRoot = decoded;
@@ -37169,7 +36347,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8").encode(value.type));
+      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.type));
       const { type: type3 } = value;
       switch (type3) {
         case 0: {
@@ -37204,7 +36382,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").decode(data, o);
+      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
@@ -37272,7 +36450,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").encode(data));
+            parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(data));
             break;
           default: {
             throw new FuelError(ErrorCode.INVALID_POLICY_TYPE, `Invalid policy type: ${type3}`);
@@ -37295,7 +36473,10 @@ 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").decode(data, o);
+        const [maturity, nextOffset] = new NumberCoder("u32", { padToWordSize: true }).decode(
+          data,
+          o
+        );
         o = nextOffset;
         policies.push({ type: 4, data: maturity });
       }
@@ -37342,7 +36523,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").encode(value.data.length));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.data.length));
       parts.push(new B256Coder().encode(value.digest));
       parts.push(new ByteArrayCoder(value.data.length).encode(value.data));
       return concat(parts);
@@ -37358,7 +36539,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").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const len = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const digest = decoded;
@@ -37482,11 +36663,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").encode(type3));
+      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(type3));
       switch (type3) {
         case 0: {
           const data = upgradePurposeType.data;
-          parts.push(new NumberCoder("u16").encode(data.witnessIndex));
+          parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(data.witnessIndex));
           parts.push(new B256Coder().encode(data.checksum));
           break;
         }
@@ -37507,11 +36688,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").decode(data, o);
+      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
-          [decoded, o] = new NumberCoder("u16").decode(data, o);
+          [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
           const witnessIndex = decoded;
           [decoded, o] = new B256Coder().decode(data, o);
           const checksum = decoded;
@@ -37542,14 +36723,14 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u32").encode(value.dataLength));
+      parts.push(new NumberCoder("u32", { padToWordSize: true }).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").decode(data, o);
+      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
       const dataLength2 = decoded;
       [decoded, o] = new ByteArrayCoder(dataLength2).decode(data, o);
       const witnessData = decoded;
@@ -37580,10 +36761,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").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 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 ByteArrayCoder(value.scriptLength.toNumber()).encode(value.script));
       parts.push(new ByteArrayCoder(value.scriptDataLength.toNumber()).encode(value.scriptData));
       parts.push(new PoliciesCoder().encode(value.policies));
@@ -37603,13 +36784,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").decode(data, o);
+      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
       const policyTypes = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const inputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const outputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const witnessesCount = decoded;
       [decoded, o] = new ByteArrayCoder(scriptLength.toNumber()).decode(data, o);
       const script = decoded;
@@ -37651,13 +36832,13 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u16").encode(value.bytecodeWitnessIndex));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.bytecodeWitnessIndex));
       parts.push(new B256Coder().encode(value.salt));
       parts.push(new BigNumberCoder("u64").encode(value.storageSlotsCount));
-      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 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 ArrayCoder(new StorageSlotCoder(), value.storageSlotsCount.toNumber()).encode(
           value.storageSlots
@@ -37672,19 +36853,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").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).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").decode(data, o);
+      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
       const policyTypes = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const inputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const outputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const witnessesCount = decoded;
       [decoded, o] = new ArrayCoder(new StorageSlotCoder(), storageSlotsCount.toNumber()).decode(
         data,
@@ -37898,7 +37079,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8").encode(value.type));
+      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.type));
       const { type: type3 } = value;
       switch (value.type) {
         case 0: {
@@ -37941,7 +37122,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").decode(data, o);
+      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
@@ -42954,6 +42135,15 @@ ${MessageCoinFragmentDoc}`;
     return normalize2(clone_default(root));
   }
 
+  // src/providers/utils/sleep.ts
+  function sleep(time) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(true);
+      }, time);
+    });
+  }
+
   // src/providers/utils/extract-tx-error.ts
   var assemblePanicError = (status) => {
     let errorMessage = `The transaction reverted with reason: "${status.reason}".`;
@@ -43567,15 +42757,6 @@ ${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
@@ -44040,37 +43221,27 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   };
 
   // src/providers/transaction-summary/call.ts
-  var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
+  var getFunctionCall = ({ abi, receipt }) => {
     const abiInterface = new Interface(abi);
     const callFunctionSelector = receipt.param1.toHex(8);
     const functionFragment = abiInterface.getFunction(callFunctionSelector);
     const inputs = functionFragment.jsonFn.inputs;
-    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();
-    }
+    const encodedArgs = receipt.param2.toHex();
     let argumentsProvided;
-    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 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,
@@ -46347,7 +45518,6 @@ 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) {
@@ -46379,7 +45549,6 @@ Supported fuel-core version: ${supportedVersion}.`
         }
         fundingAttempts += 1;
       }
-      request.shiftPredicateData();
       request.updatePredicateGasUsed(estimatedPredicates);
       const requestToReestimate = clone_default(request);
       if (addedSignatures) {
@@ -51015,40 +50184,6 @@ Supported fuel-core version: ${supportedVersion}.`
       }
     }
   };
-  function getFinalStateConfigJSON({ stateConfig, chainConfig }) {
-    const defaultCoins = defaultSnapshotConfigs.stateConfig.coins.map((coin) => ({
-      ...coin,
-      amount: "18446744073709551615"
-    }));
-    const defaultMessages = defaultSnapshotConfigs.stateConfig.messages.map((message) => ({
-      ...message,
-      amount: "18446744073709551615"
-    }));
-    const coins = defaultCoins.concat(stateConfig.coins.map((coin) => ({ ...coin, amount: coin.amount.toString() }))).filter((coin, index, self2) => self2.findIndex((c) => c.tx_id === coin.tx_id) === index);
-    const messages = defaultMessages.concat(stateConfig.messages.map((msg) => ({ ...msg, amount: msg.amount.toString() }))).filter((msg, index, self2) => self2.findIndex((m) => m.nonce === msg.nonce) === index);
-    if (!process.env.GENESIS_SECRET) {
-      const pk = Signer.generatePrivateKey();
-      const signer = new Signer(pk);
-      process.env.GENESIS_SECRET = hexlify(pk);
-      coins.push({
-        tx_id: hexlify(randomBytes22(UTXO_ID_LEN)),
-        owner: signer.address.toHexString(),
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        amount: "18446744073709551615",
-        asset_id: chainConfig.consensus_parameters.V1.base_asset_id,
-        output_index: 0,
-        tx_pointer_block_height: 0,
-        tx_pointer_tx_idx: 0
-      });
-    }
-    const json = JSON.stringify({
-      ...stateConfig,
-      coins,
-      messages
-    });
-    const regexMakeNumber = /("amount":)"(\d+)"/gm;
-    return json.replace(regexMakeNumber, "$1$2");
-  }
   var launchNode = async ({
     ip,
     port,
@@ -51056,8 +50191,7 @@ Supported fuel-core version: ${supportedVersion}.`
     useSystemFuelCore = false,
     loggingEnabled = true,
     debugEnabled = false,
-    basePath,
-    snapshotConfig = defaultSnapshotConfigs
+    basePath
   }) => (
     // eslint-disable-next-line no-async-promise-executor
     new Promise(async (resolve, reject) => {
@@ -51086,23 +50220,56 @@ Supported fuel-core version: ${supportedVersion}.`
       let snapshotDirToUse;
       const prefix = basePath || import_os.default.tmpdir();
       const suffix = basePath ? "" : (0, import_crypto19.randomUUID)();
-      const tempDir = import_path8.default.join(prefix, ".fuels", suffix, "snapshotDir");
+      const tempDirPath = import_path8.default.join(prefix, ".fuels", suffix, "snapshotDir");
       if (snapshotDir) {
         snapshotDirToUse = snapshotDir;
       } else {
-        if (!(0, import_fs2.existsSync)(tempDir)) {
-          (0, import_fs2.mkdirSync)(tempDir, { recursive: true });
-        }
-        const { metadata } = snapshotConfig;
-        const metadataPath = import_path8.default.join(tempDir, "metadata.json");
-        const chainConfigPath = import_path8.default.join(tempDir, metadata.chain_config);
-        const stateConfigPath = import_path8.default.join(tempDir, metadata.table_encoding.Json.filepath);
-        const stateTransitionPath = import_path8.default.join(tempDir, "state_transition_bytecode.wasm");
-        (0, import_fs2.writeFileSync)(chainConfigPath, JSON.stringify(snapshotConfig.chainConfig), "utf8");
-        (0, import_fs2.writeFileSync)(stateConfigPath, getFinalStateConfigJSON(snapshotConfig), "utf8");
-        (0, import_fs2.writeFileSync)(metadataPath, JSON.stringify(metadata), "utf8");
-        (0, import_fs2.writeFileSync)(stateTransitionPath, JSON.stringify(""));
-        snapshotDirToUse = tempDir;
+        if (!(0, import_fs2.existsSync)(tempDirPath)) {
+          (0, import_fs2.mkdirSync)(tempDirPath, { recursive: true });
+        }
+        let { stateConfigJson } = defaultSnapshotConfigs;
+        const { chainConfigJson, metadataJson } = defaultSnapshotConfigs;
+        stateConfigJson = {
+          ...stateConfigJson,
+          coins: [
+            ...stateConfigJson.coins.map((coin) => ({
+              ...coin,
+              amount: "18446744073709551615"
+            }))
+          ],
+          messages: stateConfigJson.messages.map((message) => ({
+            ...message,
+            amount: "18446744073709551615"
+          }))
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        };
+        if (!process.env.GENESIS_SECRET) {
+          const pk = Signer.generatePrivateKey();
+          const signer = new Signer(pk);
+          process.env.GENESIS_SECRET = hexlify(pk);
+          stateConfigJson.coins.push({
+            tx_id: hexlify(randomBytes22(UTXO_ID_LEN)),
+            owner: signer.address.toHexString(),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            amount: "18446744073709551615",
+            asset_id: chainConfigJson.consensus_parameters.V1.base_asset_id,
+            output_index: 0,
+            tx_pointer_block_height: 0,
+            tx_pointer_tx_idx: 0
+          });
+        }
+        let fixedStateConfigJSON = JSON.stringify(stateConfigJson);
+        const regexMakeNumber = /("amount":)"(\d+)"/gm;
+        fixedStateConfigJSON = fixedStateConfigJSON.replace(regexMakeNumber, "$1$2");
+        const chainConfigWritePath = import_path8.default.join(tempDirPath, "chainConfig.json");
+        const stateConfigWritePath = import_path8.default.join(tempDirPath, "stateConfig.json");
+        const metadataWritePath = import_path8.default.join(tempDirPath, "metadata.json");
+        const stateTransitionWritePath = import_path8.default.join(tempDirPath, "state_transition_bytecode.wasm");
+        (0, import_fs2.writeFileSync)(chainConfigWritePath, JSON.stringify(chainConfigJson), "utf8");
+        (0, import_fs2.writeFileSync)(stateConfigWritePath, fixedStateConfigJSON, "utf8");
+        (0, import_fs2.writeFileSync)(metadataWritePath, JSON.stringify(metadataJson), "utf8");
+        (0, import_fs2.writeFileSync)(stateTransitionWritePath, JSON.stringify(""));
+        snapshotDirToUse = tempDirPath;
       }
       const child = (0, import_child_process.spawn)(
         command,
@@ -51110,7 +50277,7 @@ Supported fuel-core version: ${supportedVersion}.`
           "run",
           ["--ip", ipToUse],
           ["--port", portToUse],
-          useInMemoryDb ? ["--db-type", "in-memory"] : ["--db-path", tempDir],
+          useInMemoryDb ? ["--db-type", "in-memory"] : ["--db-path", tempDirPath],
           ["--min-gas-price", "1"],
           poaInstant ? ["--poa-instant", "true"] : [],
           ["--consensus-key", consensusKey],
@@ -51132,28 +50299,23 @@ Supported fuel-core version: ${supportedVersion}.`
       }
       const cleanupConfig = {
         child,
-        configPath: tempDir,
+        configPath: tempDirPath,
         killFn: import_tree_kill.default,
         state: {
           isDead: false
         }
       };
       child.stderr.on("data", (chunk) => {
-        const text = typeof chunk === "string" ? chunk : chunk.toString();
-        if (text.indexOf(graphQLStartSubstring) !== -1) {
-          const rows = text.split("\n");
-          const rowWithUrl = rows.find((row) => row.indexOf(graphQLStartSubstring) !== -1);
-          const [realIp, realPort] = rowWithUrl.split(" ").at(-1).trim().split(":");
+        if (chunk.indexOf(graphQLStartSubstring) !== -1) {
           resolve({
             cleanup: () => killNode(cleanupConfig),
-            ip: realIp,
-            port: realPort,
-            url: `http://${realIp}:${realPort}/v1/graphql`,
+            ip: ipToUse,
+            port: portToUse,
             snapshotDir: snapshotDirToUse
           });
         }
-        if (/error/i.test(text)) {
-          reject(text.toString());
+        if (/error/i.test(chunk)) {
+          reject(chunk.toString());
         }
       });
       process.on("exit", () => killNode(cleanupConfig));
@@ -51186,215 +50348,6 @@ Supported fuel-core version: ${supportedVersion}.`
     };
     return { wallets, stop: cleanup, provider };
   };
-
-  // src/test-utils/asset-id.ts
-  var _AssetId = class {
-    constructor(value) {
-      this.value = value;
-    }
-    static random() {
-      return new _AssetId(hexlify(randomBytes22(32)));
-    }
-  };
-  var AssetId = _AssetId;
-  __publicField(AssetId, "A", new _AssetId(
-    "0x0101010101010101010101010101010101010101010101010101010101010101"
-  ));
-  __publicField(AssetId, "B", new _AssetId(
-    "0x0202020202020202020202020202020202020202020202020202020202020202"
-  ));
-
-  // src/test-utils/wallet-config.ts
-  var WalletConfig = class {
-    initialState;
-    options;
-    wallets;
-    generateWallets = () => {
-      const generatedWallets = [];
-      for (let index = 1; index <= this.options.count; index++) {
-        generatedWallets.push(new WalletUnlocked(randomBytes22(32)));
-      }
-      return generatedWallets;
-    };
-    constructor(baseAssetId, config) {
-      const BASE_ASSET_ID = baseAssetId.startsWith("0x") ? baseAssetId : `0x${baseAssetId}`;
-      WalletConfig.guard(config);
-      this.options = config;
-      const { assets: assets2, coinsPerAsset, amountPerCoin, messages } = this.options;
-      this.wallets = this.generateWallets();
-      this.initialState = {
-        messages: WalletConfig.createMessages(this.wallets, messages),
-        coins: WalletConfig.createCoins(
-          this.wallets,
-          BASE_ASSET_ID,
-          assets2,
-          coinsPerAsset,
-          amountPerCoin
-        )
-      };
-    }
-    apply(snapshotConfig) {
-      return {
-        ...snapshotConfig,
-        stateConfig: {
-          ...snapshotConfig?.stateConfig ?? defaultSnapshotConfigs.stateConfig,
-          coins: this.initialState.coins.concat(snapshotConfig?.stateConfig?.coins || []),
-          messages: this.initialState.messages.concat(snapshotConfig?.stateConfig?.messages ?? [])
-        }
-      };
-    }
-    static createMessages(wallets, messages) {
-      return messages.map((msg) => wallets.map((wallet) => msg.toChainMessage(wallet.address))).flatMap((x) => x);
-    }
-    static createCoins(wallets, baseAssetId, assets2, coinsPerAsset, amountPerCoin) {
-      const coins = [];
-      let assetIds = [baseAssetId];
-      if (Array.isArray(assets2)) {
-        assetIds = assetIds.concat(assets2.map((a) => a.value));
-      } else {
-        for (let index = 0; index < assets2 - 1; index++) {
-          assetIds.push(AssetId.random().value);
-        }
-      }
-      wallets.map((wallet) => wallet.address.toHexString()).forEach((walletAddress) => {
-        assetIds.forEach((assetId) => {
-          for (let index = 0; index < coinsPerAsset; index++) {
-            coins.push({
-              amount: amountPerCoin,
-              asset_id: assetId,
-              owner: walletAddress,
-              tx_pointer_block_height: 0,
-              tx_pointer_tx_idx: 0,
-              output_index: 0,
-              tx_id: hexlify(randomBytes22(32))
-            });
-          }
-        });
-      });
-      return coins;
-    }
-    static guard({
-      count: wallets,
-      assets: assets2,
-      coinsPerAsset,
-      amountPerCoin
-    }) {
-      if (Array.isArray(wallets) && wallets.length === 0 || typeof wallets === "number" && wallets <= 0) {
-        throw new FuelError(
-          FuelError.CODES.INVALID_INPUT_PARAMETERS,
-          "Number of wallets must be greater than zero."
-        );
-      }
-      if (Array.isArray(assets2) && assets2.length === 0 || typeof assets2 === "number" && assets2 <= 0) {
-        throw new FuelError(
-          FuelError.CODES.INVALID_INPUT_PARAMETERS,
-          "Number of assets per wallet must be greater than zero."
-        );
-      }
-      if (coinsPerAsset <= 0) {
-        throw new FuelError(
-          FuelError.CODES.INVALID_INPUT_PARAMETERS,
-          "Number of coins per asset must be greater than zero."
-        );
-      }
-      if (amountPerCoin <= 0) {
-        throw new FuelError(
-          FuelError.CODES.INVALID_INPUT_PARAMETERS,
-          "Amount per coin must be greater than zero."
-        );
-      }
-    }
-  };
-
-  // src/test-utils/setup-test-provider-and-wallets.ts
-  var defaultWalletConfigOptions = {
-    count: 2,
-    assets: [AssetId.A, AssetId.B],
-    coinsPerAsset: 1,
-    amountPerCoin: 1e10,
-    messages: []
-  };
-  async function setupTestProviderAndWallets({
-    walletConfig: walletConfigOptions = {},
-    providerOptions,
-    nodeOptions = {}
-  } = {}) {
-    Symbol.dispose ??= Symbol("Symbol.dispose");
-    const walletConfig = new WalletConfig(
-      nodeOptions.snapshotConfig?.chainConfig?.consensus_parameters?.V1?.base_asset_id ?? defaultSnapshotConfigs.chainConfig.consensus_parameters.V1.base_asset_id,
-      {
-        ...defaultWalletConfigOptions,
-        ...walletConfigOptions
-      }
-    );
-    const { cleanup, url } = await launchNode({
-      loggingEnabled: false,
-      ...nodeOptions,
-      snapshotConfig: mergeDeepRight_default(
-        defaultSnapshotConfigs,
-        walletConfig.apply(nodeOptions?.snapshotConfig)
-      ),
-      port: "0"
-    });
-    let provider;
-    try {
-      provider = await Provider.create(url, providerOptions);
-    } catch (err) {
-      cleanup();
-      throw err;
-    }
-    const wallets = walletConfig.wallets;
-    wallets.forEach((wallet) => {
-      wallet.connect(provider);
-    });
-    return {
-      provider,
-      wallets,
-      cleanup,
-      [Symbol.dispose]: cleanup
-    };
-  }
-
-  // src/test-utils/test-message.ts
-  var TestMessage = class {
-    sender;
-    recipient;
-    nonce;
-    amount;
-    data;
-    da_height;
-    /**
-     * A helper class to create messages for testing purposes.
-     *
-     * Used in tandem with `WalletConfig`.
-     * It can also be used standalone and passed into the initial state of a chain via the `.toChainMessage` method.
-     */
-    constructor({
-      sender = Address.fromRandom(),
-      recipient = Address.fromRandom(),
-      nonce = hexlify(randomBytes22(32)),
-      amount = 1e6,
-      data = "02",
-      da_height = 0
-    } = {}) {
-      this.sender = sender;
-      this.recipient = recipient;
-      this.nonce = nonce;
-      this.amount = amount;
-      this.data = data;
-      this.da_height = da_height;
-    }
-    toChainMessage(recipient) {
-      return {
-        sender: this.sender.toB256(),
-        recipient: recipient?.toB256() ?? this.recipient.toB256(),
-        nonce: this.nonce,
-        amount: bn(this.amount).toNumber(),
-        data: this.data,
-        da_height: this.da_height
-      };
-    }
-  };
 })();
 /*! Bundled license information: