@fuel-ts/account 0.74.0 → 0.75.0

package/dist/index.global.js

@@ -30104,7 +30104,7 @@ spurious results.`);
     return {
       FORC: "0.50.0",
       FUEL_CORE: "0.22.1",
-      FUELS: "0.74.0"
+      FUELS: "0.75.0"
     };
   }
   function parseVersion(version2) {
@@ -30170,6 +30170,7 @@ spurious results.`);
     ErrorCode2["CODER_NOT_FOUND"] = "coder-not-found";
     ErrorCode2["INVALID_DATA"] = "invalid-data";
     ErrorCode2["FUNCTION_NOT_FOUND"] = "function-not-found";
+    ErrorCode2["UNSUPPORTED_ENCODING_VERSION"] = "unsupported-encoding-version";
     ErrorCode2["INVALID_BECH32_ADDRESS"] = "invalid-bech32-address";
     ErrorCode2["INVALID_EVM_ADDRESS"] = "invalid-evm-address";
     ErrorCode2["INVALID_B256_ADDRESS"] = "invalid-b256-address";
@@ -30177,6 +30178,7 @@ spurious results.`);
     ErrorCode2["CHAIN_INFO_CACHE_EMPTY"] = "chain-info-cache-empty";
     ErrorCode2["NODE_INFO_CACHE_EMPTY"] = "node-info-cache-empty";
     ErrorCode2["MISSING_PROVIDER"] = "missing-provider";
+    ErrorCode2["INVALID_PROVIDER"] = "invalid-provider";
     ErrorCode2["INVALID_PUBLIC_KEY"] = "invalid-public-key";
     ErrorCode2["INSUFFICIENT_BALANCE"] = "insufficient-balance";
     ErrorCode2["WALLET_MANAGER_ERROR"] = "wallet-manager-error";
@@ -30259,6 +30261,66 @@ spurious results.`);
   var FuelError = _FuelError;
   __publicField2(FuelError, "CODES", ErrorCode);
 
+  // ../utils/dist/index.mjs
+  var chunkAndPadBytes = (bytes4, chunkSize) => {
+    const chunks = [];
+    for (let offset = 0; offset < bytes4.length; offset += chunkSize) {
+      const chunk = new Uint8Array(chunkSize);
+      chunk.set(bytes4.slice(offset, offset + chunkSize));
+      chunks.push(chunk);
+    }
+    const lastChunk = chunks[chunks.length - 1];
+    const remainingBytes = bytes4.length % chunkSize;
+    const paddedChunkLength = remainingBytes + (8 - remainingBytes % 8) % 8;
+    const newChunk = lastChunk.slice(0, paddedChunkLength);
+    chunks[chunks.length - 1] = newChunk;
+    return chunks;
+  };
+  var arrayify = (value) => {
+    if (value instanceof Uint8Array) {
+      return new Uint8Array(value);
+    }
+    if (typeof value === "string" && value.match(/^0x([0-9a-f][0-9a-f])*$/i)) {
+      const result = new Uint8Array((value.length - 2) / 2);
+      let offset = 2;
+      for (let i = 0; i < result.length; i++) {
+        result[i] = parseInt(value.substring(offset, offset + 2), 16);
+        offset += 2;
+      }
+      return result;
+    }
+    throw new FuelError(ErrorCode.PARSE_FAILED, "invalid BytesLike value");
+  };
+  var concatBytes2 = (arrays) => {
+    const byteArrays = arrays.map((array) => {
+      if (array instanceof Uint8Array) {
+        return array;
+      }
+      return Uint8Array.from(array);
+    });
+    const totalSize = byteArrays.reduce((accum, item) => accum + item.length, 0);
+    const concatenated = new Uint8Array(totalSize);
+    byteArrays.reduce((offset, object) => {
+      concatenated.set(object, offset);
+      return offset + object.length;
+    }, 0);
+    return concatenated;
+  };
+  var concat = (arrays) => {
+    const bytes4 = arrays.map((v) => arrayify(v));
+    return concatBytes2(bytes4);
+  };
+  var HexCharacters = "0123456789abcdef";
+  function hexlify(data) {
+    const bytes4 = arrayify(data);
+    let result = "0x";
+    for (let i = 0; i < bytes4.length; i++) {
+      const v = bytes4[i];
+      result += HexCharacters[(v & 240) >> 4] + HexCharacters[v & 15];
+    }
+    return result;
+  }
+
   // ../crypto/dist/index.mjs
   var import_crypto9 = __toESM(__require("crypto"), 1);
 
@@ -30427,9 +30489,6 @@ spurious results.`);
   function getBytes(value, name) {
     return _getBytes(value, name, false);
   }
-  function getBytesCopy(value, name) {
-    return _getBytes(value, name, true);
-  }
   function isHexString(value, length) {
     if (typeof value !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
       return false;
@@ -30442,19 +30501,16 @@ spurious results.`);
     }
     return true;
   }
-  var HexCharacters = "0123456789abcdef";
-  function hexlify(data) {
+  var HexCharacters2 = "0123456789abcdef";
+  function hexlify2(data) {
     const bytes4 = getBytes(data);
     let result = "0x";
     for (let i = 0; i < bytes4.length; i++) {
       const v = bytes4[i];
-      result += HexCharacters[(v & 240) >> 4] + HexCharacters[v & 15];
+      result += HexCharacters2[(v & 240) >> 4] + HexCharacters2[v & 15];
     }
     return result;
   }
-  function concat(datas) {
-    return "0x" + datas.map((d) => hexlify(d).substring(2)).join("");
-  }
   function dataSlice(data, start, end) {
     const bytes4 = getBytes(data);
     if (end != null && end > bytes4.length) {
@@ -30464,7 +30520,7 @@ spurious results.`);
         offset: end
       });
     }
-    return hexlify(bytes4.slice(start == null ? 0 : start, end == null ? bytes4.length : end));
+    return hexlify2(bytes4.slice(start == null ? 0 : start, end == null ? bytes4.length : end));
   }
 
   // ../../node_modules/.pnpm/ethers@6.7.1/node_modules/ethers/lib.esm/utils/maths.js
@@ -30747,7 +30803,7 @@ spurious results.`);
   function computeHmac(algorithm, _key, _data) {
     const key = getBytes(_key, "key");
     const data = getBytes(_data, "data");
-    return hexlify(__computeHmac(algorithm, key, data));
+    return hexlify2(__computeHmac(algorithm, key, data));
   }
   computeHmac._ = _computeHmac;
   computeHmac.lock = function() {
@@ -31102,7 +31158,7 @@ spurious results.`);
   var __keccak256 = _keccak256;
   function keccak2562(_data) {
     const data = getBytes(_data, "data");
-    return hexlify(__keccak256(data));
+    return hexlify2(__keccak256(data));
   }
   keccak2562._ = _keccak256;
   keccak2562.lock = function() {
@@ -31301,7 +31357,7 @@ spurious results.`);
   var __ripemd160 = _ripemd160;
   function ripemd1602(_data) {
     const data = getBytes(_data, "data");
-    return hexlify(__ripemd160(data));
+    return hexlify2(__ripemd160(data));
   }
   ripemd1602._ = _ripemd160;
   ripemd1602.lock = function() {
@@ -31324,7 +31380,7 @@ spurious results.`);
   function pbkdf22(_password, _salt, iterations, keylen, algo) {
     const password = getBytes(_password, "password");
     const salt = getBytes(_salt, "salt");
-    return hexlify(__pbkdf2(password, salt, iterations, keylen, algo));
+    return hexlify2(__pbkdf2(password, salt, iterations, keylen, algo));
   }
   pbkdf22._ = _pbkdf2;
   pbkdf22.lock = function() {
@@ -31351,7 +31407,7 @@ spurious results.`);
   var locked512 = false;
   function sha2562(_data) {
     const data = getBytes(_data, "data");
-    return hexlify(__sha256(data));
+    return hexlify2(__sha256(data));
   }
   sha2562._ = _sha256;
   sha2562.lock = function() {
@@ -31366,7 +31422,7 @@ spurious results.`);
   Object.freeze(sha2562);
   function sha512(_data) {
     const data = getBytes(_data, "data");
-    return hexlify(__sha512(data));
+    return hexlify2(__sha512(data));
   }
   sha512._ = _sha512;
   sha512.lock = function() {
@@ -31982,7 +32038,7 @@ spurious results.`);
   var keyFromPassword = (password, saltBuffer) => {
     const passBuffer = bufferFromString(String(password).normalize("NFKC"), "utf-8");
     const key = pbkdf22(passBuffer, saltBuffer, 1e5, 32, "sha256");
-    return getBytesCopy(key);
+    return arrayify(key);
   };
   var encrypt = async (password, data) => {
     const iv = randomBytes3(16);
@@ -32068,7 +32124,7 @@ spurious results.`);
   function toBech32(address) {
     return import_bech32.bech32m.encode(
       FUEL_BECH32_HRP_PREFIX,
-      import_bech32.bech32m.toWords(getBytesCopy(hexlify(address)))
+      import_bech32.bech32m.toWords(arrayify(hexlify(address)))
     );
   }
   function isBech32(address) {
@@ -32247,7 +32303,7 @@ spurious results.`);
       if (!isPublicKey(publicKey)) {
         throw new FuelError(FuelError.CODES.INVALID_PUBLIC_KEY, `Invalid Public Key: ${publicKey}.`);
       }
-      const b256Address = sha2562(hexlify(getBytesCopy(publicKey)));
+      const b256Address = sha2562(hexlify(arrayify(publicKey)));
       return new Address(toBech32(b256Address));
     }
     /**
@@ -32595,56 +32651,6 @@ spurious results.`);
     return coinQuantities;
   };
 
-  // ../utils/dist/index.mjs
-  var chunkAndPadBytes = (bytes4, chunkSize) => {
-    const chunks = [];
-    for (let offset = 0; offset < bytes4.length; offset += chunkSize) {
-      const chunk = new Uint8Array(chunkSize);
-      chunk.set(bytes4.slice(offset, offset + chunkSize));
-      chunks.push(chunk);
-    }
-    const lastChunk = chunks[chunks.length - 1];
-    const remainingBytes = bytes4.length % chunkSize;
-    const paddedChunkLength = remainingBytes + (8 - remainingBytes % 8) % 8;
-    const newChunk = lastChunk.slice(0, paddedChunkLength);
-    chunks[chunks.length - 1] = newChunk;
-    return chunks;
-  };
-  var arrayify = (value) => {
-    if (value instanceof Uint8Array) {
-      return new Uint8Array(value);
-    }
-    if (typeof value === "string" && value.match(/^0x([0-9a-f][0-9a-f])*$/i)) {
-      const result = new Uint8Array((value.length - 2) / 2);
-      let offset = 2;
-      for (let i = 0; i < result.length; i++) {
-        result[i] = parseInt(value.substring(offset, offset + 2), 16);
-        offset += 2;
-      }
-      return result;
-    }
-    throw new FuelError(ErrorCode.PARSE_FAILED, "invalid BytesLike value");
-  };
-  var concatBytes2 = (arrays) => {
-    const byteArrays = arrays.map((array) => {
-      if (array instanceof Uint8Array) {
-        return array;
-      }
-      return Uint8Array.from(array);
-    });
-    const totalSize = byteArrays.reduce((accum, item) => accum + item.length, 0);
-    const concatenated = new Uint8Array(totalSize);
-    byteArrays.reduce((offset, object) => {
-      concatenated.set(object, offset);
-      return offset + object.length;
-    }, 0);
-    return concatenated;
-  };
-  var concat2 = (arrays) => {
-    const bytes4 = arrays.map((v) => arrayify(v));
-    return concatBytes2(bytes4);
-  };
-
   // ../abi-coder/dist/index.mjs
   var __defProp3 = Object.defineProperty;
   var __defNormalProp3 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -32675,16 +32681,28 @@ spurious results.`);
       this.encodedLength = encodedLength;
     }
   };
+  var U8_CODER_TYPE = "u8";
+  var U16_CODER_TYPE = "u16";
+  var U32_CODER_TYPE = "u32";
+  var U64_CODER_TYPE = "u64";
+  var RAW_PTR_CODER_TYPE = "raw untyped ptr";
+  var RAW_SLICE_CODER_TYPE = "raw untyped slice";
+  var BOOL_CODER_TYPE = "bool";
+  var B256_CODER_TYPE = "b256";
+  var B512_CODER_TYPE = "struct B512";
   var OPTION_CODER_TYPE = "enum Option";
   var VEC_CODER_TYPE = "struct Vec";
   var BYTES_CODER_TYPE = "struct Bytes";
   var STD_STRING_CODER_TYPE = "struct String";
+  var STR_SLICE_CODER_TYPE = "str";
   var stringRegEx = /str\[(?<length>[0-9]+)\]/;
   var arrayRegEx = /\[(?<item>[\w\s\\[\]]+);\s*(?<length>[0-9]+)\]/;
   var structRegEx = /^struct (?<name>\w+)$/;
   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;
   var ASSET_ID_LEN = BYTES_32;
@@ -32767,7 +32785,7 @@ spurious results.`);
           topLevelData[parseInt(pointerIndex, 10) + totalIndex] = vData;
         });
       }
-      const byteArray = getBytesCopy(item);
+      const byteArray = arrayify(item);
       totalIndex += byteArray.byteLength / WORD_SIZE;
       return byteArray;
     });
@@ -32784,7 +32802,7 @@ spurious results.`);
   }
   function unpackDynamicData(results, baseOffset, dataOffset) {
     if (!results.dynamicData) {
-      return concat2([results]);
+      return concat([results]);
     }
     let cumulativeDynamicByteLength = 0;
     let updatedResults = results;
@@ -32802,7 +32820,7 @@ spurious results.`);
           dataOffset + vData.byteLength + cumulativeDynamicByteLength
         )
       ) : vData;
-      updatedResults = concat2([updatedResults, dataToAppend]);
+      updatedResults = concat([updatedResults, dataToAppend]);
       cumulativeDynamicByteLength += dataToAppend.byteLength;
     });
     return updatedResults;
@@ -32888,7 +32906,7 @@ spurious results.`);
     encode(value) {
       let encodedValue;
       try {
-        encodedValue = getBytesCopy(value);
+        encodedValue = arrayify(value);
       } catch (error) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.type}.`);
       }
@@ -32919,7 +32937,7 @@ spurious results.`);
     encode(value) {
       let encodedValue;
       try {
-        encodedValue = getBytesCopy(value);
+        encodedValue = arrayify(value);
       } catch (error) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Invalid ${this.type}.`);
       }
@@ -32986,6 +33004,51 @@ spurious results.`);
       return [true, offset + this.paddingLength];
     }
   };
+  var _getPaddedData;
+  var getPaddedData_fn;
+  var ByteCoder = class extends Coder {
+    constructor() {
+      super("struct", "struct Bytes", BASE_VECTOR_OFFSET);
+      __privateAdd2(this, _getPaddedData);
+    }
+    encode(value) {
+      if (!Array.isArray(value)) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+      }
+      const parts = [];
+      const pointer = new U64Coder().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 U64Coder().encode(data.byteLength));
+      parts.push(new U64Coder().encode(value.length));
+      return concatWithDynamicData(parts);
+    }
+    decode(data, offset) {
+      if (data.length < BASE_VECTOR_OFFSET) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid byte data size.`);
+      }
+      const len = data.slice(16, 24);
+      const encodedLength = bn(new U64Coder().decode(len, 0)[0]).toNumber();
+      const byteData = data.slice(BASE_VECTOR_OFFSET, BASE_VECTOR_OFFSET + encodedLength);
+      if (byteData.length !== encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid bytes byte data size.`);
+      }
+      return [byteData, offset + BASE_VECTOR_OFFSET];
+    }
+  };
+  _getPaddedData = /* @__PURE__ */ new WeakSet();
+  getPaddedData_fn = function(value) {
+    const data = [Uint8Array.from(value)];
+    const paddingLength = (WORD_SIZE - value.length % WORD_SIZE) % WORD_SIZE;
+    if (paddingLength) {
+      data.push(new Uint8Array(paddingLength));
+    }
+    return concat(data);
+  };
+  __publicField3(ByteCoder, "memorySize", 1);
   var isFullyNativeEnum = (enumCoders) => Object.values(enumCoders).every(
     // @ts-expect-error complicated types
     ({ type: type3, coders }) => type3 === "()" && JSON.stringify(coders) === JSON.stringify([])
@@ -33012,7 +33075,7 @@ spurious results.`);
       const encodedValue = valueCoder.encode([]);
       const caseIndex = Object.keys(this.coders).indexOf(value);
       const padding = new Uint8Array(this.#encodedValueSize - valueCoder.encodedLength);
-      return concat2([this.#caseIndexCoder.encode(caseIndex), padding, encodedValue]);
+      return concat([this.#caseIndexCoder.encode(caseIndex), padding, encodedValue]);
     }
     encode(value) {
       if (typeof value === "string" && this.coders[value]) {
@@ -33059,6 +33122,31 @@ spurious results.`);
       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 - 1) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid option data size.`);
+      }
+      const [decoded, newOffset] = super.decode(data, offset);
+      return [this.toOption(decoded), newOffset];
+    }
+    toOption(output4) {
+      if (output4 && "Some" in output4) {
+        return output4.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
@@ -33129,6 +33217,77 @@ spurious results.`);
       return [toNumber2(bytes4), offset + 8];
     }
   };
