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

package/dist/test-utils.global.js

@@ -32432,7 +32432,7 @@ spurious results.`);
   // ../versions/dist/index.mjs
   function getBuiltinVersions() {
     return {
-      FORC: "0.58.0",
+      FORC: "0.56.1",
       FUEL_CORE: "0.26.0",
       FUELS: "0.85.0"
     };
@@ -32933,6 +32933,13 @@ 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: {
@@ -33687,9 +33694,9 @@ This unreleased fuel-core build may include features and updates not yet support
     da_block_height: 0
   };
   var defaultSnapshotConfigs = {
-    chainConfigJson: chainConfig_default,
-    metadataJson: metadata_default,
-    stateConfigJson: stateConfig_default
+    chainConfig: chainConfig_default,
+    metadata: metadata_default,
+    stateConfig: stateConfig_default
   };
   var defaultConsensusKey = "0xa449b1ffee0e2205fa924c6740cc48b3b473aa28587df6dab12abc245d1f5298";
   function isDefined(value) {
@@ -34312,11 +34319,72 @@ 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);
@@ -34333,6 +34401,11 @@ 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;
@@ -34446,6 +34519,46 @@ 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";
 
@@ -34799,6 +34912,19 @@ This unreleased fuel-core build may include features and updates not yet support
     __defNormalProp4(obj, typeof key !== "symbol" ? key + "" : key, value);
     return value;
   };
+  var __accessCheck2 = (obj, member, msg) => {
+    if (!member.has(obj))
+      throw TypeError("Cannot " + msg);
+  };
+  var __privateAdd2 = (obj, member, value) => {
+    if (member.has(obj))
+      throw TypeError("Cannot add the same private member more than once");
+    member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  };
+  var __privateMethod2 = (obj, member, method) => {
+    __accessCheck2(obj, member, "access private method");
+    return method;
+  };
   var Coder = class {
     name;
     type;
@@ -34830,6 +34956,7 @@ This unreleased fuel-core build may include features and updates not yet support
   var enumRegEx = /^enum (?<name>\w+)$/;
   var tupleRegEx = /^\((?<items>.*)\)$/;
   var genericRegEx = /^generic (?<name>\w+)$/;
+  var ENCODING_V0 = "0";
   var ENCODING_V1 = "1";
   var WORD_SIZE = 8;
   var BYTES_32 = 32;
@@ -34840,6 +34967,10 @@ This unreleased fuel-core build may include features and updates not yet support
   var TX_LEN = WORD_SIZE * 4;
   var TX_POINTER_LEN = WORD_SIZE * 2;
   var MAX_BYTES = 2 ** 32 - 1;
+  var calculateVmTxMemory = ({ maxInputs }) => BYTES_32 + // Tx ID
+  ASSET_ID_LEN + // Base asset ID
+  // Asset ID/Balance coin input pairs
+  maxInputs * (ASSET_ID_LEN + WORD_SIZE) + WORD_SIZE;
   var SCRIPT_FIXED_SIZE = WORD_SIZE + // Identifier
   WORD_SIZE + // Gas limit
   WORD_SIZE + // Script size
@@ -34870,6 +35001,125 @@ This unreleased fuel-core build may include features and updates not yet support
   WORD_SIZE + // Predicate size
   WORD_SIZE + // Predicate data size
   WORD_SIZE;
+  var encodedLengths = {
+    u64: WORD_SIZE,
+    u256: WORD_SIZE * 4
+  };
+  var BigNumberCoder = class extends Coder {
+    constructor(baseType) {
+      super("bigNumber", baseType, encodedLengths[baseType]);
+    }
+    encode(value) {
+      let bytes2;
+      try {
+        bytes2 = toBytes2(value, this.encodedLength);
+      } catch (error) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.type}.`);
+      }
+      return bytes2;
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} data size.`);
+      }
+      let bytes2 = data.slice(offset, offset + this.encodedLength);
+      bytes2 = bytes2.slice(0, this.encodedLength);
+      if (bytes2.length !== this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} byte data size.`);
+      }
+      return [bn(bytes2), offset + this.encodedLength];
+    }
+  };
+  var VEC_PROPERTY_SPACE = 3;
+  var BASE_VECTOR_OFFSET = VEC_PROPERTY_SPACE * WORD_SIZE;
+  var RAW_SLICE_PROPERTY_SPACE = 2;
+  var BASE_RAW_SLICE_OFFSET = RAW_SLICE_PROPERTY_SPACE * WORD_SIZE;
+  function concatWithDynamicData(items) {
+    const topLevelData = {};
+    let totalIndex = 0;
+    const objects = items.map((item) => {
+      const dynamicData = item.dynamicData;
+      if (dynamicData) {
+        Object.entries(dynamicData).forEach(([pointerIndex, vData]) => {
+          topLevelData[parseInt(pointerIndex, 10) + totalIndex] = vData;
+        });
+      }
+      const byteArray = arrayify(item);
+      totalIndex += byteArray.byteLength / WORD_SIZE;
+      return byteArray;
+    });
+    const length = objects.reduce((accum, item) => accum + item.length, 0);
+    const result = new Uint8Array(length);
+    objects.reduce((offset, object) => {
+      result.set(object, offset);
+      return offset + object.length;
+    }, 0);
+    if (Object.keys(topLevelData).length) {
+      result.dynamicData = topLevelData;
+    }
+    return result;
+  }
+  function unpackDynamicData(results, baseOffset, dataOffset) {
+    if (!results.dynamicData) {
+      return concat([results]);
+    }
+    let cumulativeDynamicByteLength = 0;
+    let updatedResults = results;
+    Object.entries(results.dynamicData).forEach(([pointerIndex, vData]) => {
+      const pointerOffset = parseInt(pointerIndex, 10) * WORD_SIZE;
+      const adjustedValue = new BigNumberCoder("u64").encode(
+        dataOffset + baseOffset + cumulativeDynamicByteLength
+      );
+      updatedResults.set(adjustedValue, pointerOffset);
+      const dataToAppend = vData.dynamicData ? (
+        // unpack child dynamic data
+        unpackDynamicData(
+          vData,
+          baseOffset,
+          dataOffset + vData.byteLength + cumulativeDynamicByteLength
+        )
+      ) : vData;
+      updatedResults = concat([updatedResults, dataToAppend]);
+      cumulativeDynamicByteLength += dataToAppend.byteLength;
+    });
+    return updatedResults;
+  }
+  var chunkByLength = (data, length = WORD_SIZE) => {
+    const chunks = [];
+    let offset = 0;
+    let chunk = data.slice(offset, offset + length);
+    while (chunk.length) {
+      chunks.push(chunk);
+      offset += length;
+      chunk = data.slice(offset, offset + length);
+    }
+    return chunks;
+  };
+  var isPointerType = (type3) => {
+    switch (type3) {
+      case "u8":
+      case "u16":
+      case "u32":
+      case "u64":
+      case "bool": {
+        return false;
+      }
+      default: {
+        return true;
+      }
+    }
+  };
+  var isHeapType = (type3) => type3 === VEC_CODER_TYPE || type3 === BYTES_CODER_TYPE || type3 === STD_STRING_CODER_TYPE;
+  var isMultipleOfWordSize = (length) => length % WORD_SIZE === 0;
+  var getWordSizePadding = (length) => WORD_SIZE - length % WORD_SIZE;
+  var rightPadToWordSize = (encoded) => {
+    if (isMultipleOfWordSize(encoded.length)) {
+      return encoded;
+    }
+    const padding = new Uint8Array(WORD_SIZE - encoded.length % WORD_SIZE);
+    return concatBytes2([encoded, padding]);
+  };
+  var isUint8Array = (value) => value instanceof Uint8Array;
   var ArrayCoder = class extends Coder {
     coder;
     length;
@@ -34885,7 +35135,7 @@ This unreleased fuel-core build may include features and updates not yet support
       if (this.length !== value.length) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Types/values length mismatch.`);
       }
-      return concat(Array.from(value).map((v) => this.coder.encode(v)));
+      return concatWithDynamicData(Array.from(value).map((v) => this.coder.encode(v)));
     }
     decode(data, offset) {
       if (data.length < this.encodedLength || data.length > MAX_BYTES) {
@@ -34962,42 +35212,16 @@ 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 = {
-      padToWordSize: false
+      isSmallBytes: false,
+      isRightPadded: false
     }) {
-      const encodedLength = options.padToWordSize ? WORD_SIZE : 1;
-      super("boolean", "boolean", encodedLength);
+      const paddingLength = options.isSmallBytes ? 1 : 8;
+      super("boolean", "boolean", paddingLength);
+      this.paddingLength = paddingLength;
       this.options = options;
     }
     encode(value) {
@@ -35005,45 +35229,73 @@ This unreleased fuel-core build may include features and updates not yet support
       if (!isTrueBool) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid boolean value.`);
       }
