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

package/dist/index.global.js

@@ -29470,7 +29470,7 @@ spurious results.`);
   // ../versions/dist/index.mjs
   function getBuiltinVersions() {
     return {
-      FORC: "0.56.1",
+      FORC: "0.58.0",
       FUEL_CORE: "0.26.0",
       FUELS: "0.85.0"
     };
@@ -29985,13 +29985,6 @@ This unreleased fuel-core build may include features and updates not yet support
   };
   var DateTime = _DateTime;
   __publicField3(DateTime, "TAI64_NULL", "");
-  function sleep(time) {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve(true);
-      }, time);
-    });
-  }
   function isDefined(value) {
     return value !== void 0;
   }
@@ -31099,19 +31092,6 @@ This unreleased fuel-core build may include features and updates not yet support
     __defNormalProp4(obj, typeof key !== "symbol" ? key + "" : key, value);
     return value;
   };
-  var __accessCheck2 = (obj, member, msg) => {
-    if (!member.has(obj))
-      throw TypeError("Cannot " + msg);
-  };
-  var __privateAdd2 = (obj, member, value) => {
-    if (member.has(obj))
-      throw TypeError("Cannot add the same private member more than once");
-    member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-  };
-  var __privateMethod2 = (obj, member, method) => {
-    __accessCheck2(obj, member, "access private method");
-    return method;
-  };
   var Coder = class {
     name;
     type;
@@ -31143,7 +31123,6 @@ This unreleased fuel-core build may include features and updates not yet support
   var enumRegEx = /^enum (?<name>\w+)$/;
   var tupleRegEx = /^\((?<items>.*)\)$/;
   var genericRegEx = /^generic (?<name>\w+)$/;
-  var ENCODING_V0 = "0";
   var ENCODING_V1 = "1";
   var WORD_SIZE = 8;
   var BYTES_32 = 32;
@@ -31154,10 +31133,6 @@ This unreleased fuel-core build may include features and updates not yet support
   var TX_LEN = WORD_SIZE * 4;
   var TX_POINTER_LEN = WORD_SIZE * 2;
   var MAX_BYTES = 2 ** 32 - 1;
-  var calculateVmTxMemory = ({ maxInputs }) => BYTES_32 + // Tx ID
-  ASSET_ID_LEN + // Base asset ID
-  // Asset ID/Balance coin input pairs
-  maxInputs * (ASSET_ID_LEN + WORD_SIZE) + WORD_SIZE;
   var SCRIPT_FIXED_SIZE = WORD_SIZE + // Identifier
   WORD_SIZE + // Gas limit
   WORD_SIZE + // Script size
@@ -31188,125 +31163,6 @@ This unreleased fuel-core build may include features and updates not yet support
   WORD_SIZE + // Predicate size
   WORD_SIZE + // Predicate data size
   WORD_SIZE;
-  var encodedLengths = {
-    u64: WORD_SIZE,
-    u256: WORD_SIZE * 4
-  };
-  var BigNumberCoder = class extends Coder {
-    constructor(baseType) {
-      super("bigNumber", baseType, encodedLengths[baseType]);
-    }
-    encode(value) {
-      let bytes2;
-      try {
-        bytes2 = toBytes2(value, this.encodedLength);
-      } catch (error) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.type}.`);
-      }
-      return bytes2;
-    }
-    decode(data, offset) {
-      if (data.length < this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} data size.`);
-      }
-      let bytes2 = data.slice(offset, offset + this.encodedLength);
-      bytes2 = bytes2.slice(0, this.encodedLength);
-      if (bytes2.length !== this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} byte data size.`);
-      }
-      return [bn(bytes2), offset + this.encodedLength];
-    }
-  };
-  var VEC_PROPERTY_SPACE = 3;
-  var BASE_VECTOR_OFFSET = VEC_PROPERTY_SPACE * WORD_SIZE;
-  var RAW_SLICE_PROPERTY_SPACE = 2;
-  var BASE_RAW_SLICE_OFFSET = RAW_SLICE_PROPERTY_SPACE * WORD_SIZE;
-  function concatWithDynamicData(items) {
-    const topLevelData = {};
-    let totalIndex = 0;
-    const objects = items.map((item) => {
-      const dynamicData = item.dynamicData;
-      if (dynamicData) {
-        Object.entries(dynamicData).forEach(([pointerIndex, vData]) => {
-          topLevelData[parseInt(pointerIndex, 10) + totalIndex] = vData;
-        });
-      }
-      const byteArray = arrayify(item);
-      totalIndex += byteArray.byteLength / WORD_SIZE;
-      return byteArray;
-    });
-    const length = objects.reduce((accum, item) => accum + item.length, 0);
-    const result = new Uint8Array(length);
-    objects.reduce((offset, object) => {
-      result.set(object, offset);
-      return offset + object.length;
-    }, 0);
-    if (Object.keys(topLevelData).length) {
-      result.dynamicData = topLevelData;
-    }
-    return result;
-  }
-  function unpackDynamicData(results, baseOffset, dataOffset) {
-    if (!results.dynamicData) {
-      return concat([results]);
-    }
-    let cumulativeDynamicByteLength = 0;
-    let updatedResults = results;
-    Object.entries(results.dynamicData).forEach(([pointerIndex, vData]) => {
-      const pointerOffset = parseInt(pointerIndex, 10) * WORD_SIZE;
-      const adjustedValue = new BigNumberCoder("u64").encode(
-        dataOffset + baseOffset + cumulativeDynamicByteLength
-      );
-      updatedResults.set(adjustedValue, pointerOffset);
-      const dataToAppend = vData.dynamicData ? (
-        // unpack child dynamic data
-        unpackDynamicData(
-          vData,
-          baseOffset,
-          dataOffset + vData.byteLength + cumulativeDynamicByteLength
-        )
-      ) : vData;
-      updatedResults = concat([updatedResults, dataToAppend]);
-      cumulativeDynamicByteLength += dataToAppend.byteLength;
-    });
-    return updatedResults;
-  }
-  var chunkByLength = (data, length = WORD_SIZE) => {
-    const chunks = [];
-    let offset = 0;
-    let chunk = data.slice(offset, offset + length);
-    while (chunk.length) {
-      chunks.push(chunk);
-      offset += length;
-      chunk = data.slice(offset, offset + length);
-    }
-    return chunks;
-  };
-  var isPointerType = (type3) => {
-    switch (type3) {
-      case "u8":
-      case "u16":
-      case "u32":
-      case "u64":
-      case "bool": {
-        return false;
-      }
-      default: {
-        return true;
-      }
-    }
-  };
-  var isHeapType = (type3) => type3 === VEC_CODER_TYPE || type3 === BYTES_CODER_TYPE || type3 === STD_STRING_CODER_TYPE;
-  var isMultipleOfWordSize = (length) => length % WORD_SIZE === 0;
-  var getWordSizePadding = (length) => WORD_SIZE - length % WORD_SIZE;
-  var rightPadToWordSize = (encoded) => {
-    if (isMultipleOfWordSize(encoded.length)) {
-      return encoded;
-    }
-    const padding = new Uint8Array(WORD_SIZE - encoded.length % WORD_SIZE);
-    return concatBytes2([encoded, padding]);
-  };
-  var isUint8Array = (value) => value instanceof Uint8Array;
   var ArrayCoder = class extends Coder {
     coder;
     length;
@@ -31322,7 +31178,7 @@ This unreleased fuel-core build may include features and updates not yet support
       if (this.length !== value.length) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Types/values length mismatch.`);
       }
-      return concatWithDynamicData(Array.from(value).map((v) => this.coder.encode(v)));
+      return concat(Array.from(value).map((v) => this.coder.encode(v)));
     }
     decode(data, offset) {
       if (data.length < this.encodedLength || data.length > MAX_BYTES) {
@@ -31399,16 +31255,42 @@ This unreleased fuel-core build may include features and updates not yet support
       return [toHex(bytes2, this.encodedLength), offset + this.encodedLength];
     }
   };
+  var encodedLengths = {
+    u64: WORD_SIZE,
+    u256: WORD_SIZE * 4
+  };
+  var BigNumberCoder = class extends Coder {
+    constructor(baseType) {
+      super("bigNumber", baseType, encodedLengths[baseType]);
+    }
+    encode(value) {
+      let bytes2;
+      try {
+        bytes2 = toBytes2(value, this.encodedLength);
+      } catch (error) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.type}.`);
+      }
+      return bytes2;
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} data size.`);
+      }
+      let bytes2 = data.slice(offset, offset + this.encodedLength);
+      bytes2 = bytes2.slice(0, this.encodedLength);
+      if (bytes2.length !== this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid ${this.type} byte data size.`);
+      }
+      return [bn(bytes2), offset + this.encodedLength];
+    }
+  };
   var BooleanCoder = class extends Coder {
-    paddingLength;
     options;
     constructor(options = {
-      isSmallBytes: false,
-      isRightPadded: false
+      padToWordSize: false
     }) {
-      const paddingLength = options.isSmallBytes ? 1 : 8;
-      super("boolean", "boolean", paddingLength);
-      this.paddingLength = paddingLength;
+      const encodedLength = options.padToWordSize ? WORD_SIZE : 1;
+      super("boolean", "boolean", encodedLength);
       this.options = options;
     }
     encode(value) {
@@ -31416,73 +31298,45 @@ This unreleased fuel-core build may include features and updates not yet support
       if (!isTrueBool) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid boolean value.`);
       }
-      const output2 = toBytes2(value ? 1 : 0, this.paddingLength);
-      if (this.options.isRightPadded) {
-        return output2.reverse();
-      }
-      return output2;
+      return toBytes2(value ? 1 : 0, this.encodedLength);
     }
     decode(data, offset) {
-      if (data.length < this.paddingLength) {
+      if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean data size.`);
       }