+  var RawSliceCoder = class extends Coder {
+    constructor() {
+      super("raw untyped slice", "raw untyped slice", BASE_RAW_SLICE_OFFSET);
+    }
+    encode(value) {
+      if (!Array.isArray(value)) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+      }
+      const parts = [];
+      const coder = new NumberCoder("u8", { isSmallBytes: true });
+      const pointer = new U64Coder().encode(BASE_RAW_SLICE_OFFSET);
+      pointer.dynamicData = {
+        0: concatWithDynamicData(value.map((v) => coder.encode(v)))
+      };
+      parts.push(pointer);
+      parts.push(new U64Coder().encode(value.length));
+      return concatWithDynamicData(parts);
+    }
+    decode(data, offset) {
+      const dataBytes = data.slice(offset);
+      const internalCoder = new ArrayCoder(
+        new NumberCoder("u8", { isSmallBytes: true }),
+        dataBytes.length
+      );
+      const [decodedValue] = internalCoder.decode(dataBytes, 0);
+      return [decodedValue, offset + dataBytes.length];
+    }
+  };
+  var _getPaddedData2;
+  var getPaddedData_fn2;
+  var StdStringCoder = class extends Coder {
+    constructor() {
+      super("struct", "struct String", 1);
+      __privateAdd2(this, _getPaddedData2);
+    }
+    encode(value) {
+      const parts = [];
+      const pointer = new U64Coder().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 U64Coder().encode(data.byteLength));
+      parts.push(new U64Coder().encode(value.length));
+      return concatWithDynamicData(parts);
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid std string data size.`);
+      }
+      const len = data.slice(16, 24);
+      const encodedLength = bn(new U64Coder().decode(len, 0)[0]).toNumber();
+      const byteData = data.slice(BASE_VECTOR_OFFSET, BASE_VECTOR_OFFSET + encodedLength);
+      if (byteData.length !== encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid std string byte data size.`);
+      }
+      const value = toUtf8String(byteData);
+      return [value, offset + BASE_VECTOR_OFFSET];
+    }
+  };
+  _getPaddedData2 = /* @__PURE__ */ new WeakSet();
+  getPaddedData_fn2 = function(value) {
+    const data = [toUtf8Bytes(value)];
+    const paddingLength = (WORD_SIZE - value.length % WORD_SIZE) % WORD_SIZE;
+    if (paddingLength) {
+      data.push(new Uint8Array(paddingLength));
+    }
+    return concat(data);
+  };
+  __publicField3(StdStringCoder, "memorySize", 1);
   var StringCoder = class extends Coder {
     length;
     #paddingLength;
@@ -33145,7 +33304,7 @@ spurious results.`);
       }
       const encoded = toUtf8Bytes(value);
       const padding = new Uint8Array(this.#paddingLength);
-      return concat2([encoded, padding]);
+      return concat([encoded, padding]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -33160,31 +33319,6 @@ spurious results.`);
       return [value, offset + this.length + padding];
     }
   };
-  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 - 1) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid option data size.`);
-      }
-      const [decoded, newOffset] = super.decode(data, offset);
-      return [this.toOption(decoded), newOffset];
-    }
-    toOption(output4) {
-      if (output4 && "Some" in output4) {
-        return output4.Some;
-      }
-      return void 0;
-    }
-  };
   var StructCoder = class extends Coder {
     name;
     coders;
@@ -33309,122 +33443,246 @@ spurious results.`);
       ];
     }
   };
-  var _getPaddedData;
-  var getPaddedData_fn;
-  var ByteCoder = class extends Coder {
-    constructor() {
-      super("struct", "struct Bytes", BASE_VECTOR_OFFSET);
-      __privateAdd2(this, _getPaddedData);
-    }
-    encode(value) {
-      if (!Array.isArray(value)) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
-      }
-      const parts = [];
-      const pointer = new U64Coder().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 U64Coder().encode(data.byteLength));
-      parts.push(new U64Coder().encode(value.length));
-      return concatWithDynamicData(parts);
+  var ResolvedAbiType = class {
+    abi;
+    name;
+    type;
+    originalTypeArguments;
+    components;
+    constructor(abi, argument) {
+      this.abi = abi;
+      const type3 = findOrThrow(
+        abi.types,
+        (t) => t.typeId === argument.type,
+        () => {
+          throw new FuelError(
+            ErrorCode.TYPE_NOT_FOUND,
+            `Type does not exist in the provided abi: ${JSON.stringify({
+              argument,
+              abi: this.abi
+            })}`
+          );
+        }
+      );
+      this.name = argument.name;
+      this.type = type3.type;
+      this.originalTypeArguments = argument.typeArguments;
+      this.components = ResolvedAbiType.getResolvedGenericComponents(
+        abi,
+        argument,
+        type3.components,
+        type3.typeParameters ?? ResolvedAbiType.getImplicitGenericTypeParameters(abi, type3.components)
+      );
     }
-    decode(data, offset) {
-      if (data.length < BASE_VECTOR_OFFSET) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid byte data size.`);
+    static getResolvedGenericComponents(abi, arg, components, typeParameters) {
+      if (components === null) {
+        return null;
       }
-      const len = data.slice(16, 24);
-      const encodedLength = bn(new U64Coder().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.`);
+      if (typeParameters === null || typeParameters.length === 0) {
+        return components.map((c) => new ResolvedAbiType(abi, c));
       }
-      return [byteData, offset + BASE_VECTOR_OFFSET];
+      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));
     }
-  };
-  _getPaddedData = /* @__PURE__ */ new WeakSet();
-  getPaddedData_fn = function(value) {
-    const data = [Uint8Array.from(value)];
-    const paddingLength = (WORD_SIZE - value.length % WORD_SIZE) % WORD_SIZE;
-    if (paddingLength) {
-      data.push(new Uint8Array(paddingLength));
+    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 = findOrThrow(abi.types, (t) => t.typeId === 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;
+      });
     }
-    return concat2(data);
-  };
-  __publicField3(ByteCoder, "memorySize", 1);
-  var RawSliceCoder = class extends Coder {
-    constructor() {
-      super("raw untyped slice", "raw untyped slice", BASE_RAW_SLICE_OFFSET);
+    static getImplicitGenericTypeParameters(abi, args, implicitGenericParametersParam) {
+      if (!Array.isArray(args)) {
+        return null;
+      }
+      const implicitGenericParameters = implicitGenericParametersParam ?? [];
+      args.forEach((a) => {
+        const argType = findOrThrow(abi.types, (t) => t.typeId === 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;
     }
-    encode(value) {
-      if (!Array.isArray(value)) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+    getSignature() {
+      const prefix = this.getArgSignaturePrefix();
+      const content = this.getArgSignatureContent();
+      return `${prefix}${content}`;
+    }
+    getArgSignaturePrefix() {
+      const structMatch = structRegEx.test(this.type);
+      if (structMatch) {
+        return "s";
       }
-      const parts = [];
-      const coder = new NumberCoder("u8", { isSmallBytes: true });
-      const pointer = new U64Coder().encode(BASE_RAW_SLICE_OFFSET);
-      pointer.dynamicData = {
-        0: concatWithDynamicData(value.map((v) => coder.encode(v)))
-      };
-      parts.push(pointer);
-      parts.push(new U64Coder().encode(value.length));
-      return concatWithDynamicData(parts);
+      const arrayMatch = arrayRegEx.test(this.type);
+      if (arrayMatch) {
+        return "a";
+      }
+      const enumMatch = enumRegEx.test(this.type);
+      if (enumMatch) {
+        return "e";
+      }
+      return "";
     }
-    decode(data, offset) {
-      const dataBytes = data.slice(offset);
-      const internalCoder = new ArrayCoder(
-        new NumberCoder("u8", { isSmallBytes: true }),
-        dataBytes.length
-      );
-      const [decodedValue] = internalCoder.decode(dataBytes, 0);
-      return [decodedValue, offset + dataBytes.length];
+    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}`;
     }
   };
-  var _getPaddedData2;
-  var getPaddedData_fn2;
-  var StdStringCoder = class extends Coder {
-    constructor() {
-      super("struct", "struct String", 1);
-      __privateAdd2(this, _getPaddedData2);
+  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 U64Coder();
+      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;
     }
-    encode(value) {
-      const parts = [];
-      const pointer = new U64Coder().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 U64Coder().encode(data.byteLength));
-      parts.push(new U64Coder().encode(value.length));
-      return concatWithDynamicData(parts);
+    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);
     }
-    decode(data, offset) {
-      if (data.length < this.encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid std string data size.`);
+    if (resolvedAbiType.type === VEC_CODER_TYPE) {
+      const arg = findOrThrow(components, (c) => c.name === "buf").originalTypeArguments?.[0];
+      if (!arg) {
+        throw new FuelError(
+          ErrorCode.INVALID_COMPONENT,
+          `The provided Vec type is missing the 'type argument'.`
+        );
       }
-      const len = data.slice(16, 24);
-      const encodedLength = bn(new U64Coder().decode(len, 0)[0]).toNumber();
-      const byteData = data.slice(BASE_VECTOR_OFFSET, BASE_VECTOR_OFFSET + encodedLength);
-      if (byteData.length !== encodedLength) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid std string byte data size.`);
+      const 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);
       }
-      const value = toUtf8String(byteData);
-      return [value, offset + BASE_VECTOR_OFFSET];
+      return new EnumCoder(enumMatch.name, coders);
     }
-  };
-  _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));
+    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`"
+      );
     }
-    return concat2(data);
+    throw new FuelError(
+      ErrorCode.CODER_NOT_FOUND,
+      `Coder not found: ${JSON.stringify(resolvedAbiType)}.`
+    );
   };
-  __publicField3(StdStringCoder, "memorySize", 1);
   var BooleanCoder2 = class extends Coder {
     constructor() {
       super("boolean", "boolean", 1);
@@ -33452,10 +33710,15 @@ spurious results.`);
   };
   var ByteCoder2 = class extends Coder {
     constructor() {
-      super("struct", "struct Bytes", 1);
+      super("struct", "struct Bytes", WORD_SIZE);
     }
-    encode(_value) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Bytes encode unsupported in v1`);
+    encode(value) {
+      if (!Array.isArray(value)) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+      }
+      const bytes4 = new Uint8Array(value);
+      const lengthBytes = new U64Coder().encode(value.length);
+      return new Uint8Array([...lengthBytes, ...bytes4]);
     }
     decode(data, offset) {
       if (data.length < WORD_SIZE) {
@@ -33464,12 +33727,11 @@ spurious results.`);
       const offsetAndLength = offset + WORD_SIZE;
       const lengthBytes = data.slice(offset, offsetAndLength);
       const length = bn(new U64Coder().decode(lengthBytes, 0)[0]).toNumber();
-      const dataLength2 = length * this.encodedLength;
-      const dataBytes = data.slice(offsetAndLength, offsetAndLength + dataLength2);
+      const dataBytes = data.slice(offsetAndLength, offsetAndLength + length);
       if (dataBytes.length !== length) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid bytes byte data size.`);
       }
-      return [dataBytes, offset + dataLength2];
+      return [dataBytes, offsetAndLength + length];
     }
   };
   __publicField3(ByteCoder2, "memorySize", 1);
@@ -33494,8 +33756,28 @@ spurious results.`);
       this.#caseIndexCoder = caseIndexCoder;
       this.#encodedValueSize = encodedValueSize;
     }
-    encode(_value) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Enum encode unsupported in v1`);
+    #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];
@@ -33570,8 +33852,14 @@ spurious results.`);
     constructor() {
       super("raw untyped slice", "raw untyped slice", WORD_SIZE);
     }
-    encode(_value) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Raw slice encode unsupported in v1`);
+    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 bytes4 = internalCoder.encode(value);
+      const lengthBytes = new U64Coder().encode(bytes4.length);
+      return new Uint8Array([...lengthBytes, ...bytes4]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -33593,8 +33881,10 @@ spurious results.`);
     constructor() {
       super("struct", "struct String", WORD_SIZE);
     }
-    encode(_value) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `StdString encode unsupported in v1`);
+    encode(value) {
+      const bytes4 = toUtf8Bytes(value);
+      const lengthBytes = new U64Coder().encode(value.length);
+      return new Uint8Array([...lengthBytes, ...bytes4]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -33644,8 +33934,20 @@ spurious results.`);
       this.name = name;
       this.coders = coders;
     }
-    encode(_value) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Struct encode unsupported in v1`);
+    encode(value) {
+      return concatBytes2(
+        Object.keys(this.coders).map((fieldName) => {
+          const fieldCoder = this.coders[fieldName];
+          const fieldValue = value[fieldName];
+          if (!(fieldCoder instanceof OptionCoder) && fieldValue == null) {
+            throw new FuelError(
+              ErrorCode.ENCODE_ERROR,
+              `Invalid ${this.type}. Field "${fieldName}" not present.`
+            );
+          }
+          return fieldCoder.encode(fieldValue);
+        })
+      );
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -33673,7 +33975,7 @@ spurious results.`);
       if (this.coders.length !== value.length) {
         throw new FuelError(ErrorCode.ENCODE_ERROR, `Types/values length mismatch.`);
       }
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Tuple encode unsupported in v1`);
+      return concatBytes2(this.coders.map((coder, i) => coder.encode(value[i])));
     }
     decode(data, offset) {
       if (data.length < this.encodedLength) {
@@ -33694,180 +33996,140 @@ spurious results.`);
       super("struct", `struct Vec`, coder.encodedLength + WORD_SIZE);
       this.coder = coder;
     }