-      return toBytes2(value ? 1 : 0, this.encodedLength);
+      const output2 = toBytes2(value ? 1 : 0, this.paddingLength);
+      if (this.options.isRightPadded) {
+        return output2.reverse();
+      }
+      return output2;
     }
     decode(data, offset) {
-      if (data.length < this.encodedLength) {
+      if (data.length < this.paddingLength) {
         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];
+      let bytes2;
+      if (this.options.isRightPadded) {
+        bytes2 = data.slice(offset, offset + 1);
+      } else {
+        bytes2 = data.slice(offset, offset + this.paddingLength);
       }
-      if (!bytes2.eq(bn(1))) {
+      const decodedValue = bn(bytes2);
+      if (decodedValue.isZero()) {
+        return [false, offset + this.paddingLength];
+      }
+      if (!decodedValue.eq(bn(1))) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean value.`);
       }
-      return [true, offset + this.encodedLength];
+      return [true, offset + this.paddingLength];
     }
   };
+  var _getPaddedData;
+  var getPaddedData_fn;
   var ByteCoder = class extends Coder {
     constructor() {
-      super("struct", "struct Bytes", WORD_SIZE);
+      super("struct", "struct Bytes", BASE_VECTOR_OFFSET);
+      __privateAdd2(this, _getPaddedData);
     }
     encode(value) {
-      const bytes2 = value instanceof Uint8Array ? value : new Uint8Array(value);
-      const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
-      return new Uint8Array([...lengthBytes, ...bytes2]);
+      const parts = [];
+      const pointer = new BigNumberCoder("u64").encode(BASE_VECTOR_OFFSET);
+      const data = __privateMethod2(this, _getPaddedData, getPaddedData_fn).call(this, value);
+      pointer.dynamicData = {
+        0: concatWithDynamicData([data])
+      };
+      parts.push(pointer);
+      parts.push(new BigNumberCoder("u64").encode(data.byteLength));
+      parts.push(new BigNumberCoder("u64").encode(value.length));
+      return concatWithDynamicData(parts);
     }
     decode(data, offset) {
-      if (data.length < WORD_SIZE) {
+      if (data.length < BASE_VECTOR_OFFSET) {
         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) {
+      const len = data.slice(16, 24);
+      const encodedLength = bn(new BigNumberCoder("u64").decode(len, 0)[0]).toNumber();
+      const byteData = data.slice(BASE_VECTOR_OFFSET, BASE_VECTOR_OFFSET + encodedLength);
+      if (byteData.length !== encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid bytes byte data size.`);
       }
-      return [dataBytes, offsetAndLength + length];
+      return [byteData, offset + BASE_VECTOR_OFFSET];
     }
   };
