@fuel-ts/account 0.0.0-pr-1699-20240214162434 → 0.0.0-pr-1788-20240222085506

package/dist/index.global.js

@@ -30103,8 +30103,8 @@ spurious results.`);
   function getBuiltinVersions() {
     return {
       FORC: "0.50.0",
-      FUEL_CORE: "0.22.0",
-      FUELS: "0.73.0"
+      FUEL_CORE: "0.22.1",
+      FUELS: "0.74.0"
     };
   }
   function parseVersion(version2) {
@@ -30177,10 +30177,12 @@ 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";
     ErrorCode2["HD_WALLET_ERROR"] = "hd-wallet-error";
+    ErrorCode2["MISSING_CONNECTOR"] = "missing-connector";
     ErrorCode2["PARSE_FAILED"] = "parse-failed";
     ErrorCode2["ENCODE_ERROR"] = "encode-error";
     ErrorCode2["DECODE_ERROR"] = "decode-error";
@@ -30258,6 +30260,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);
 
@@ -30426,9 +30488,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;
@@ -30441,19 +30500,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) {
@@ -30463,7 +30519,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
@@ -30746,7 +30802,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() {
@@ -31101,7 +31157,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() {
@@ -31300,7 +31356,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() {
@@ -31323,7 +31379,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() {
@@ -31350,7 +31406,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() {
@@ -31365,7 +31421,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() {
@@ -31981,7 +32037,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);
@@ -32067,7 +32123,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) {
@@ -32246,7 +32302,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));
     }
     /**
@@ -32594,56 +32650,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;
@@ -32766,7 +32772,7 @@ spurious results.`);
           topLevelData[parseInt(pointerIndex, 10) + totalIndex] = vData;
         });
       }
-      const byteArray = getBytesCopy(item);
+      const byteArray = arrayify(item);
       totalIndex += byteArray.byteLength / WORD_SIZE;
       return byteArray;
     });
@@ -32783,7 +32789,7 @@ spurious results.`);
   }
   function unpackDynamicData(results, baseOffset, dataOffset) {
     if (!results.dynamicData) {
-      return concat2([results]);
+      return concat([results]);
     }
     let cumulativeDynamicByteLength = 0;
     let updatedResults = results;
@@ -32801,7 +32807,7 @@ spurious results.`);
           dataOffset + vData.byteLength + cumulativeDynamicByteLength
         )
       ) : vData;
-      updatedResults = concat2([updatedResults, dataToAppend]);
+      updatedResults = concat([updatedResults, dataToAppend]);
       cumulativeDynamicByteLength += dataToAppend.byteLength;
     });
     return updatedResults;
@@ -32887,7 +32893,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}.`);
       }
@@ -32918,7 +32924,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}.`);
       }
@@ -32985,6 +32991,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([])
@@ -33011,7 +33062,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]) {
@@ -33058,6 +33109,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
@@ -33128,6 +33204,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;
@@ -33144,7 +33291,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) {
@@ -33159,31 +33306,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;
@@ -33308,122 +33430,6 @@ 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);
-    }
-    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 concat2(data);
-  };
-  __publicField3(ByteCoder, "memorySize", 1);
-  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 concat2(data);
-  };
-  __publicField3(StdStringCoder, "memorySize", 1);
   var BooleanCoder2 = class extends Coder {
     constructor() {
       super("boolean", "boolean", 1);
@@ -34065,7 +34071,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 !== "()"
       );
@@ -34110,7 +34116,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);
     }
@@ -34177,7 +34183,7 @@ 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, {
+      return AbiCoder.decode(this.jsonAbi, loggedType, arrayify(data), 0, {
         version: this.jsonAbi.encoding
       });
     }
@@ -34234,12 +34240,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;
@@ -34285,7 +34291,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;
@@ -34349,7 +34355,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;
@@ -34390,11 +34396,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);
     }