-    encode(_value) {
-      throw new FuelError(ErrorCode.ENCODE_ERROR, `Vec encode unsupported in v1`);
+    encode(value) {
+      if (!Array.isArray(value)) {
+        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+      }
+      const bytes4 = value.map((v) => this.coder.encode(v));
+      const lengthBytes = new U64Coder().encode(value.length);
+      return new Uint8Array([...lengthBytes, ...concatBytes2(bytes4)]);
     }
     decode(data, offset) {
       if (data.length < this.encodedLength || data.length > MAX_BYTES) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec data size.`);
       }
       const offsetAndLength = offset + WORD_SIZE;
-      const lengthBytes = data.slice(offset, offsetAndLength);
-      const length = bn(new U64Coder().decode(lengthBytes, 0)[0]).toNumber();
-      const dataLength2 = length * this.coder.encodedLength;
-      const dataBytes = data.slice(offsetAndLength, offsetAndLength + dataLength2);
-      if (dataBytes.length !== dataLength2) {
-        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec byte data size.`);
-      }
-      return [
-        chunkByLength(dataBytes, this.coder.encodedLength).map(
-          (chunk) => this.coder.decode(chunk, 0)[0]
-        ),
-        offsetAndLength + dataLength2
-      ];
-    }
-  };
-  var ResolvedAbiType = class {
-    abi;
-    name;
-    type;
-    originalTypeArguments;
-    components;
-    constructor(abi, argument) {
-      this.abi = abi;
-      const type3 = findOrThrow(
-        abi.types,
-        (t) => t.typeId === argument.type,
-        () => {
-          throw new FuelError(
-            ErrorCode.TYPE_NOT_FOUND,
-            `Type does not exist in the provided abi: ${JSON.stringify({
-              argument,
-              abi: this.abi
-            })}`
-          );
-        }
-      );
-      this.name = argument.name;
-      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 = findOrThrow(abi.types, (t) => t.typeId === 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 = findOrThrow(abi.types, (t) => t.typeId === 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 lengthBytes = data.slice(offset, offsetAndLength);
+      const length = bn(new U64Coder().decode(lengthBytes, 0)[0]).toNumber();
+      const dataLength2 = length * this.coder.encodedLength;
+      const dataBytes = data.slice(offsetAndLength, offsetAndLength + dataLength2);
+      if (dataBytes.length !== dataLength2) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid vec byte data size.`);
       }
-      const strMatch = stringRegEx.exec(this.type)?.groups;
-      if (strMatch) {
-        return `str[${strMatch.length}]`;
+      return [
+        chunkByLength(dataBytes, this.coder.encodedLength).map(
+          (chunk) => this.coder.decode(chunk, 0)[0]
+        ),
+        offsetAndLength + dataLength2
+      ];
+    }
+  };
+  var getCoder2 = (resolvedAbiType, _options) => {
+    switch (resolvedAbiType.type) {
+      case U8_CODER_TYPE:
+      case U16_CODER_TYPE:
+      case U32_CODER_TYPE:
+        return new NumberCoder2(resolvedAbiType.type);
+      case U64_CODER_TYPE:
+      case RAW_PTR_CODER_TYPE:
+        return new U64Coder();
+      case RAW_SLICE_CODER_TYPE:
+        return new RawSliceCoder2();
+      case BOOL_CODER_TYPE:
+        return new BooleanCoder2();
+      case B256_CODER_TYPE:
+        return new B256Coder();
+      case B512_CODER_TYPE:
+        return new B512Coder();
+      case BYTES_CODER_TYPE:
+        return new ByteCoder2();
+      case STD_STRING_CODER_TYPE:
+        return new StdStringCoder2();
+      default:
+        break;
+    }
+    const stringMatch = stringRegEx.exec(resolvedAbiType.type)?.groups;
+    if (stringMatch) {
+      const length = parseInt(stringMatch.length, 10);
+      return new StringCoder2(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'.`
+        );
       }
-      if (this.components === null) {
-        return this.type;
+      const arrayElementCoder = getCoder2(arg, { isSmallBytes: true });
+      return new ArrayCoder(arrayElementCoder, length);
+    }
+    if (resolvedAbiType.type === VEC_CODER_TYPE) {
+      const arg = findOrThrow(components, (c) => c.name === "buf").originalTypeArguments?.[0];
+      if (!arg) {
+        throw new FuelError(
+          ErrorCode.INVALID_COMPONENT,
+          `The provided Vec type is missing the 'type argument'.`
+        );
       }
-      const arrayMatch = arrayRegEx.exec(this.type)?.groups;
-      if (arrayMatch) {
-        return `[${this.components[0].getSignature()};${arrayMatch.length}]`;
+      const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
+      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, { isRightPadded: true, getCoder: getCoder2 });
+      return new StructCoder2(structMatch.name, coders);
+    }
+    const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
+    if (enumMatch) {
+      const coders = getCoders(components, { getCoder: getCoder2 });
+      const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
+      if (isOptionEnum) {
+        return new OptionCoder(enumMatch.name, coders);
       }
-      const typeArgumentsSignature = this.originalTypeArguments !== null ? `<${this.originalTypeArguments.map((a) => new ResolvedAbiType(this.abi, a).getSignature()).join(",")}>` : "";
-      const componentsSignature = `(${this.components.map((c) => c.getSignature()).join(",")})`;
-      return `${typeArgumentsSignature}${componentsSignature}`;
+      return new EnumCoder2(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);
+    }
+    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)}.`
+    );
   };
+  function getCoderForEncoding(encoding = ENCODING_V0) {
+    switch (encoding) {
+      case ENCODING_V1:
+        return getCoder2;
+      case ENCODING_V0:
+        return getCoder;
+      default:
+        throw new FuelError(
+          ErrorCode.UNSUPPORTED_ENCODING_VERSION,
+          `Encoding version ${encoding} is unsupported.`
+        );
+    }
+  }
   var AbiCoder = class {
     static getCoder(abi, argument, options = {
       isSmallBytes: false
     }) {
       const resolvedAbiType = new ResolvedAbiType(abi, argument);
-      return AbiCoder.getCoderImpl(resolvedAbiType, options);
+      return getCoderForEncoding(options.encoding)(resolvedAbiType, options);
     }
     static encode(abi, argument, value, options) {
       return this.getCoder(abi, argument, options).encode(value);
@@ -33875,103 +34137,6 @@ spurious results.`);
     static decode(abi, argument, data, offset, options) {
       return this.getCoder(abi, argument, options).decode(data, offset);
     }
-    static getCoderImpl(resolvedAbiType, options = {
-      isSmallBytes: false
-    }) {
-      const { version: version2 } = options;
-      switch (resolvedAbiType.type) {
-        case "u8":
-        case "u16":
-        case "u32":
-          return version2 ? new NumberCoder2(resolvedAbiType.type) : new NumberCoder(resolvedAbiType.type, options);
-        case "u64":
-        case "raw untyped ptr":
-          return new U64Coder();
-        case "raw untyped slice":
-          return version2 ? new RawSliceCoder2() : new RawSliceCoder();
-        case "bool":
-          return version2 ? new BooleanCoder2() : new BooleanCoder(options);
-        case "b256":
-          return new B256Coder();
-        case "struct B512":
-          return new B512Coder();
-        case BYTES_CODER_TYPE:
-          return version2 ? new ByteCoder2() : new ByteCoder();
-        case STD_STRING_CODER_TYPE:
-          return version2 ? new StdStringCoder2() : new StdStringCoder();
-        default:
-          break;
-      }
-      const stringMatch = stringRegEx.exec(resolvedAbiType.type)?.groups;
-      if (stringMatch) {
-        const length = parseInt(stringMatch.length, 10);
-        return version2 ? new StringCoder2(length) : 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 = AbiCoder.getCoderImpl(arg, { version: version2, isSmallBytes: true });
-        return new ArrayCoder(arrayElementCoder, length);
-      }
-      if (resolvedAbiType.type === VEC_CODER_TYPE) {
-        const arg = findOrThrow(components, (c) => c.name === "buf").originalTypeArguments?.[0];
-        if (!arg) {
-          throw new FuelError(
-            ErrorCode.INVALID_COMPONENT,
-            `The provided Vec type is missing the 'type argument'.`
-          );
-        }
-        const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
-        const itemCoder = AbiCoder.getCoderImpl(argType, { version: version2, isSmallBytes: true });
-        return version2 ? new VecCoder2(itemCoder) : new VecCoder(itemCoder);
-      }
-      const structMatch = structRegEx.exec(resolvedAbiType.type)?.groups;
-      if (structMatch) {
-        const coders = AbiCoder.getCoders(components, { version: version2, isRightPadded: true });
-        return version2 ? new StructCoder2(structMatch.name, coders) : new StructCoder(structMatch.name, coders);
-      }
-      const enumMatch = enumRegEx.exec(resolvedAbiType.type)?.groups;
-      if (enumMatch) {
-        const coders = AbiCoder.getCoders(components, { version: version2 });
-        const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
-        if (isOptionEnum) {
-          return new OptionCoder(enumMatch.name, coders);
-        }
-        return version2 ? new EnumCoder2(enumMatch.name, coders) : new EnumCoder(enumMatch.name, coders);
-      }
-      const tupleMatch = tupleRegEx.exec(resolvedAbiType.type)?.groups;
-      if (tupleMatch) {
-        const coders = components.map(
-          (component) => AbiCoder.getCoderImpl(component, { version: version2, isRightPadded: true })
-        );
-        return version2 ? new TupleCoder2(coders) : new TupleCoder(coders);
-      }
-      if (resolvedAbiType.type === "str") {
-        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)}.`
-      );
-    }
-    static getCoders(components, options) {
-      return components.reduce((obj, component) => {
-        const o = obj;
-        o[component.name] = AbiCoder.getCoderImpl(component, options);
-        return o;
-      }, {});
-    }
   };
   var FunctionFragment = class {
     signature;
@@ -34066,7 +34231,7 @@ spurious results.`);
       throw new FuelError(ErrorCode.ABI_TYPES_AND_VALUES_MISMATCH, errorMsg);
     }
     decodeArguments(data) {
-      const bytes4 = getBytesCopy(data);
+      const bytes4 = arrayify(data);
       const nonEmptyInputs = this.jsonFn.inputs.filter(
         (x) => findOrThrow(this.jsonAbi.types, (t) => t.typeId === x.type).type !== "()"
       );
@@ -34111,7 +34276,7 @@ spurious results.`);
       if (outputAbiType.type === "()") {
         return [void 0, 0];
       }
-      const bytes4 = getBytesCopy(data);
+      const bytes4 = arrayify(data);
       const coder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output);
       return coder.decode(bytes4, 0);
     }
@@ -34178,8 +34343,8 @@ spurious results.`);
         return externalInterface.decodeLog(data, logId, receiptId);
       }
       const { loggedType } = findOrThrow(this.jsonAbi.loggedTypes, (type3) => type3.logId === logId);
-      return AbiCoder.decode(this.jsonAbi, loggedType, getBytesCopy(data), 0, {
-        version: this.jsonAbi.encoding
+      return AbiCoder.decode(this.jsonAbi, loggedType, arrayify(data), 0, {
+        encoding: this.jsonAbi.encoding
       });
     }
     updateExternalLoggedTypes(id, loggedTypes) {
@@ -34235,12 +34400,12 @@ spurious results.`);
     }
     encode(value) {
       const parts = [];
-      const data = getBytesCopy(value);
+      const data = arrayify(value);
       parts.push(data);
       if (this.#paddingLength) {
         parts.push(new Uint8Array(this.#paddingLength));
       }
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34286,7 +34451,7 @@ spurious results.`);
       parts.push(new NumberCoder("u32").encode(value.predicateDataLength));
       parts.push(new ByteArrayCoder(value.predicateLength).encode(value.predicate));
       parts.push(new ByteArrayCoder(value.predicateDataLength).encode(value.predicateData));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34350,7 +34515,7 @@ spurious results.`);
       parts.push(new B256Coder().encode(value.stateRoot));
       parts.push(new TxPointerCoder().encode(value.txPointer));
       parts.push(new B256Coder().encode(value.contractID));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34391,11 +34556,11 @@ spurious results.`);
       parts.push(new ByteArrayCoder(32).encode(value.recipient));
       parts.push(new ByteArrayCoder(32).encode(value.nonce));
       parts.push(new U64Coder().encode(value.amount));
-      parts.push(getBytesCopy(value.data || "0x"));
-      return sha2562(concat2(parts));
+      parts.push(arrayify(value.data || "0x"));
+      return sha2562(concat(parts));
     }
     static encodeData(messageData) {
-      const bytes4 = getBytesCopy(messageData || "0x");
+      const bytes4 = arrayify(messageData || "0x");
       const dataLength2 = bytes4.length;
       return new ByteArrayCoder(dataLength2).encode(bytes4);
     }
@@ -34408,19 +34573,19 @@ spurious results.`);
       parts.push(new ByteArrayCoder(32).encode(value.nonce));
       parts.push(new NumberCoder("u8").encode(value.witnessIndex));
       parts.push(new U64Coder().encode(value.predicateGasUsed));
-      parts.push(new NumberCoder("u16").encode(data.length));
-      parts.push(new NumberCoder("u16").encode(value.predicateLength));
-      parts.push(new NumberCoder("u16").encode(value.predicateDataLength));
+      parts.push(new NumberCoder("u32").encode(data.length));
+      parts.push(new NumberCoder("u32").encode(value.predicateLength));
+      parts.push(new NumberCoder("u32").encode(value.predicateDataLength));
       parts.push(new ByteArrayCoder(data.length).encode(data));
       parts.push(new ByteArrayCoder(value.predicateLength).encode(value.predicate));
       parts.push(new ByteArrayCoder(value.predicateDataLength).encode(value.predicateData));
-      return concat2(parts);
+      return concat(parts);
     }
     static decodeData(messageData) {
-      const bytes4 = getBytesCopy(messageData);
+      const bytes4 = arrayify(messageData);
       const dataLength2 = bytes4.length;
       const [data] = new ByteArrayCoder(dataLength2).decode(bytes4, 0);
-      return getBytesCopy(data);
+      return arrayify(data);
     }
     decode(data, offset) {
       let decoded;
@@ -34437,11 +34602,11 @@ spurious results.`);
       const witnessIndex = Number(decoded);
       [decoded, o] = new U64Coder().decode(data, o);
       const predicateGasUsed = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
-      const predicateLength = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
       const dataLength2 = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
+      const predicateLength = decoded;
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
       const predicateDataLength = decoded;
       [decoded, o] = new ByteArrayCoder(dataLength2).decode(data, o);
       const messageData = decoded;