+  _getPaddedData = /* @__PURE__ */ new WeakSet();
+  getPaddedData_fn = function(value) {
+    const data = value instanceof Uint8Array ? [value] : [new Uint8Array(value)];
+    const paddingLength = (WORD_SIZE - value.length % WORD_SIZE) % WORD_SIZE;
+    if (paddingLength) {
+      data.push(new Uint8Array(paddingLength));
+    }
+    return concat(data);
+  };
   __publicField4(ByteCoder, "memorySize", 1);
   var isFullyNativeEnum = (enumCoders) => Object.values(enumCoders).every(
     // @ts-expect-error complicated types
@@ -35087,7 +35339,8 @@ 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]);
-      return new Uint8Array([...this.#caseIndexCoder.encode(caseIndex), ...encodedValue]);
+      const padding = new Uint8Array(this.#encodedValueSize - valueCoder.encodedLength);
+      return concatWithDynamicData([this.#caseIndexCoder.encode(caseIndex), padding, encodedValue]);
     }
     #decodeNativeEnum(caseKey, newOffset) {
       return [caseKey, newOffset];
@@ -35096,8 +35349,10 @@ 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.`);
       }
-      const caseBytes = new BigNumberCoder("u64").decode(data, offset)[0];
-      const caseIndex = toNumber(caseBytes);
+      let newOffset = offset;
+      let decoded;
+      [decoded, newOffset] = new BigNumberCoder("u64").decode(data, newOffset);
+      const caseIndex = toNumber(decoded);
       const caseKey = Object.keys(this.coders)[caseIndex];
       if (!caseKey) {
         throw new FuelError(
@@ -35106,35 +35361,67 @@ This unreleased fuel-core build may include features and updates not yet support
         );
       }
       const valueCoder = this.coders[caseKey];
-      const offsetAndCase = offset + WORD_SIZE;
-      const [decoded, newOffset] = valueCoder.decode(data, offsetAndCase);
+      const padding = this.#encodedValueSize - valueCoder.encodedLength;
+      newOffset += padding;
+      [decoded, newOffset] = valueCoder.decode(data, newOffset);
       if (isFullyNativeEnum(this.coders)) {
         return this.#decodeNativeEnum(caseKey, newOffset);
       }
       return [{ [caseKey]: decoded }, newOffset];
     }
   };
-  var 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 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 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 = {
-      padToWordSize: false
+      isSmallBytes: false,
+      isRightPadded: false
     }) {
-      const length = options.padToWordSize ? WORD_SIZE : getLength(baseType);
-      super("number", baseType, length);
+      const paddingLength = options.isSmallBytes && baseType === "u8" ? 1 : 8;
+      super("number", baseType, paddingLength);
       this.baseType = baseType;
+      switch (baseType) {
+        case "u8":
+          this.length = 1;
+          break;
+        case "u16":
+          this.length = 2;
+          break;
+        case "u32":
+        default:
+          this.length = 4;
+          break;
+      }
+      this.paddingLength = paddingLength;
       this.options = options;
     }
     encode(value) {
@@ -35144,140 +35431,142 @@ This unreleased fuel-core build may include features and updates not yet support
       } catch (error) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}.`);
       }
-      if (bytes2.length > this.encodedLength) {
+      if (bytes2.length > this.length) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}, too many bytes.`);
       }
-      return toBytes2(bytes2, this.encodedLength);
+      const output2 = toBytes2(bytes2, this.paddingLength);
+      if (this.baseType !== "u8") {
+        return output2;
+      }
+      return this.options.isRightPadded ? output2.reverse() : output2;
+    }
+    decodeU8(data, offset) {
+      let bytes2;
+      if (this.options.isRightPadded) {
+        bytes2 = data.slice(offset, offset + 1);
+      } else {
+        bytes2 = data.slice(offset, offset + this.paddingLength);
+        bytes2 = bytes2.slice(this.paddingLength - this.length, this.paddingLength);
+      }
+      return [toNumber(bytes2), offset + this.paddingLength];
     }
     decode(data, offset) {
-      if (data.length < this.encodedLength) {
+      if (data.length < this.paddingLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number data size.`);
       }
-      const bytes2 = data.slice(offset, offset + this.encodedLength);
-      if (bytes2.length !== this.encodedLength) {
+      if (this.baseType === "u8") {
+        return this.decodeU8(data, offset);
+      }
+      let bytes2 = data.slice(offset, offset + this.paddingLength);
+      bytes2 = bytes2.slice(8 - this.length, 8);
+      if (bytes2.length !== this.paddingLength - (this.paddingLength - this.length)) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number byte data size.`);
       }
-      return [toNumber(bytes2), offset + this.encodedLength];
+      return [toNumber(bytes2), offset + 8];
     }
   };
-  var OptionCoder = class extends EnumCoder {
-    encode(value) {
-      const result = super.encode(this.toSwayOption(value));
-      return result;
+  var RawSliceCoder = class extends Coder {
+    constructor() {
+      super("raw untyped slice", "raw untyped slice", BASE_RAW_SLICE_OFFSET);
     }
-    toSwayOption(input) {
-      if (input !== void 0) {
-        return { Some: input };
+    encode(value) {
+      if (!Array.isArray(value)) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
       }
-      return { None: [] };
+      const parts = [];
+      const coder = new NumberCoder("u8", { isSmallBytes: true });
+      const pointer = new BigNumberCoder("u64").encode(
+        BASE_RAW_SLICE_OFFSET
+      );
+      pointer.dynamicData = {
+        0: concatWithDynamicData(value.map((v) => coder.encode(v)))
+      };
+      parts.push(pointer);
+      parts.push(new BigNumberCoder("u64").encode(value.length));
+      return concatWithDynamicData(parts);
     }
     decode(data, offset) {
-      const [decoded, newOffset] = super.decode(data, offset);
-      return [this.toOption(decoded), newOffset];
-    }
-    toOption(output2) {
-      if (output2 && "Some" in output2) {
-        return output2.Some;
-      }
-      return void 0;
+      const dataBytes = data.slice(offset);
+      const internalCoder = new ArrayCoder(
+        new NumberCoder("u8", { isSmallBytes: true }),
+        dataBytes.length
+      );
+      const [decodedValue] = internalCoder.decode(dataBytes, 0);
+      return [decodedValue, offset + dataBytes.length];
     }
   };
-  var RawSliceCoder = class extends Coder {
+  var _getPaddedData2;
+  var getPaddedData_fn2;
+  var StdStringCoder = class extends Coder {
     constructor() {
-      super("raw untyped slice", "raw untyped slice", WORD_SIZE);
+      super("struct", "struct String", 1);
+      __privateAdd2(this, _getPaddedData2);
     }
     encode(value) {
-      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]);
+      const parts = [];
+      const pointer = new BigNumberCoder("u64").encode(BASE_VECTOR_OFFSET);
+      const data = __privateMethod2(this, _getPaddedData2, getPaddedData_fn2).call(this, value);
+      pointer.dynamicData = {
+        0: concatWithDynamicData([data])
+      };
+      parts.push(pointer);
+      parts.push(new BigNumberCoder("u64").encode(data.byteLength));
+      parts.push(new BigNumberCoder("u64").encode(value.length));
+      return concatWithDynamicData(parts);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid raw slice data size.`);
+        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 raw slice byte data size.`);
-      }
-      const internalCoder = new ArrayCoder(new NumberCoder("u8"), length);
-      const [decodedValue] = internalCoder.decode(dataBytes, 0);
-      return [decodedValue, offsetAndLength + length];
-    }
-  };
-  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) {
+      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.`);
       }
-      return [toUtf8String(dataBytes), offsetAndLength + length];
+      const value = toUtf8String(byteData);
+      return [value, offset + BASE_VECTOR_OFFSET];
     }
   };
-  __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];
-    }
+  _getPaddedData2 = /* @__PURE__ */ new WeakSet();
+  getPaddedData_fn2 = function(value) {
+    const data = [toUtf8Bytes(value)];
+    const paddingLength = (WORD_SIZE - value.length % WORD_SIZE) % WORD_SIZE;
+    if (paddingLength) {
+      data.push(new Uint8Array(paddingLength));
+    }
+    return concat(data);
   };