@@ -34413,13 +34419,13 @@ spurious results.`);
       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;
@@ -34496,7 +34502,7 @@ spurious results.`);
           );
         }
       }
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34542,7 +34548,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;
@@ -34573,7 +34579,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;
@@ -34604,7 +34610,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;
@@ -34635,7 +34641,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;
@@ -34665,7 +34671,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;
@@ -34720,7 +34726,7 @@ spurious results.`);
           );
         }
       }
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -34800,7 +34806,7 @@ spurious results.`);
           }
         }
       });
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset, policyTypes) {
       let o = offset;
@@ -34854,8 +34860,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 = [];
@@ -34866,7 +34872,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;
@@ -34884,7 +34890,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: "",
@@ -34900,9 +34906,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() {
@@ -34918,7 +34924,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;
@@ -34960,7 +34966,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;
@@ -35009,7 +35015,7 @@ spurious results.`);
       const parts = [];
       parts.push(new NumberCoder("u16").encode(value.dataLength));
       parts.push(new ByteArrayCoder(value.dataLength).encode(value.data));
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -35053,7 +35059,7 @@ 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;
@@ -35129,7 +35135,7 @@ 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;
@@ -35192,7 +35198,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;
@@ -35252,7 +35258,7 @@ spurious results.`);
           );
         }
       }
-      return concat2(parts);
+      return concat(parts);
     }
     decode(data, offset) {
       let decoded;
@@ -35282,6 +35288,242 @@ 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());
 
@@ -39528,18 +39770,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,
@@ -39558,16 +39800,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),
@@ -39803,7 +40045,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,
@@ -39945,9 +40187,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)) {
@@ -40061,7 +40301,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
@@ -40476,7 +40716,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      *
      * @param quantities - CoinQuantity Array.
      */
-    fundWithFakeUtxos(quantities) {
+    fundWithFakeUtxos(quantities, resourcesOwner) {
       let idCounter = 0;
       const generateId = () => {
         const counterString = String(idCounter++);
@@ -40500,7 +40740,7 @@ ${MessageCoinFragmentFragmentDoc}`;
               id: generateId(),
               amount: quantity,
               assetId,
-              owner: Address.fromRandom(),
+              owner: resourcesOwner || Address.fromRandom(),
               maturity: 0,
               blockCreated: bn(1),
               txCreatedIdx: bn(1)
@@ -40533,19 +40773,29 @@ ${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.Contract:
+            return;
+          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:
+            break;
+        }
+        if (correspondingInput && "predicateGasUsed" in correspondingInput && bn(correspondingInput.predicateGasUsed).gt(0)) {
+          i.predicate = correspondingInput.predicate;
+          i.predicateData = correspondingInput.predicateData;
+          i.predicateGasUsed = correspondingInput.predicateGasUsed;
+        }
+      });
     }
   };
 
@@ -40632,7 +40882,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) => {
@@ -40737,7 +40987,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()
@@ -40752,7 +41002,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 = {
@@ -40766,7 +41016,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)
   };
 
@@ -40794,8 +41044,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`.
@@ -40803,8 +41053,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,
@@ -40967,7 +41217,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 {
@@ -40982,7 +41232,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,
@@ -41775,7 +42025,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      */
     decodeTransaction(transactionWithReceipts) {
       return new TransactionCoder().decode(
-        getBytesCopy(transactionWithReceipts.rawPayload),
+        arrayify(transactionWithReceipts.rawPayload),
         0
       )?.[0];
     }
@@ -41801,7 +42051,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         id: this.id,
         receipts,
         transaction: decodedTransaction,
-        transactionBytes: getBytesCopy(transaction.rawPayload),
+        transactionBytes: arrayify(transaction.rawPayload),
         gqlTransactionStatus: transaction.status,
         gasPerByte,
         gasPriceFactor,
@@ -42233,7 +42483,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({
@@ -42252,6 +42502,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
@@ -42282,34 +42540,33 @@ ${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: []
+        };
       }
-      while (tries < MAX_RETRIES) {
+      await this.estimatePredicates(transactionRequest);
+      let receipts = [];
+      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) {
+          transactionRequest.addVariableOutputs(missingOutputVariables.length);
+          missingOutputContractIds.forEach(({ contractId }) => {
+            transactionRequest.addContractInputAndOutput(Address.fromString(contractId));
+          });
+        } else {
+          break;
         }
-        txRequest.addVariableOutputs(missingOutputVariableCount);
-        missingOutputContractIds.forEach(
-          ({ contractId }) => txRequest.addContractInputAndOutput(Address.fromString(contractId))
-        );
-        tries += 1;
       }
+      return {
+        receipts
+      };
     }
     /**
      * Executes a signed transaction without applying the states changes
@@ -42324,7 +42581,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({
@@ -42351,36 +42608,38 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @param tolerance - The tolerance to add on top of the gasUsed.
      * @returns A promise that resolves to the transaction cost object.
      */
-    async getTransactionCost(transactionRequestLike, forwardingQuantities = [], { estimateTxDependencies = true, estimatePredicates = true } = {}) {
-      const transactionRequest = transactionRequestify(clone_default(transactionRequestLike));
+    async getTransactionCost(transactionRequestLike, forwardingQuantities = [], {
+      estimateTxDependencies = true,
+      estimatePredicates = true,
+      resourcesOwner
+    } = {}) {
+      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);
         }
-        await this.estimatePredicates(transactionRequest);
+        if (resourcesOwner && "populateTransactionPredicateData" in resourcesOwner) {
+          resourcesOwner.populateTransactionPredicateData(txRequestClone);
+        }
+        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);
-      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
-        });
+      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;
       }
