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

package/dist/test-utils.global.js

@@ -33065,8 +33065,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) {
@@ -33139,10 +33139,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";
@@ -36465,6 +36467,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([])
@@ -36538,6 +36585,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
@@ -36608,6 +36680,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;
@@ -36639,31 +36782,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;
@@ -36788,122 +36906,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);
@@ -38732,35 +38734,271 @@ spurious results.`);
           );
         }
       }
-      return concat2(parts);
+      return concat2(parts);
+    }
+    decode(data, offset) {
+      let decoded;
+      let o = offset;
+      [decoded, o] = new NumberCoder("u8").decode(data, o);
+      const type3 = decoded;
+      switch (type3) {
+        case 0: {
+          [decoded, o] = new TransactionScriptCoder().decode(data, o);
+          return [decoded, o];
+        }
+        case 1: {
+          [decoded, o] = new TransactionCreateCoder().decode(data, o);
+          return [decoded, o];
+        }
+        case 2: {
+          [decoded, o] = new TransactionMintCoder().decode(data, o);
+          return [decoded, o];
+        }
+        default: {
+          throw new FuelError(
+            ErrorCode.INVALID_TRANSACTION_TYPE,
+            `Invalid transaction type: ${type3}`
+          );
+        }
+      }
+    }
+  };
+
+  // ../../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;
     }
-    decode(data, offset) {
-      let decoded;
-      let o = offset;
-      [decoded, o] = new NumberCoder("u8").decode(data, o);
-      const type3 = decoded;
-      switch (type3) {
-        case 0: {
-          [decoded, o] = new TransactionScriptCoder().decode(data, o);
-          return [decoded, o];
-        }
-        case 1: {
-          [decoded, o] = new TransactionCreateCoder().decode(data, o);
-          return [decoded, o];
-        }
-        case 2: {
-          [decoded, o] = new TransactionMintCoder().decode(data, o);
-          return [decoded, o];
-        }
-        default: {
-          throw new FuelError(
-            ErrorCode.INVALID_TRANSACTION_TYPE,
-            `Invalid transaction type: ${type3}`
-          );
-        }
+    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());
@@ -43879,7 +44117,7 @@ ${MessageCoinFragmentFragmentDoc}`;
      *
      * @param quantities - CoinQuantity Array.
      */
-    fundWithFakeUtxos(quantities) {
+    fundWithFakeUtxos(quantities, resourcesOwner) {
       let idCounter = 0;
       const generateId = () => {
         const counterString = String(idCounter++);
@@ -43903,7 +44141,7 @@ ${MessageCoinFragmentFragmentDoc}`;
               id: generateId(),
               amount: quantity,
               assetId,
-              owner: Address.fromRandom(),
+              owner: resourcesOwner || Address.fromRandom(),
               maturity: 0,
               blockCreated: bn(1),
               txCreatedIdx: bn(1)
@@ -43936,19 +44174,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;
+        }
+      });
     }
   };
 
@@ -45562,7 +45810,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({
@@ -45581,6 +45829,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
@@ -45611,34 +45867,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
@@ -45653,7 +45908,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({
@@ -45680,36 +45935,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,
@@ -45727,7 +45984,9 @@ ${MessageCoinFragmentFragmentDoc}`;
         maxGas,
         usedFee,
         minFee,
-        maxFee
+        maxFee,
+        estimatedInputs: txRequestClone.inputs,
+        estimatedOutputs: txRequestClone.outputs
       };
     }
     async getResourcesForTransaction(owner, transactionRequestLike, forwardingQuantities = []) {
@@ -46117,6 +46376,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();
@@ -46133,6 +46396,51 @@ ${MessageCoinFragmentFragmentDoc}`;
   __publicField(Provider, "chainInfoCache", {});
   __publicField(Provider, "nodeInfoCache", {});
 
+  // src/providers/chains.ts
+  var CHAIN_IDS = {
+    eth: {
+      sepolia: 11155111,
+      foundry: 31337
+    },
+    fuel: {
+      beta5: 0,
+      devnet: 10
+    }
+  };
+
+  // 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) => {
@@ -46176,15 +46484,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);
     }
     /**
@@ -46390,7 +46700,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({
@@ -46400,6 +46713,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         minGasPrice
       });
       await this.fund(request, requiredQuantities, maxFee);
+      request.updatePredicateInputs(estimatedInputs);
       return request;
     }
     /**
@@ -46413,7 +46727,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.
@@ -46492,17 +46806,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
       });
     }
@@ -46512,9 +46839,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({
@@ -46543,11 +46872,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}`);
@@ -46577,7 +46906,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);
@@ -46585,23 +46914,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;
     }