-  __publicField4(StrSliceCoder, "memorySize", 1);
+  __publicField4(StdStringCoder, "memorySize", 1);
   var StringCoder = class extends Coder {
+    length;
+    #paddingLength;
     constructor(length) {
-      super("string", `str[${length}]`, length);
+      let paddingLength = (8 - length) % 8;
+      paddingLength = paddingLength < 0 ? paddingLength + 8 : paddingLength;
+      super("string", `str[${length}]`, length + paddingLength);
+      this.length = length;
+      this.#paddingLength = paddingLength;
     }
     encode(value) {
-      if (value.length !== this.encodedLength) {
+      if (this.length !== value.length) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Value length mismatch during encode.`);
       }
-      return toUtf8Bytes(value);
+      const encoded = toUtf8Bytes(value);
+      const padding = new Uint8Array(this.#paddingLength);
+      return concat([encoded, padding]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string data size.`);
       }
-      const bytes2 = data.slice(offset, offset + this.encodedLength);
-      if (bytes2.length !== this.encodedLength) {
+      const bytes2 = data.slice(offset, offset + this.length);
+      if (bytes2.length !== this.length) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string byte data size.`);
       }
-      return [toUtf8String(bytes2), offset + this.encodedLength];
+      const value = toUtf8String(bytes2);
+      const padding = this.#paddingLength;
+      return [value, offset + this.length + padding];
     }
   };
   var StructCoder = class extends Coder {
@@ -35293,19 +35582,22 @@ This unreleased fuel-core build may include features and updates not yet support
       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 OptionCoder) && fieldValue == null) {
-            throw new FuelError(
-              ErrorCode.ENCODE_ERROR,
-              `Invalid ${this.type}. Field "${fieldName}" not present.`
-            );
-          }
-          return fieldCoder.encode(fieldValue);
-        })
-      );
+      const encodedFields = Object.keys(this.coders).map((fieldName) => {
+        const fieldCoder = this.coders[fieldName];
+        const fieldValue = value[fieldName];
+        if (!(fieldCoder instanceof OptionCoder) && fieldValue == null) {
+          throw new FuelError(
+            ErrorCode.ENCODE_ERROR,
+            `Invalid ${this.type}. Field "${fieldName}" not present.`
+          );
+        }
+        const encoded = fieldCoder.encode(fieldValue);
+        if (!isMultipleOfWordSize(encoded.length)) {
+          return rightPadToWordSize(encoded);
+        }
+        return encoded;
+      });
+      return concatWithDynamicData([concatWithDynamicData(encodedFields)]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -35316,6 +35608,9 @@ 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;
       }, {});
@@ -35333,7 +35628,15 @@ 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 concatBytes2(this.coders.map((coder, i) => coder.encode(value[i])));
+      return concatWithDynamicData(
+        this.coders.map((coder, i) => {
+          const encoded = coder.encode(value[i]);
+          if (!isMultipleOfWordSize(encoded.length)) {
+            return rightPadToWordSize(encoded);
+          }
+          return encoded;
+        })
+      );
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -35343,19 +35646,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 + WORD_SIZE);
+      super("struct", `struct Vec`, coder.encodedLength + BASE_VECTOR_OFFSET);
       this.coder = coder;
-      this.#isOptionVec = this.coder instanceof OptionCoder;
     }
     encode(value) {
       if (!Array.isArray(value) && !isUint8Array(value)) {
@@ -35364,39 +35667,40 @@ 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 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)]);
+      const parts = [];
+      const pointer = new BigNumberCoder("u64").encode(BASE_VECTOR_OFFSET);
+      pointer.dynamicData = {
+        0: concatWithDynamicData(Array.from(value).map((v) => this.coder.encode(v)))
+      };
+      parts.push(pointer);
+      parts.push(new BigNumberCoder("u64").encode(value.length));
+      parts.push(new BigNumberCoder("u64").encode(value.length));
+      return concatWithDynamicData(parts);
     }
     decode(data, offset) {
-      if (!this.#isOptionVec && (data.length < this.encodedLength || data.length > MAX_BYTES)) {
+      if (data.length < BASE_VECTOR_OFFSET || data.length > MAX_BYTES) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec 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 dataLength2 = length * this.coder.encodedLength;
-      const dataBytes = data.slice(offsetAndLength, offsetAndLength + dataLength2);
-      if (!this.#isOptionVec && dataBytes.length !== dataLength2) {
+      const len = data.slice(16, 24);
+      const encodedLength = bn(new BigNumberCoder("u64").decode(len, 0)[0]).toNumber();
+      const vectorRawDataLength = encodedLength * this.coder.encodedLength;
+      const vectorRawData = data.slice(BASE_VECTOR_OFFSET, BASE_VECTOR_OFFSET + vectorRawDataLength);
+      if (vectorRawData.length !== vectorRawDataLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec byte data size.`);
       }
-      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];
+      return [
+        chunkByLength(vectorRawData, this.coder.encodedLength).map(
+          (chunk) => this.coder.decode(chunk, 0)[0]
+        ),
+        offset + BASE_VECTOR_OFFSET
+      ];
     }
   };
   var getEncodingVersion = (encoding) => {
     switch (encoding) {
       case void 0:
+      case ENCODING_V0:
+        return ENCODING_V0;
       case ENCODING_V1:
         return ENCODING_V1;
       default:
@@ -35510,98 +35814,576 @@ This unreleased fuel-core build may include features and updates not yet support
         return arg;
       });
     }
-    static getImplicitGenericTypeParameters(abi, args, implicitGenericParametersParam) {
-      if (!Array.isArray(args)) {
-        return null;
+    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.`);
       }
-      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 concatBytes2(this.coders.map((coder, i) => coder.encode(value[i])));
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid tuple data size.`);
+      }
+      let newOffset = offset;
+      const decodedValue = this.coders.map((coder) => {
+        let decoded;
+        [decoded, newOffset] = coder.decode(data, newOffset);
+        return decoded;
       });
-      return implicitGenericParameters.length > 0 ? implicitGenericParameters : null;
+      return [decodedValue, newOffset];
     }
-    getSignature() {
-      const prefix = this.getArgSignaturePrefix();
-      const content = this.getArgSignatureContent();
-      return `${prefix}${content}`;
+  };
+  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;
     }