-      let bytes2;
-      if (this.options.isRightPadded) {
-        bytes2 = data.slice(offset, offset + 1);
-      } else {
-        bytes2 = data.slice(offset, offset + this.paddingLength);
-      }
-      const decodedValue = bn(bytes2);
-      if (decodedValue.isZero()) {
-        return [false, offset + this.paddingLength];
+      const bytes2 = bn(data.slice(offset, offset + this.encodedLength));
+      if (bytes2.isZero()) {
+        return [false, offset + this.encodedLength];
       }
-      if (!decodedValue.eq(bn(1))) {
+      if (!bytes2.eq(bn(1))) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid boolean value.`);
       }
-      return [true, offset + this.paddingLength];
+      return [true, offset + this.encodedLength];
     }
   };
-  var _getPaddedData;
-  var getPaddedData_fn;
   var ByteCoder = class extends Coder {
     constructor() {
-      super("struct", "struct Bytes", BASE_VECTOR_OFFSET);
-      __privateAdd2(this, _getPaddedData);
+      super("struct", "struct Bytes", WORD_SIZE);
     }
     encode(value) {
-      const parts = [];
-      const pointer = new BigNumberCoder("u64").encode(BASE_VECTOR_OFFSET);
-      const data = __privateMethod2(this, _getPaddedData, getPaddedData_fn).call(this, value);
-      pointer.dynamicData = {
-        0: concatWithDynamicData([data])
-      };
-      parts.push(pointer);
-      parts.push(new BigNumberCoder("u64").encode(data.byteLength));
-      parts.push(new BigNumberCoder("u64").encode(value.length));
-      return concatWithDynamicData(parts);
+      const bytes2 = value instanceof Uint8Array ? value : new Uint8Array(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
     }
     decode(data, offset) {
-      if (data.length < BASE_VECTOR_OFFSET) {
+      if (data.length < WORD_SIZE) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid byte data size.`);
       }
-      const len = data.slice(16, 24);
-      const encodedLength = bn(new BigNumberCoder("u64").decode(len, 0)[0]).toNumber();
-      const byteData = data.slice(BASE_VECTOR_OFFSET, BASE_VECTOR_OFFSET + encodedLength);
-      if (byteData.length !== encodedLength) {
+      const offsetAndLength = offset + WORD_SIZE;
+      const lengthBytes = data.slice(offset, offsetAndLength);
+      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
+      const dataBytes = data.slice(offsetAndLength, offsetAndLength + length);
+      if (dataBytes.length !== length) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid bytes byte data size.`);
       }
-      return [byteData, offset + BASE_VECTOR_OFFSET];
+      return [dataBytes, offsetAndLength + length];
     }
   };
-  _getPaddedData = /* @__PURE__ */ new WeakSet();
-  getPaddedData_fn = function(value) {
-    const data = value instanceof Uint8Array ? [value] : [new Uint8Array(value)];
-    const paddingLength = (WORD_SIZE - value.length % WORD_SIZE) % WORD_SIZE;
-    if (paddingLength) {
-      data.push(new Uint8Array(paddingLength));
-    }
-    return concat(data);
-  };
   __publicField4(ByteCoder, "memorySize", 1);
   var isFullyNativeEnum = (enumCoders) => Object.values(enumCoders).every(
     // @ts-expect-error complicated types
@@ -31526,8 +31380,7 @@ This unreleased fuel-core build may include features and updates not yet support
       const valueCoder = this.coders[caseKey];
       const caseIndex = Object.keys(this.coders).indexOf(caseKey);
       const encodedValue = valueCoder.encode(value[caseKey]);
-      const padding = new Uint8Array(this.#encodedValueSize - valueCoder.encodedLength);
-      return concatWithDynamicData([this.#caseIndexCoder.encode(caseIndex), padding, encodedValue]);
+      return new Uint8Array([...this.#caseIndexCoder.encode(caseIndex), ...encodedValue]);
     }
     #decodeNativeEnum(caseKey, newOffset) {
       return [caseKey, newOffset];
@@ -31536,10 +31389,8 @@ This unreleased fuel-core build may include features and updates not yet support
       if (data.length < this.#encodedValueSize) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid enum data size.`);
       }
-      let newOffset = offset;
-      let decoded;
-      [decoded, newOffset] = new BigNumberCoder("u64").decode(data, newOffset);
-      const caseIndex = toNumber(decoded);
+      const caseBytes = new BigNumberCoder("u64").decode(data, offset)[0];
+      const caseIndex = toNumber(caseBytes);
       const caseKey = Object.keys(this.coders)[caseIndex];
       if (!caseKey) {
         throw new FuelError(
@@ -31548,67 +31399,35 @@ This unreleased fuel-core build may include features and updates not yet support
         );
       }
       const valueCoder = this.coders[caseKey];
-      const padding = this.#encodedValueSize - valueCoder.encodedLength;
-      newOffset += padding;
-      [decoded, newOffset] = valueCoder.decode(data, newOffset);
+      const offsetAndCase = offset + WORD_SIZE;
+      const [decoded, newOffset] = valueCoder.decode(data, offsetAndCase);
       if (isFullyNativeEnum(this.coders)) {
         return this.#decodeNativeEnum(caseKey, newOffset);
       }
       return [{ [caseKey]: decoded }, newOffset];
     }
   };
-  var OptionCoder = class extends EnumCoder {
-    encode(value) {
-      const result = super.encode(this.toSwayOption(value));
-      return result;
-    }
-    toSwayOption(input) {
-      if (input !== void 0) {
-        return { Some: input };
-      }
-      return { None: [] };
-    }
-    decode(data, offset) {
-      if (data.length < this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid option data size.`);
-      }
-      const [decoded, newOffset] = super.decode(data, offset);
-      return [this.toOption(decoded), newOffset];
-    }
-    toOption(output2) {
-      if (output2 && "Some" in output2) {
-        return output2.Some;
-      }
-      return void 0;
+  var getLength = (baseType) => {
+    switch (baseType) {
+      case "u8":
+        return 1;
+      case "u16":
+        return 2;
+      case "u32":
+        return 4;
+      default:
+        throw new FuelError(ErrorCode.TYPE_NOT_SUPPORTED, `Invalid number type: ${baseType}`);
     }
   };
   var NumberCoder = class extends Coder {
-    // This is to align the bits to the total bytes
-    // See https://github.com/FuelLabs/fuel-specs/blob/master/specs/protocol/abi.md#unsigned-integers
-    length;
-    paddingLength;
     baseType;
     options;
     constructor(baseType, options = {
-      isSmallBytes: false,
-      isRightPadded: false
+      padToWordSize: false
     }) {
-      const paddingLength = options.isSmallBytes && baseType === "u8" ? 1 : 8;
-      super("number", baseType, paddingLength);
+      const length = options.padToWordSize ? WORD_SIZE : getLength(baseType);
+      super("number", baseType, length);
       this.baseType = baseType;
-      switch (baseType) {
-        case "u8":
-          this.length = 1;
-          break;
-        case "u16":
-          this.length = 2;
-          break;
-        case "u32":
-        default:
-          this.length = 4;
-          break;
-      }
-      this.paddingLength = paddingLength;
       this.options = options;
     }
     encode(value) {
@@ -31618,142 +31437,140 @@ This unreleased fuel-core build may include features and updates not yet support
       } catch (error) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}.`);
       }
-      if (bytes2.length > this.length) {
+      if (bytes2.length > this.encodedLength) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.baseType}, too many bytes.`);
       }
-      const output2 = toBytes2(bytes2, this.paddingLength);
-      if (this.baseType !== "u8") {
-        return output2;
-      }
-      return this.options.isRightPadded ? output2.reverse() : output2;
-    }
-    decodeU8(data, offset) {
-      let bytes2;
-      if (this.options.isRightPadded) {
-        bytes2 = data.slice(offset, offset + 1);
-      } else {
-        bytes2 = data.slice(offset, offset + this.paddingLength);
-        bytes2 = bytes2.slice(this.paddingLength - this.length, this.paddingLength);
-      }
-      return [toNumber(bytes2), offset + this.paddingLength];
+      return toBytes2(bytes2, this.encodedLength);
     }
     decode(data, offset) {
-      if (data.length < this.paddingLength) {
+      if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number data size.`);
       }
