@fuel-ts/account 0.0.0-pr-1699-20240214162434 → 0.0.0-pr-1784-20240221124858

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";
@@ -32985,6 +32987,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 concat2(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([])
@@ -33058,6 +33105,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 +33200,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 concat2(data);
+  };
+  __publicField3(StdStringCoder, "memorySize", 1);
   var StringCoder = class extends Coder {
     length;
     #paddingLength;
@@ -33159,31 +33302,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 +33426,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);
@@ -35282,6 +35284,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());
 
@@ -40476,7 +40714,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      *
      * @param quantities - CoinQuantity Array.
      */
-    fundWithFakeUtxos(quantities) {
+    fundWithFakeUtxos(quantities, resourcesOwner) {
       let idCounter = 0;
       const generateId = () => {
         const counterString = String(idCounter++);
@@ -40500,7 +40738,7 @@ ${MessageCoinFragmentFragmentDoc}`;
               id: generateId(),
               amount: quantity,
               assetId,
-              owner: Address.fromRandom(),
+              owner: resourcesOwner || Address.fromRandom(),
               maturity: 0,
               blockCreated: bn(1),
               txCreatedIdx: bn(1)
@@ -40533,19 +40771,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;
+        }
+      });
     }
   };
 
@@ -42233,7 +42481,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 +42500,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 +42538,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 +42579,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 +42606,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);
+        }
+        if (resourcesOwner && "populateTransactionPredicateData" in resourcesOwner) {
+          resourcesOwner.populateTransactionPredicateData(txRequestClone);
         }
-        await this.estimatePredicates(transactionRequest);
+        await this.estimatePredicates(txRequestClone);
       }
-      const minGas = transactionRequest.calculateMinGas(chainInfo);
-      const maxGas = transactionRequest.calculateMaxGas(chainInfo, minGas);
-      const coinOutputsQuantities = transactionRequest.getCoinOutputsQuantities();
-      const allQuantities = mergeQuantities(coinOutputsQuantities, forwardingQuantities);
-      transactionRequest.fundWithFakeUtxos(allQuantities);
-      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 +42655,9 @@ ${MessageCoinFragmentFragmentDoc}`;
         maxGas,
         usedFee,
         minFee,
-        maxFee
+        maxFee,
+        estimatedInputs: txRequestClone.inputs,
+        estimatedOutputs: txRequestClone.outputs
       };
     }
     async getResourcesForTransaction(owner, transactionRequestLike, forwardingQuantities = []) {
@@ -42788,6 +43047,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();
@@ -42896,6 +43159,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) => {
@@ -42939,15 +43323,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 +43539,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 +43552,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         minGasPrice
       });
       await this.fund(request, requiredQuantities, maxFee);
+      request.updatePredicateInputs(estimatedInputs);
       return request;
     }
     /**
@@ -43176,7 +43566,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.
@@ -43255,17 +43645,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 +43678,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 +43711,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 +43745,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 +43753,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;
     }
@@ -43578,313 +43983,77 @@ ${MessageCoinFragmentFragmentDoc}`;
     1541459225
   ]);
   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;
+  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;
     }
-    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 +44490,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 +44528,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 +44554,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 +44944,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 +45089,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 +45141,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 +45184,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 +45300,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
     };
   }
@@ -45530,12 +45699,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 +45715,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),
         {
@@ -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) *)