-    getArgSignaturePrefix() {
-      const structMatch = structRegEx.test(this.type);
-      if (structMatch) {
-        return "s";
-      }
-      const arrayMatch = arrayRegEx.test(this.type);
-      if (arrayMatch) {
-        return "a";
+    encode(value) {
+      if (!Array.isArray(value) && !isUint8Array(value)) {
+        throw new FuelError(
+          ErrorCode.ENCODE_ERROR,
+          `Expected array value, or a Uint8Array. You can use arrayify to convert a value to a Uint8Array.`
+        );
       }
-      const enumMatch = enumRegEx.test(this.type);
-      if (enumMatch) {
-        return "e";
+      const lengthCoder = new BigNumberCoder("u64");
+      if (isUint8Array(value)) {
+        return new Uint8Array([...lengthCoder.encode(value.length), ...value]);
       }
-      return "";
+      const bytes2 = value.map((v) => this.coder.encode(v));
+      const lengthBytes = lengthCoder.encode(value.length);
+      return new Uint8Array([...lengthBytes, ...concatBytes2(bytes2)]);
     }
-    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}]`;
+    decode(data, offset) {
+      if (!this.#isOptionVec && (data.length < this.encodedLength || data.length > MAX_BYTES)) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec data size.`);
       }
-      if (this.components === null) {
-        return this.type;
+      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.`);
       }
-      const arrayMatch = arrayRegEx.exec(this.type)?.groups;
-      if (arrayMatch) {
-        return `[${this.components[0].getSignature()};${arrayMatch.length}]`;
+      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 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}`;
+      return [chunks, newOffset];
     }
   };
-  function getCoders(components, options) {
-    const { getCoder: getCoder2 } = options;
-    return components.reduce((obj, component) => {
-      const o = obj;
-      o[component.name] = getCoder2(component, options);
-      return o;
-    }, {});
-  }
-  var getCoder = (resolvedAbiType, _options) => {
+  var getCoder2 = (resolvedAbiType, _options) => {
     switch (resolvedAbiType.type) {
       case U8_CODER_TYPE:
       case U16_CODER_TYPE:
       case U32_CODER_TYPE:
-        return new NumberCoder(resolvedAbiType.type);
+        return new NumberCoder2(resolvedAbiType.type);
       case U64_CODER_TYPE:
       case RAW_PTR_CODER_TYPE:
         return new BigNumberCoder("u64");
       case U256_CODER_TYPE:
         return new BigNumberCoder("u256");
       case RAW_SLICE_CODER_TYPE:
-        return new RawSliceCoder();
+        return new RawSliceCoder2();
       case BOOL_CODER_TYPE:
-        return new BooleanCoder();
+        return new BooleanCoder2();
       case B256_CODER_TYPE:
         return new B256Coder();
       case B512_CODER_TYPE:
         return new B512Coder();
       case BYTES_CODER_TYPE:
-        return new ByteCoder();
+        return new ByteCoder2();
       case STD_STRING_CODER_TYPE:
-        return new StdStringCoder();
+        return new StdStringCoder2();
       case STR_SLICE_CODER_TYPE:
         return new StrSliceCoder();
       default:
@@ -35610,7 +36392,7 @@ This unreleased fuel-core build may include features and updates not yet support
     const stringMatch = stringRegEx.exec(resolvedAbiType.type)?.groups;
     if (stringMatch) {
       const length = parseInt(stringMatch.length, 10);
-      return new StringCoder(length);
+      return new StringCoder2(length);
     }
     const components = resolvedAbiType.components;
     const arrayMatch = arrayRegEx.exec(resolvedAbiType.type)?.groups;
@@ -35623,42 +36405,46 @@ This unreleased fuel-core build may include features and updates not yet support
           `The provided Array type is missing an item of 'component'.`
         );
       }
-      const arrayElementCoder = getCoder(arg);
+      const arrayElementCoder = getCoder2(arg, { isSmallBytes: true });
       return new ArrayCoder(arrayElementCoder, length);
     }
     if (resolvedAbiType.type === VEC_CODER_TYPE) {
       const arg = findVectorBufferArgument(components);
       const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
-      const itemCoder = getCoder(argType, { encoding: ENCODING_V1 });
-      return new VecCoder(itemCoder);
+      const itemCoder = getCoder2(argType, { isSmallBytes: true, encoding: ENCODING_V0 });
+      return new VecCoder2(itemCoder);
     }
     const structMatch = structRegEx.exec(resolvedAbiType.type)?.groups;
     if (structMatch) {
-      const coders = getCoders(components, { getCoder });
-      return new StructCoder(structMatch.name, coders);
+      const coders = getCoders(components, { isRightPadded: true, getCoder: getCoder2 });
+      return new StructCoder2(structMatch.name, coders);
     }
     const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
     if (enumMatch) {
-      const coders = getCoders(components, { getCoder });
+      const coders = getCoders(components, { getCoder: getCoder2 });
       const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
       if (isOptionEnum) {
-        return new OptionCoder(enumMatch.name, coders);
+        return new OptionCoder2(enumMatch.name, coders);
       }
-      return new EnumCoder(enumMatch.name, coders);
+      return new EnumCoder2(enumMatch.name, coders);
     }
     const tupleMatch = tupleRegEx.exec(resolvedAbiType.type)?.groups;
     if (tupleMatch) {
-      const coders = components.map((component) => getCoder(component, { encoding: ENCODING_V1 }));
-      return new TupleCoder(coders);
+      const coders = components.map(
+        (component) => getCoder2(component, { isRightPadded: true, encoding: ENCODING_V0 })
+      );
+      return new TupleCoder2(coders);
     }
     throw new FuelError(
       ErrorCode.CODER_NOT_FOUND,
       `Coder not found: ${JSON.stringify(resolvedAbiType)}.`
     );
   };