+      const gasUsed = isScriptTransaction ? getGasUsedFromReceipts(receipts) : minGas;
       const usedFee = calculatePriceWithFactor(
         gasUsed,
         gasPrice,
@@ -42398,7 +42657,9 @@ ${MessageCoinFragmentFragmentDoc}`;
         maxGas,
         usedFee,
         minFee,
-        maxFee
+        maxFee,
+        estimatedInputs: txRequestClone.inputs,
+        estimatedOutputs: txRequestClone.outputs
       };
     }
     async getResourcesForTransaction(owner, transactionRequestLike, forwardingQuantities = []) {
@@ -42566,7 +42827,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]
         )
       };
     }
@@ -42582,7 +42843,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         return null;
       }
       return new TransactionCoder().decode(
-        getBytesCopy(transaction.rawPayload),
+        arrayify(transaction.rawPayload),
         0
       )?.[0];
     }
@@ -42788,6 +43049,10 @@ ${MessageCoinFragmentFragmentDoc}`;
       });
       return bn(latestBlockHeight);
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getTransactionResponse(transactionId) {
+      return new TransactionResponse2(transactionId, this);
+    }
   };
   var Provider = _Provider;
   _cacheInputs = new WeakSet();
@@ -42817,7 +43082,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       );
     }
     const [decodedTransaction] = new TransactionCoder().decode(
-      getBytesCopy(gqlTransaction.rawPayload),
+      arrayify(gqlTransaction.rawPayload),
       0
     );
     const receipts = gqlTransaction.receipts?.map(processGqlReceipt) || [];
@@ -42828,7 +43093,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),
@@ -42870,13 +43135,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,
@@ -42896,6 +43161,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) => {
@@ -42903,9 +43289,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;
   };
@@ -42939,15 +43325,17 @@ ${MessageCoinFragmentFragmentDoc}`;
      * The provider used to interact with the network.
      */
     _provider;
+    _connector;
     /**
      * Creates a new Account instance.
      *
      * @param address - The address of the account.
      * @param provider - A Provider instance  (optional).
      */
-    constructor(address, provider) {
+    constructor(address, provider, connector) {
       super();
       this._provider = provider;
+      this._connector = connector;
       this.address = Address.fromDynamicInput(address);
     }
     /**
@@ -43153,7 +43541,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({
@@ -43163,6 +43554,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         minGasPrice
       });
       await this.fund(request, requiredQuantities, maxFee);
+      request.updatePredicateInputs(estimatedInputs);
       return request;
     }
     /**
@@ -43176,7 +43568,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.
@@ -43227,14 +43619,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
       ]);
@@ -43255,17 +43647,30 @@ ${MessageCoinFragmentFragmentDoc}`;
       await this.fund(request, requiredQuantities, maxFee);
       return this.sendTransaction(request);
     }