-      if (this.baseType === "u8") {
-        return this.decodeU8(data, offset);
-      }
-      let bytes2 = data.slice(offset, offset + this.paddingLength);
-      bytes2 = bytes2.slice(8 - this.length, 8);
-      if (bytes2.length !== this.paddingLength - (this.paddingLength - this.length)) {
+      const bytes2 = data.slice(offset, offset + this.encodedLength);
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid number byte data size.`);
       }
-      return [toNumber(bytes2), offset + 8];
+      return [toNumber(bytes2), offset + this.encodedLength];
+    }
+  };
+  var 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) {
+      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 RawSliceCoder = class extends Coder {
     constructor() {
-      super("raw untyped slice", "raw untyped slice", BASE_RAW_SLICE_OFFSET);
+      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 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);
+      const internalCoder = new ArrayCoder(new NumberCoder("u8"), value.length);
+      const bytes2 = internalCoder.encode(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(bytes2.length);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
     }
     decode(data, offset) {
-      const dataBytes = data.slice(offset);
-      const internalCoder = new ArrayCoder(
-        new NumberCoder("u8", { isSmallBytes: true }),
-        dataBytes.length
-      );
+      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 NumberCoder("u8"), length);
       const [decodedValue] = internalCoder.decode(dataBytes, 0);
-      return [decodedValue, offset + dataBytes.length];
+      return [decodedValue, offsetAndLength + length];
     }
   };
-  var _getPaddedData2;
-  var getPaddedData_fn2;
   var StdStringCoder = class extends Coder {
     constructor() {
-      super("struct", "struct String", 1);
-      __privateAdd2(this, _getPaddedData2);
+      super("struct", "struct String", WORD_SIZE);
     }
     encode(value) {
-      const parts = [];
-      const pointer = new BigNumberCoder("u64").encode(BASE_VECTOR_OFFSET);
-      const data = __privateMethod2(this, _getPaddedData2, getPaddedData_fn2).call(this, value);
-      pointer.dynamicData = {
-        0: concatWithDynamicData([data])
-      };
-      parts.push(pointer);
-      parts.push(new BigNumberCoder("u64").encode(data.byteLength));
-      parts.push(new BigNumberCoder("u64").encode(value.length));
-      return concatWithDynamicData(parts);
+      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 len = data.slice(16, 24);
-      const encodedLength = bn(new BigNumberCoder("u64").decode(len, 0)[0]).toNumber();
-      const byteData = data.slice(BASE_VECTOR_OFFSET, BASE_VECTOR_OFFSET + encodedLength);
-      if (byteData.length !== encodedLength) {
+      const offsetAndLength = offset + WORD_SIZE;
+      const lengthBytes = data.slice(offset, offsetAndLength);
+      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
+      const dataBytes = data.slice(offsetAndLength, offsetAndLength + length);
+      if (dataBytes.length !== length) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid std string byte data size.`);
       }
-      const value = toUtf8String(byteData);
-      return [value, offset + BASE_VECTOR_OFFSET];
+      return [toUtf8String(dataBytes), 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(StdStringCoder, "memorySize", 1);
-  var StringCoder = class extends Coder {
-    length;
-    #paddingLength;
-    constructor(length) {
-      let paddingLength = (8 - length) % 8;
-      paddingLength = paddingLength < 0 ? paddingLength + 8 : paddingLength;
-      super("string", `str[${length}]`, length + paddingLength);
-      this.length = length;
-      this.#paddingLength = paddingLength;
+  var StrSliceCoder = class extends Coder {
+    constructor() {
+      super("strSlice", "str", WORD_SIZE);
     }
     encode(value) {
-      if (this.length !== value.length) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Value length mismatch during encode.`);
-      }
-      const encoded = toUtf8Bytes(value);
-      const padding = new Uint8Array(this.#paddingLength);
-      return concat([encoded, padding]);
+      const bytes2 = toUtf8Bytes(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(value.length);
+      return new Uint8Array([...lengthBytes, ...bytes2]);
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string slice data size.`);
+      }
+      const offsetAndLength = offset + WORD_SIZE;
+      const lengthBytes = data.slice(offset, offsetAndLength);
+      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
+      const bytes2 = data.slice(offsetAndLength, offsetAndLength + length);
+      if (bytes2.length !== length) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string slice byte data size.`);
+      }
+      return [toUtf8String(bytes2), offsetAndLength + length];
+    }
+  };
+  __publicField4(StrSliceCoder, "memorySize", 1);
+  var StringCoder = class extends Coder {
+    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.length);
-      if (bytes2.length !== this.length) {
+      const bytes2 = data.slice(offset, offset + this.encodedLength);
+      if (bytes2.length !== this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string byte data size.`);
       }
-      const value = toUtf8String(bytes2);
-      const padding = this.#paddingLength;
-      return [value, offset + this.length + padding];
+      return [toUtf8String(bytes2), offset + this.encodedLength];
     }
   };
   var StructCoder = class extends Coder {
@@ -31769,22 +31586,19 @@ This unreleased fuel-core build may include features and updates not yet support
       this.coders = coders;
     }
     encode(value) {
-      const encodedFields = Object.keys(this.coders).map((fieldName) => {
-        const fieldCoder = this.coders[fieldName];
-        const fieldValue = value[fieldName];
-        if (!(fieldCoder instanceof OptionCoder) && fieldValue == null) {
-          throw new FuelError(
-            ErrorCode.ENCODE_ERROR,
-            `Invalid ${this.type}. Field "${fieldName}" not present.`
-          );
-        }
-        const encoded = fieldCoder.encode(fieldValue);
-        if (!isMultipleOfWordSize(encoded.length)) {
-          return rightPadToWordSize(encoded);
-        }
-        return encoded;
-      });
-      return concatWithDynamicData([concatWithDynamicData(encodedFields)]);
+      return concatBytes2(
+        Object.keys(this.coders).map((fieldName) => {
+          const fieldCoder = this.coders[fieldName];
+          const fieldValue = value[fieldName];
+          if (!(fieldCoder instanceof OptionCoder) && fieldValue == null) {
+            throw new FuelError(
+              ErrorCode.ENCODE_ERROR,
+              `Invalid ${this.type}. Field "${fieldName}" not present.`
+            );
+          }
+          return fieldCoder.encode(fieldValue);
+        })
+      );
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -31795,9 +31609,6 @@ This unreleased fuel-core build may include features and updates not yet support
         const fieldCoder = this.coders[fieldName];
         let decoded;
         [decoded, newOffset] = fieldCoder.decode(data, newOffset);
-        if (!isMultipleOfWordSize(newOffset)) {
-          newOffset += getWordSizePadding(newOffset);
-        }
         obj[fieldName] = decoded;
         return obj;
       }, {});
@@ -31815,15 +31626,7 @@ This unreleased fuel-core build may include features and updates not yet support
       if (this.coders.length !== value.length) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Types/values length mismatch.`);
       }
-      return concatWithDynamicData(
-        this.coders.map((coder, i) => {
-          const encoded = coder.encode(value[i]);
-          if (!isMultipleOfWordSize(encoded.length)) {
-            return rightPadToWordSize(encoded);
-          }
-          return encoded;
-        })
-      );
+      return concatBytes2(this.coders.map((coder, i) => coder.encode(value[i])));
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -31833,19 +31636,19 @@ This unreleased fuel-core build may include features and updates not yet support
       const decodedValue = this.coders.map((coder) => {
         let decoded;
         [decoded, newOffset] = coder.decode(data, newOffset);
-        if (!isMultipleOfWordSize(newOffset)) {
-          newOffset += getWordSizePadding(newOffset);
-        }
         return decoded;
       });
       return [decodedValue, newOffset];
     }
   };
+  var isUint8Array = (value) => value instanceof Uint8Array;
   var VecCoder = class extends Coder {
     coder;
+    #isOptionVec;
     constructor(coder) {
-      super("struct", `struct Vec`, coder.encodedLength + BASE_VECTOR_OFFSET);
+      super("struct", `struct Vec`, coder.encodedLength + WORD_SIZE);
       this.coder = coder;
+      this.#isOptionVec = this.coder instanceof OptionCoder;
     }
     encode(value) {
       if (!Array.isArray(value) && !isUint8Array(value)) {
@@ -31854,40 +31657,39 @@ This unreleased fuel-core build may include features and updates not yet support
           `Expected array value, or a Uint8Array. You can use arrayify to convert a value to a Uint8Array.`
         );
       }
-      const parts = [];
-      const pointer = new BigNumberCoder("u64").encode(BASE_VECTOR_OFFSET);
-      pointer.dynamicData = {
-        0: concatWithDynamicData(Array.from(value).map((v) => this.coder.encode(v)))
-      };
-      parts.push(pointer);
-      parts.push(new BigNumberCoder("u64").encode(value.length));
-      parts.push(new BigNumberCoder("u64").encode(value.length));
-      return concatWithDynamicData(parts);
+      const lengthCoder = new BigNumberCoder("u64");
+      if (isUint8Array(value)) {
+        return new Uint8Array([...lengthCoder.encode(value.length), ...value]);
+      }
+      const bytes2 = value.map((v) => this.coder.encode(v));
+      const lengthBytes = lengthCoder.encode(value.length);
+      return new Uint8Array([...lengthBytes, ...concatBytes2(bytes2)]);
     }
     decode(data, offset) {
-      if (data.length < BASE_VECTOR_OFFSET || data.length > MAX_BYTES) {
+      if (!this.#isOptionVec && (data.length < this.encodedLength || data.length > MAX_BYTES)) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec data size.`);
       }