-  function getCoderForEncoding(encoding = ENCODING_V1) {
+  function getCoderForEncoding(encoding = ENCODING_V0) {
     switch (encoding) {
       case ENCODING_V1:
+        return getCoder2;
+      case ENCODING_V0:
         return getCoder;
       default:
         throw new FuelError(
@@ -35669,7 +36455,7 @@ This unreleased fuel-core build may include features and updates not yet support
   }
   var AbiCoder = class {
     static getCoder(abi, argument, options = {
-      padToWordSize: false
+      isSmallBytes: false
     }) {
       const resolvedAbiType = new ResolvedAbiType(abi, argument);
       return getCoderForEncoding(options.encoding)(resolvedAbiType, options);
@@ -35689,6 +36475,8 @@ This unreleased fuel-core build may include features and updates not yet support
     name;
     jsonFn;
     attributes;
+    isInputDataPointer;
+    outputMetadata;
     jsonAbi;
     constructor(jsonAbi, name) {
       this.jsonAbi = jsonAbi;
@@ -35696,8 +36484,13 @@ This unreleased fuel-core build may include features and updates not yet support
       this.name = name;
       this.signature = FunctionFragment.getSignature(this.jsonAbi, this.jsonFn);
       this.selector = FunctionFragment.getFunctionSelector(this.signature);
-      this.selectorBytes = new StdStringCoder().encode(name);
+      this.selectorBytes = new StdStringCoder2().encode(name);
       this.encoding = getEncodingVersion(jsonAbi.encoding);
+      this.isInputDataPointer = this.#isInputDataPointer();
+      this.outputMetadata = {
+        isHeapType: this.#isOutputDataHeap(),
+        encodedLength: this.#getOutputEncodedLength()
+      };
       this.attributes = this.jsonFn.attributes ?? [];
     }
     static getSignature(abi, fn) {
@@ -35710,7 +36503,29 @@ This unreleased fuel-core build may include features and updates not yet support
       const hashedFunctionSignature = sha2562(bufferFromString2(functionSignature, "utf-8"));
       return bn(hashedFunctionSignature.slice(0, 10)).toHex(8);
     }
-    encodeArguments(values) {
+    #isInputDataPointer() {
+      const inputTypes = this.jsonFn.inputs.map((i) => findTypeById(this.jsonAbi, i.type));
+      return this.jsonFn.inputs.length > 1 || isPointerType(inputTypes[0]?.type || "");
+    }
+    #isOutputDataHeap() {
+      const outputType = findTypeById(this.jsonAbi, this.jsonFn.output.type);
+      return isHeapType(outputType?.type || "");
+    }
+    #getOutputEncodedLength() {
+      try {
+        const heapCoder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output);
+        if (heapCoder instanceof VecCoder) {
+          return heapCoder.coder.encodedLength;
+        }
+        if (heapCoder instanceof ByteCoder) {
+          return ByteCoder.memorySize;
+        }
+        return heapCoder.encodedLength;
+      } catch (e) {
+        return 0;
+      }
+    }
+    encodeArguments(values, offset = 0) {
       FunctionFragment.verifyArgsAndInputsAlign(values, this.jsonFn.inputs, this.jsonAbi);
       const shallowCopyValues = values.slice();
       const nonEmptyInputs = findNonEmptyInputs(this.jsonAbi, this.jsonFn.inputs);
@@ -35720,10 +36535,15 @@ This unreleased fuel-core build may include features and updates not yet support
       }
       const coders = nonEmptyInputs.map(
         (t) => AbiCoder.getCoder(this.jsonAbi, t, {
+          isRightPadded: nonEmptyInputs.length > 1,
           encoding: this.encoding
         })
       );
-      return new TupleCoder(coders).encode(shallowCopyValues);
+      if (this.encoding === ENCODING_V1) {
+        return new TupleCoder2(coders).encode(shallowCopyValues);
+      }
+      const results = new TupleCoder(coders).encode(shallowCopyValues);
+      return unpackDynamicData(results, offset, results.byteLength);
     }
     static verifyArgsAndInputsAlign(args, inputs, abi) {
       if (args.length === inputs.length) {
@@ -35832,9 +36652,9 @@ This unreleased fuel-core build may include features and updates not yet support
       const fragment = typeof functionFragment === "string" ? this.getFunction(functionFragment) : functionFragment;
       return fragment.decodeArguments(data);
     }
-    encodeFunctionData(functionFragment, values) {
+    encodeFunctionData(functionFragment, values, offset = 0) {
       const fragment = typeof functionFragment === "string" ? this.getFunction(functionFragment) : functionFragment;
-      return fragment.encodeArguments(values);
+      return fragment.encodeArguments(values, offset);
     }
     // Decode the result of a function call
     decodeFunctionResult(functionFragment, data) {
@@ -35862,7 +36682,9 @@ This unreleased fuel-core build may include features and updates not yet support
         );
       }
       return AbiCoder.encode(this.jsonAbi, configurable.configurableType, value, {
-        encoding: this.encoding
+        isRightPadded: true,
+        // TODO: Review support for configurables in v1 encoding when it becomes available
+        encoding: ENCODING_V0
       });
     }
     getTypeById(typeId) {
@@ -35912,8 +36734,8 @@ This unreleased fuel-core build may include features and updates not yet support
   var TxPointerCoder = class extends StructCoder {
     constructor() {
       super("TxPointer", {
-        blockHeight: new NumberCoder("u32", { padToWordSize: true }),
-        txIndex: new NumberCoder("u16", { padToWordSize: true })
+        blockHeight: new NumberCoder("u32"),
+        txIndex: new NumberCoder("u16")
       });
     }
   };
@@ -35930,12 +36752,12 @@ This unreleased fuel-core build may include features and updates not yet support
     encode(value) {
       const parts = [];
       parts.push(new B256Coder().encode(value.txID));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputIndex));
+      parts.push(new NumberCoder("u16").encode(value.outputIndex));
       parts.push(new B256Coder().encode(value.owner));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(new B256Coder().encode(value.assetId));
       parts.push(new TxPointerCoder().encode(value.txPointer));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessIndex));
+      parts.push(new NumberCoder("u16").encode(value.witnessIndex));
       parts.push(new BigNumberCoder("u64").encode(value.predicateGasUsed));
       parts.push(new BigNumberCoder("u64").encode(value.predicateLength));
       parts.push(new BigNumberCoder("u64").encode(value.predicateDataLength));
@@ -35950,7 +36772,7 @@ This unreleased fuel-core build may include features and updates not yet support
       let o = offset;
       [decoded, o] = new B256Coder().decode(data, o);
       const txID = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const outputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const owner = decoded;
@@ -35960,7 +36782,7 @@ This unreleased fuel-core build may include features and updates not yet support
       const assetId = decoded;
       [decoded, o] = new TxPointerCoder().decode(data, o);
       const txPointer = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const witnessIndex = Number(decoded);
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateGasUsed = decoded;
@@ -35999,7 +36821,7 @@ This unreleased fuel-core build may include features and updates not yet support
     encode(value) {
       const parts = [];
       parts.push(new B256Coder().encode(value.txID));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputIndex));
+      parts.push(new NumberCoder("u16").encode(value.outputIndex));
       parts.push(new B256Coder().encode(value.balanceRoot));
       parts.push(new B256Coder().encode(value.stateRoot));
       parts.push(new TxPointerCoder().encode(value.txPointer));