+    async signMessage(message) {
+      if (!this._connector) {
+        throw new FuelError(ErrorCode.MISSING_CONNECTOR, "A connector is required to sign messages.");
+      }
+      return this._connector.signMessage(this.address.toString(), message);
+    }
     /**
      * Sends a transaction to the network.
      *
      * @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
       });
     }
@@ -43275,9 +43680,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({
@@ -43306,11 +43713,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}`);
@@ -43340,7 +43747,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);
@@ -43348,23 +43755,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;
     }
@@ -43579,312 +43986,76 @@ ${MessageCoinFragmentFragmentDoc}`;
   ]);
   var SHA256_W2 = /* @__PURE__ */ new Uint32Array(64);
   var SHA2562 = class extends SHA23 {
-    constructor() {
-      super(64, 32, 8, false);
-      this.A = IV2[0] | 0;
-      this.B = IV2[1] | 0;
-      this.C = IV2[2] | 0;
-      this.D = IV2[3] | 0;
-      this.E = IV2[4] | 0;
-      this.F = IV2[5] | 0;
-      this.G = IV2[6] | 0;
-      this.H = IV2[7] | 0;
-    }
-    get() {
-      const { A, B, C, D, E, F, G, H } = this;
-      return [A, B, C, D, E, F, G, H];
-    }
-    // prettier-ignore
-    set(A, B, C, D, E, F, G, H) {
-      this.A = A | 0;
-      this.B = B | 0;
-      this.C = C | 0;
-      this.D = D | 0;
-      this.E = E | 0;
-      this.F = F | 0;
-      this.G = G | 0;
-      this.H = H | 0;
-    }
-    process(view, offset) {
-      for (let i = 0; i < 16; i++, offset += 4)
-        SHA256_W2[i] = view.getUint32(offset, false);
-      for (let i = 16; i < 64; i++) {
-        const W15 = SHA256_W2[i - 15];
-        const W2 = SHA256_W2[i - 2];
-        const s0 = rotr2(W15, 7) ^ rotr2(W15, 18) ^ W15 >>> 3;
-        const s1 = rotr2(W2, 17) ^ rotr2(W2, 19) ^ W2 >>> 10;
-        SHA256_W2[i] = s1 + SHA256_W2[i - 7] + s0 + SHA256_W2[i - 16] | 0;
-      }
-      let { A, B, C, D, E, F, G, H } = this;
-      for (let i = 0; i < 64; i++) {
-        const sigma1 = rotr2(E, 6) ^ rotr2(E, 11) ^ rotr2(E, 25);
-        const T1 = H + sigma1 + Chi2(E, F, G) + SHA256_K2[i] + SHA256_W2[i] | 0;
-        const sigma0 = rotr2(A, 2) ^ rotr2(A, 13) ^ rotr2(A, 22);
-        const T2 = sigma0 + Maj2(A, B, C) | 0;
-        H = G;
-        G = F;
-        F = E;
-        E = D + T1 | 0;
-        D = C;
-        C = B;
-        B = A;
-        A = T1 + T2 | 0;
-      }
-      A = A + this.A | 0;
-      B = B + this.B | 0;
-      C = C + this.C | 0;
-      D = D + this.D | 0;
-      E = E + this.E | 0;
-      F = F + this.F | 0;
-      G = G + this.G | 0;
-      H = H + this.H | 0;
-      this.set(A, B, C, D, E, F, G, H);
-    }
-    roundClean() {
-      SHA256_W2.fill(0);
-    }
-    destroy() {
-      this.set(0, 0, 0, 0, 0, 0, 0, 0);
-      this.buffer.fill(0);
-    }
-  };
-  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;
+    constructor() {
+      super(64, 32, 8, false);
+      this.A = IV2[0] | 0;
+      this.B = IV2[1] | 0;
+      this.C = IV2[2] | 0;
+      this.D = IV2[3] | 0;
+      this.E = IV2[4] | 0;
+      this.F = IV2[5] | 0;
+      this.G = IV2[6] | 0;
+      this.H = IV2[7] | 0;
     }