-      const len = data.slice(16, 24);
-      const encodedLength = bn(new BigNumberCoder("u64").decode(len, 0)[0]).toNumber();
-      const vectorRawDataLength = encodedLength * this.coder.encodedLength;
-      const vectorRawData = data.slice(BASE_VECTOR_OFFSET, BASE_VECTOR_OFFSET + vectorRawDataLength);
-      if (vectorRawData.length !== vectorRawDataLength) {
+      const offsetAndLength = offset + WORD_SIZE;
+      const lengthBytes = data.slice(offset, offsetAndLength);
+      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
+      const dataLength2 = length * this.coder.encodedLength;
+      const dataBytes = data.slice(offsetAndLength, offsetAndLength + dataLength2);
+      if (!this.#isOptionVec && dataBytes.length !== dataLength2) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec byte data size.`);
       }
-      return [
-        chunkByLength(vectorRawData, this.coder.encodedLength).map(
-          (chunk) => this.coder.decode(chunk, 0)[0]
-        ),
-        offset + BASE_VECTOR_OFFSET
-      ];
+      let newOffset = offsetAndLength;
+      const chunks = [];
+      for (let i = 0; i < length; i++) {
+        const [decoded, optionOffset] = this.coder.decode(data, newOffset);
+        chunks.push(decoded);
+        newOffset = optionOffset;
+      }
+      return [chunks, newOffset];
     }
   };
   var getEncodingVersion = (encoding) => {
     switch (encoding) {
       case void 0:
-      case ENCODING_V0:
-        return ENCODING_V0;
       case ENCODING_V1:
         return ENCODING_V1;
       default:
@@ -31924,653 +31726,175 @@ This unreleased fuel-core build may include features and updates not yet support
     if (!bufferComponent || !bufferTypeArgument) {
       throw new FuelError(
         ErrorCode.INVALID_COMPONENT,
-        `The Vec type provided is missing or has a malformed 'buf' component.`
-      );
-    }
-    return bufferTypeArgument;
-  };
-  var ResolvedAbiType = class {
-    abi;
-    name;
-    type;
-    originalTypeArguments;
-    components;
-    constructor(abi, argument) {
-      this.abi = abi;
-      this.name = argument.name;
-      const type3 = findTypeById(abi, argument.type);
-      this.type = type3.type;
-      this.originalTypeArguments = argument.typeArguments;
-      this.components = ResolvedAbiType.getResolvedGenericComponents(
-        abi,
-        argument,
-        type3.components,
-        type3.typeParameters ?? ResolvedAbiType.getImplicitGenericTypeParameters(abi, type3.components)
-      );
-    }
-    static getResolvedGenericComponents(abi, arg, components, typeParameters) {
-      if (components === null) {
-        return null;
-      }
-      if (typeParameters === null || typeParameters.length === 0) {
-        return components.map((c) => new ResolvedAbiType(abi, c));
-      }
-      const typeParametersAndArgsMap = typeParameters.reduce(
-        (obj, typeParameter, typeParameterIndex) => {
-          const o = { ...obj };
-          o[typeParameter] = structuredClone(
-            arg.typeArguments?.[typeParameterIndex]
-          );
-          return o;
-        },
-        {}
-      );
-      const resolvedComponents = this.resolveGenericArgTypes(
-        abi,
-        components,
-        typeParametersAndArgsMap
-      );
-      return resolvedComponents.map((c) => new ResolvedAbiType(abi, c));
-    }
-    static resolveGenericArgTypes(abi, args, typeParametersAndArgsMap) {
-      return args.map((arg) => {
-        if (typeParametersAndArgsMap[arg.type] !== void 0) {
-          return {
-            ...typeParametersAndArgsMap[arg.type],
-            name: arg.name
-          };
-        }
-        if (arg.typeArguments) {
-          return {
-            ...structuredClone(arg),
-            typeArguments: this.resolveGenericArgTypes(
-              abi,
-              arg.typeArguments,
-              typeParametersAndArgsMap
-            )
-          };
-        }
-        const argType = findTypeById(abi, arg.type);
-        const implicitTypeParameters = this.getImplicitGenericTypeParameters(abi, argType.components);
-        if (implicitTypeParameters && implicitTypeParameters.length > 0) {
-          return {
-            ...structuredClone(arg),
-            typeArguments: implicitTypeParameters.map((itp) => typeParametersAndArgsMap[itp])
-          };
-        }
-        return arg;
-      });
-    }
-    static getImplicitGenericTypeParameters(abi, args, implicitGenericParametersParam) {
-      if (!Array.isArray(args)) {
-        return null;
-      }
-      const implicitGenericParameters = implicitGenericParametersParam ?? [];
-      args.forEach((a) => {
-        const argType = findTypeById(abi, a.type);
-        if (genericRegEx.test(argType.type)) {
-          implicitGenericParameters.push(argType.typeId);
-          return;
-        }
-        if (!Array.isArray(a.typeArguments)) {
-          return;
-        }
-        this.getImplicitGenericTypeParameters(abi, a.typeArguments, implicitGenericParameters);
-      });
-      return implicitGenericParameters.length > 0 ? implicitGenericParameters : null;
-    }
-    getSignature() {
-      const prefix = this.getArgSignaturePrefix();
-      const content = this.getArgSignatureContent();
-      return `${prefix}${content}`;
-    }
-    getArgSignaturePrefix() {
-      const structMatch = structRegEx.test(this.type);
-      if (structMatch) {
-        return "s";
-      }
-      const arrayMatch = arrayRegEx.test(this.type);
-      if (arrayMatch) {
-        return "a";
-      }
-      const enumMatch = enumRegEx.test(this.type);
-      if (enumMatch) {
-        return "e";
-      }
-      return "";
-    }
-    getArgSignatureContent() {
-      if (this.type === "raw untyped ptr") {
-        return "rawptr";
-      }
-      if (this.type === "raw untyped slice") {
-        return "rawslice";
-      }
-      const strMatch = stringRegEx.exec(this.type)?.groups;
-      if (strMatch) {
-        return `str[${strMatch.length}]`;
-      }
-      if (this.components === null) {
-        return this.type;
-      }
-      const arrayMatch = arrayRegEx.exec(this.type)?.groups;
-      if (arrayMatch) {
-        return `[${this.components[0].getSignature()};${arrayMatch.length}]`;
-      }
-      const typeArgumentsSignature = this.originalTypeArguments !== null ? `<${this.originalTypeArguments.map((a) => new ResolvedAbiType(this.abi, a).getSignature()).join(",")}>` : "";
-      const componentsSignature = `(${this.components.map((c) => c.getSignature()).join(",")})`;
-      return `${typeArgumentsSignature}${componentsSignature}`;
-    }
-  };
-  function getCoders(components, options) {
-    const { getCoder: getCoder3 } = options;
-    return components.reduce((obj, component) => {
-      const o = obj;
-      o[component.name] = getCoder3(component, options);
-      return o;
-    }, {});
-  }
-  var getCoder = (resolvedAbiType, options) => {
-    switch (resolvedAbiType.type) {
-      case U8_CODER_TYPE:
-      case U16_CODER_TYPE:
-      case U32_CODER_TYPE:
-        return new NumberCoder(resolvedAbiType.type, options);
-      case U64_CODER_TYPE:
-      case RAW_PTR_CODER_TYPE:
-        return new BigNumberCoder("u64");
-      case U256_CODER_TYPE:
-        return new BigNumberCoder("u256");
-      case RAW_SLICE_CODER_TYPE:
-        return new RawSliceCoder();
-      case BOOL_CODER_TYPE:
-        return new BooleanCoder(options);
-      case B256_CODER_TYPE:
-        return new B256Coder();
-      case B512_CODER_TYPE:
-        return new B512Coder();
-      case BYTES_CODER_TYPE:
-        return new ByteCoder();
-      case STD_STRING_CODER_TYPE:
-        return new StdStringCoder();
-      default:
-        break;
-    }
-    const stringMatch = stringRegEx.exec(resolvedAbiType.type)?.groups;
-    if (stringMatch) {
-      const length = parseInt(stringMatch.length, 10);
-      return new StringCoder(length);
-    }
-    const components = resolvedAbiType.components;
-    const arrayMatch = arrayRegEx.exec(resolvedAbiType.type)?.groups;
-    if (arrayMatch) {
-      const length = parseInt(arrayMatch.length, 10);
-      const arg = components[0];
-      if (!arg) {
-        throw new FuelError(
-          ErrorCode.INVALID_COMPONENT,
-          `The provided Array type is missing an item of 'component'.`
-        );
-      }
-      const arrayElementCoder = getCoder(arg, { isSmallBytes: true });
-      return new ArrayCoder(arrayElementCoder, length);
-    }
-    if (resolvedAbiType.type === VEC_CODER_TYPE) {
-      const arg = findVectorBufferArgument(components);
-      const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
-      const itemCoder = getCoder(argType, { isSmallBytes: true, encoding: ENCODING_V0 });
-      return new VecCoder(itemCoder);
-    }
-    const structMatch = structRegEx.exec(resolvedAbiType.type)?.groups;
-    if (structMatch) {
-      const coders = getCoders(components, { isRightPadded: true, getCoder });
-      return new StructCoder(structMatch.name, coders);
-    }
-    const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
-    if (enumMatch) {
-      const coders = getCoders(components, { getCoder });
-      const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
-      if (isOptionEnum) {
-        return new OptionCoder(enumMatch.name, coders);
-      }
-      return new EnumCoder(enumMatch.name, coders);
-    }
-    const tupleMatch = tupleRegEx.exec(resolvedAbiType.type)?.groups;
-    if (tupleMatch) {
-      const coders = components.map(
-        (component) => getCoder(component, { isRightPadded: true, encoding: ENCODING_V0 })
-      );
-      return new TupleCoder(coders);
-    }
-    if (resolvedAbiType.type === STR_SLICE_CODER_TYPE) {
-      throw new FuelError(
-        ErrorCode.INVALID_DATA,
-        "String slices can not be decoded from logs. Convert the slice to `str[N]` with `__to_str_array`"
-      );
-    }
-    throw new FuelError(
-      ErrorCode.CODER_NOT_FOUND,
-      `Coder not found: ${JSON.stringify(resolvedAbiType)}.`
-    );
-  };
-  var BooleanCoder2 = class extends Coder {
-    constructor() {
-      super("boolean", "boolean", 1);
-    }
-    encode(value) {
-      const isTrueBool = value === true || value === false;
-      if (!isTrueBool) {
-        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];
+        `The Vec type provided is missing or has a malformed 'buf' component.`
+      );
     }
+    return bufferTypeArgument;
   };
-  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;
+  var ResolvedAbiType = class {
+    abi;
+    name;
+    type;
+    originalTypeArguments;
+    components;
+    constructor(abi, argument) {
+      this.abi = abi;
+      this.name = argument.name;
+      const type3 = findTypeById(abi, argument.type);
+      this.type = type3.type;
+      this.originalTypeArguments = argument.typeArguments;
+      this.components = ResolvedAbiType.getResolvedGenericComponents(
+        abi,
+        argument,
+        type3.components,
+        type3.typeParameters ?? ResolvedAbiType.getImplicitGenericTypeParameters(abi, type3.components)
+      );
     }
-    encode(value) {
-      if (this.coders.length !== value.length) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Types/values length mismatch.`);
+    static getResolvedGenericComponents(abi, arg, components, typeParameters) {
+      if (components === null) {
+        return null;
       }
-      return concatBytes2(this.coders.map((coder, i) => coder.encode(value[i])));
+      if (typeParameters === null || typeParameters.length === 0) {
+        return components.map((c) => new ResolvedAbiType(abi, c));
+      }
+      const typeParametersAndArgsMap = typeParameters.reduce(
+        (obj, typeParameter, typeParameterIndex) => {
+          const o = { ...obj };
+          o[typeParameter] = structuredClone(
+            arg.typeArguments?.[typeParameterIndex]
+          );
+          return o;
+        },
+        {}
+      );
+      const resolvedComponents = this.resolveGenericArgTypes(
+        abi,
+        components,
+        typeParametersAndArgsMap
+      );
+      return resolvedComponents.map((c) => new ResolvedAbiType(abi, c));
     }
-    decode(data, offset) {
-      if (data.length < this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid tuple data size.`);
+    static resolveGenericArgTypes(abi, args, typeParametersAndArgsMap) {
+      return args.map((arg) => {
+        if (typeParametersAndArgsMap[arg.type] !== void 0) {
+          return {
+            ...typeParametersAndArgsMap[arg.type],
+            name: arg.name
+          };
+        }
+        if (arg.typeArguments) {
+          return {
+            ...structuredClone(arg),
+            typeArguments: this.resolveGenericArgTypes(
+              abi,
+              arg.typeArguments,
+              typeParametersAndArgsMap
+            )
+          };
+        }
+        const argType = findTypeById(abi, arg.type);
+        const implicitTypeParameters = this.getImplicitGenericTypeParameters(abi, argType.components);
+        if (implicitTypeParameters && implicitTypeParameters.length > 0) {
+          return {
+            ...structuredClone(arg),
+            typeArguments: implicitTypeParameters.map((itp) => typeParametersAndArgsMap[itp])
+          };
+        }
+        return arg;
+      });
+    }
+    static getImplicitGenericTypeParameters(abi, args, implicitGenericParametersParam) {
+      if (!Array.isArray(args)) {
+        return null;
       }
-      let newOffset = offset;
-      const decodedValue = this.coders.map((coder) => {
-        let decoded;
-        [decoded, newOffset] = coder.decode(data, newOffset);
-        return decoded;
+      const implicitGenericParameters = implicitGenericParametersParam ?? [];
+      args.forEach((a) => {
+        const argType = findTypeById(abi, a.type);
+        if (genericRegEx.test(argType.type)) {
+          implicitGenericParameters.push(argType.typeId);
+          return;
+        }
+        if (!Array.isArray(a.typeArguments)) {
+          return;
+        }
+        this.getImplicitGenericTypeParameters(abi, a.typeArguments, implicitGenericParameters);
       });
-      return [decodedValue, newOffset];
+      return implicitGenericParameters.length > 0 ? implicitGenericParameters : null;
     }
-  };
-  var VecCoder2 = class extends Coder {
-    coder;
-    #isOptionVec;
-    constructor(coder) {
-      super("struct", `struct Vec`, coder.encodedLength + WORD_SIZE);
-      this.coder = coder;
-      this.#isOptionVec = this.coder instanceof OptionCoder2;
+    getSignature() {
+      const prefix = this.getArgSignaturePrefix();
+      const content = this.getArgSignatureContent();
+      return `${prefix}${content}`;
     }
-    encode(value) {
-      if (!Array.isArray(value) && !isUint8Array(value)) {
-        throw new FuelError(
-          ErrorCode.ENCODE_ERROR,
-          `Expected array value, or a Uint8Array. You can use arrayify to convert a value to a Uint8Array.`
-        );
+    getArgSignaturePrefix() {
+      const structMatch = structRegEx.test(this.type);
+      if (structMatch) {
+        return "s";
       }
-      const lengthCoder = new BigNumberCoder("u64");
-      if (isUint8Array(value)) {
-        return new Uint8Array([...lengthCoder.encode(value.length), ...value]);
+      const arrayMatch = arrayRegEx.test(this.type);
+      if (arrayMatch) {
+        return "a";
       }
-      const bytes2 = value.map((v) => this.coder.encode(v));
-      const lengthBytes = lengthCoder.encode(value.length);
-      return new Uint8Array([...lengthBytes, ...concatBytes2(bytes2)]);
+      const enumMatch = enumRegEx.test(this.type);
+      if (enumMatch) {
+        return "e";
+      }
+      return "";
     }
-    decode(data, offset) {
-      if (!this.#isOptionVec && (data.length < this.encodedLength || data.length > MAX_BYTES)) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec data size.`);
+    getArgSignatureContent() {
+      if (this.type === "raw untyped ptr") {
+        return "rawptr";
       }
-      const offsetAndLength = offset + WORD_SIZE;
-      const lengthBytes = data.slice(offset, offsetAndLength);
-      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
-      const dataLength2 = length * this.coder.encodedLength;
-      const dataBytes = data.slice(offsetAndLength, offsetAndLength + dataLength2);
-      if (!this.#isOptionVec && dataBytes.length !== dataLength2) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec byte data size.`);
+      if (this.type === "raw untyped slice") {
+        return "rawslice";
       }
-      let newOffset = offsetAndLength;
-      const chunks = [];
-      for (let i = 0; i < length; i++) {
-        const [decoded, optionOffset] = this.coder.decode(data, newOffset);
-        chunks.push(decoded);
-        newOffset = optionOffset;
+      const strMatch = stringRegEx.exec(this.type)?.groups;
+      if (strMatch) {
+        return `str[${strMatch.length}]`;
       }
-      return [chunks, newOffset];
+      if (this.components === null) {
+        return this.type;
+      }
+      const arrayMatch = arrayRegEx.exec(this.type)?.groups;
+      if (arrayMatch) {
+        return `[${this.components[0].getSignature()};${arrayMatch.length}]`;
+      }
+      const typeArgumentsSignature = this.originalTypeArguments !== null ? `<${this.originalTypeArguments.map((a) => new ResolvedAbiType(this.abi, a).getSignature()).join(",")}>` : "";
+      const componentsSignature = `(${this.components.map((c) => c.getSignature()).join(",")})`;
+      return `${typeArgumentsSignature}${componentsSignature}`;
     }
   };
-  var getCoder2 = (resolvedAbiType, _options) => {
+  function getCoders(components, options) {
+    const { getCoder: getCoder2 } = options;
+    return components.reduce((obj, component) => {
+      const o = obj;
+      o[component.name] = getCoder2(component, options);
+      return o;
+    }, {});
+  }
+  var getCoder = (resolvedAbiType, _options) => {
     switch (resolvedAbiType.type) {
       case U8_CODER_TYPE:
       case U16_CODER_TYPE:
       case U32_CODER_TYPE:
-        return new NumberCoder2(resolvedAbiType.type);
+        return new NumberCoder(resolvedAbiType.type);
       case U64_CODER_TYPE:
       case RAW_PTR_CODER_TYPE:
         return new BigNumberCoder("u64");
       case U256_CODER_TYPE:
         return new BigNumberCoder("u256");
       case RAW_SLICE_CODER_TYPE:
-        return new RawSliceCoder2();
+        return new RawSliceCoder();
       case BOOL_CODER_TYPE:
-        return new BooleanCoder2();
+        return new BooleanCoder();
       case B256_CODER_TYPE:
         return new B256Coder();
       case B512_CODER_TYPE:
         return new B512Coder();
       case BYTES_CODER_TYPE:
-        return new ByteCoder2();
+        return new ByteCoder();
       case STD_STRING_CODER_TYPE:
-        return new StdStringCoder2();
+        return new StdStringCoder();
       case STR_SLICE_CODER_TYPE:
         return new StrSliceCoder();
       default:
@@ -32579,7 +31903,7 @@ This unreleased fuel-core build may include features and updates not yet support
     const stringMatch = stringRegEx.exec(resolvedAbiType.type)?.groups;
     if (stringMatch) {
       const length = parseInt(stringMatch.length, 10);
-      return new StringCoder2(length);
+      return new StringCoder(length);
     }
     const components = resolvedAbiType.components;
     const arrayMatch = arrayRegEx.exec(resolvedAbiType.type)?.groups;
@@ -32592,46 +31916,42 @@ This unreleased fuel-core build may include features and updates not yet support
           `The provided Array type is missing an item of 'component'.`
         );
       }
-      const arrayElementCoder = getCoder2(arg, { isSmallBytes: true });
+      const arrayElementCoder = getCoder(arg);
       return new ArrayCoder(arrayElementCoder, length);
     }
     if (resolvedAbiType.type === VEC_CODER_TYPE) {
       const arg = findVectorBufferArgument(components);
       const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
-      const itemCoder = getCoder2(argType, { isSmallBytes: true, encoding: ENCODING_V0 });
-      return new VecCoder2(itemCoder);
+      const itemCoder = getCoder(argType, { encoding: ENCODING_V1 });
+      return new VecCoder(itemCoder);
     }
     const structMatch = structRegEx.exec(resolvedAbiType.type)?.groups;
     if (structMatch) {
-      const coders = getCoders(components, { isRightPadded: true, getCoder: getCoder2 });
-      return new StructCoder2(structMatch.name, coders);
+      const coders = getCoders(components, { getCoder });
+      return new StructCoder(structMatch.name, coders);
     }
     const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
     if (enumMatch) {
-      const coders = getCoders(components, { getCoder: getCoder2 });
+      const coders = getCoders(components, { getCoder });
       const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
       if (isOptionEnum) {
-        return new OptionCoder2(enumMatch.name, coders);
+        return new OptionCoder(enumMatch.name, coders);
       }
-      return new EnumCoder2(enumMatch.name, coders);
+      return new EnumCoder(enumMatch.name, coders);
     }
     const tupleMatch = tupleRegEx.exec(resolvedAbiType.type)?.groups;
     if (tupleMatch) {
-      const coders = components.map(
-        (component) => getCoder2(component, { isRightPadded: true, encoding: ENCODING_V0 })
-      );
-      return new TupleCoder2(coders);
+      const coders = components.map((component) => getCoder(component, { encoding: ENCODING_V1 }));
+      return new TupleCoder(coders);
     }
     throw new FuelError(
       ErrorCode.CODER_NOT_FOUND,
       `Coder not found: ${JSON.stringify(resolvedAbiType)}.`
     );
   };
-  function getCoderForEncoding(encoding = ENCODING_V0) {
+  function getCoderForEncoding(encoding = ENCODING_V1) {
     switch (encoding) {
       case ENCODING_V1:
-        return getCoder2;
-      case ENCODING_V0:
         return getCoder;
       default:
         throw new FuelError(
@@ -32642,7 +31962,7 @@ This unreleased fuel-core build may include features and updates not yet support
   }
   var AbiCoder = class {
     static getCoder(abi, argument, options = {
-      isSmallBytes: false
+      padToWordSize: false
     }) {
       const resolvedAbiType = new ResolvedAbiType(abi, argument);
       return getCoderForEncoding(options.encoding)(resolvedAbiType, options);
@@ -32662,8 +31982,6 @@ This unreleased fuel-core build may include features and updates not yet support
     name;
     jsonFn;
     attributes;
-    isInputDataPointer;
-    outputMetadata;
     jsonAbi;
     constructor(jsonAbi, name) {
       this.jsonAbi = jsonAbi;
@@ -32671,13 +31989,8 @@ This unreleased fuel-core build may include features and updates not yet support
       this.name = name;
       this.signature = FunctionFragment.getSignature(this.jsonAbi, this.jsonFn);
       this.selector = FunctionFragment.getFunctionSelector(this.signature);
-      this.selectorBytes = new StdStringCoder2().encode(name);
+      this.selectorBytes = new StdStringCoder().encode(name);
       this.encoding = getEncodingVersion(jsonAbi.encoding);
-      this.isInputDataPointer = this.#isInputDataPointer();
-      this.outputMetadata = {
-        isHeapType: this.#isOutputDataHeap(),
-        encodedLength: this.#getOutputEncodedLength()
-      };
       this.attributes = this.jsonFn.attributes ?? [];
     }
     static getSignature(abi, fn) {
@@ -32690,29 +32003,7 @@ This unreleased fuel-core build may include features and updates not yet support
       const hashedFunctionSignature = sha2562(bufferFromString2(functionSignature, "utf-8"));
       return bn(hashedFunctionSignature.slice(0, 10)).toHex(8);
     }
-    #isInputDataPointer() {
-      const inputTypes = this.jsonFn.inputs.map((i) => findTypeById(this.jsonAbi, i.type));
-      return this.jsonFn.inputs.length > 1 || isPointerType(inputTypes[0]?.type || "");
-    }
-    #isOutputDataHeap() {
-      const outputType = findTypeById(this.jsonAbi, this.jsonFn.output.type);
-      return isHeapType(outputType?.type || "");
-    }
-    #getOutputEncodedLength() {
-      try {
-        const heapCoder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output);
-        if (heapCoder instanceof VecCoder) {
-          return heapCoder.coder.encodedLength;
-        }
-        if (heapCoder instanceof ByteCoder) {
-          return ByteCoder.memorySize;
-        }
-        return heapCoder.encodedLength;
-      } catch (e) {
-        return 0;
-      }
-    }
-    encodeArguments(values, offset = 0) {
+    encodeArguments(values) {
       FunctionFragment.verifyArgsAndInputsAlign(values, this.jsonFn.inputs, this.jsonAbi);
       const shallowCopyValues = values.slice();
       const nonEmptyInputs = findNonEmptyInputs(this.jsonAbi, this.jsonFn.inputs);
@@ -32722,15 +32013,10 @@ This unreleased fuel-core build may include features and updates not yet support
       }
       const coders = nonEmptyInputs.map(
         (t) => AbiCoder.getCoder(this.jsonAbi, t, {
-          isRightPadded: nonEmptyInputs.length > 1,
           encoding: this.encoding
         })
       );
-      if (this.encoding === ENCODING_V1) {
-        return new TupleCoder2(coders).encode(shallowCopyValues);
-      }
-      const results = new TupleCoder(coders).encode(shallowCopyValues);
-      return unpackDynamicData(results, offset, results.byteLength);
+      return new TupleCoder(coders).encode(shallowCopyValues);
     }
     static verifyArgsAndInputsAlign(args, inputs, abi) {
       if (args.length === inputs.length) {
@@ -32839,9 +32125,9 @@ This unreleased fuel-core build may include features and updates not yet support
       const fragment = typeof functionFragment === "string" ? this.getFunction(functionFragment) : functionFragment;
       return fragment.decodeArguments(data);
     }
-    encodeFunctionData(functionFragment, values, offset = 0) {
+    encodeFunctionData(functionFragment, values) {
       const fragment = typeof functionFragment === "string" ? this.getFunction(functionFragment) : functionFragment;
-      return fragment.encodeArguments(values, offset);
+      return fragment.encodeArguments(values);
     }
     // Decode the result of a function call
     decodeFunctionResult(functionFragment, data) {
@@ -32869,9 +32155,7 @@ This unreleased fuel-core build may include features and updates not yet support
         );
       }
       return AbiCoder.encode(this.jsonAbi, configurable.configurableType, value, {
-        isRightPadded: true,
-        // TODO: Review support for configurables in v1 encoding when it becomes available
-        encoding: ENCODING_V0
+        encoding: this.encoding
       });
     }
     getTypeById(typeId) {
@@ -32921,8 +32205,8 @@ This unreleased fuel-core build may include features and updates not yet support
   var TxPointerCoder = class extends StructCoder {
     constructor() {
       super("TxPointer", {
-        blockHeight: new NumberCoder("u32"),
-        txIndex: new NumberCoder("u16")
+        blockHeight: new NumberCoder("u32", { padToWordSize: true }),
+        txIndex: new NumberCoder("u16", { padToWordSize: true })
       });
     }
   };
@@ -32939,12 +32223,12 @@ This unreleased fuel-core build may include features and updates not yet support
     encode(value) {
       const parts = [];
       parts.push(new B256Coder().encode(value.txID));
-      parts.push(new NumberCoder("u16").encode(value.outputIndex));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputIndex));
       parts.push(new B256Coder().encode(value.owner));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(new B256Coder().encode(value.assetId));
       parts.push(new TxPointerCoder().encode(value.txPointer));
-      parts.push(new NumberCoder("u16").encode(value.witnessIndex));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessIndex));
       parts.push(new BigNumberCoder("u64").encode(value.predicateGasUsed));
       parts.push(new BigNumberCoder("u64").encode(value.predicateLength));
       parts.push(new BigNumberCoder("u64").encode(value.predicateDataLength));
@@ -32959,7 +32243,7 @@ This unreleased fuel-core build may include features and updates not yet support
       let o = offset;
       [decoded, o] = new B256Coder().decode(data, o);
       const txID = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const outputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const owner = decoded;
@@ -32969,7 +32253,7 @@ This unreleased fuel-core build may include features and updates not yet support
       const assetId = decoded;
       [decoded, o] = new TxPointerCoder().decode(data, o);
       const txPointer = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const witnessIndex = Number(decoded);
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateGasUsed = decoded;
@@ -33008,7 +32292,7 @@ This unreleased fuel-core build may include features and updates not yet support
     encode(value) {
       const parts = [];
       parts.push(new B256Coder().encode(value.txID));
-      parts.push(new NumberCoder("u16").encode(value.outputIndex));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputIndex));
       parts.push(new B256Coder().encode(value.balanceRoot));
       parts.push(new B256Coder().encode(value.stateRoot));
       parts.push(new TxPointerCoder().encode(value.txPointer));
@@ -33020,7 +32304,7 @@ This unreleased fuel-core build may include features and updates not yet support
       let o = offset;
       [decoded, o] = new B256Coder().decode(data, o);
       const txID = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const outputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const balanceRoot = decoded;
@@ -33069,7 +32353,7 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new ByteArrayCoder(32).encode(value.recipient));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(new ByteArrayCoder(32).encode(value.nonce));
-      parts.push(new NumberCoder("u16").encode(value.witnessIndex));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessIndex));
       parts.push(new BigNumberCoder("u64").encode(value.predicateGasUsed));
       parts.push(new BigNumberCoder("u64").encode(data.length));
       parts.push(new BigNumberCoder("u64").encode(value.predicateLength));
@@ -33098,11 +32382,11 @@ This unreleased fuel-core build may include features and updates not yet support
       const amount = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const nonce = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const witnessIndex = Number(decoded);
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateGasUsed = decoded;
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
       const dataLength2 = decoded;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const predicateLength = decoded;
@@ -33140,7 +32424,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8").encode(value.type));
+      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.type));
       const { type: type3 } = value;
       switch (type3) {
         case 0: {
@@ -33167,7 +32451,7 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
@@ -33236,7 +32520,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8").encode(value.inputIndex));
+      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.inputIndex));
       parts.push(new B256Coder().encode(value.balanceRoot));
       parts.push(new B256Coder().encode(value.stateRoot));
       return concat(parts);
@@ -33244,7 +32528,7 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
       const inputIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const balanceRoot = decoded;
@@ -33356,7 +32640,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8").encode(value.type));
+      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.type));
       const { type: type3 } = value;
       switch (type3) {
         case 0: {
@@ -33391,7 +32675,7 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
@@ -33459,7 +32743,7 @@ This unreleased fuel-core build may include features and updates not yet support
             parts.push(new BigNumberCoder("u64").encode(data));
             break;
           case 4:
-            parts.push(new NumberCoder("u32").encode(data));
+            parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(data));
             break;
           default: {
             throw new FuelError(ErrorCode.INVALID_POLICY_TYPE, `Invalid policy type: ${type3}`);
@@ -33482,7 +32766,10 @@ This unreleased fuel-core build may include features and updates not yet support
         policies.push({ type: 2, data: witnessLimit });
       }
       if (policyTypes & 4) {
-        const [maturity, nextOffset] = new NumberCoder("u32").decode(data, o);
+        const [maturity, nextOffset] = new NumberCoder("u32", { padToWordSize: true }).decode(
+          data,
+          o
+        );
         o = nextOffset;
         policies.push({ type: 4, data: maturity });
       }
@@ -33529,7 +32816,7 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new B256Coder().encode(value.recipient));
       parts.push(new BigNumberCoder("u64").encode(value.amount));
       parts.push(new B256Coder().encode(value.nonce));