@@ -36011,7 +36833,7 @@ This unreleased fuel-core build may include features and updates not yet support
       let o = offset;
       [decoded, o] = new B256Coder().decode(data, o);
       const txID = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const outputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const balanceRoot = decoded;
@@ -36060,7 +36882,7 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new ByteArrayCoder(32).encode(value.recipient));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(new ByteArrayCoder(32).encode(value.nonce));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessIndex));
+      parts.push(new NumberCoder("u16").encode(value.witnessIndex));
       parts.push(new BigNumberCoder("u64").encode(value.predicateGasUsed));
       parts.push(new BigNumberCoder("u64").encode(data.length));
       parts.push(new BigNumberCoder("u64").encode(value.predicateLength));
@@ -36089,11 +36911,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", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const witnessIndex = Number(decoded);
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateGasUsed = decoded;
-      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
       const dataLength2 = decoded;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateLength = decoded;
@@ -36131,7 +36953,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.type));
+      parts.push(new NumberCoder("u8").encode(value.type));
       const { type: type3 } = value;
       switch (type3) {
         case 0: {
@@ -36158,7 +36980,7 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u8").decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
@@ -36227,7 +37049,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.inputIndex));
+      parts.push(new NumberCoder("u8").encode(value.inputIndex));
       parts.push(new B256Coder().encode(value.balanceRoot));
       parts.push(new B256Coder().encode(value.stateRoot));
       return concat(parts);
@@ -36235,7 +37057,7 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u8").decode(data, o);
       const inputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const balanceRoot = decoded;
@@ -36347,7 +37169,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.type));
+      parts.push(new NumberCoder("u8").encode(value.type));
       const { type: type3 } = value;
       switch (type3) {
         case 0: {
@@ -36382,7 +37204,7 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u8").decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
@@ -36450,7 +37272,7 @@ This unreleased fuel-core build may include features and updates not yet support
             parts.push(new BigNumberCoder("u64").encode(data));
             break;
           case 4:
-            parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(data));
+            parts.push(new NumberCoder("u32").encode(data));
             break;
           default: {
             throw new FuelError(ErrorCode.INVALID_POLICY_TYPE, `Invalid policy type: ${type3}`);
@@ -36473,10 +37295,7 @@ This unreleased fuel-core build may include features and updates not yet support
         policies.push({ type: 2, data: witnessLimit });
       }
       if (policyTypes & 4) {
-        const [maturity, nextOffset] = new NumberCoder("u32", { padToWordSize: true }).decode(
-          data,
-          o
-        );
+        const [maturity, nextOffset] = new NumberCoder("u32").decode(data, o);
         o = nextOffset;
         policies.push({ type: 4, data: maturity });
       }
@@ -36523,7 +37342,7 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new B256Coder().encode(value.recipient));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(new B256Coder().encode(value.nonce));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.data.length));
+      parts.push(new NumberCoder("u16").encode(value.data.length));
       parts.push(new B256Coder().encode(value.digest));
       parts.push(new ByteArrayCoder(value.data.length).encode(value.data));
       return concat(parts);
@@ -36539,7 +37358,7 @@ This unreleased fuel-core build may include features and updates not yet support
       const amount = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const nonce = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const len = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const digest = decoded;
@@ -36663,11 +37482,11 @@ This unreleased fuel-core build may include features and updates not yet support
     encode(upgradePurposeType) {
       const parts = [];
       const { type: type3 } = upgradePurposeType;
-      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(type3));
+      parts.push(new NumberCoder("u8").encode(type3));
       switch (type3) {
         case 0: {
           const data = upgradePurposeType.data;
-          parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(data.witnessIndex));
+          parts.push(new NumberCoder("u16").encode(data.witnessIndex));
           parts.push(new B256Coder().encode(data.checksum));
           break;
         }
@@ -36688,11 +37507,11 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let o = offset;
       let decoded;
-      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u8").decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
-          [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+          [decoded, o] = new NumberCoder("u16").decode(data, o);
           const witnessIndex = decoded;
           [decoded, o] = new B256Coder().decode(data, o);
           const checksum = decoded;
@@ -36723,14 +37542,14 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(value.dataLength));
+      parts.push(new NumberCoder("u32").encode(value.dataLength));
       parts.push(new ByteArrayCoder(value.dataLength).encode(value.data));
       return concat(parts);
     }
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
       const dataLength2 = decoded;
       [decoded, o] = new ByteArrayCoder(dataLength2).decode(data, o);
       const witnessData = decoded;
@@ -36761,10 +37580,10 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new B256Coder().encode(value.receiptsRoot));
       parts.push(new BigNumberCoder("u64").encode(value.scriptLength));
       parts.push(new BigNumberCoder("u64").encode(value.scriptDataLength));
-      parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(value.policyTypes));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.inputsCount));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputsCount));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessesCount));
+      parts.push(new NumberCoder("u32").encode(value.policyTypes));
+      parts.push(new NumberCoder("u16").encode(value.inputsCount));
+      parts.push(new NumberCoder("u16").encode(value.outputsCount));
+      parts.push(new NumberCoder("u16").encode(value.witnessesCount));
       parts.push(new ByteArrayCoder(value.scriptLength.toNumber()).encode(value.script));
       parts.push(new ByteArrayCoder(value.scriptDataLength.toNumber()).encode(value.scriptData));
       parts.push(new PoliciesCoder().encode(value.policies));
@@ -36784,13 +37603,13 @@ This unreleased fuel-core build may include features and updates not yet support
       const scriptLength = decoded;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const scriptDataLength = decoded;
-      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
       const policyTypes = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const inputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const outputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const witnessesCount = decoded;
       [decoded, o] = new ByteArrayCoder(scriptLength.toNumber()).decode(data, o);
       const script = decoded;
@@ -36832,13 +37651,13 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.bytecodeWitnessIndex));
+      parts.push(new NumberCoder("u16").encode(value.bytecodeWitnessIndex));
       parts.push(new B256Coder().encode(value.salt));
       parts.push(new BigNumberCoder("u64").encode(value.storageSlotsCount));