-    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}`);
+    get() {
+      const { A, B, C, D, E, F, G, H } = this;
+      return [A, B, C, D, E, F, G, H];
+    }
+    // prettier-ignore
+    set(A, B, C, D, E, F, G, H) {
+      this.A = A | 0;
+      this.B = B | 0;
+      this.C = C | 0;
+      this.D = D | 0;
+      this.E = E | 0;
+      this.F = F | 0;
+      this.G = G | 0;
+      this.H = H | 0;
+    }
+    process(view, offset) {
+      for (let i = 0; i < 16; i++, offset += 4)
+        SHA256_W2[i] = view.getUint32(offset, false);
+      for (let i = 16; i < 64; i++) {
+        const W15 = SHA256_W2[i - 15];
+        const W2 = SHA256_W2[i - 2];
+        const s0 = rotr2(W15, 7) ^ rotr2(W15, 18) ^ W15 >>> 3;
+        const s1 = rotr2(W2, 17) ^ rotr2(W2, 19) ^ W2 >>> 10;
+        SHA256_W2[i] = s1 + SHA256_W2[i - 7] + s0 + SHA256_W2[i - 16] | 0;
       }
-    } else if (isBytes3(hex)) {
-      res = Uint8Array.from(hex);
-    } else {
-      throw new Error(`${title} must be hex string or Uint8Array`);
+      let { A, B, C, D, E, F, G, H } = this;
+      for (let i = 0; i < 64; i++) {
+        const sigma1 = rotr2(E, 6) ^ rotr2(E, 11) ^ rotr2(E, 25);
+        const T1 = H + sigma1 + Chi2(E, F, G) + SHA256_K2[i] + SHA256_W2[i] | 0;
+        const sigma0 = rotr2(A, 2) ^ rotr2(A, 13) ^ rotr2(A, 22);
+        const T2 = sigma0 + Maj2(A, B, C) | 0;
+        H = G;
+        G = F;
+        F = E;
+        E = D + T1 | 0;
+        D = C;
+        C = B;
+        B = A;
+        A = T1 + T2 | 0;
+      }
+      A = A + this.A | 0;
+      B = B + this.B | 0;
+      C = C + this.C | 0;
+      D = D + this.D | 0;
+      E = E + this.E | 0;
+      F = F + this.F | 0;
+      G = G + this.G | 0;
+      H = H + this.H | 0;
+      this.set(A, B, C, D, E, F, G, H);
     }
-    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;
+    roundClean() {
+      SHA256_W2.fill(0);
     }
-    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;
+    destroy() {
+      this.set(0, 0, 0, 0, 0, 0, 0, 0);
+      this.buffer.fill(0);
     }
-    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;
-  }
+  var sha2563 = /* @__PURE__ */ wrapConstructor3(() => new SHA2562());
 
   // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/modular.js
   var _0n4 = BigInt(0);
@@ -44321,7 +44492,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)
@@ -44359,7 +44530,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);
@@ -44385,7 +44556,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");
@@ -44775,7 +44946,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 {
@@ -44920,7 +45091,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)
@@ -44972,7 +45143,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);
@@ -45015,7 +45186,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) {
@@ -45131,7 +45302,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
     };
   }
@@ -45255,11 +45426,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
@@ -45268,8 +45439,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)}`;
     }