-      parts.push(new NumberCoder("u16").encode(value.data.length));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.data.length));
       parts.push(new B256Coder().encode(value.digest));
       parts.push(new ByteArrayCoder(value.data.length).encode(value.data));
       return concat(parts);
@@ -33545,7 +32832,7 @@ This unreleased fuel-core build may include features and updates not yet support
       const amount = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const nonce = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const len = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const digest = decoded;
@@ -33669,11 +32956,11 @@ This unreleased fuel-core build may include features and updates not yet support
     encode(upgradePurposeType) {
       const parts = [];
       const { type: type3 } = upgradePurposeType;
-      parts.push(new NumberCoder("u8").encode(type3));
+      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(type3));
       switch (type3) {
         case 0: {
           const data = upgradePurposeType.data;
-          parts.push(new NumberCoder("u16").encode(data.witnessIndex));
+          parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(data.witnessIndex));
           parts.push(new B256Coder().encode(data.checksum));
           break;
         }
@@ -33694,11 +32981,11 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let o = offset;
       let decoded;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
-          [decoded, o] = new NumberCoder("u16").decode(data, o);
+          [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
           const witnessIndex = decoded;
           [decoded, o] = new B256Coder().decode(data, o);
           const checksum = decoded;
@@ -33729,14 +33016,14 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u32").encode(value.dataLength));
+      parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(value.dataLength));
       parts.push(new ByteArrayCoder(value.dataLength).encode(value.data));
       return concat(parts);
     }
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
       const dataLength2 = decoded;
       [decoded, o] = new ByteArrayCoder(dataLength2).decode(data, o);
       const witnessData = decoded;