-      parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(value.policyTypes));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.inputsCount));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputsCount));
-      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessesCount));
+      parts.push(new NumberCoder("u32").encode(value.policyTypes));
+      parts.push(new NumberCoder("u16").encode(value.inputsCount));
+      parts.push(new NumberCoder("u16").encode(value.outputsCount));
+      parts.push(new NumberCoder("u16").encode(value.witnessesCount));
       parts.push(
         new ArrayCoder(new StorageSlotCoder(), value.storageSlotsCount.toNumber()).encode(
           value.storageSlots
@@ -36853,19 +37672,19 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const bytecodeWitnessIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const salt = decoded;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const storageSlotsCount = decoded;
-      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
       const policyTypes = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const inputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const outputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u16").decode(data, o);
       const witnessesCount = decoded;
       [decoded, o] = new ArrayCoder(new StorageSlotCoder(), storageSlotsCount.toNumber()).decode(
         data,
@@ -37079,7 +37898,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.type));
+      parts.push(new NumberCoder("u8").encode(value.type));
       const { type: type3 } = value;
       switch (value.type) {
         case 0: {
@@ -37122,7 +37941,7 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
+      [decoded, o] = new NumberCoder("u8").decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
@@ -42135,15 +42954,6 @@ ${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}".`;
@@ -42757,6 +43567,15 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         }
       });
     }
+    shiftPredicateData() {
+      this.inputs.forEach((input) => {
+        if ("predicateData" in input && "padPredicateData" in input && typeof input.padPredicateData === "function") {
+          input.predicateData = input.padPredicateData(
+            BaseTransactionRequest.getPolicyMeta(this).policies.length
+          );
+        }
+      });
+    }
   };
 
   // src/providers/transaction-request/hash-transaction.ts
@@ -43221,27 +44040,37 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   };
 
   // src/providers/transaction-summary/call.ts
-  var getFunctionCall = ({ abi, receipt }) => {
+  var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
     const abiInterface = new Interface(abi);
     const callFunctionSelector = receipt.param1.toHex(8);
     const functionFragment = abiInterface.getFunction(callFunctionSelector);
     const inputs = functionFragment.jsonFn.inputs;
-    const encodedArgs = receipt.param2.toHex();
+    let encodedArgs;
+    if (functionFragment.isInputDataPointer) {
+      if (rawPayload) {
+        const argsOffset = bn(receipt.param2).sub(calculateVmTxMemory({ maxInputs: maxInputs.toNumber() })).toNumber();
+        encodedArgs = `0x${rawPayload.slice(2).slice(argsOffset * 2)}`;
+      }
+    } else {
+      encodedArgs = receipt.param2.toHex();
+    }
     let argumentsProvided;
-    const data = functionFragment.decodeArguments(encodedArgs);
-    if (data) {
-      argumentsProvided = inputs.reduce((prev, input, index) => {
-        const value = data[index];
-        const name = input.name;
-        if (name) {
-          return {
-            ...prev,
-            // reparse to remove bn
-            [name]: JSON.parse(JSON.stringify(value))
-          };
-        }
-        return prev;
-      }, {});
+    if (encodedArgs) {
+      const data = functionFragment.decodeArguments(encodedArgs);
+      if (data) {
+        argumentsProvided = inputs.reduce((prev, input, index) => {
+          const value = data[index];
+          const name = input.name;
+          if (name) {
+            return {
+              ...prev,
+              // reparse to remove bn
+              [name]: JSON.parse(JSON.stringify(value))
+            };
+          }
+          return prev;
+        }, {});
+      }
     }
     const call = {
       functionSignature: functionFragment.signature,
@@ -45518,6 +46347,7 @@ Supported fuel-core version: ${supportedVersion}.`
           cacheRequestInputsResourcesFromOwner(request.inputs, this.address)
         );
         request.addResources(resources);
+        request.shiftPredicateData();
         request.updatePredicateGasUsed(estimatedPredicates);
         const requestToReestimate2 = clone_default(request);
         if (addedSignatures) {
@@ -45549,6 +46379,7 @@ Supported fuel-core version: ${supportedVersion}.`
         }
         fundingAttempts += 1;
       }
+      request.shiftPredicateData();
       request.updatePredicateGasUsed(estimatedPredicates);
       const requestToReestimate = clone_default(request);
       if (addedSignatures) {
@@ -50184,6 +51015,40 @@ 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,
@@ -50191,7 +51056,8 @@ Supported fuel-core version: ${supportedVersion}.`
     useSystemFuelCore = false,
     loggingEnabled = true,
     debugEnabled = false,
-    basePath
+    basePath,
+    snapshotConfig = defaultSnapshotConfigs
   }) => (
     // eslint-disable-next-line no-async-promise-executor
     new Promise(async (resolve, reject) => {
@@ -50220,56 +51086,23 @@ Supported fuel-core version: ${supportedVersion}.`
       let snapshotDirToUse;
       const prefix = basePath || import_os.default.tmpdir();
       const suffix = basePath ? "" : (0, import_crypto19.randomUUID)();
-      const tempDirPath = import_path8.default.join(prefix, ".fuels", suffix, "snapshotDir");
+      const tempDir = import_path8.default.join(prefix, ".fuels", suffix, "snapshotDir");
       if (snapshotDir) {
         snapshotDirToUse = snapshotDir;
       } else {
-        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;
+        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;
       }
       const child = (0, import_child_process.spawn)(
         command,
@@ -50277,7 +51110,7 @@ Supported fuel-core version: ${supportedVersion}.`
           "run",
           ["--ip", ipToUse],
           ["--port", portToUse],
-          useInMemoryDb ? ["--db-type", "in-memory"] : ["--db-path", tempDirPath],
+          useInMemoryDb ? ["--db-type", "in-memory"] : ["--db-path", tempDir],
           ["--min-gas-price", "1"],
           poaInstant ? ["--poa-instant", "true"] : [],
           ["--consensus-key", consensusKey],
@@ -50299,23 +51132,28 @@ Supported fuel-core version: ${supportedVersion}.`
       }
       const cleanupConfig = {
         child,
-        configPath: tempDirPath,
+        configPath: tempDir,
         killFn: import_tree_kill.default,
         state: {
           isDead: false
         }
       };
       child.stderr.on("data", (chunk) => {
-        if (chunk.indexOf(graphQLStartSubstring) !== -1) {
+        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(":");
           resolve({
             cleanup: () => killNode(cleanupConfig),
-            ip: ipToUse,
-            port: portToUse,
+            ip: realIp,
+            port: realPort,
+            url: `http://${realIp}:${realPort}/v1/graphql`,
             snapshotDir: snapshotDirToUse
           });
         }
-        if (/error/i.test(chunk)) {
-          reject(chunk.toString());
+        if (/error/i.test(text)) {
+          reject(text.toString());
         }
       });
       process.on("exit", () => killNode(cleanupConfig));
@@ -50348,6 +51186,215 @@ 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: