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

package/dist/index.global.js

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