@@ -45281,7 +45452,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;
@@ -45289,7 +45460,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);
     }
     /**
@@ -45309,7 +45480,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
@@ -45318,7 +45489,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));
     }
   };
@@ -45497,7 +45668,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.
@@ -45510,7 +45681,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.
@@ -45530,12 +45701,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 }
       );
     }
     /**
@@ -45544,9 +45717,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),
         {
@@ -47689,14 +47864,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"));
@@ -47716,7 +47891,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,
@@ -47799,7 +47974,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(" ");
@@ -47868,14 +48043,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
@@ -47886,7 +48061,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";
@@ -47916,7 +48091,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);
     }
   };
@@ -48001,9 +48176,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) {
@@ -48014,10 +48189,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) {
@@ -48071,9 +48246,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);
     }
     /**
@@ -48085,13 +48258,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.");
@@ -48757,7 +48930,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]));
@@ -48870,7 +49043,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);
@@ -48970,14 +49143,6 @@ ${MessageCoinFragmentFragmentDoc}`;
   })(FuelConnectorEventTypes || {});
   var FuelConnectorEventType = "FuelConnector";
 
-  // src/connectors/types/constants.ts
-  var CONNECTOR_SCRIPT = "FuelConnectorScript";
-  var CONTENT_SCRIPT_NAME = "FuelContentScript";
-  var BACKGROUND_SCRIPT_NAME = "FuelBackgroundScript";
-  var POPUP_SCRIPT_NAME = "FuelPopUpScript";
-  var VAULT_SCRIPT_NAME = "FuelVaultScript";
-  var EVENT_MESSAGE = "message";
-
   // src/connectors/types/data-type.ts
   var MessageTypes = /* @__PURE__ */ ((MessageTypes2) => {
     MessageTypes2["ping"] = "ping";
@@ -49227,40 +49392,6 @@ ${MessageCoinFragmentFragmentDoc}`;
     }
   };
 
-  // src/connectors/fuel-wallet-locked.ts
-  var FuelWalletLocked = class extends WalletLocked {
-    connector;
-    _provider;
-    constructor(address, connector, provider) {
-      super(address, provider);
-      this.connector = connector;
-      this._provider = provider;
-    }
-    async signMessage(message) {
-      return this.connector.signMessage(this.address.toString(), message);
-    }
-    async sendTransaction(transaction) {
-      const transactionId = await this.connector.sendTransaction(
-        this.address.toString(),
-        transaction
-      );
-      return this.provider.getTransactionResponse(transactionId);
-    }
-  };
-
-  // src/connectors/fuel-wallet-provider.ts
-  var FuelWalletProvider = class extends Provider {
-    static async create(url, options) {
-      const provider = new FuelWalletProvider(url, options);
-      await provider.fetchChainAndNodeInfo();
-      return provider;
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async getTransactionResponse(transactionId) {
-      return new TransactionResponse2(transactionId, this);
-    }
-  };
-
   // src/connectors/utils/cache.ts
   function cacheFor(fn, { cache: cache2, cacheTime, key }) {
     return async (...args) => {
@@ -49290,23 +49421,6 @@ ${MessageCoinFragmentFragmentDoc}`;
     );
   }
 
-  // src/connectors/utils/get-asset-by-chain.ts
-  function getAssetByChain(asset, chainId, network = "fuel") {
-    const assetFuelNetwork = asset.networks.find(
-      (item) => item.chainId === chainId && item.type === network
-    );
-    if (!assetFuelNetwork) {
-      throw new Error("Asset not found for the given chain and network.");
-    }
-    return {
-      ...asset,
-      assetId: assetFuelNetwork.assetId,
-      decimals: assetFuelNetwork.decimals,
-      chainId: assetFuelNetwork.chainId,
-      network: assetFuelNetwork.type
-    };
-  }
-
   // src/connectors/utils/promises.ts
   function deferPromise() {
     const defer = {};
@@ -49328,6 +49442,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 = [];
@@ -49596,14 +49711,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);
     }
     /**
@@ -49615,12 +49728,12 @@ ${MessageCoinFragmentFragmentDoc}`;
       if (providerOrNetwork && "getTransactionResponse" in providerOrNetwork) {
         provider = providerOrNetwork;
       } else if (providerOrNetwork && "chainId" in providerOrNetwork && "url" in providerOrNetwork) {
-        provider = await FuelWalletProvider.create(providerOrNetwork.url);
+        provider = await Provider.create(providerOrNetwork.url);
       } else if (!providerOrNetwork) {
         const currentNetwork = await this.currentNetwork();
-        provider = await FuelWalletProvider.create(currentNetwork.url);
+        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;
     }
@@ -49630,7 +49743,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      */
     async getWallet(address, providerOrNetwork) {
       const provider = await this._getProvider(providerOrNetwork);
-      return new FuelWalletLocked(address, this, provider);
+      return new Account(address, provider, this);
     }
     /**
      * Remove all open listeners this is useful when you want to
@@ -49683,12 +49796,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) *)