@@ -34497,7 +34662,7 @@ spurious results.`);
           );
         }
       }
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34543,7 +34708,7 @@ spurious results.`);
       parts.push(new B256Coder().encode(value.to));
       parts.push(new U64Coder().encode(value.amount));
       parts.push(new B256Coder().encode(value.assetId));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34574,7 +34739,7 @@ spurious results.`);
       parts.push(new NumberCoder("u8").encode(value.inputIndex));
       parts.push(new B256Coder().encode(value.balanceRoot));
       parts.push(new B256Coder().encode(value.stateRoot));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34605,7 +34770,7 @@ spurious results.`);
       parts.push(new B256Coder().encode(value.to));
       parts.push(new U64Coder().encode(value.amount));
       parts.push(new B256Coder().encode(value.assetId));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34636,7 +34801,7 @@ spurious results.`);
       parts.push(new B256Coder().encode(value.to));
       parts.push(new U64Coder().encode(value.amount));
       parts.push(new B256Coder().encode(value.assetId));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34666,7 +34831,7 @@ spurious results.`);
       const parts = [];
       parts.push(new B256Coder().encode(value.contractId));
       parts.push(new B256Coder().encode(value.stateRoot));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34721,7 +34886,7 @@ spurious results.`);
           );
         }
       }
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34801,7 +34966,7 @@ spurious results.`);
           }
         }
       });
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset, policyTypes) {
       let o = offset;
@@ -34855,8 +35020,8 @@ spurious results.`);
       parts.push(new ByteArrayCoder(32).encode(value.recipient));
       parts.push(new ByteArrayCoder(32).encode(value.nonce));
       parts.push(new U64Coder().encode(value.amount));
-      parts.push(getBytesCopy(value.data || "0x"));
-      return sha2562(concat2(parts));
+      parts.push(arrayify(value.data || "0x"));
+      return sha2562(concat(parts));
     }
     encode(value) {
       const parts = [];
@@ -34867,7 +35032,7 @@ spurious results.`);
       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 concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34885,7 +35050,7 @@ spurious results.`);
       [decoded, o] = new B256Coder().decode(data, o);
       const digest = decoded;
       [decoded, o] = new ByteArrayCoder(len).decode(data, o);
-      const messageData = getBytesCopy(decoded);
+      const messageData = arrayify(decoded);
       const receiptMessageOut = {
         type: 10,
         messageId: "",
@@ -34901,9 +35066,9 @@ spurious results.`);
     }
   };
   var getAssetId = (contractId, subId) => {
-    const contractIdBytes = getBytesCopy(contractId);
-    const subIdBytes = getBytesCopy(subId);
-    return sha2562(concat2([contractIdBytes, subIdBytes]));
+    const contractIdBytes = arrayify(contractId);
+    const subIdBytes = arrayify(subId);
+    return sha2562(concat([contractIdBytes, subIdBytes]));
   };
   var ReceiptMintCoder = class extends Coder {
     constructor() {
@@ -34919,7 +35084,7 @@ spurious results.`);
       parts.push(new U64Coder().encode(value.val));
       parts.push(new U64Coder().encode(value.pc));
       parts.push(new U64Coder().encode(value.is));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34961,7 +35126,7 @@ spurious results.`);
       parts.push(new U64Coder().encode(value.val));
       parts.push(new U64Coder().encode(value.pc));
       parts.push(new U64Coder().encode(value.is));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -35008,14 +35173,14 @@ spurious results.`);
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u16").encode(value.dataLength));
+      parts.push(new NumberCoder("u32").encode(value.dataLength));
       parts.push(new ByteArrayCoder(value.dataLength).encode(value.data));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u16").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;
@@ -35041,8 +35206,8 @@ spurious results.`);
     encode(value) {
       const parts = [];
       parts.push(new U64Coder().encode(value.scriptGasLimit));
-      parts.push(new NumberCoder("u16").encode(value.scriptLength));
-      parts.push(new NumberCoder("u16").encode(value.scriptDataLength));
+      parts.push(new NumberCoder("u32").encode(value.scriptLength));
+      parts.push(new NumberCoder("u32").encode(value.scriptDataLength));
       parts.push(new NumberCoder("u32").encode(value.policyTypes));
       parts.push(new NumberCoder("u8").encode(value.inputsCount));
       parts.push(new NumberCoder("u8").encode(value.outputsCount));
@@ -35054,16 +35219,16 @@ spurious results.`);
       parts.push(new ArrayCoder(new InputCoder(), value.inputsCount).encode(value.inputs));
       parts.push(new ArrayCoder(new OutputCoder(), value.outputsCount).encode(value.outputs));
       parts.push(new ArrayCoder(new WitnessCoder(), value.witnessesCount).encode(value.witnesses));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
       let o = offset;
       [decoded, o] = new U64Coder().decode(data, o);
       const scriptGasLimit = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
       const scriptLength = decoded;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
       const scriptDataLength = decoded;
       [decoded, o] = new NumberCoder("u32").decode(data, o);
       const policyTypes = decoded;
@@ -35115,7 +35280,7 @@ spurious results.`);
     }
     encode(value) {
       const parts = [];
-      parts.push(new NumberCoder("u16").encode(value.bytecodeLength));
+      parts.push(new NumberCoder("u32").encode(value.bytecodeLength));
       parts.push(new NumberCoder("u8").encode(value.bytecodeWitnessIndex));
       parts.push(new NumberCoder("u32").encode(value.policyTypes));
       parts.push(new NumberCoder("u16").encode(value.storageSlotsCount));
@@ -35130,12 +35295,12 @@ spurious results.`);
       parts.push(new ArrayCoder(new InputCoder(), value.inputsCount).encode(value.inputs));
       parts.push(new ArrayCoder(new OutputCoder(), value.outputsCount).encode(value.outputs));
       parts.push(new ArrayCoder(new WitnessCoder(), value.witnessesCount).encode(value.witnesses));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
       let o = offset;
-      [decoded, o] = new NumberCoder("u16").decode(data, o);
+      [decoded, o] = new NumberCoder("u32").decode(data, o);
       const bytecodeLength = decoded;
       [decoded, o] = new NumberCoder("u8").decode(data, o);
       const bytecodeWitnessIndex = decoded;
@@ -35193,7 +35358,7 @@ spurious results.`);
       parts.push(new OutputContractCoder().encode(value.outputContract));
       parts.push(new U64Coder().encode(value.mintAmount));
       parts.push(new B256Coder().encode(value.mintAssetId));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -35253,7 +35418,7 @@ spurious results.`);
           );
         }
       }
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -35280,8 +35445,244 @@ spurious results.`);
           );
         }
       }
-    }
+    }
+  };
+
+  // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/utils.js
+  var utils_exports = {};
+  __export(utils_exports, {
+    bitGet: () => bitGet,
+    bitLen: () => bitLen,
+    bitMask: () => bitMask,
+    bitSet: () => bitSet,
+    bytesToHex: () => bytesToHex2,
+    bytesToNumberBE: () => bytesToNumberBE,
+    bytesToNumberLE: () => bytesToNumberLE,
+    concatBytes: () => concatBytes3,
+    createHmacDrbg: () => createHmacDrbg,
+    ensureBytes: () => ensureBytes,
+    equalBytes: () => equalBytes,
+    hexToBytes: () => hexToBytes2,
+    hexToNumber: () => hexToNumber,
+    isBytes: () => isBytes,
+    numberToBytesBE: () => numberToBytesBE,
+    numberToBytesLE: () => numberToBytesLE,
+    numberToHexUnpadded: () => numberToHexUnpadded,
+    numberToVarBytesBE: () => numberToVarBytesBE,
+    utf8ToBytes: () => utf8ToBytes3,
+    validateObject: () => validateObject
+  });
+  var _0n3 = BigInt(0);
+  var _1n3 = BigInt(1);
+  var _2n3 = BigInt(2);
+  function isBytes(a) {
+    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+  }
+  var hexes3 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+  function bytesToHex2(bytes4) {
+    if (!isBytes(bytes4))
+      throw new Error("Uint8Array expected");
+    let hex = "";
+    for (let i = 0; i < bytes4.length; i++) {
+      hex += hexes3[bytes4[i]];
+    }
+    return hex;
+  }
+  function numberToHexUnpadded(num) {
+    const hex = num.toString(16);
+    return hex.length & 1 ? `0${hex}` : hex;
+  }
+  function hexToNumber(hex) {
+    if (typeof hex !== "string")
+      throw new Error("hex string expected, got " + typeof hex);
+    return BigInt(hex === "" ? "0" : `0x${hex}`);
+  }
+  var asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
+  function asciiToBase16(char) {
+    if (char >= asciis._0 && char <= asciis._9)
+      return char - asciis._0;
+    if (char >= asciis._A && char <= asciis._F)
+      return char - (asciis._A - 10);
+    if (char >= asciis._a && char <= asciis._f)
+      return char - (asciis._a - 10);
+    return;
+  }
+  function hexToBytes2(hex) {
+    if (typeof hex !== "string")
+      throw new Error("hex string expected, got " + typeof hex);
+    const hl = hex.length;
+    const al = hl / 2;
+    if (hl % 2)
+      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
+    const array = new Uint8Array(al);
+    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+      const n1 = asciiToBase16(hex.charCodeAt(hi));
+      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+      if (n1 === void 0 || n2 === void 0) {
+        const char = hex[hi] + hex[hi + 1];
+        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+      }
+      array[ai] = n1 * 16 + n2;
+    }
+    return array;
+  }
+  function bytesToNumberBE(bytes4) {
+    return hexToNumber(bytesToHex2(bytes4));
+  }
+  function bytesToNumberLE(bytes4) {
+    if (!isBytes(bytes4))
+      throw new Error("Uint8Array expected");
+    return hexToNumber(bytesToHex2(Uint8Array.from(bytes4).reverse()));
+  }
+  function numberToBytesBE(n, len) {
+    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
+  }
+  function numberToBytesLE(n, len) {
+    return numberToBytesBE(n, len).reverse();
+  }
+  function numberToVarBytesBE(n) {
+    return hexToBytes2(numberToHexUnpadded(n));
+  }
+  function ensureBytes(title, hex, expectedLength) {
+    let res;
+    if (typeof hex === "string") {
+      try {
+        res = hexToBytes2(hex);
+      } catch (e) {
+        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
+      }
+    } else if (isBytes(hex)) {
+      res = Uint8Array.from(hex);
+    } else {
+      throw new Error(`${title} must be hex string or Uint8Array`);
+    }
+    const len = res.length;
+    if (typeof expectedLength === "number" && len !== expectedLength)
+      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
+    return res;
+  }
+  function concatBytes3(...arrays) {
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      if (!isBytes(a))
+        throw new Error("Uint8Array expected");
+      sum += a.length;
+    }
+    let res = new Uint8Array(sum);
+    let pad3 = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      res.set(a, pad3);
+      pad3 += a.length;
+    }
+    return res;
+  }
+  function equalBytes(a, b) {
+    if (a.length !== b.length)
+      return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i++)
+      diff |= a[i] ^ b[i];
+    return diff === 0;
+  }
+  function utf8ToBytes3(str) {
+    if (typeof str !== "string")
+      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+    return new Uint8Array(new TextEncoder().encode(str));
+  }
+  function bitLen(n) {
+    let len;
+    for (len = 0; n > _0n3; n >>= _1n3, len += 1)
+      ;
+    return len;
+  }
+  function bitGet(n, pos) {
+    return n >> BigInt(pos) & _1n3;
+  }
+  var bitSet = (n, pos, value) => {
+    return n | (value ? _1n3 : _0n3) << BigInt(pos);
+  };
+  var bitMask = (n) => (_2n3 << BigInt(n - 1)) - _1n3;
+  var u8n = (data) => new Uint8Array(data);
+  var u8fr = (arr) => Uint8Array.from(arr);
+  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
+    if (typeof hashLen !== "number" || hashLen < 2)
+      throw new Error("hashLen must be a number");
+    if (typeof qByteLen !== "number" || qByteLen < 2)
+      throw new Error("qByteLen must be a number");
+    if (typeof hmacFn !== "function")
+      throw new Error("hmacFn must be a function");
+    let v = u8n(hashLen);
+    let k = u8n(hashLen);
+    let i = 0;
+    const reset = () => {
+      v.fill(1);
+      k.fill(0);
+      i = 0;
+    };
+    const h = (...b) => hmacFn(k, v, ...b);
+    const reseed = (seed = u8n()) => {
+      k = h(u8fr([0]), seed);
+      v = h();
+      if (seed.length === 0)
+        return;
+      k = h(u8fr([1]), seed);
+      v = h();
+    };
+    const gen3 = () => {
+      if (i++ >= 1e3)
+        throw new Error("drbg: tried 1000 values");
+      let len = 0;
+      const out = [];
+      while (len < qByteLen) {
+        v = h();
+        const sl = v.slice();
+        out.push(sl);
+        len += v.length;
+      }
+      return concatBytes3(...out);
+    };
+    const genUntil = (seed, pred) => {
+      reset();
+      reseed(seed);
+      let res = void 0;
+      while (!(res = pred(gen3())))
+        reseed();
+      reset();
+      return res;
+    };
+    return genUntil;
+  }
+  var validatorFns = {
+    bigint: (val) => typeof val === "bigint",
+    function: (val) => typeof val === "function",
+    boolean: (val) => typeof val === "boolean",
+    string: (val) => typeof val === "string",
+    stringOrUint8Array: (val) => typeof val === "string" || isBytes(val),
+    isSafeInteger: (val) => Number.isSafeInteger(val),
+    array: (val) => Array.isArray(val),
+    field: (val, object) => object.Fp.isValid(val),
+    hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
   };