@@ -33767,10 +33054,10 @@ This unreleased fuel-core build may include features and updates not yet support
       parts.push(new B256Coder().encode(value.receiptsRoot));
       parts.push(new BigNumberCoder("u64").encode(value.scriptLength));
       parts.push(new BigNumberCoder("u64").encode(value.scriptDataLength));
-      parts.push(new NumberCoder("u32").encode(value.policyTypes));
-      parts.push(new NumberCoder("u16").encode(value.inputsCount));
-      parts.push(new NumberCoder("u16").encode(value.outputsCount));
-      parts.push(new NumberCoder("u16").encode(value.witnessesCount));
+      parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(value.policyTypes));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.inputsCount));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputsCount));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessesCount));
       parts.push(new ByteArrayCoder(value.scriptLength.toNumber()).encode(value.script));
       parts.push(new ByteArrayCoder(value.scriptDataLength.toNumber()).encode(value.scriptData));
       parts.push(new PoliciesCoder().encode(value.policies));
@@ -33790,13 +33077,13 @@ This unreleased fuel-core build may include features and updates not yet support
       const scriptLength = decoded;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const scriptDataLength = decoded;
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
       const policyTypes = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const inputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const outputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const witnessesCount = decoded;
       [decoded, o] = new ByteArrayCoder(scriptLength.toNumber()).decode(data, o);
       const script = decoded;