@@ -46887,242 +47216,6 @@ ${MessageCoinFragmentFragmentDoc}`;
   };
   var sha2563 = /* @__PURE__ */ wrapConstructor3(() => new SHA2562());
 
-  // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/utils.js
-  var utils_exports = {};
-  __export(utils_exports, {
-    bitGet: () => bitGet,
-    bitLen: () => bitLen,
-    bitMask: () => bitMask,
-    bitSet: () => bitSet,
-    bytesToHex: () => bytesToHex2,
-    bytesToNumberBE: () => bytesToNumberBE,
-    bytesToNumberLE: () => bytesToNumberLE,
-    concatBytes: () => concatBytes4,
-    createHmacDrbg: () => createHmacDrbg,
-    ensureBytes: () => ensureBytes,
-    equalBytes: () => equalBytes,
-    hexToBytes: () => hexToBytes2,
-    hexToNumber: () => hexToNumber,
-    isBytes: () => isBytes3,
-    numberToBytesBE: () => numberToBytesBE,
-    numberToBytesLE: () => numberToBytesLE,
-    numberToHexUnpadded: () => numberToHexUnpadded,
-    numberToVarBytesBE: () => numberToVarBytesBE,
-    utf8ToBytes: () => utf8ToBytes4,
-    validateObject: () => validateObject
-  });
-  var _0n3 = BigInt(0);
-  var _1n3 = BigInt(1);
-  var _2n3 = BigInt(2);
-  function isBytes3(a) {
-    return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
-  }
-  var hexes3 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-  function bytesToHex2(bytes4) {
-    if (!isBytes3(bytes4))
-      throw new Error("Uint8Array expected");
-    let hex = "";
-    for (let i = 0; i < bytes4.length; i++) {
-      hex += hexes3[bytes4[i]];
-    }
-    return hex;
-  }
-  function numberToHexUnpadded(num) {
-    const hex = num.toString(16);
-    return hex.length & 1 ? `0${hex}` : hex;
-  }
-  function hexToNumber(hex) {
-    if (typeof hex !== "string")
-      throw new Error("hex string expected, got " + typeof hex);
-    return BigInt(hex === "" ? "0" : `0x${hex}`);
-  }
-  var asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
-  function asciiToBase16(char) {
-    if (char >= asciis._0 && char <= asciis._9)
-      return char - asciis._0;
-    if (char >= asciis._A && char <= asciis._F)
-      return char - (asciis._A - 10);
-    if (char >= asciis._a && char <= asciis._f)
-      return char - (asciis._a - 10);
-    return;
-  }
-  function hexToBytes2(hex) {
-    if (typeof hex !== "string")
-      throw new Error("hex string expected, got " + typeof hex);
-    const hl = hex.length;
-    const al = hl / 2;
-    if (hl % 2)
-      throw new Error("padded hex string expected, got unpadded hex of length " + hl);
-    const array = new Uint8Array(al);
-    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
-      const n1 = asciiToBase16(hex.charCodeAt(hi));
-      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
-      if (n1 === void 0 || n2 === void 0) {
-        const char = hex[hi] + hex[hi + 1];
-        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
-      }
-      array[ai] = n1 * 16 + n2;
-    }
-    return array;
-  }
-  function bytesToNumberBE(bytes4) {
-    return hexToNumber(bytesToHex2(bytes4));
-  }
-  function bytesToNumberLE(bytes4) {
-    if (!isBytes3(bytes4))
-      throw new Error("Uint8Array expected");
-    return hexToNumber(bytesToHex2(Uint8Array.from(bytes4).reverse()));
-  }
-  function numberToBytesBE(n, len) {
-    return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
-  }
-  function numberToBytesLE(n, len) {
-    return numberToBytesBE(n, len).reverse();
-  }
-  function numberToVarBytesBE(n) {
-    return hexToBytes2(numberToHexUnpadded(n));
-  }
-  function ensureBytes(title, hex, expectedLength) {
-    let res;
-    if (typeof hex === "string") {
-      try {
-        res = hexToBytes2(hex);
-      } catch (e) {
-        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
-      }
-    } else if (isBytes3(hex)) {
-      res = Uint8Array.from(hex);
-    } else {
-      throw new Error(`${title} must be hex string or Uint8Array`);
-    }
-    const len = res.length;
-    if (typeof expectedLength === "number" && len !== expectedLength)
-      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
-    return res;
-  }
-  function concatBytes4(...arrays) {
-    let sum = 0;
-    for (let i = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      if (!isBytes3(a))
-        throw new Error("Uint8Array expected");
-      sum += a.length;
-    }
-    let res = new Uint8Array(sum);
-    let pad3 = 0;
-    for (let i = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      res.set(a, pad3);
-      pad3 += a.length;
-    }
-    return res;
-  }
-  function equalBytes(a, b) {
-    if (a.length !== b.length)
-      return false;
-    let diff = 0;
-    for (let i = 0; i < a.length; i++)
-      diff |= a[i] ^ b[i];
-    return diff === 0;
-  }
-  function utf8ToBytes4(str) {
-    if (typeof str !== "string")
-      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
-    return new Uint8Array(new TextEncoder().encode(str));
-  }
-  function bitLen(n) {
-    let len;
-    for (len = 0; n > _0n3; n >>= _1n3, len += 1)
-      ;
-    return len;
-  }
-  function bitGet(n, pos) {
-    return n >> BigInt(pos) & _1n3;
-  }
-  var bitSet = (n, pos, value) => {
-    return n | (value ? _1n3 : _0n3) << BigInt(pos);
-  };
-  var bitMask = (n) => (_2n3 << BigInt(n - 1)) - _1n3;
-  var u8n = (data) => new Uint8Array(data);
-  var u8fr = (arr) => Uint8Array.from(arr);
-  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
-    if (typeof hashLen !== "number" || hashLen < 2)
-      throw new Error("hashLen must be a number");
-    if (typeof qByteLen !== "number" || qByteLen < 2)
-      throw new Error("qByteLen must be a number");
-    if (typeof hmacFn !== "function")
-      throw new Error("hmacFn must be a function");
-    let v = u8n(hashLen);
-    let k = u8n(hashLen);
-    let i = 0;
-    const reset = () => {
-      v.fill(1);
-      k.fill(0);
-      i = 0;
-    };
-    const h = (...b) => hmacFn(k, v, ...b);
-    const reseed = (seed = u8n()) => {
-      k = h(u8fr([0]), seed);
-      v = h();
-      if (seed.length === 0)
-        return;
-      k = h(u8fr([1]), seed);
-      v = h();
-    };
-    const gen3 = () => {
-      if (i++ >= 1e3)
-        throw new Error("drbg: tried 1000 values");
-      let len = 0;
-      const out = [];
-      while (len < qByteLen) {
-        v = h();
-        const sl = v.slice();
-        out.push(sl);
-        len += v.length;
-      }
-      return concatBytes4(...out);
-    };
-    const genUntil = (seed, pred) => {
-      reset();
-      reseed(seed);
-      let res = void 0;
-      while (!(res = pred(gen3())))
-        reseed();
-      reset();
-      return res;
-    };
-    return genUntil;
-  }
-  var validatorFns = {
-    bigint: (val) => typeof val === "bigint",
-    function: (val) => typeof val === "function",
-    boolean: (val) => typeof val === "boolean",
-    string: (val) => typeof val === "string",
-    stringOrUint8Array: (val) => typeof val === "string" || isBytes3(val),
-    isSafeInteger: (val) => Number.isSafeInteger(val),
-    array: (val) => Array.isArray(val),
-    field: (val, object) => object.Fp.isValid(val),
-    hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
-  };
-  function validateObject(object, validators, optValidators = {}) {
-    const checkField = (fieldName, type3, isOptional) => {
-      const checkVal = validatorFns[type3];
-      if (typeof checkVal !== "function")
-        throw new Error(`Invalid validator "${type3}", expected function`);
-      const val = object[fieldName];
-      if (isOptional && val === void 0)
-        return;
-      if (!checkVal(val, object)) {
-        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type3}`);
-      }
-    };
-    for (const [fieldName, type3] of Object.entries(validators))
-      checkField(fieldName, type3, false);
-    for (const [fieldName, type3] of Object.entries(optValidators))
-      checkField(fieldName, type3, true);
-    return object;
-  }
-
   // ../../node_modules/.pnpm/@noble+curves@1.3.0/node_modules/@noble/curves/esm/abstract/modular.js
   var _0n4 = BigInt(0);
   var _1n4 = BigInt(1);
@@ -47558,7 +47651,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)
@@ -47596,7 +47689,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);
@@ -47622,7 +47715,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");
@@ -48012,7 +48105,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 {
@@ -48157,7 +48250,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)
@@ -48209,7 +48302,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);
@@ -48252,7 +48345,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) {
@@ -48368,7 +48461,7 @@ ${MessageCoinFragmentFragmentDoc}`;
   function getHash(hash5) {
     return {
       hash: hash5,
-      hmac: (key, ...msgs) => hmac2(hash5, key, concatBytes3(...msgs)),
+      hmac: (key, ...msgs) => hmac2(hash5, key, concatBytes4(...msgs)),
       randomBytes: randomBytes4
     };
   }
@@ -48767,12 +48860,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 }
       );
     }
     /**
@@ -48781,9 +48876,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),
         {
@@ -51767,12 +51864,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) *)