+  function validateObject(object, validators, optValidators = {}) {
+    const checkField = (fieldName, type3, isOptional) => {
+      const checkVal = validatorFns[type3];
+      if (typeof checkVal !== "function")
+        throw new Error(`Invalid validator "${type3}", expected function`);
+      const val = object[fieldName];
+      if (isOptional && val === void 0)
+        return;
+      if (!checkVal(val, object)) {
+        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type3}`);
+      }
+    };
+    for (const [fieldName, type3] of Object.entries(validators))
+      checkField(fieldName, type3, false);
+    for (const [fieldName, type3] of Object.entries(optValidators))
+      checkField(fieldName, type3, true);
+    return object;
+  }
 
   // src/providers/provider.ts
   var import_graphql_request = __toESM(require_dist2());
@@ -39405,67 +39806,63 @@ ${MessageCoinFragmentFragmentDoc}`;
   }
 
   // src/providers/fuel-graphql-subscriber.ts
-  var _FuelSubscriptionStream = class {
-    readable;
-    writable;
-    readableStreamController;
-    constructor() {
-      this.readable = new ReadableStream({
-        start: (controller) => {
-          this.readableStreamController = controller;
-        }
-      });
-      this.writable = new WritableStream({
-        write: (bytes4) => {
-          const text = _FuelSubscriptionStream.textDecoder.decode(bytes4);
-          if (text.startsWith("data:")) {
-            const { data, errors } = JSON.parse(text.split("data:")[1]);
-            if (Array.isArray(errors)) {
-              this.readableStreamController.enqueue(
-                new FuelError(
-                  FuelError.CODES.INVALID_REQUEST,
-                  errors.map((err) => err.message).join("\n\n")
-                )
-              );
-            } else {
-              this.readableStreamController.enqueue(data);
-            }
-          }
+  var _FuelGraphqlSubscriber = class {
+    constructor(options) {
+      this.options = options;
+    }
+    stream;
+    async setStream() {
+      const { url, query, variables, fetchFn } = this.options;
+      const response = await fetchFn(`${url}-sub`, {
+        method: "POST",
+        body: JSON.stringify({
+          query: print(query),
+          variables
+        }),
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
         }
       });
+      this.stream = response.body.getReader();
     }
-  };
-  var FuelSubscriptionStream = _FuelSubscriptionStream;
-  __publicField(FuelSubscriptionStream, "textDecoder", new TextDecoder());
-  async function* fuelGraphQLSubscriber({
-    url,
-    variables,
-    query,
-    fetchFn
-  }) {
-    const response = await fetchFn(`${url}-sub`, {
-      method: "POST",
-      body: JSON.stringify({
-        query: print(query),
-        variables
-      }),
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "text/event-stream"
+    async next() {
+      if (!this.stream) {
+        await this.setStream();
       }
-    });
-    const subscriptionStreamReader = response.body.pipeThrough(new FuelSubscriptionStream()).getReader();
-    while (true) {
-      const { value, done } = await subscriptionStreamReader.read();
-      if (value instanceof FuelError) {
-        throw value;
-      }
-      yield value;
-      if (done) {
-        break;
+      while (true) {
+        const { value, done } = await this.stream.read();
+        if (done) {
+          return { value, done };
+        }
+        const text = _FuelGraphqlSubscriber.textDecoder.decode(value);
+        if (!text.startsWith("data:")) {
+          continue;
+        }
+        const { data, errors } = JSON.parse(text.split("data:")[1]);
+        if (Array.isArray(errors)) {
+          throw new FuelError(
+            FuelError.CODES.INVALID_REQUEST,
+            errors.map((err) => err.message).join("\n\n")
+          );
+        }
+        return { value: data, done: false };
       }
     }
-  }
+    /**
+     * Gets called when `break` is called in a `for-await-of` loop.
+     */
+    async return() {
+      await this.stream.cancel();
+      this.stream.releaseLock();
+      return { done: true, value: void 0 };
+    }
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+  var FuelGraphqlSubscriber = _FuelGraphqlSubscriber;
+  __publicField(FuelGraphqlSubscriber, "textDecoder", new TextDecoder());
 
   // src/providers/memory-cache.ts
   var cache = {};
@@ -39529,18 +39926,18 @@ ${MessageCoinFragmentFragmentDoc}`;
     const { type: type3 } = value;
     switch (value.type) {
       case InputType.Coin: {
-        const predicate = getBytesCopy(value.predicate ?? "0x");
-        const predicateData = getBytesCopy(value.predicateData ?? "0x");
+        const predicate = arrayify(value.predicate ?? "0x");
+        const predicateData = arrayify(value.predicateData ?? "0x");
         return {
           type: InputType.Coin,
-          txID: hexlify(getBytesCopy(value.id).slice(0, 32)),
-          outputIndex: getBytesCopy(value.id)[32],
+          txID: hexlify(arrayify(value.id).slice(0, 32)),
+          outputIndex: arrayify(value.id)[32],
           owner: hexlify(value.owner),
           amount: bn(value.amount),
           assetId: hexlify(value.assetId),
           txPointer: {
-            blockHeight: toNumber2(getBytesCopy(value.txPointer).slice(0, 8)),
-            txIndex: toNumber2(getBytesCopy(value.txPointer).slice(8, 16))
+            blockHeight: toNumber2(arrayify(value.txPointer).slice(0, 8)),
+            txIndex: toNumber2(arrayify(value.txPointer).slice(8, 16))
           },
           witnessIndex: value.witnessIndex,
           maturity: value.maturity ?? 0,
@@ -39559,16 +39956,16 @@ ${MessageCoinFragmentFragmentDoc}`;
           balanceRoot: ZeroBytes32,
           stateRoot: ZeroBytes32,
           txPointer: {
-            blockHeight: toNumber2(getBytesCopy(value.txPointer).slice(0, 8)),
-            txIndex: toNumber2(getBytesCopy(value.txPointer).slice(8, 16))
+            blockHeight: toNumber2(arrayify(value.txPointer).slice(0, 8)),
+            txIndex: toNumber2(arrayify(value.txPointer).slice(8, 16))
           },
           contractID: hexlify(value.contractId)
         };
       }
       case InputType.Message: {
-        const predicate = getBytesCopy(value.predicate ?? "0x");
-        const predicateData = getBytesCopy(value.predicateData ?? "0x");
-        const data = getBytesCopy(value.data ?? "0x");
+        const predicate = arrayify(value.predicate ?? "0x");
+        const predicateData = arrayify(value.predicateData ?? "0x");
+        const data = arrayify(value.data ?? "0x");
         return {
           type: InputType.Message,
           sender: hexlify(value.sender),
@@ -39804,7 +40201,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         const recipient = hexOrZero(receipt.recipient);
         const nonce = hexOrZero(receipt.nonce);
         const amount = bn(receipt.amount);
-        const data = receipt.data ? getBytesCopy(receipt.data) : Uint8Array.from([]);
+        const data = receipt.data ? arrayify(receipt.data) : Uint8Array.from([]);
         const digest = hexOrZero(receipt.digest);
         const messageId = ReceiptMessageOutCoder.getMessageId({
           sender,
@@ -39946,9 +40343,7 @@ ${MessageCoinFragmentFragmentDoc}`;
     const totalGas = inputs.reduce((total, input) => {
       if ("predicate" in input && input.predicate && input.predicate !== "0x") {
         return total.add(
-          resolveGasDependentCosts(txBytesSize, gasCosts.vmInitialization).add(
-            resolveGasDependentCosts(getBytesCopy(input.predicate).length, gasCosts.contractRoot)
-          ).add(bn(input.predicateGasUsed))
+          resolveGasDependentCosts(txBytesSize, gasCosts.vmInitialization).add(resolveGasDependentCosts(arrayify(input.predicate).length, gasCosts.contractRoot)).add(bn(input.predicateGasUsed))
         );
       }
       if ("witnessIndex" in input && !witnessCache.includes(input.witnessIndex)) {
@@ -40062,7 +40457,7 @@ ${MessageCoinFragmentFragmentDoc}`;
 
   // src/providers/transaction-request/witness.ts
   var witnessify = (value) => {
-    const data = getBytesCopy(value);
+    const data = arrayify(value);
     return {
       data: hexlify(data),
       dataLength: data.length
@@ -40534,19 +40929,27 @@ ${MessageCoinFragmentFragmentDoc}`;
     toJSON() {
       return normalizeJSON(this);
     }
-    /**
-     * @hidden
-     *
-     * Determines whether the transaction has a predicate input.
-     *
-     * @returns Whether the transaction has a predicate input.
-     */
-    hasPredicateInput() {
-      return Boolean(
-        this.inputs.find(
-          (input) => "predicate" in input && input.predicate && input.predicate !== getBytesCopy("0x")
-        )
-      );
+    updatePredicateInputs(inputs) {
+      this.inputs.forEach((i) => {
+        let correspondingInput;
+        switch (i.type) {
+          case InputType.Coin:
+            correspondingInput = inputs.find((x) => x.type === InputType.Coin && x.owner === i.owner);
+            break;
+          case InputType.Message:
+            correspondingInput = inputs.find(
+              (x) => x.type === InputType.Message && x.sender === i.sender
+            );
+            break;
+          default:
+            return;
+        }
+        if (correspondingInput && "predicateGasUsed" in correspondingInput && bn(correspondingInput.predicateGasUsed).gt(0)) {
+          i.predicate = correspondingInput.predicate;
+          i.predicateData = correspondingInput.predicateData;
+          i.predicateGasUsed = correspondingInput.predicateGasUsed;
+        }
+      });
     }
   };
 
@@ -40633,7 +41036,7 @@ ${MessageCoinFragmentFragmentDoc}`;
   // src/providers/transaction-request/storage-slot.ts
   var getStorageValue = (value) => {
     const v = new Uint8Array(32);
-    v.set(getBytesCopy(value));
+    v.set(arrayify(value));
     return v;
   };
   var storageSlotify = (storageSlot) => {
@@ -40738,7 +41141,7 @@ ${MessageCoinFragmentFragmentDoc}`;
     }
     metadataGas(gasCosts) {
       return calculateMetadataGasForTxCreate({
-        contractBytesSize: bn(getBytesCopy(this.witnesses[this.bytecodeWitnessIndex] || "0x").length),
+        contractBytesSize: bn(arrayify(this.witnesses[this.bytecodeWitnessIndex] || "0x").length),
         gasCosts,
         stateRootSize: this.storageSlots.length,
         txBytesSize: this.byteSize()
@@ -40753,7 +41156,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         Opcode::NOOP
       */
     // TODO: Don't use hardcoded scripts: https://github.com/FuelLabs/fuels-ts/issues/281
-    bytes: getBytesCopy("0x24000000"),
+    bytes: arrayify("0x24000000"),
     encodeScriptData: () => new Uint8Array(0)
   };
   var withdrawScript = {
@@ -40767,7 +41170,7 @@ ${MessageCoinFragmentFragmentDoc}`;
             00000000 00000000 [amount value]
         */
     // TODO: Don't use hardcoded scripts: https://github.com/FuelLabs/fuels-ts/issues/281
-    bytes: getBytesCopy("0x5040C0105D44C0064C40001124000000"),
+    bytes: arrayify("0x5040C0105D44C0064C40001124000000"),
     encodeScriptData: () => new Uint8Array(0)
   };
 
@@ -40795,8 +41198,8 @@ ${MessageCoinFragmentFragmentDoc}`;
     constructor({ script, scriptData, gasLimit, ...rest } = {}) {
       super(rest);
       this.gasLimit = bn(gasLimit);
-      this.script = getBytesCopy(script ?? returnZeroScript.bytes);
-      this.scriptData = getBytesCopy(scriptData ?? returnZeroScript.encodeScriptData());
+      this.script = arrayify(script ?? returnZeroScript.bytes);
+      this.scriptData = arrayify(scriptData ?? returnZeroScript.encodeScriptData());
     }
     /**
      * Converts the transaction request to a `TransactionScript`.
@@ -40804,8 +41207,8 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns The transaction script object.
      */
     toTransaction() {
-      const script = getBytesCopy(this.script ?? "0x");
-      const scriptData = getBytesCopy(this.scriptData ?? "0x");
+      const script = arrayify(this.script ?? "0x");
+      const scriptData = arrayify(this.scriptData ?? "0x");
       return {
         type: TransactionType.Script,
         scriptGasLimit: this.gasLimit,
@@ -40968,7 +41371,7 @@ ${MessageCoinFragmentFragmentDoc}`;
     } = params;
     const gasPerByte = bn(feeParams.gasPerByte);
     const gasPriceFactor = bn(feeParams.gasPriceFactor);
-    const transactionBytes = getBytesCopy(rawPayload);
+    const transactionBytes = arrayify(rawPayload);
     const [transaction] = new TransactionCoder().decode(transactionBytes, 0);
     if (transaction.type === TransactionType.Mint) {
       return {
@@ -40983,7 +41386,7 @@ ${MessageCoinFragmentFragmentDoc}`;
     let gasLimit = bn(0);
     if (type3 === TransactionType.Create) {
       const { bytecodeWitnessIndex, storageSlots } = transaction;
-      const contractBytesSize = bn(getBytesCopy(witnesses[bytecodeWitnessIndex].data).length);
+      const contractBytesSize = bn(arrayify(witnesses[bytecodeWitnessIndex].data).length);
       metadataGas = calculateMetadataGasForTxCreate({
         contractBytesSize,
         gasCosts,
@@ -41172,7 +41575,6 @@ ${MessageCoinFragmentFragmentDoc}`;
     OperationName2["contractCreated"] = "Contract created";
     OperationName2["transfer"] = "Transfer asset";
     OperationName2["contractCall"] = "Contract call";
-    OperationName2["contractTransfer"] = "Contract transfer";
     OperationName2["receive"] = "Receive asset";
     OperationName2["mint"] = "Mint asset";
     OperationName2["predicatecall"] = "Predicate call";
@@ -41272,33 +41674,6 @@ ${MessageCoinFragmentFragmentDoc}`;
   function getReceiptsTransferOut(receipts) {
     return getReceiptsByType(receipts, ReceiptType.TransferOut);
   }
-  function getContractTransferOperations({ receipts }) {
-    const transferOutReceipts = getReceiptsTransferOut(receipts);
-    const contractTransferOperations = transferOutReceipts.reduce(
-      (prevContractTransferOps, receipt) => {
-        const newContractTransferOps = addOperation(prevContractTransferOps, {
-          name: "Contract transfer" /* contractTransfer */,
-          from: {
-            type: 0 /* contract */,
-            address: receipt.from
-          },
-          to: {
-            type: 1 /* account */,
-            address: receipt.to
-          },
-          assetsSent: [
-            {
-              amount: receipt.amount,
-              assetId: receipt.assetId
-            }
-          ]
-        });
-        return newContractTransferOps;
-      },
-      []
-    );
-    return contractTransferOperations;
-  }
   function getWithdrawFromFuelOperations({
     inputs,
     receipts
@@ -41396,70 +41771,77 @@ ${MessageCoinFragmentFragmentDoc}`;
     }, []);
     return contractCallOperations;
   }
+  function extractTransferOperationFromReceipt(receipt, contractInputs, changeOutputs) {
+    const { to: toAddress, assetId, amount } = receipt;
+    let { from: fromAddress } = receipt;
+    const toType = contractInputs.some((input) => input.contractID === toAddress) ? 0 /* contract */ : 1 /* account */;
+    if (ZeroBytes32 === fromAddress) {
+      const change = changeOutputs.find((output4) => output4.assetId === assetId);
+      fromAddress = change?.to || fromAddress;
+    }
+    const fromType = contractInputs.some((input) => input.contractID === fromAddress) ? 0 /* contract */ : 1 /* account */;
+    return {
+      name: "Transfer asset" /* transfer */,
+      from: {
+        type: fromType,
+        address: fromAddress
+      },
+      to: {
+        type: toType,
+        address: toAddress
+      },
+      assetsSent: [
+        {
+          assetId: assetId.toString(),
+          amount
+        }
+      ]
+    };
+  }
   function getTransferOperations({
     inputs,
     outputs,
     receipts
   }) {
+    let operations = [];
     const coinOutputs = getOutputsCoin(outputs);
-    const [transferReceipt] = getReceiptsByType(
+    const contractInputs = getInputsContract(inputs);
+    const changeOutputs = getOutputsChange(outputs);
+    coinOutputs.forEach((output4) => {
+      const { amount, assetId, to } = output4;
+      const changeOutput = changeOutputs.find((change) => change.assetId === assetId);
+      if (changeOutput) {
+        operations = addOperation(operations, {
+          name: "Transfer asset" /* transfer */,
+          from: {
+            type: 1 /* account */,
+            address: changeOutput.to
+          },
+          to: {
+            type: 1 /* account */,
+            address: to
+          },
+          assetsSent: [
+            {
+              assetId,
+              amount
+            }
+          ]
+        });
+      }
+    });
+    const transferReceipts = getReceiptsByType(
       receipts,
       ReceiptType.Transfer
     );
-    let operations = [];
-    if (transferReceipt) {
-      const changeOutputs = getOutputsChange(outputs);
-      changeOutputs.forEach((output4) => {
-        const { assetId } = output4;
-        const [contractInput] = getInputsContract(inputs);
-        const utxo = getInputFromAssetId(inputs, assetId);
-        if (utxo && contractInput) {
-          const inputAddress = getInputAccountAddress(utxo);
-          operations = addOperation(operations, {
-            name: "Transfer asset" /* transfer */,
-            from: {
-              type: 1 /* account */,
-              address: inputAddress
-            },
-            to: {
-              type: 0 /* contract */,
-              address: contractInput.contractID
-            },
-            assetsSent: [
-              {
-                assetId: assetId.toString(),
-                amount: transferReceipt.amount
-              }
-            ]
-          });
-        }
-      });
-    } else {
-      coinOutputs.forEach((output4) => {
-        const input = getInputFromAssetId(inputs, output4.assetId);
-        if (input) {
-          const inputAddress = getInputAccountAddress(input);
-          const operationToAdd = {
-            name: "Transfer asset" /* transfer */,
-            from: {
-              type: 1 /* account */,
-              address: inputAddress
-            },
-            to: {
-              type: 1 /* account */,
-              address: output4.to.toString()
-            },
-            assetsSent: [
-              {
-                assetId: output4.assetId.toString(),
-                amount: output4.amount
-              }
-            ]
-          };
-          operations = addOperation(operations, operationToAdd);
-        }
-      });
-    }
+    const transferOutReceipts = getReceiptsByType(
+      receipts,
+      ReceiptType.TransferOut
+    );
+    [...transferReceipts, ...transferOutReceipts].forEach((receipt) => {
+      const operation = extractTransferOperationFromReceipt(receipt, contractInputs, changeOutputs);
+      operations = addOperation(operations, operation);
+    });
     return operations;
   }
   function getPayProducerOperations(outputs) {
@@ -41532,7 +41914,6 @@ ${MessageCoinFragmentFragmentDoc}`;
           rawPayload,
           maxInputs
         }),
-        ...getContractTransferOperations({ receipts }),
         ...getWithdrawFromFuelOperations({ inputs, receipts })
       ];
     }
@@ -41776,7 +42157,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      */
     decodeTransaction(transactionWithReceipts) {
       return new TransactionCoder().decode(
-        getBytesCopy(transactionWithReceipts.rawPayload),
+        arrayify(transactionWithReceipts.rawPayload),
         0
       )?.[0];
     }
@@ -41802,7 +42183,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         id: this.id,
         receipts,
         transaction: decodedTransaction,
-        transactionBytes: getBytesCopy(transaction.rawPayload),
+        transactionBytes: arrayify(transaction.rawPayload),
         gqlTransactionStatus: transaction.status,
         gasPerByte,
         gasPriceFactor,
@@ -42101,7 +42482,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         const opDefinition = query.definitions.find((x) => x.kind === "OperationDefinition");
         const isSubscription = opDefinition?.operation === "subscription";
         if (isSubscription) {
-          return fuelGraphQLSubscriber({
+          return new FuelGraphqlSubscriber({
             url: this.url,
             query,
             fetchFn: (url, requestInit) => fetchFn(url, requestInit, this.options),
@@ -42234,7 +42615,7 @@ ${MessageCoinFragmentFragmentDoc}`;
     async call(transactionRequestLike, { utxoValidation, estimateTxDependencies = true } = {}) {
       const transactionRequest = transactionRequestify(transactionRequestLike);
       if (estimateTxDependencies) {
-        await this.estimateTxDependencies(transactionRequest);
+        return this.estimateTxDependencies(transactionRequest);
       }
       const encodedTransaction = hexlify(transactionRequest.toTransactionBytes());
       const { dryRun: gqlReceipts } = await this.operations.dryRun({
@@ -42253,6 +42634,14 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns A promise that resolves to the estimated transaction request object.
      */
     async estimatePredicates(transactionRequest) {
+      const shouldEstimatePredicates = Boolean(
+        transactionRequest.inputs.find(
+          (input) => "predicate" in input && input.predicate && !equalBytes(arrayify(input.predicate), arrayify("0x")) && new BN(input.predicateGasUsed).isZero()
+        )
+      );
+      if (!shouldEstimatePredicates) {
+        return transactionRequest;
+      }
       const encodedTransaction = hexlify(transactionRequest.toTransactionBytes());
       const response = await this.operations.estimatePredicates({
         encodedTransaction
@@ -42283,34 +42672,41 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns A promise.
      */
     async estimateTxDependencies(transactionRequest) {
-      let missingOutputVariableCount = 0;
-      let missingOutputContractIdsCount = 0;
-      let tries = 0;
       if (transactionRequest.type === TransactionType.Create) {
-        return;
-      }
-      let txRequest = transactionRequest;
-      if (txRequest.hasPredicateInput()) {
-        txRequest = await this.estimatePredicates(txRequest);
+        return {
+          receipts: [],
+          outputVariables: 0,
+          missingContractIds: []
+        };
       }
-      while (tries < MAX_RETRIES) {
+      await this.estimatePredicates(transactionRequest);
+      let receipts = [];
+      const missingContractIds = [];
+      let outputVariables = 0;
+      for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
         const { dryRun: gqlReceipts } = await this.operations.dryRun({
-          encodedTransaction: hexlify(txRequest.toTransactionBytes()),
+          encodedTransaction: hexlify(transactionRequest.toTransactionBytes()),
           utxoValidation: false
         });
-        const receipts = gqlReceipts.map(processGqlReceipt);
+        receipts = gqlReceipts.map(processGqlReceipt);
         const { missingOutputVariables, missingOutputContractIds } = getReceiptsWithMissingData(receipts);
-        missingOutputVariableCount = missingOutputVariables.length;
-        missingOutputContractIdsCount = missingOutputContractIds.length;
-        if (missingOutputVariableCount === 0 && missingOutputContractIdsCount === 0) {
-          return;
+        const hasMissingOutputs = missingOutputVariables.length !== 0 || missingOutputContractIds.length !== 0;
+        if (hasMissingOutputs) {
+          outputVariables += missingOutputVariables.length;
+          transactionRequest.addVariableOutputs(missingOutputVariables.length);
+          missingOutputContractIds.forEach(({ contractId }) => {
+            transactionRequest.addContractInputAndOutput(Address.fromString(contractId));
+            missingContractIds.push(contractId);
+          });
+        } else {
+          break;
         }
-        txRequest.addVariableOutputs(missingOutputVariableCount);
-        missingOutputContractIds.forEach(
-          ({ contractId }) => txRequest.addContractInputAndOutput(Address.fromString(contractId))
-        );
-        tries += 1;
       }
+      return {
+        receipts,
+        outputVariables,
+        missingContractIds
+      };
     }
     /**
      * Executes a signed transaction without applying the states changes
@@ -42325,7 +42721,7 @@ ${MessageCoinFragmentFragmentDoc}`;
     async simulate(transactionRequestLike, { estimateTxDependencies = true } = {}) {
       const transactionRequest = transactionRequestify(transactionRequestLike);
       if (estimateTxDependencies) {
-        await this.estimateTxDependencies(transactionRequest);
+        return this.estimateTxDependencies(transactionRequest);
       }
       const encodedTransaction = hexlify(transactionRequest.toTransactionBytes());
       const { dryRun: gqlReceipts } = await this.operations.dryRun({
@@ -42357,35 +42753,37 @@ ${MessageCoinFragmentFragmentDoc}`;
       estimatePredicates = true,
       resourcesOwner
     } = {}) {
-      const transactionRequest = transactionRequestify(clone_default(transactionRequestLike));
+      const txRequestClone = clone_default(transactionRequestify(transactionRequestLike));
       const chainInfo = this.getChain();
       const { gasPriceFactor, minGasPrice, maxGasPerTx } = this.getGasConfig();
-      const gasPrice = max(transactionRequest.gasPrice, minGasPrice);
-      const isScriptTransaction = transactionRequest.type === TransactionType.Script;
-      if (transactionRequest.hasPredicateInput() && estimatePredicates) {
+      const gasPrice = max(txRequestClone.gasPrice, minGasPrice);
+      const isScriptTransaction = txRequestClone.type === TransactionType.Script;
+      const coinOutputsQuantities = txRequestClone.getCoinOutputsQuantities();
+      const allQuantities = mergeQuantities(coinOutputsQuantities, forwardingQuantities);
+      txRequestClone.fundWithFakeUtxos(allQuantities, resourcesOwner?.address);
+      if (estimatePredicates) {
         if (isScriptTransaction) {
-          transactionRequest.gasLimit = bn(0);
+          txRequestClone.gasLimit = bn(0);
+        }
+        if (resourcesOwner && "populateTransactionPredicateData" in resourcesOwner) {
+          resourcesOwner.populateTransactionPredicateData(txRequestClone);
         }
-        await this.estimatePredicates(transactionRequest);
+        await this.estimatePredicates(txRequestClone);
       }
-      const minGas = transactionRequest.calculateMinGas(chainInfo);
-      const maxGas = transactionRequest.calculateMaxGas(chainInfo, minGas);
-      const coinOutputsQuantities = transactionRequest.getCoinOutputsQuantities();
-      const allQuantities = mergeQuantities(coinOutputsQuantities, forwardingQuantities);
-      transactionRequest.fundWithFakeUtxos(allQuantities, resourcesOwner);
-      let gasUsed = minGas;
+      const minGas = txRequestClone.calculateMinGas(chainInfo);
+      const maxGas = txRequestClone.calculateMaxGas(chainInfo, minGas);
       let receipts = [];
-      if (isScriptTransaction) {
-        transactionRequest.gasPrice = bn(0);
-        transactionRequest.gasLimit = bn(maxGasPerTx.sub(maxGas).toNumber() * 0.9);
-        const result = await this.call(transactionRequest, {
-          estimateTxDependencies
-        });
+      let missingContractIds = [];
+      let outputVariables = 0;
+      if (isScriptTransaction && estimateTxDependencies) {
+        txRequestClone.gasPrice = bn(0);
+        txRequestClone.gasLimit = bn(maxGasPerTx.sub(maxGas).toNumber() * 0.9);
+        const result = await this.estimateTxDependencies(txRequestClone);
         receipts = result.receipts;
-        gasUsed = getGasUsedFromReceipts(receipts);
-      } else {
-        gasUsed = minGas;
+        outputVariables = result.outputVariables;
+        missingContractIds = result.missingContractIds;
       }
+      const gasUsed = isScriptTransaction ? getGasUsedFromReceipts(receipts) : minGas;
       const usedFee = calculatePriceWithFactor(
         gasUsed,
         gasPrice,
@@ -42403,7 +42801,10 @@ ${MessageCoinFragmentFragmentDoc}`;
         maxGas,
         usedFee,
         minFee,
-        maxFee
+        maxFee,
+        estimatedInputs: txRequestClone.inputs,
+        outputVariables,
+        missingContractIds
       };
     }
     async getResourcesForTransaction(owner, transactionRequestLike, forwardingQuantities = []) {
@@ -42571,7 +42972,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         time: block2.header.time,
         transactionIds: block2.transactions.map((tx) => tx.id),
         transactions: block2.transactions.map(
-          (tx) => new TransactionCoder().decode(getBytesCopy(tx.rawPayload), 0)?.[0]
+          (tx) => new TransactionCoder().decode(arrayify(tx.rawPayload), 0)?.[0]
         )
       };
     }
@@ -42587,7 +42988,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         return null;
       }
       return new TransactionCoder().decode(
-        getBytesCopy(transaction.rawPayload),
+        arrayify(transaction.rawPayload),
         0
       )?.[0];
     }
@@ -42826,7 +43227,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       );
     }
     const [decodedTransaction] = new TransactionCoder().decode(
-      getBytesCopy(gqlTransaction.rawPayload),
+      arrayify(gqlTransaction.rawPayload),
       0
     );
     const receipts = gqlTransaction.receipts?.map(processGqlReceipt) || [];
@@ -42837,7 +43238,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       id: gqlTransaction.id,
       receipts,
       transaction: decodedTransaction,
-      transactionBytes: getBytesCopy(gqlTransaction.rawPayload),
+      transactionBytes: arrayify(gqlTransaction.rawPayload),
       gqlTransactionStatus: gqlTransaction.status,
       gasPerByte: bn(gasPerByte),
       gasPriceFactor: bn(gasPriceFactor),
@@ -42879,13 +43280,13 @@ ${MessageCoinFragmentFragmentDoc}`;
     const transactions = edges.map((edge) => {
       const { node: gqlTransaction } = edge;
       const { id, rawPayload, receipts: gqlReceipts, status } = gqlTransaction;
-      const [decodedTransaction] = new TransactionCoder().decode(getBytesCopy(rawPayload), 0);
+      const [decodedTransaction] = new TransactionCoder().decode(arrayify(rawPayload), 0);
       const receipts = gqlReceipts?.map(processGqlReceipt) || [];
       const transactionSummary = assembleTransactionSummary({
         id,
         receipts,
         transaction: decodedTransaction,
-        transactionBytes: getBytesCopy(rawPayload),
+        transactionBytes: arrayify(rawPayload),
         gqlTransactionStatus: status,
         abiMap,
         gasPerByte,
@@ -42905,6 +43306,127 @@ ${MessageCoinFragmentFragmentDoc}`;
     };
   }
 
+  // src/providers/chains.ts
+  var CHAIN_IDS = {
+    eth: {
+      sepolia: 11155111,
+      foundry: 31337
+    },
+    fuel: {
+      beta5: 0,
+      devnet: 10
+    }
+  };
+
+  // src/providers/assets/utils/network.ts
+  var getDefaultChainId = (networkType) => {
+    if (networkType === "ethereum") {
+      return CHAIN_IDS.eth.sepolia;
+    }
+    if (networkType === "fuel") {
+      return CHAIN_IDS.fuel.beta5;
+    }
+    return void 0;
+  };
+  var getAssetNetwork = ({
+    asset,
+    chainId,
+    networkType
+  }) => {
+    const network = asset.networks.find(
+      (item) => item.chainId === chainId && item.type === networkType
+    );
+    return network;
+  };
+  var getAssetWithNetwork = ({
+    asset,
+    chainId,
+    networkType
+  }) => {
+    const { networks: _, ...assetRest } = asset;
+    const chainIdToUse = chainId ?? getDefaultChainId(networkType);
+    if (chainIdToUse === void 0) {
+      return void 0;
+    }
+    const assetNetwork = getAssetNetwork({
+      asset,
+      chainId: chainIdToUse,
+      networkType
+    });
+    if (!assetNetwork) {
+      return void 0;
+    }
+    return {
+      ...assetRest,
+      ...assetNetwork
+    };
+  };
+  var getAssetEth = (asset, chainId) => getAssetWithNetwork({
+    asset,
+    networkType: "ethereum",
+    chainId
+  });
+  var getAssetFuel = (asset, chainId) => getAssetWithNetwork({
+    asset,
+    networkType: "fuel",
+    chainId
+  });
+
+  // src/providers/assets/utils/url.ts
+  var DELIMITER_PATH = "/";
+  var trimRegex = /^\/|\/$/g;
+  var trimPath = (path = "") => path.replace(trimRegex, "");
+  function urlJoin(baseUrl, ...paths) {
+    const hasBaseUrl = baseUrl !== null && baseUrl !== void 0;
+    const rootPath = baseUrl?.[0] === "/" && baseUrl.length > 1;
+    const allPaths = [baseUrl, ...paths].filter(Boolean).map(trimPath);
+    if (rootPath && hasBaseUrl) {
+      allPaths.unshift("");
+    }
+    return allPaths.join(DELIMITER_PATH);
+  }
+
+  // src/providers/assets/utils/resolveIconPaths.ts
+  function resolveIconPaths(assets2, basePath = "./") {
+    return assets2.map((asset) => ({
+      ...asset,
+      icon: urlJoin(basePath, asset.icon)
+    }));
+  }
+
+  // src/providers/assets/index.ts
+  var assets = [
+    {
+      name: "Ethereum",
+      symbol: "ETH",
+      icon: "eth.svg",
+      networks: [
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.sepolia,
+          decimals: 18
+        },
+        {
+          type: "ethereum",
+          chainId: CHAIN_IDS.eth.foundry,
+          decimals: 18
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.beta5,
+          decimals: 9,
+          assetId: "0x0000000000000000000000000000000000000000000000000000000000000000"
+        },
+        {
+          type: "fuel",
+          chainId: CHAIN_IDS.fuel.devnet,
+          decimals: 9,
+          assetId: "0x0000000000000000000000000000000000000000000000000000000000000000"
+        }
+      ]
+    }
+  ];
+
   // src/utils/formatTransferToContractScriptData.ts
   var asm = __toESM(require_node());
   var formatTransferToContractScriptData = (params) => {
@@ -42912,9 +43434,9 @@ ${MessageCoinFragmentFragmentDoc}`;
     const numberCoder = new U64Coder();
     const encoded = numberCoder.encode(new BN(amountToTransfer).toNumber());
     const scriptData = Uint8Array.from([
-      ...getBytesCopy(hexlifiedContractId),
+      ...arrayify(hexlifiedContractId),
       ...encoded,
-      ...getBytesCopy(assetId)
+      ...arrayify(assetId)
     ]);
     return scriptData;
   };
@@ -43164,7 +43686,10 @@ ${MessageCoinFragmentFragmentDoc}`;
       const params = { gasPrice: minGasPrice, ...txParams };
       const request = new ScriptTransactionRequest(params);
       request.addCoinOutput(Address.fromAddressOrString(destination), amount, assetId);
-      const { maxFee, requiredQuantities, gasUsed } = await this.provider.getTransactionCost(request);
+      const { maxFee, requiredQuantities, gasUsed, estimatedInputs } = await this.provider.getTransactionCost(request, [], {
+        estimateTxDependencies: true,
+        resourcesOwner: this
+      });
       request.gasPrice = bn(txParams.gasPrice ?? minGasPrice);
       request.gasLimit = bn(txParams.gasLimit ?? gasUsed);
       this.validateGas({
@@ -43174,6 +43699,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         minGasPrice
       });
       await this.fund(request, requiredQuantities, maxFee);
+      request.updatePredicateInputs(estimatedInputs);
       return request;
     }
     /**
@@ -43187,7 +43713,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      */
     async transfer(destination, amount, assetId = BaseAssetId, txParams = {}) {
       const request = await this.createTransfer(destination, amount, assetId, txParams);
-      return this.sendTransaction(request);
+      return this.sendTransaction(request, { estimateTxDependencies: false });
     }
     /**
      * Transfers coins to a contract address.
@@ -43238,14 +43764,14 @@ ${MessageCoinFragmentFragmentDoc}`;
     async withdrawToBaseLayer(recipient, amount, txParams = {}) {
       const { minGasPrice } = this.provider.getGasConfig();
       const recipientAddress = Address.fromAddressOrString(recipient);
-      const recipientDataArray = getBytesCopy(
+      const recipientDataArray = arrayify(
         "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
       );
-      const amountDataArray = getBytesCopy(
+      const amountDataArray = arrayify(
         "0x".concat(bn(amount).toHex().substring(2).padStart(16, "0"))
       );
       const script = new Uint8Array([
-        ...getBytesCopy(withdrawScript.bytes),
+        ...arrayify(withdrawScript.bytes),
         ...recipientDataArray,
         ...amountDataArray
       ]);
@@ -43278,16 +43804,18 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @param transactionRequestLike - The transaction request to be sent.
      * @returns A promise that resolves to the transaction response.
      */
-    async sendTransaction(transactionRequestLike, options) {
+    async sendTransaction(transactionRequestLike, { estimateTxDependencies = true, awaitExecution } = {}) {
       if (this._connector) {
         return this.provider.getTransactionResponse(
           await this._connector.sendTransaction(this.address.toString(), transactionRequestLike)
         );
       }
       const transactionRequest = transactionRequestify(transactionRequestLike);
-      await this.provider.estimateTxDependencies(transactionRequest);
+      if (estimateTxDependencies) {
+        await this.provider.estimateTxDependencies(transactionRequest);
+      }
       return this.provider.sendTransaction(transactionRequest, {
-        ...options,
+        awaitExecution,
         estimateTxDependencies: false
       });
     }
@@ -43297,9 +43825,11 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @param transactionRequestLike - The transaction request to be simulated.
      * @returns A promise that resolves to the call result.
      */
-    async simulateTransaction(transactionRequestLike) {
+    async simulateTransaction(transactionRequestLike, { estimateTxDependencies = true } = {}) {
       const transactionRequest = transactionRequestify(transactionRequestLike);
-      await this.provider.estimateTxDependencies(transactionRequest);
+      if (estimateTxDependencies) {
+        await this.provider.estimateTxDependencies(transactionRequest);
+      }
       return this.provider.simulate(transactionRequest, { estimateTxDependencies: false });
     }
     validateGas({
@@ -43328,11 +43858,11 @@ ${MessageCoinFragmentFragmentDoc}`;
     if (!Number.isSafeInteger(n) || n < 0)
       throw new Error(`Wrong positive integer: ${n}`);
   }
-  function isBytes(a) {
+  function isBytes2(a) {
     return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
   }
   function bytes3(b, ...lengths) {
-    if (!isBytes(b))
+    if (!isBytes2(b))
       throw new Error("Expected Uint8Array");
     if (lengths.length > 0 && !lengths.includes(b.length))
       throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
@@ -43362,7 +43892,7 @@ ${MessageCoinFragmentFragmentDoc}`;
   var crypto5 = nc2 && typeof nc2 === "object" && "webcrypto" in nc2 ? nc2.webcrypto : void 0;
 
   // ../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/esm/utils.js
-  function isBytes2(a) {
+  function isBytes3(a) {
     return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
   }
   var createView3 = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
@@ -43370,23 +43900,23 @@ ${MessageCoinFragmentFragmentDoc}`;
   var isLE3 = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
   if (!isLE3)
     throw new Error("Non little-endian hardware is not supported");
-  function utf8ToBytes3(str) {
+  function utf8ToBytes4(str) {
     if (typeof str !== "string")
       throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
     return new Uint8Array(new TextEncoder().encode(str));
   }
   function toBytes4(data) {
     if (typeof data === "string")
-      data = utf8ToBytes3(data);
-    if (!isBytes2(data))
+      data = utf8ToBytes4(data);
+    if (!isBytes3(data))
       throw new Error(`expected Uint8Array, got ${typeof data}`);
     return data;
   }
-  function concatBytes3(...arrays) {
+  function concatBytes4(...arrays) {
     let sum = 0;
     for (let i = 0; i < arrays.length; i++) {
       const a = arrays[i];
-      if (!isBytes2(a))
+      if (!isBytes3(a))
         throw new Error("Uint8Array expected");
       sum += a.length;
     }
@@ -43672,242 +44202,6 @@ ${MessageCoinFragmentFragmentDoc}`;
   };
   var sha2563 = /* @__PURE__ */ wrapConstructor3(() => new SHA2562());
 
-  // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/utils.js
-  var utils_exports = {};
-  __export(utils_exports, {
-    bitGet: () => bitGet,
-    bitLen: () => bitLen,
-    bitMask: () => bitMask,
-    bitSet: () => bitSet,
-    bytesToHex: () => bytesToHex2,
-    bytesToNumberBE: () => bytesToNumberBE,
-    bytesToNumberLE: () => bytesToNumberLE,
-    concatBytes: () => concatBytes4,
-    createHmacDrbg: () => createHmacDrbg,
-    ensureBytes: () => ensureBytes,
-    equalBytes: () => equalBytes,
-    hexToBytes: () => hexToBytes2,
-    hexToNumber: () => hexToNumber,
-    isBytes: () => isBytes3,
-    numberToBytesBE: () => numberToBytesBE,
-    numberToBytesLE: () => numberToBytesLE,
-    numberToHexUnpadded: () => numberToHexUnpadded,
-    numberToVarBytesBE: () => numberToVarBytesBE,
-    utf8ToBytes: () => utf8ToBytes4,
-    validateObject: () => validateObject
-  });
-  var _0n3 = BigInt(0);
-  var _1n3 = BigInt(1);
-  var _2n3 = BigInt(2);
-  function isBytes3(a) {
-    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
-  }
-  var hexes3 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-  function bytesToHex2(bytes4) {
-    if (!isBytes3(bytes4))
-      throw new Error("Uint8Array expected");
-    let hex = "";
-    for (let i = 0; i < bytes4.length; i++) {
-      hex += hexes3[bytes4[i]];
-    }
-    return hex;
-  }
-  function numberToHexUnpadded(num) {
-    const hex = num.toString(16);
-    return hex.length & 1 ? `0${hex}` : hex;
-  }
-  function hexToNumber(hex) {
-    if (typeof hex !== "string")
-      throw new Error("hex string expected, got " + typeof hex);
-    return BigInt(hex === "" ? "0" : `0x${hex}`);
-  }
-  var asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
-  function asciiToBase16(char) {
-    if (char >= asciis._0 && char <= asciis._9)
-      return char - asciis._0;
-    if (char >= asciis._A && char <= asciis._F)
-      return char - (asciis._A - 10);
-    if (char >= asciis._a && char <= asciis._f)
-      return char - (asciis._a - 10);
-    return;
-  }
-  function hexToBytes2(hex) {
-    if (typeof hex !== "string")
-      throw new Error("hex string expected, got " + typeof hex);
-    const hl = hex.length;
-    const al = hl / 2;
-    if (hl % 2)
-      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
-    const array = new Uint8Array(al);
-    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
-      const n1 = asciiToBase16(hex.charCodeAt(hi));
-      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
-      if (n1 === void 0 || n2 === void 0) {
-        const char = hex[hi] + hex[hi + 1];
-        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
-      }
-      array[ai] = n1 * 16 + n2;
-    }
-    return array;
-  }
-  function bytesToNumberBE(bytes4) {
-    return hexToNumber(bytesToHex2(bytes4));
-  }
-  function bytesToNumberLE(bytes4) {
-    if (!isBytes3(bytes4))
-      throw new Error("Uint8Array expected");
-    return hexToNumber(bytesToHex2(Uint8Array.from(bytes4).reverse()));
-  }
-  function numberToBytesBE(n, len) {
-    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
-  }
-  function numberToBytesLE(n, len) {
-    return numberToBytesBE(n, len).reverse();
-  }
-  function numberToVarBytesBE(n) {
-    return hexToBytes2(numberToHexUnpadded(n));
-  }
-  function ensureBytes(title, hex, expectedLength) {
-    let res;
-    if (typeof hex === "string") {
-      try {
-        res = hexToBytes2(hex);
-      } catch (e) {
-        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
-      }
-    } else if (isBytes3(hex)) {
-      res = Uint8Array.from(hex);
-    } else {
-      throw new Error(`${title} must be hex string or Uint8Array`);
-    }
-    const len = res.length;
-    if (typeof expectedLength === "number" && len !== expectedLength)
-      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
-    return res;
-  }
-  function concatBytes4(...arrays) {
-    let sum = 0;
-    for (let i = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      if (!isBytes3(a))
-        throw new Error("Uint8Array expected");
-      sum += a.length;
-    }
-    let res = new Uint8Array(sum);
-    let pad3 = 0;
-    for (let i = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      res.set(a, pad3);
-      pad3 += a.length;
-    }
-    return res;
-  }
-  function equalBytes(a, b) {
-    if (a.length !== b.length)
-      return false;
-    let diff = 0;
-    for (let i = 0; i < a.length; i++)
-      diff |= a[i] ^ b[i];
-    return diff === 0;
-  }
-  function utf8ToBytes4(str) {
-    if (typeof str !== "string")
-      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
-    return new Uint8Array(new TextEncoder().encode(str));
-  }
-  function bitLen(n) {
-    let len;
-    for (len = 0; n > _0n3; n >>= _1n3, len += 1)
-      ;
-    return len;
-  }
-  function bitGet(n, pos) {
-    return n >> BigInt(pos) & _1n3;
-  }
-  var bitSet = (n, pos, value) => {
-    return n | (value ? _1n3 : _0n3) << BigInt(pos);
-  };
-  var bitMask = (n) => (_2n3 << BigInt(n - 1)) - _1n3;
-  var u8n = (data) => new Uint8Array(data);
-  var u8fr = (arr) => Uint8Array.from(arr);
-  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
-    if (typeof hashLen !== "number" || hashLen < 2)
-      throw new Error("hashLen must be a number");
-    if (typeof qByteLen !== "number" || qByteLen < 2)
-      throw new Error("qByteLen must be a number");
-    if (typeof hmacFn !== "function")
-      throw new Error("hmacFn must be a function");
-    let v = u8n(hashLen);
-    let k = u8n(hashLen);
-    let i = 0;
-    const reset = () => {
-      v.fill(1);
-      k.fill(0);
-      i = 0;
-    };
-    const h = (...b) => hmacFn(k, v, ...b);
-    const reseed = (seed = u8n()) => {
-      k = h(u8fr([0]), seed);
-      v = h();
-      if (seed.length === 0)
-        return;
-      k = h(u8fr([1]), seed);
-      v = h();
-    };
-    const gen3 = () => {
-      if (i++ >= 1e3)
-        throw new Error("drbg: tried 1000 values");
-      let len = 0;
-      const out = [];
-      while (len < qByteLen) {
-        v = h();
-        const sl = v.slice();
-        out.push(sl);
-        len += v.length;
-      }
-      return concatBytes4(...out);
-    };
-    const genUntil = (seed, pred) => {
-      reset();
-      reseed(seed);
-      let res = void 0;
-      while (!(res = pred(gen3())))
-        reseed();
-      reset();
-      return res;
-    };
-    return genUntil;
-  }
-  var validatorFns = {
-    bigint: (val) => typeof val === "bigint",
-    function: (val) => typeof val === "function",
-    boolean: (val) => typeof val === "boolean",
-    string: (val) => typeof val === "string",
-    stringOrUint8Array: (val) => typeof val === "string" || isBytes3(val),
-    isSafeInteger: (val) => Number.isSafeInteger(val),
-    array: (val) => Array.isArray(val),
-    field: (val, object) => object.Fp.isValid(val),
-    hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
-  };
-  function validateObject(object, validators, optValidators = {}) {
-    const checkField = (fieldName, type3, isOptional) => {
-      const checkVal = validatorFns[type3];
-      if (typeof checkVal !== "function")
-        throw new Error(`Invalid validator "${type3}", expected function`);
-      const val = object[fieldName];
-      if (isOptional && val === void 0)
-        return;
-      if (!checkVal(val, object)) {
-        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type3}`);
-      }
-    };
-    for (const [fieldName, type3] of Object.entries(validators))
-      checkField(fieldName, type3, false);
-    for (const [fieldName, type3] of Object.entries(optValidators))
-      checkField(fieldName, type3, true);
-    return object;
-  }
-
   // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/modular.js
   var _0n4 = BigInt(0);
   var _1n4 = BigInt(1);
@@ -44343,7 +44637,7 @@ ${MessageCoinFragmentFragmentDoc}`;
     toSig(hex) {
       const { Err: E } = DER;
       const data = typeof hex === "string" ? h2b(hex) : hex;
-      if (!isBytes3(data))
+      if (!isBytes(data))
         throw new Error("ui8a expected");
       let l = data.length;
       if (l < 2 || data[0] != 48)
@@ -44381,7 +44675,7 @@ ${MessageCoinFragmentFragmentDoc}`;
     const { Fp: Fp2 } = CURVE;
     const toBytes5 = CURVE.toBytes || ((_c, point, _isCompressed) => {
       const a = point.toAffine();
-      return concatBytes4(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
+      return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y));
     });
     const fromBytes = CURVE.fromBytes || ((bytes4) => {
       const tail = bytes4.subarray(1);
@@ -44407,7 +44701,7 @@ ${MessageCoinFragmentFragmentDoc}`;
     function normPrivateKeyToScalar(key) {
       const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;
       if (lengths && typeof key !== "bigint") {
-        if (isBytes3(key))
+        if (isBytes(key))
           key = bytesToHex2(key);
         if (typeof key !== "string" || !lengths.includes(key.length))
           throw new Error("Invalid key");
@@ -44797,7 +45091,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       toBytes(_c, point, isCompressed) {
         const a = point.toAffine();
         const x = Fp2.toBytes(a.x);
-        const cat = concatBytes4;
+        const cat = concatBytes3;
         if (isCompressed) {
           return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
         } else {
@@ -44942,7 +45236,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
     }
     function isProbPub(item) {
-      const arr = isBytes3(item);
+      const arr = isBytes(item);
       const str = typeof item === "string";
       const len = (arr || str) && item.length;
       if (arr)
@@ -44994,7 +45288,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         const e = ent === true ? randomBytes5(Fp2.BYTES) : ent;
         seedArgs.push(ensureBytes("extraEntropy", e));
       }
-      const seed = concatBytes4(...seedArgs);
+      const seed = concatBytes3(...seedArgs);
       const m = h1int;
       function k2sig(kBytes) {
         const k = bits2int(kBytes);
@@ -45037,7 +45331,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       let _sig = void 0;
       let P;
       try {
-        if (typeof sg === "string" || isBytes3(sg)) {
+        if (typeof sg === "string" || isBytes(sg)) {
           try {
             _sig = Signature2.fromDER(sg);
           } catch (derError) {
@@ -45153,7 +45447,7 @@ ${MessageCoinFragmentFragmentDoc}`;
   function getHash(hash6) {
     return {
       hash: hash6,
-      hmac: (key, ...msgs) => hmac2(hash6, key, concatBytes3(...msgs)),
+      hmac: (key, ...msgs) => hmac2(hash6, key, concatBytes4(...msgs)),
       randomBytes: randomBytes4
     };
   }
@@ -45277,11 +45571,11 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns hashed signature
      */
     sign(data) {
-      const signature = secp256k1.sign(getBytesCopy(data), getBytesCopy(this.privateKey));
+      const signature = secp256k1.sign(arrayify(data), arrayify(this.privateKey));
       const r = toBytes3(`0x${signature.r.toString(16)}`, 32);
       const s = toBytes3(`0x${signature.s.toString(16)}`, 32);
       s[0] |= (signature.recovery || 0) << 7;
-      return concat([r, s]);
+      return hexlify(concat([r, s]));
     }
     /**
      * Add point on the current elliptic curve
@@ -45290,8 +45584,8 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns compressed point on the curve
      */
     addPoint(point) {
-      const p0 = secp256k1.ProjectivePoint.fromHex(getBytesCopy(this.compressedPublicKey));
-      const p1 = secp256k1.ProjectivePoint.fromHex(getBytesCopy(point));
+      const p0 = secp256k1.ProjectivePoint.fromHex(arrayify(this.compressedPublicKey));
+      const p1 = secp256k1.ProjectivePoint.fromHex(arrayify(point));
       const result = p0.add(p1);
       return `0x${result.toHex(true)}`;
     }
@@ -45303,7 +45597,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns public key from signature from the
      */
     static recoverPublicKey(data, signature) {
-      const signedMessageBytes = getBytesCopy(signature);
+      const signedMessageBytes = arrayify(signature);
       const r = signedMessageBytes.slice(0, 32);
       const s = signedMessageBytes.slice(32, 64);
       const recoveryParam = (s[0] & 128) >> 7;
@@ -45311,7 +45605,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       const sig = new secp256k1.Signature(BigInt(hexlify(r)), BigInt(hexlify(s))).addRecoveryBit(
         recoveryParam
       );
-      const publicKey = sig.recoverPublicKey(getBytesCopy(data)).toRawBytes(false).slice(1);
+      const publicKey = sig.recoverPublicKey(arrayify(data)).toRawBytes(false).slice(1);
       return hexlify(publicKey);
     }
     /**
@@ -45331,7 +45625,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns random 32-byte hashed
      */
     static generatePrivateKey(entropy) {
-      return entropy ? hash3(concat([randomBytes22(32), getBytesCopy(entropy)])) : randomBytes22(32);
+      return entropy ? hash3(concat([randomBytes22(32), arrayify(entropy)])) : randomBytes22(32);
     }
     /**
      * Extended publicKey from a compact publicKey
@@ -45340,7 +45634,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns extended publicKey
      */
     static extendPublicKey(publicKey) {
-      const point = secp256k1.ProjectivePoint.fromHex(getBytesCopy(publicKey));
+      const point = secp256k1.ProjectivePoint.fromHex(arrayify(publicKey));
       return hexlify(point.toRawBytes(false).slice(1));
     }
   };
@@ -45519,7 +45813,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      */
     async signMessage(message) {
       const signedMessage = await this.signer().sign(hashMessage(message));
-      return signedMessage;
+      return hexlify(signedMessage);
     }
     /**
      * Signs a transaction with the wallet's private key.
@@ -45532,7 +45826,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       const chainId = this.provider.getChain().consensusParameters.chainId.toNumber();
       const hashedTransaction = transactionRequest.getTransactionId(chainId);
       const signature = await this.signer().sign(hashedTransaction);
-      return signature;
+      return hexlify(signature);
     }
     /**
      * Populates a transaction with the witnesses signature.
@@ -45552,12 +45846,14 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @param transactionRequestLike - The transaction request to send.
      * @returns A promise that resolves to the TransactionResponse object.
      */
-    async sendTransaction(transactionRequestLike, options) {
+    async sendTransaction(transactionRequestLike, { estimateTxDependencies = true, awaitExecution } = {}) {
       const transactionRequest = transactionRequestify(transactionRequestLike);
-      await this.provider.estimateTxDependencies(transactionRequest);
+      if (estimateTxDependencies) {
+        await this.provider.estimateTxDependencies(transactionRequest);
+      }
       return this.provider.sendTransaction(
         await this.populateTransactionWitnessesSignature(transactionRequest),
-        { ...options, estimateTxDependencies: false }
+        { awaitExecution, estimateTxDependencies: false }
       );
     }
     /**
@@ -45566,9 +45862,11 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @param transactionRequestLike - The transaction request to simulate.
      * @returns A promise that resolves to the CallResult object.
      */
-    async simulateTransaction(transactionRequestLike) {
+    async simulateTransaction(transactionRequestLike, { estimateTxDependencies = true } = {}) {
       const transactionRequest = transactionRequestify(transactionRequestLike);
-      await this.provider.estimateTxDependencies(transactionRequest);
+      if (estimateTxDependencies) {
+        await this.provider.estimateTxDependencies(transactionRequest);
+      }
       return this.provider.call(
         await this.populateTransactionWitnessesSignature(transactionRequest),
         {
@@ -47711,14 +48009,14 @@ ${MessageCoinFragmentFragmentDoc}`;
       }
     }
     const checksumBits = entropy.length / 4;
-    const checksum = getBytesCopy(sha2562(entropy))[0] & getUpperMask(checksumBits);
+    const checksum = arrayify(sha2562(entropy))[0] & getUpperMask(checksumBits);
     indices[indices.length - 1] <<= checksumBits;
     indices[indices.length - 1] |= checksum >> 8 - checksumBits;
     return indices;
   }
   function mnemonicWordsToEntropy(words, wordlist) {
     const size = Math.ceil(11 * words.length / 8);
-    const entropy = getBytesCopy(new Uint8Array(size));
+    const entropy = arrayify(new Uint8Array(size));
     let offset = 0;
     for (let i = 0; i < words.length; i += 1) {
       const index = wordlist.indexOf(words[i].normalize("NFKD"));
@@ -47738,7 +48036,7 @@ ${MessageCoinFragmentFragmentDoc}`;
     const entropyBits = 32 * words.length / 3;
     const checksumBits = words.length / 3;
     const checksumMask = getUpperMask(checksumBits);
-    const checksum = getBytesCopy(sha2562(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
+    const checksum = arrayify(sha2562(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
     if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
       throw new FuelError(
         ErrorCode.INVALID_CHECKSUM,
@@ -47821,7 +48119,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns 64-byte array contains privateKey and chainCode as described on BIP39
      */
     static entropyToMnemonic(entropy, wordlist = english) {
-      const entropyBytes = getBytesCopy(entropy);
+      const entropyBytes = arrayify(entropy);
       assertWordList(wordlist);
       assertEntropy(entropyBytes);
       return entropyToMnemonicIndices(entropyBytes).map((i) => wordlist[i]).join(" ");
@@ -47890,14 +48188,14 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns 64-byte array contains privateKey and chainCode as described on BIP39
      */
     static masterKeysFromSeed(seed) {
-      const seedArray = getBytesCopy(seed);
+      const seedArray = arrayify(seed);
       if (seedArray.length < 16 || seedArray.length > 64) {
         throw new FuelError(
           ErrorCode.INVALID_SEED,
           `Seed length should be between 16 and 64 bytes, but received ${seedArray.length} bytes.`
         );
       }
-      return getBytesCopy(computeHmac("sha512", MasterSecret, seedArray));
+      return arrayify(computeHmac("sha512", MasterSecret, seedArray));
     }
     /**
      * Get the extendKey as defined on BIP-32 from the provided seed
@@ -47908,7 +48206,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      */
     static seedToExtendedKey(seed, testnet = false) {
       const masterKey = Mnemonic.masterKeysFromSeed(seed);
-      const prefix = getBytesCopy(testnet ? TestnetPRV : MainnetPRV);
+      const prefix = arrayify(testnet ? TestnetPRV : MainnetPRV);
       const depth = "0x00";
       const fingerprint = "0x00000000";
       const index = "0x00000000";
@@ -47938,7 +48236,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns A randomly generated mnemonic
      */
     static generate(size = 32, extraEntropy = "") {
-      const entropy = extraEntropy ? sha2562(concat([randomBytes22(size), getBytesCopy(extraEntropy)])) : randomBytes22(size);
+      const entropy = extraEntropy ? sha2562(concat([randomBytes22(size), arrayify(extraEntropy)])) : randomBytes22(size);
       return Mnemonic.entropyToMnemonic(entropy);
     }
   };
@@ -48023,9 +48321,9 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns A new instance of HDWallet on the derived index
      */
     deriveIndex(index) {
-      const privateKey = this.privateKey && getBytesCopy(this.privateKey);
-      const publicKey = getBytesCopy(this.publicKey);
-      const chainCode = getBytesCopy(this.chainCode);
+      const privateKey = this.privateKey && arrayify(this.privateKey);
+      const publicKey = arrayify(this.publicKey);
+      const chainCode = arrayify(this.chainCode);
       const data = new Uint8Array(37);
       if (index & HARDENED_INDEX) {
         if (!privateKey) {
@@ -48036,10 +48334,10 @@ ${MessageCoinFragmentFragmentDoc}`;
         }
         data.set(privateKey, 1);
       } else {
-        data.set(getBytesCopy(this.publicKey));
+        data.set(arrayify(this.publicKey));
       }
       data.set(toBytes3(index, 4), 33);
-      const bytes4 = getBytesCopy(computeHmac("sha512", chainCode, data));
+      const bytes4 = arrayify(computeHmac("sha512", chainCode, data));
       const IL = bytes4.slice(0, 32);
       const IR = bytes4.slice(32);
       if (privateKey) {
@@ -48093,9 +48391,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       const index = toHex(this.index, 4);
       const chainCode = this.chainCode;
       const key = this.privateKey != null && !isPublic ? concat(["0x00", this.privateKey]) : this.publicKey;
-      const extendedKey = getBytesCopy(
-        concat([prefix, depth, parentFingerprint, index, chainCode, key])
-      );
+      const extendedKey = arrayify(concat([prefix, depth, parentFingerprint, index, chainCode, key]));
       return base58check(extendedKey);
     }
     /**
@@ -48107,13 +48403,13 @@ ${MessageCoinFragmentFragmentDoc}`;
     static fromSeed(seed) {
       const masterKey = mnemonic_default.masterKeysFromSeed(seed);
       return new HDWallet({
-        chainCode: getBytesCopy(masterKey.slice(32)),
-        privateKey: getBytesCopy(masterKey.slice(0, 32))
+        chainCode: arrayify(masterKey.slice(32)),
+        privateKey: arrayify(masterKey.slice(0, 32))
       });
     }
     static fromExtendedKey(extendedKey) {
       const decoded = toBeHex(decodeBase58(extendedKey));
-      const bytes4 = getBytesCopy(decoded);
+      const bytes4 = arrayify(decoded);
       const validChecksum = base58check(bytes4.slice(0, 78)) === extendedKey;
       if (bytes4.length !== 82 || !isValidExtendedKey(bytes4)) {
         throw new FuelError(ErrorCode.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
@@ -48779,7 +49075,7 @@ ${MessageCoinFragmentFragmentDoc}`;
   // src/predicate/utils/getPredicateRoot.ts
   var getPredicateRoot = (bytecode) => {
     const chunkSize = 16 * 1024;
-    const bytes4 = getBytesCopy(bytecode);
+    const bytes4 = arrayify(bytecode);
     const chunks = chunkAndPadBytes(bytes4, chunkSize);
     const codeRoot = calcRoot(chunks.map((c) => hexlify(c)));
     const predicateRoot = hash3(concat(["0x4655454C", codeRoot]));
@@ -48892,7 +49188,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @returns An object containing the new predicate bytes and interface.
      */
     static processPredicateData(bytes4, jsonAbi, configurableConstants) {
-      let predicateBytes = getBytesCopy(bytes4);
+      let predicateBytes = arrayify(bytes4);
       let abiInterface;
       if (jsonAbi) {
         abiInterface = new Interface(jsonAbi);
@@ -48992,17 +49288,6 @@ ${MessageCoinFragmentFragmentDoc}`;
   })(FuelConnectorEventTypes || {});
   var FuelConnectorEventType = "FuelConnector";
 
-  // src/connectors/types/data-type.ts
-  var MessageTypes = /* @__PURE__ */ ((MessageTypes2) => {
-    MessageTypes2["ping"] = "ping";
-    MessageTypes2["uiEvent"] = "uiEvent";
-    MessageTypes2["event"] = "event";
-    MessageTypes2["request"] = "request";
-    MessageTypes2["response"] = "response";
-    MessageTypes2["removeConnection"] = "removeConnection";
-    return MessageTypes2;
-  })(MessageTypes || {});
-
   // src/connectors/types/local-storage.ts
   var LocalStorage = class {
     storage;
@@ -49291,6 +49576,7 @@ ${MessageCoinFragmentFragmentDoc}`;
   // src/connectors/fuel.ts
   var HAS_CONNECTOR_TIMEOUT = 2e3;
   var PING_CACHE_TIME = 5e3;
+  var { warn } = console;
   var _Fuel = class extends FuelConnector {
     _storage = null;
     _connectors = [];
@@ -49559,14 +49845,12 @@ ${MessageCoinFragmentFragmentDoc}`;
      * Return a Fuel Provider instance with extends features to work with
      * connectors.
      *
-     * @deprecated Provider is going to be deprecated in the future.
+     * @deprecated getProvider is deprecated and is going to be removed in the future, use getWallet instead.
      */
     async getProvider(providerOrNetwork) {
-      if (process.env.NODE_ENV !== "production") {
-        console.warn(
-          "Get provider is deprecated, use getWallet instead. Provider is going to be removed in the future."
-        );
-      }
+      warn(
+        "getProvider is deprecated and is going to be removed in the future, use getWallet instead."
+      );
       return this._getProvider(providerOrNetwork);
     }
     /**
@@ -49583,7 +49867,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         const currentNetwork = await this.currentNetwork();
         provider = await Provider.create(currentNetwork.url);
       } else {
-        throw new Error("Provider is not valid.");
+        throw new FuelError(ErrorCode.INVALID_PROVIDER, "Provider is not valid.");
       }
       return provider;
     }
@@ -49646,12 +49930,12 @@ mime-types/index.js:
 @noble/hashes/esm/utils.js:
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
-@noble/hashes/esm/utils.js:
-  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
 @noble/curves/esm/abstract/utils.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
 @noble/curves/esm/abstract/modular.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)