@@ -33838,13 +33125,13 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u16").encode(value.bytecodeWitnessIndex));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.bytecodeWitnessIndex));
       parts.push(new B256Coder().encode(value.salt));
       parts.push(new BigNumberCoder("u64").encode(value.storageSlotsCount));
-      parts.push(new NumberCoder("u32").encode(value.policyTypes));
-      parts.push(new NumberCoder("u16").encode(value.inputsCount));
-      parts.push(new NumberCoder("u16").encode(value.outputsCount));
-      parts.push(new NumberCoder("u16").encode(value.witnessesCount));
+      parts.push(new NumberCoder("u32", { padToWordSize: true }).encode(value.policyTypes));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.inputsCount));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.outputsCount));
+      parts.push(new NumberCoder("u16", { padToWordSize: true }).encode(value.witnessesCount));
       parts.push(
         new ArrayCoder(new StorageSlotCoder(), value.storageSlotsCount.toNumber()).encode(
           value.storageSlots
@@ -33859,19 +33146,19 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const bytecodeWitnessIndex = decoded;
       [decoded, o] = new B256Coder().decode(data, o);
       const salt = decoded;
       [decoded, o] = new BigNumberCoder("u64").decode(data, o);
       const storageSlotsCount = decoded;
-      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      [decoded, o] = new NumberCoder("u32", { padToWordSize: true }).decode(data, o);
       const policyTypes = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const inputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const outputsCount = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u16", { padToWordSize: true }).decode(data, o);
       const witnessesCount = decoded;
       [decoded, o] = new ArrayCoder(new StorageSlotCoder(), storageSlotsCount.toNumber()).decode(
         data,
@@ -34085,7 +33372,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u8").encode(value.type));
+      parts.push(new NumberCoder("u8", { padToWordSize: true }).encode(value.type));
       const { type: type3 } = value;
       switch (value.type) {
         case 0: {
@@ -34128,7 +33415,7 @@ This unreleased fuel-core build may include features and updates not yet support
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      [decoded, o] = new NumberCoder("u8", { padToWordSize: true }).decode(data, o);
       const type3 = decoded;
       switch (type3) {
         case 0: {
@@ -39205,6 +38492,15 @@ ${MessageCoinFragmentDoc}`;
     return normalize2(clone_default(root));
   }
 
+  // src/providers/utils/sleep.ts
+  function sleep(time) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(true);
+      }, time);
+    });
+  }
+
   // src/providers/utils/extract-tx-error.ts
   var assemblePanicError = (status) => {
     let errorMessage = `The transaction reverted with reason: "${status.reason}".`;
@@ -39846,15 +39142,6 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
         }
       });
     }
-    shiftPredicateData() {
-      this.inputs.forEach((input) => {
-        if ("predicateData" in input && "padPredicateData" in input && typeof input.padPredicateData === "function") {
-          input.predicateData = input.padPredicateData(
-            BaseTransactionRequest.getPolicyMeta(this).policies.length
-          );
-        }
-      });
-    }
   };
 
   // src/providers/transaction-request/hash-transaction.ts
@@ -40319,37 +39606,27 @@ ${PANIC_DOC_URL}#variant.${status.reason}`;
   };
 
   // src/providers/transaction-summary/call.ts
-  var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
+  var getFunctionCall = ({ abi, receipt }) => {
     const abiInterface = new Interface(abi);
     const callFunctionSelector = receipt.param1.toHex(8);
     const functionFragment = abiInterface.getFunction(callFunctionSelector);
     const inputs = functionFragment.jsonFn.inputs;
-    let encodedArgs;
-    if (functionFragment.isInputDataPointer) {
-      if (rawPayload) {
-        const argsOffset = bn(receipt.param2).sub(calculateVmTxMemory({ maxInputs: maxInputs.toNumber() })).toNumber();
-        encodedArgs = `0x${rawPayload.slice(2).slice(argsOffset * 2)}`;
-      }
-    } else {
-      encodedArgs = receipt.param2.toHex();
-    }
+    const encodedArgs = receipt.param2.toHex();
     let argumentsProvided;
-    if (encodedArgs) {
-      const data = functionFragment.decodeArguments(encodedArgs);
-      if (data) {
-        argumentsProvided = inputs.reduce((prev, input, index) => {
-          const value = data[index];
-          const name = input.name;
-          if (name) {
-            return {
-              ...prev,
-              // reparse to remove bn
-              [name]: JSON.parse(JSON.stringify(value))
-            };
-          }
-          return prev;
-        }, {});
-      }
+    const data = functionFragment.decodeArguments(encodedArgs);
+    if (data) {
+      argumentsProvided = inputs.reduce((prev, input, index) => {
+        const value = data[index];
+        const name = input.name;
+        if (name) {
+          return {
+            ...prev,
+            // reparse to remove bn
+            [name]: JSON.parse(JSON.stringify(value))
+          };
+        }
+        return prev;
+      }, {});
     }
     const call = {
       functionSignature: functionFragment.signature,
@@ -42846,7 +42123,6 @@ Supported fuel-core version: ${supportedVersion}.`
           cacheRequestInputsResourcesFromOwner(request.inputs, this.address)
         );
         request.addResources(resources);
-        request.shiftPredicateData();
         request.updatePredicateGasUsed(estimatedPredicates);
         const requestToReestimate2 = clone_default(request);
         if (addedSignatures) {
@@ -42878,7 +42154,6 @@ Supported fuel-core version: ${supportedVersion}.`
         }
         fundingAttempts += 1;
       }
-      request.shiftPredicateData();
       request.updatePredicateGasUsed(estimatedPredicates);
       const requestToReestimate = clone_default(request);
       if (addedSignatures) {
@@ -47952,7 +47227,6 @@ Supported fuel-core version: ${supportedVersion}.`
      */
     populateTransactionPredicateData(transactionRequestLike) {
       const request = transactionRequestify(transactionRequestLike);
-      const { policies } = BaseTransactionRequest.getPolicyMeta(request);
       const placeholderIndex = this.getIndexFromPlaceholderWitness(request);
       if (placeholderIndex !== -1) {
         request.removeWitness(placeholderIndex);
@@ -47960,7 +47234,7 @@ Supported fuel-core version: ${supportedVersion}.`
       request.inputs.filter(isRequestInputResource).forEach((input) => {
         if (isRequestInputResourceFromOwner(input, this.address)) {
           input.predicate = hexlify(this.bytes);
-          input.predicateData = hexlify(this.getPredicateData(policies.length));
+          input.predicateData = hexlify(this.getPredicateData());
           input.witnessIndex = 0;
         }
       });
@@ -47986,17 +47260,12 @@ Supported fuel-core version: ${supportedVersion}.`
       const transactionRequest = transactionRequestify(transactionRequestLike);
       return super.simulateTransaction(transactionRequest, { estimateTxDependencies: false });
     }
-    getPredicateData(policiesLength) {
+    getPredicateData() {
       if (!this.predicateData.length) {
         return new Uint8Array();
       }
       const mainFn = this.interface?.functions.main;
-      const paddedCode = new ByteArrayCoder(this.bytes.length).encode(this.bytes);
-      const VM_TX_MEMORY = calculateVmTxMemory({
-        maxInputs: this.provider.getChain().consensusParameters.txParameters.maxInputs.toNumber()
-      });
-      const OFFSET = VM_TX_MEMORY + SCRIPT_FIXED_SIZE + INPUT_COIN_FIXED_SIZE + WORD_SIZE + paddedCode.byteLength + policiesLength * WORD_SIZE;
-      return mainFn?.encodeArguments(this.predicateData, OFFSET) || new Uint8Array();
+      return mainFn?.encodeArguments(this.predicateData) || new Uint8Array();
     }
     /**
      * Processes the predicate data and returns the altered bytecode and interface.
@@ -48045,8 +47314,7 @@ Supported fuel-core version: ${supportedVersion}.`
       );
       return resources.map((resource) => ({
         ...resource,
-        predicate: hexlify(this.bytes),
-        padPredicateData: (policiesLength) => hexlify(this.getPredicateData(policiesLength))
+        predicate: hexlify(this.bytes)
       }));
     }
     /**