@fuel-ts/account 0.78.0 → 0.80.0

package/dist/index.global.js

@@ -28952,9 +28952,9 @@ spurious results.`);
   // ../versions/dist/index.mjs
   function getBuiltinVersions() {
     return {
-      FORC: "0.51.1",
+      FORC: "0.49.3",
       FUEL_CORE: "0.22.1",
-      FUELS: "0.78.0"
+      FUELS: "0.80.0"
     };
   }
   function parseVersion(version2) {
@@ -29013,9 +29013,9 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["ABI_TYPES_AND_VALUES_MISMATCH"] = "abi-types-and-values-mismatch";
     ErrorCode2["ABI_MAIN_METHOD_MISSING"] = "abi-main-method-missing";
     ErrorCode2["INVALID_COMPONENT"] = "invalid-component";
-    ErrorCode2["FRAGMENT_NOT_FOUND"] = "fragment-not-found";
     ErrorCode2["CONFIGURABLE_NOT_FOUND"] = "configurable-not-found";
     ErrorCode2["TYPE_NOT_FOUND"] = "type-not-found";
+    ErrorCode2["LOG_TYPE_NOT_FOUND"] = "log-type-not-found";
     ErrorCode2["TYPE_NOT_SUPPORTED"] = "type-not-supported";
     ErrorCode2["INVALID_DECODE_VALUE"] = "invalid-decode-value";
     ErrorCode2["JSON_ABI_ERROR"] = "json-abi-error";
@@ -29028,14 +29028,12 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["INVALID_BECH32_ADDRESS"] = "invalid-bech32-address";
     ErrorCode2["INVALID_EVM_ADDRESS"] = "invalid-evm-address";
     ErrorCode2["INVALID_B256_ADDRESS"] = "invalid-b256-address";
-    ErrorCode2["INVALID_URL"] = "invalid-url";
     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["CONNECTION_REFUSED"] = "connection-refused";
     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";
@@ -29052,7 +29050,6 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["ELEMENT_NOT_FOUND"] = "element-not-found";
     ErrorCode2["MISSING_REQUIRED_PARAMETER"] = "missing-required-parameter";
     ErrorCode2["INVALID_REQUEST"] = "invalid-request";
-    ErrorCode2["UNEXPECTED_HEX_VALUE"] = "unexpected-hex-value";
     ErrorCode2["INVALID_TRANSFER_AMOUNT"] = "invalid-transfer-amount";
     ErrorCode2["GAS_PRICE_TOO_LOW"] = "gas-price-too-low";
     ErrorCode2["GAS_LIMIT_TOO_LOW"] = "gas-limit-too-low";
@@ -29076,7 +29073,6 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["INVALID_PASSWORD"] = "invalid-password";
     ErrorCode2["ACCOUNT_REQUIRED"] = "account-required";
     ErrorCode2["UNLOCKED_WALLET_REQUIRED"] = "unlocked-wallet-required";
-    ErrorCode2["LATEST_BLOCK_UNAVAILABLE"] = "latest-block-unavailable";
     ErrorCode2["ERROR_BUILDING_BLOCK_EXPLORER_URL"] = "error-building-block-explorer-url";
     ErrorCode2["UNSUPPORTED_FUEL_CLIENT_VERSION"] = "unsupported-fuel-client-version";
     ErrorCode2["VITEPRESS_PLUGIN_ERROR"] = "vitepress-plugin-error";
@@ -29088,6 +29084,7 @@ This unreleased fuel-core build may include features and updates not yet support
   })(ErrorCode || {});
   var _FuelError = class extends Error {
     VERSIONS = versions;
+    metadata;
     static parse(e) {
       const error = e;
       if (error.code === void 0) {
@@ -29107,14 +29104,15 @@ This unreleased fuel-core build may include features and updates not yet support
       return new _FuelError(error.code, error.message);
     }
     code;
-    constructor(code, message) {
+    constructor(code, message, metadata = {}) {
       super(message);
       this.code = code;
       this.name = "FuelError";
+      this.metadata = metadata;
     }
     toObject() {
-      const { code, name, message, VERSIONS } = this;
-      return { code, name, message, VERSIONS };
+      const { code, name, message, metadata, VERSIONS } = this;
+      return { code, name, message, metadata, VERSIONS };
     }
   };
   var FuelError = _FuelError;
@@ -31282,7 +31280,7 @@ This unreleased fuel-core build may include features and updates not yet support
   var import_bn = __toESM(require_bn(), 1);
   var DEFAULT_PRECISION = 9;
   var DEFAULT_MIN_PRECISION = 3;
-  var DECIMAL_UNITS = 9;
+  var DEFAULT_DECIMAL_UNITS = 9;
   function toFixed(value, options) {
     const { precision = DEFAULT_PRECISION, minPrecision = DEFAULT_MIN_PRECISION } = options || {};
     const [valueUnits = "0", valueDecimals = "0"] = String(value || "0.0").split(".");
@@ -31348,7 +31346,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     format(options) {
       const {
-        units = DECIMAL_UNITS,
+        units = DEFAULT_DECIMAL_UNITS,
         precision = DEFAULT_PRECISION,
         minPrecision = DEFAULT_MIN_PRECISION
       } = options || {};
@@ -31364,7 +31362,7 @@ This unreleased fuel-core build may include features and updates not yet support
       }
       return formattedFixed;
     }
-    formatUnits(units = DECIMAL_UNITS) {
+    formatUnits(units = DEFAULT_DECIMAL_UNITS) {
       const valueUnits = this.toString().slice(0, units * -1);
       const valueDecimals = this.toString().slice(units * -1);
       const length = valueDecimals.length;
@@ -31473,7 +31471,7 @@ This unreleased fuel-core build may include features and updates not yet support
     // END ANCHOR: OVERRIDES to avoid losing references
   };
   var bn = (value, base, endian) => new BN(value, base, endian);
-  bn.parseUnits = (value, units = DECIMAL_UNITS) => {
+  bn.parseUnits = (value, units = DEFAULT_DECIMAL_UNITS) => {
     const valueToParse = value === "." ? "0." : value;
     const [valueUnits = "0", valueDecimals = "0"] = valueToParse.split(".");
     const length = valueDecimals.length;
@@ -31607,6 +31605,7 @@ This unreleased fuel-core build may include features and updates not yet support
   var ENCODING_V1 = "1";
   var WORD_SIZE = 8;
   var BYTES_32 = 32;
+  var UTXO_ID_LEN = BYTES_32 + 1;
   var ASSET_ID_LEN = BYTES_32;
   var ADDRESS_LEN = BYTES_32;
   var NONCE_LEN = BYTES_32;
@@ -31757,15 +31756,6 @@ This unreleased fuel-core build may include features and updates not yet support
     }
   };
   var isHeapType = (type3) => type3 === VEC_CODER_TYPE || type3 === BYTES_CODER_TYPE || type3 === STD_STRING_CODER_TYPE;
-  function findOrThrow(arr, predicate, throwFn = () => {
-    throw new FuelError(ErrorCode.ELEMENT_NOT_FOUND, "Element not found in the array.");
-  }) {
-    const found = arr.find(predicate);
-    if (found === void 0) {
-      throwFn();
-    }
-    return found;
-  }
   var isMultipleOfWordSize = (length) => length % WORD_SIZE === 0;
   var getWordSizePadding = (length) => WORD_SIZE - length % WORD_SIZE;
   var rightPadToWordSize = (encoded) => {
@@ -31775,6 +31765,7 @@ This unreleased fuel-core build may include features and updates not yet support
     const padding = new Uint8Array(WORD_SIZE - encoded.length % WORD_SIZE);
     return concatBytes2([encoded, padding]);
   };
+  var isUint8Array = (value) => value instanceof Uint8Array;
   var ArrayCoder = class extends Coder {
     coder;
     length;
@@ -31918,9 +31909,6 @@ This unreleased fuel-core build may include features and updates not yet support
       __privateAdd2(this, _getPaddedData);
     }
     encode(value) {
-      if (!Array.isArray(value)) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
-      }
       const parts = [];
       const pointer = new BigNumberCoder("u64").encode(BASE_VECTOR_OFFSET);
       const data = __privateMethod2(this, _getPaddedData, getPaddedData_fn).call(this, value);
@@ -31947,7 +31935,7 @@ This unreleased fuel-core build may include features and updates not yet support
   };
   _getPaddedData = /* @__PURE__ */ new WeakSet();
   getPaddedData_fn = function(value) {
-    const data = [Uint8Array.from(value)];
+    const data = value instanceof Uint8Array ? [value] : [new Uint8Array(value)];
     const paddingLength = (WORD_SIZE - value.length % WORD_SIZE) % WORD_SIZE;
     if (paddingLength) {
       data.push(new Uint8Array(paddingLength));
@@ -31970,7 +31958,7 @@ This unreleased fuel-core build may include features and updates not yet support
         (max2, coder) => Math.max(max2, coder.encodedLength),
         0
       );
-      super("enum", `enum ${name}`, caseIndexCoder.encodedLength + encodedValueSize);
+      super(`enum ${name}`, `enum ${name}`, caseIndexCoder.encodedLength + encodedValueSize);
       this.name = name;
       this.coders = coders;
       this.#caseIndexCoder = caseIndexCoder;
@@ -32040,7 +32028,7 @@ This unreleased fuel-core build may include features and updates not yet support
       return { None: [] };
     }
     decode(data, offset) {
-      if (data.length < this.encodedLength - 1) {
+      if (data.length < this.encodedLength) {
         throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid option data size.`);
       }
       const [decoded, newOffset] = super.decode(data, offset);
@@ -32319,8 +32307,11 @@ This unreleased fuel-core build may include features and updates not yet support
       this.coder = coder;
     }
     encode(value) {
-      if (!Array.isArray(value)) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
+      if (!Array.isArray(value) && !isUint8Array(value)) {
+        throw new FuelError(
+          ErrorCode.ENCODE_ERROR,
+          `Expected array value, or a Uint8Array. You can use arrayify to convert a value to a Uint8Array.`
+        );
       }
       const parts = [];
       const pointer = new BigNumberCoder("u64").encode(BASE_VECTOR_OFFSET);
@@ -32351,6 +32342,38 @@ This unreleased fuel-core build may include features and updates not yet support
       ];
     }
   };
+  var findFunctionByName = (abi, name) => {
+    const fn = abi.functions.find((f2) => f2.name === name);
+    if (!fn) {
+      throw new FuelError(
+        ErrorCode.FUNCTION_NOT_FOUND,
+        `Function with name '${name}' doesn't exist in the ABI`
+      );
+    }
+    return fn;
+  };
+  var findTypeById = (abi, typeId) => {
+    const type3 = abi.types.find((t) => t.typeId === typeId);
+    if (!type3) {
+      throw new FuelError(
+        ErrorCode.TYPE_NOT_FOUND,
+        `Type with typeId '${typeId}' doesn't exist in the ABI.`
+      );
+    }
+    return type3;
+  };
+  var findNonEmptyInputs = (abi, inputs) => inputs.filter((input) => findTypeById(abi, input.type).type !== "()");
+  var findVectorBufferArgument = (components) => {
+    const bufferComponent = components.find((c) => c.name === "buf");
+    const bufferTypeArgument = bufferComponent?.originalTypeArguments?.[0];
+    if (!bufferComponent || !bufferTypeArgument) {
+      throw new FuelError(
+        ErrorCode.INVALID_COMPONENT,
+        `The Vec type provided is missing or has a malformed 'buf' component.`
+      );
+    }
+    return bufferTypeArgument;
+  };
   var ResolvedAbiType = class {
     abi;
     name;
@@ -32359,20 +32382,8 @@ This unreleased fuel-core build may include features and updates not yet support
     components;
     constructor(abi, argument) {
       this.abi = abi;
-      const type3 = findOrThrow(
-        abi.types,
-        (t) => t.typeId === argument.type,
-        () => {
-          throw new FuelError(
-            ErrorCode.TYPE_NOT_FOUND,
-            `Type does not exist in the provided abi: ${JSON.stringify({
-              argument,
-              abi: this.abi
-            })}`
-          );
-        }
-      );
       this.name = argument.name;
+      const type3 = findTypeById(abi, argument.type);
       this.type = type3.type;
       this.originalTypeArguments = argument.typeArguments;
       this.components = ResolvedAbiType.getResolvedGenericComponents(
@@ -32424,7 +32435,7 @@ This unreleased fuel-core build may include features and updates not yet support
             )
           };
         }
-        const argType = findOrThrow(abi.types, (t) => t.typeId === arg.type);
+        const argType = findTypeById(abi, arg.type);
         const implicitTypeParameters = this.getImplicitGenericTypeParameters(abi, argType.components);
         if (implicitTypeParameters && implicitTypeParameters.length > 0) {
           return {
@@ -32441,7 +32452,7 @@ This unreleased fuel-core build may include features and updates not yet support
       }
       const implicitGenericParameters = implicitGenericParametersParam ?? [];
       args.forEach((a) => {
-        const argType = findOrThrow(abi.types, (t) => t.typeId === a.type);
+        const argType = findTypeById(abi, a.type);
         if (genericRegEx.test(argType.type)) {
           implicitGenericParameters.push(argType.typeId);
           return;
@@ -32550,13 +32561,7 @@ This unreleased fuel-core build may include features and updates not yet support
       return new ArrayCoder(arrayElementCoder, length);
     }
     if (resolvedAbiType.type === VEC_CODER_TYPE) {
-      const arg = findOrThrow(components, (c) => c.name === "buf").originalTypeArguments?.[0];
-      if (!arg) {
-        throw new FuelError(
-          ErrorCode.INVALID_COMPONENT,
-          `The provided Vec type is missing the 'type argument'.`
-        );
-      }
+      const arg = findVectorBufferArgument(components);
       const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
       const itemCoder = getCoder(argType, { isSmallBytes: true, encoding: ENCODING_V0 });
       return new VecCoder(itemCoder);
@@ -32623,11 +32628,8 @@ This unreleased fuel-core build may include features and updates not yet support
       super("struct", "struct Bytes", WORD_SIZE);
     }
     encode(value) {
-      if (!Array.isArray(value)) {
-        throw new FuelError(ErrorCode.ENCODE_ERROR, `Expected array value.`);
-      }
-      const bytes3 = new Uint8Array(value);
-      const lengthBytes = new BigNumberCoder("u64").encode(value.length);
+      const bytes3 = value instanceof Uint8Array ? value : new Uint8Array(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(bytes3.length);
       return new Uint8Array([...lengthBytes, ...bytes3]);
     }
     decode(data, offset) {
@@ -32660,7 +32662,7 @@ This unreleased fuel-core build may include features and updates not yet support
         (max2, coder) => Math.max(max2, coder.encodedLength),
         0
       );
-      super("enum", `enum ${name}`, caseIndexCoder.encodedLength + encodedValueSize);
+      super(`enum ${name}`, `enum ${name}`, caseIndexCoder.encodedLength + encodedValueSize);
       this.name = name;
       this.coders = coders;
       this.#caseIndexCoder = caseIndexCoder;
@@ -32758,6 +32760,28 @@ This unreleased fuel-core build may include features and updates not yet support
       return [toNumber2(bytes3), offset + this.length];
     }
   };
+  var OptionCoder2 = class extends EnumCoder2 {
+    encode(value) {
+      const result = super.encode(this.toSwayOption(value));
+      return result;
+    }
+    toSwayOption(input) {
+      if (input !== void 0) {
+        return { Some: input };
+      }
+      return { None: [] };
+    }
+    decode(data, offset) {
+      const [decoded, newOffset] = super.decode(data, offset);
+      return [this.toOption(decoded), newOffset];
+    }
+    toOption(output3) {
+      if (output3 && "Some" in output3) {
+        return output3.Some;
+      }
+      return void 0;
+    }
+  };
   var RawSliceCoder2 = class extends Coder {
     constructor() {
       super("raw untyped slice", "raw untyped slice", WORD_SIZE);
@@ -32811,6 +32835,30 @@ This unreleased fuel-core build may include features and updates not yet support
     }
   };
   __publicField4(StdStringCoder2, "memorySize", 1);
+  var StrSliceCoder = class extends Coder {
+    constructor() {
+      super("strSlice", "str", WORD_SIZE);
+    }
+    encode(value) {
+      const bytes3 = toUtf8Bytes(value);
+      const lengthBytes = new BigNumberCoder("u64").encode(value.length);
+      return new Uint8Array([...lengthBytes, ...bytes3]);
+    }
+    decode(data, offset) {
+      if (data.length < this.encodedLength) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string slice data size.`);
+      }
+      const offsetAndLength = offset + WORD_SIZE;
+      const lengthBytes = data.slice(offset, offsetAndLength);
+      const length = bn(new BigNumberCoder("u64").decode(lengthBytes, 0)[0]).toNumber();
+      const bytes3 = data.slice(offsetAndLength, offsetAndLength + length);
+      if (bytes3.length !== length) {
+        throw new FuelError(ErrorCode.DECODE_ERROR, `Invalid string slice byte data size.`);
+      }
+      return [toUtf8String(bytes3), offsetAndLength + length];
+    }
+  };
+  __publicField4(StrSliceCoder, "memorySize", 1);
   var StringCoder2 = class extends Coder {
     constructor(length) {
       super("string", `str[${length}]`, length);
@@ -32849,7 +32897,7 @@ This unreleased fuel-core build may include features and updates not yet support
         Object.keys(this.coders).map((fieldName) => {
           const fieldCoder = this.coders[fieldName];
           const fieldValue = value[fieldName];
-          if (!(fieldCoder instanceof OptionCoder) && fieldValue == null) {
+          if (!(fieldCoder instanceof OptionCoder2) && fieldValue == null) {
             throw new FuelError(
               ErrorCode.ENCODE_ERROR,
               `Invalid ${this.type}. Field "${fieldName}" not present.`
@@ -32957,6 +33005,8 @@ This unreleased fuel-core build may include features and updates not yet support
         return new ByteCoder2();
       case STD_STRING_CODER_TYPE:
         return new StdStringCoder2();
+      case STR_SLICE_CODER_TYPE:
+        return new StrSliceCoder();
       default:
         break;
     }
@@ -32980,13 +33030,7 @@ This unreleased fuel-core build may include features and updates not yet support
       return new ArrayCoder(arrayElementCoder, length);
     }
     if (resolvedAbiType.type === VEC_CODER_TYPE) {
-      const arg = findOrThrow(components, (c) => c.name === "buf").originalTypeArguments?.[0];
-      if (!arg) {
-        throw new FuelError(
-          ErrorCode.INVALID_COMPONENT,
-          `The provided Vec type is missing the 'type argument'.`
-        );
-      }
+      const arg = findVectorBufferArgument(components);
       const argType = new ResolvedAbiType(resolvedAbiType.abi, arg);
       const itemCoder = getCoder2(argType, { isSmallBytes: true, encoding: ENCODING_V0 });
       return new VecCoder2(itemCoder);
@@ -33001,7 +33045,7 @@ This unreleased fuel-core build may include features and updates not yet support
       const coders = getCoders(components, { getCoder: getCoder2 });
       const isOptionEnum = resolvedAbiType.type === OPTION_CODER_TYPE;
       if (isOptionEnum) {
-        return new OptionCoder(enumMatch.name, coders);
+        return new OptionCoder2(enumMatch.name, coders);
       }
       return new EnumCoder2(enumMatch.name, coders);
     }
@@ -33012,12 +33056,6 @@ This unreleased fuel-core build may include features and updates not yet support
       );
       return new TupleCoder2(coders);
     }
-    if (resolvedAbiType.type === STR_SLICE_CODER_TYPE) {
-      throw new FuelError(
-        ErrorCode.INVALID_DATA,
-        "String slices can not be decoded from logs. Convert the slice to `str[N]` with `__to_str_array`"
-      );
-    }
     throw new FuelError(
       ErrorCode.CODER_NOT_FOUND,
       `Coder not found: ${JSON.stringify(resolvedAbiType)}.`
@@ -33053,6 +33091,8 @@ This unreleased fuel-core build may include features and updates not yet support
   var FunctionFragment = class {
     signature;
     selector;
+    selectorBytes;
+    encoding;
     name;
     jsonFn;
     attributes;
@@ -33061,10 +33101,12 @@ This unreleased fuel-core build may include features and updates not yet support
     jsonAbi;
     constructor(jsonAbi, name) {
       this.jsonAbi = jsonAbi;
-      this.jsonFn = findOrThrow(this.jsonAbi.functions, (f2) => f2.name === name);
+      this.jsonFn = findFunctionByName(this.jsonAbi, name);
       this.name = name;
       this.signature = FunctionFragment.getSignature(this.jsonAbi, this.jsonFn);
       this.selector = FunctionFragment.getFunctionSelector(this.signature);
+      this.selectorBytes = new StdStringCoder2().encode(name);
+      this.encoding = this.jsonAbi.encoding ?? ENCODING_V0;
       this.isInputDataPointer = this.#isInputDataPointer();
       this.outputMetadata = {
         isHeapType: this.#isOutputDataHeap(),
@@ -33083,13 +33125,11 @@ This unreleased fuel-core build may include features and updates not yet support
       return bn(hashedFunctionSignature.slice(0, 10)).toHex(8);
     }
     #isInputDataPointer() {
-      const inputTypes = this.jsonFn.inputs.map(
-        (i) => this.jsonAbi.types.find((t) => t.typeId === i.type)
-      );
+      const inputTypes = this.jsonFn.inputs.map((i) => findTypeById(this.jsonAbi, i.type));
       return this.jsonFn.inputs.length > 1 || isPointerType(inputTypes[0]?.type || "");
     }
     #isOutputDataHeap() {
-      const outputType = findOrThrow(this.jsonAbi.types, (t) => t.typeId === this.jsonFn.output.type);
+      const outputType = findTypeById(this.jsonAbi, this.jsonFn.output.type);
       return isHeapType(outputType?.type || "");
     }
     #getOutputEncodedLength() {
@@ -33109,27 +33149,28 @@ This unreleased fuel-core build may include features and updates not yet support
     encodeArguments(values, offset = 0) {
       FunctionFragment.verifyArgsAndInputsAlign(values, this.jsonFn.inputs, this.jsonAbi);
       const shallowCopyValues = values.slice();
-      const nonEmptyInputs = this.jsonFn.inputs.filter(
-        (x) => findOrThrow(this.jsonAbi.types, (t) => t.typeId === x.type).type !== "()"
-      );
+      const nonEmptyInputs = findNonEmptyInputs(this.jsonAbi, this.jsonFn.inputs);
       if (Array.isArray(values) && nonEmptyInputs.length !== values.length) {
         shallowCopyValues.length = this.jsonFn.inputs.length;
         shallowCopyValues.fill(void 0, values.length);
       }
       const coders = nonEmptyInputs.map(
         (t) => AbiCoder.getCoder(this.jsonAbi, t, {
-          isRightPadded: nonEmptyInputs.length > 1
+          isRightPadded: nonEmptyInputs.length > 1,
+          encoding: this.encoding
         })
       );
-      const coder = new TupleCoder(coders);
-      const results = coder.encode(shallowCopyValues);
+      if (this.encoding === ENCODING_V1) {
+        return new TupleCoder2(coders).encode(shallowCopyValues);
+      }
+      const results = new TupleCoder(coders).encode(shallowCopyValues);
       return unpackDynamicData(results, offset, results.byteLength);
     }
     static verifyArgsAndInputsAlign(args, inputs, abi) {
       if (args.length === inputs.length) {
         return;
       }
-      const inputTypes = inputs.map((i) => findOrThrow(abi.types, (t) => t.typeId === i.type));
+      const inputTypes = inputs.map((input) => findTypeById(abi, input.type));
       const optionalInputs = inputTypes.filter(
         (x) => x.type === OPTION_CODER_TYPE || x.type === "()"
       );
@@ -33144,9 +33185,7 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     decodeArguments(data) {
       const bytes3 = arrayify(data);
-      const nonEmptyInputs = this.jsonFn.inputs.filter(
-        (x) => findOrThrow(this.jsonAbi.types, (t) => t.typeId === x.type).type !== "()"
-      );
+      const nonEmptyInputs = findNonEmptyInputs(this.jsonAbi, this.jsonFn.inputs);
       if (nonEmptyInputs.length === 0) {
         if (bytes3.length === 0) {
           return void 0;
@@ -33169,7 +33208,7 @@ This unreleased fuel-core build may include features and updates not yet support
       }
       const result = nonEmptyInputs.reduce(
         (obj, input) => {
-          const coder = AbiCoder.getCoder(this.jsonAbi, input);
+          const coder = AbiCoder.getCoder(this.jsonAbi, input, { encoding: this.encoding });
           const [decodedValue, decodedValueByteSize] = coder.decode(bytes3, obj.offset);
           return {
             decoded: [...obj.decoded, decodedValue],
@@ -33181,33 +33220,32 @@ This unreleased fuel-core build may include features and updates not yet support
       return result.decoded;
     }
     decodeOutput(data) {
-      const outputAbiType = findOrThrow(
-        this.jsonAbi.types,
-        (t) => t.typeId === this.jsonFn.output.type
-      );
+      const outputAbiType = findTypeById(this.jsonAbi, this.jsonFn.output.type);
       if (outputAbiType.type === "()") {
         return [void 0, 0];
       }
       const bytes3 = arrayify(data);
-      const coder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output);
+      const coder = AbiCoder.getCoder(this.jsonAbi, this.jsonFn.output, {
+        encoding: this.encoding
+      });
       return coder.decode(bytes3, 0);
     }
+    /**
+     * Checks if the function is read-only i.e. it only reads from storage, does not write to it.
+     *
+     * @returns True if the function is read-only or pure, false otherwise.
+     */
+    isReadOnly() {
+      const storageAttribute = this.attributes.find((attr) => attr.name === "storage");
+      return !storageAttribute?.arguments.includes("write");
+    }
   };
   var Interface = class {
     functions;
     configurables;
-    /*
-      TODO: Refactor so that there's no need for externalLoggedTypes
-    
-      This is dedicated to external contracts added via `<base-invocation-scope.ts>.addContracts()` method.
-      This is used to decode logs from contracts other than the main contract
-      we're interacting with.
-      */
-    externalLoggedTypes;
     jsonAbi;
     constructor(jsonAbi) {
       this.jsonAbi = jsonAbi;
-      this.externalLoggedTypes = {};
       this.functions = Object.fromEntries(
         this.jsonAbi.functions.map((x) => [x.name, new FunctionFragment(this.jsonAbi, x.name)])
       );
@@ -33231,16 +33269,10 @@ This unreleased fuel-core build may include features and updates not yet support
     }
     decodeFunctionData(functionFragment, data) {
       const fragment = typeof functionFragment === "string" ? this.getFunction(functionFragment) : functionFragment;
-      if (!fragment) {
-        throw new FuelError(ErrorCode.FRAGMENT_NOT_FOUND, "Fragment not found.");
-      }
       return fragment.decodeArguments(data);
     }
     encodeFunctionData(functionFragment, values, offset = 0) {
       const fragment = typeof functionFragment === "string" ? this.getFunction(functionFragment) : functionFragment;
-      if (!fragment) {
-        throw new FuelError(ErrorCode.FRAGMENT_NOT_FOUND, "Fragment not found.");
-      }
       return fragment.encodeArguments(values, offset);
     }
     // Decode the result of a function call
@@ -33248,46 +33280,34 @@ This unreleased fuel-core build may include features and updates not yet support
       const fragment = typeof functionFragment === "string" ? this.getFunction(functionFragment) : functionFragment;
       return fragment.decodeOutput(data);
     }
-    decodeLog(data, logId, receiptId) {
-      const isExternalLoggedType = this.externalLoggedTypes[receiptId];
-      if (isExternalLoggedType) {
-        const externalInterface = this.externalLoggedTypes[receiptId];
-        return externalInterface.decodeLog(data, logId, receiptId);
+    decodeLog(data, logId) {
+      const loggedType = this.jsonAbi.loggedTypes.find((type3) => type3.logId === logId);
+      if (!loggedType) {
+        throw new FuelError(
+          ErrorCode.LOG_TYPE_NOT_FOUND,
+          `Log type with logId '${logId}' doesn't exist in the ABI.`
+        );
       }
-      const { loggedType } = findOrThrow(this.jsonAbi.loggedTypes, (type3) => type3.logId === logId);
-      return AbiCoder.decode(this.jsonAbi, loggedType, arrayify(data), 0, {
+      return AbiCoder.decode(this.jsonAbi, loggedType.loggedType, arrayify(data), 0, {
         encoding: this.jsonAbi.encoding
       });
     }
-    updateExternalLoggedTypes(id, loggedTypes) {
-      this.externalLoggedTypes[id] = loggedTypes;
-    }
     encodeConfigurable(name, value) {
-      const configurable = findOrThrow(
-        this.jsonAbi.configurables,
-        (c) => c.name === name,
-        () => {
-          throw new FuelError(
-            ErrorCode.CONFIGURABLE_NOT_FOUND,
-            `A configurable with the '${name}' was not found in the ABI.`
-          );
-        }
-      );
+      const configurable = this.jsonAbi.configurables.find((c) => c.name === name);
+      if (!configurable) {
+        throw new FuelError(
+          ErrorCode.CONFIGURABLE_NOT_FOUND,
+          `A configurable with the '${name}' was not found in the ABI.`
+        );
+      }
       return AbiCoder.encode(this.jsonAbi, configurable.configurableType, value, {
-        isRightPadded: true
+        isRightPadded: true,
+        // TODO: Review support for configurables in v1 encoding when it becomes available
+        encoding: ENCODING_V0
       });
     }
     getTypeById(typeId) {
-      return findOrThrow(
-        this.jsonAbi.types,
-        (t) => t.typeId === typeId,
-        () => {
-          throw new FuelError(
-            ErrorCode.TYPE_NOT_FOUND,
-            `Type with typeId '${typeId}' doesn't exist in the ABI.`
-          );
-        }
-      );
+      return findTypeById(this.jsonAbi, typeId);
     }
   };
 
@@ -33977,7 +33997,7 @@ This unreleased fuel-core build may include features and updates not yet support
       return [receiptMessageOut, o];
     }
   };
-  var getAssetId = (contractId, subId) => {
+  var getMintedAssetId = (contractId, subId) => {
     const contractIdBytes = arrayify(contractId);
     const subIdBytes = arrayify(subId);
     return sha2563(concat([contractIdBytes, subIdBytes]));
@@ -33987,7 +34007,7 @@ This unreleased fuel-core build may include features and updates not yet support
       super("ReceiptMint", "struct ReceiptMint", 0);
     }
     static getAssetId(contractId, subId) {
-      return getAssetId(contractId, subId);
+      return getMintedAssetId(contractId, subId);
     }
     encode(value) {
       const parts = [];
@@ -34029,7 +34049,7 @@ This unreleased fuel-core build may include features and updates not yet support
       super("ReceiptBurn", "struct ReceiptBurn", 0);
     }
     static getAssetId(contractId, subId) {
-      return getAssetId(contractId, subId);
+      return getMintedAssetId(contractId, subId);
     }
     encode(value) {
       const parts = [];
@@ -38854,8 +38874,8 @@ ${MessageCoinFragmentFragmentDoc}`;
         const predicateData = arrayify(value.predicateData ?? "0x");
         return {
           type: InputType.Coin,
-          txID: hexlify(arrayify(value.id).slice(0, 32)),
-          outputIndex: arrayify(value.id)[32],
+          txID: hexlify(arrayify(value.id).slice(0, BYTES_32)),
+          outputIndex: toNumber2(arrayify(value.id).slice(BYTES_32, UTXO_ID_LEN)),
           owner: hexlify(value.owner),
           amount: bn(value.amount),
           assetId: hexlify(value.assetId),
@@ -38979,7 +38999,60 @@ ${MessageCoinFragmentFragmentDoc}`;
   var MAX_SCRIPT_DATA_LENGTH = 1024 * 1024 * 1024;
   var MAX_PREDICATE_LENGTH = 1024 * 1024;
   var MAX_PREDICATE_DATA_LENGTH = 1024 * 1024;
+  var FAILED_REQUIRE_SIGNAL = "0xffffffffffff0000";
   var FAILED_TRANSFER_TO_ADDRESS_SIGNAL = "0xffffffffffff0001";
+  var FAILED_ASSERT_EQ_SIGNAL = "0xffffffffffff0003";
+  var FAILED_ASSERT_SIGNAL = "0xffffffffffff0004";
+  var FAILED_ASSERT_NE_SIGNAL = "0xffffffffffff0005";
+  var PANIC_REASONS = [
+    "UnknownPanicReason",
+    "Revert",
+    "OutOfGas",
+    "TransactionValidity",
+    "MemoryOverflow",
+    "ArithmeticOverflow",
+    "ContractNotFound",
+    "MemoryOwnership",
+    "NotEnoughBalance",
+    "ExpectedInternalContext",
+    "AssetIdNotFound",
+    "InputNotFound",
+    "OutputNotFound",
+    "WitnessNotFound",
+    "TransactionMaturity",
+    "InvalidMetadataIdentifier",
+    "MalformedCallStructure",
+    "ReservedRegisterNotWritable",
+    "InvalidFlags",
+    "InvalidImmediateValue",
+    "ExpectedCoinInput",
+    "EcalError",
+    "MemoryWriteOverlap",
+    "ContractNotInInputs",
+    "InternalBalanceOverflow",
+    "ContractMaxSize",
+    "ExpectedUnallocatedStack",
+    "MaxStaticContractsReached",
+    "TransferAmountCannotBeZero",
+    "ExpectedOutputVariable",
+    "ExpectedParentInternalContext",
+    "PredicateReturnedNonOne",
+    "ContractIdAlreadyDeployed",
+    "ContractMismatch",
+    "MessageDataTooLong",
+    "ArithmeticError",
+    "ContractInstructionNotAllowed",
+    "TransferZeroCoins",
+    "InvalidInstruction",
+    "MemoryNotExecutable",
+    "PolicyIsNotSet",
+    "PolicyNotFound",
+    "TooManyReceipts",
+    "BalanceOverflow",
+    "InvalidBlockHeight",
+    "TooManySlots"
+  ];
+  var PANIC_DOC_URL = "https://docs.rs/fuel-asm/latest/fuel_asm/enum.PanicReason.html";
 
   // src/providers/utils/receipts.ts
   var doesReceiptHaveMissingOutputVariables = (receipt) => receipt.type === ReceiptType.Revert && receipt.val.toString("hex") === FAILED_TRANSFER_TO_ADDRESS_SIGNAL;
@@ -39353,6 +39426,74 @@ ${MessageCoinFragmentFragmentDoc}`;
     });
   }
 
+  // src/providers/utils/extract-tx-error.ts
+  var assemblePanicError = (status) => {
+    let errorMessage = `The transaction reverted with reason: "${status.reason}".`;
+    const reason = status.reason;
+    if (PANIC_REASONS.includes(status.reason)) {
+      errorMessage = `${errorMessage}
+
+You can read more about this error at:
+
+${PANIC_DOC_URL}#variant.${status.reason}`;
+    }
+    return { errorMessage, reason };
+  };
+  var stringify2 = (obj) => JSON.stringify(obj, null, 2);
+  var assembleRevertError = (receipts, logs) => {
+    let errorMessage = "The transaction reverted with an unknown reason.";
+    const revertReceipt = receipts.find(({ type: type3 }) => type3 === ReceiptType.Revert);
+    let reason = "";
+    if (revertReceipt) {
+      const reasonHex = bn(revertReceipt.val).toHex();
+      switch (reasonHex) {
+        case FAILED_REQUIRE_SIGNAL: {
+          reason = "require";
+          errorMessage = `The transaction reverted because a "require" statement has thrown ${logs.length ? stringify2(logs[0]) : "an error."}.`;
+          break;
+        }
+        case FAILED_ASSERT_EQ_SIGNAL: {
+          const sufix = logs.length >= 2 ? ` comparing ${stringify2(logs[1])} and ${stringify2(logs[0])}.` : ".";
+          reason = "assert_eq";
+          errorMessage = `The transaction reverted because of an "assert_eq" statement${sufix}`;
+          break;
+        }
+        case FAILED_ASSERT_NE_SIGNAL: {
+          const sufix = logs.length >= 2 ? ` comparing ${stringify2(logs[1])} and ${stringify2(logs[0])}.` : ".";
+          reason = "assert_ne";
+          errorMessage = `The transaction reverted because of an "assert_ne" statement${sufix}`;
+          break;
+        }
+        case FAILED_ASSERT_SIGNAL:
+          reason = "assert";
+          errorMessage = `The transaction reverted because an "assert" statement failed to evaluate to true.`;
+          break;
+        case FAILED_TRANSFER_TO_ADDRESS_SIGNAL:
+          reason = "MissingOutputChange";
+          errorMessage = `The transaction reverted because it's missing an "OutputChange".`;
+          break;
+        default:
+          reason = "unknown";
+          errorMessage = `The transaction reverted with an unknown reason: ${revertReceipt.val}`;
+      }
+    }
+    return { errorMessage, reason };
+  };
+  var extractTxError = (params) => {
+    const { receipts, status, logs } = params;
+    const isPanic = receipts.some(({ type: type3 }) => type3 === ReceiptType.Panic);
+    const isRevert = receipts.some(({ type: type3 }) => type3 === ReceiptType.Revert);
+    const { errorMessage, reason } = status?.type === "FailureStatus" && isPanic ? assemblePanicError(status) : assembleRevertError(receipts, logs);
+    const metadata = {
+      logs,
+      receipts,
+      panic: isPanic,
+      revert: isRevert,
+      reason
+    };
+    return new FuelError(ErrorCode.SCRIPT_REVERTED, errorMessage, metadata);
+  };
+
   // src/providers/transaction-request/errors.ts
   var ChangeOutputCollisionError = class extends Error {
     name = "ChangeOutputCollisionError";
@@ -39633,8 +39774,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         assetId,
         txPointer: "0x00000000000000000000000000000000",
         witnessIndex,
-        predicate: predicate?.bytes,
-        predicateData: predicate?.predicateDataBytes
+        predicate: predicate?.bytes
       };
       this.pushInput(input);
       this.addChangeOutput(owner, assetId);
@@ -39666,8 +39806,7 @@ ${MessageCoinFragmentFragmentDoc}`;
         recipient: recipient.toB256(),
         amount,
         witnessIndex,
-        predicate: predicate?.bytes,
-        predicateData: predicate?.predicateDataBytes
+        predicate: predicate?.bytes
       };
       this.pushInput(input);
       this.addChangeOutput(recipient, assetId);
@@ -39822,12 +39961,6 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @param quantities - CoinQuantity Array.
      */
     fundWithFakeUtxos(quantities, resourcesOwner) {
-      let idCounter = 0;
-      const generateId = () => {
-        const counterString = String(idCounter++);
-        const id = ZeroBytes32.slice(0, -counterString.length).concat(counterString);
-        return id;
-      };
       const findAssetInput = (assetId) => this.inputs.find((input) => {
         if ("assetId" in input) {
           return input.assetId === assetId;
@@ -39837,12 +39970,12 @@ ${MessageCoinFragmentFragmentDoc}`;
       const updateAssetInput = (assetId, quantity) => {
         const assetInput = findAssetInput(assetId);
         if (assetInput && "assetId" in assetInput) {
-          assetInput.id = generateId();
+          assetInput.id = hexlify(randomBytes22(UTXO_ID_LEN));
           assetInput.amount = quantity;
         } else {
           this.addResources([
             {
-              id: generateId(),
+              id: hexlify(randomBytes22(UTXO_ID_LEN)),
               amount: quantity,
               assetId,
               owner: resourcesOwner || Address.fromRandom(),
@@ -40124,6 +40257,7 @@ ${MessageCoinFragmentFragmentDoc}`;
     script;
     /** Script input data (parameters) */
     scriptData;
+    abis;
     /**
      * Constructor for `ScriptTransactionRequest`.
      *
@@ -40134,6 +40268,7 @@ ${MessageCoinFragmentFragmentDoc}`;
       this.gasLimit = bn(gasLimit);
       this.script = arrayify(script ?? returnZeroScript.bytes);
       this.scriptData = arrayify(scriptData ?? returnZeroScript.encodeScriptData());
+      this.abis = rest.abis;
     }
     /**
      * Converts the transaction request to a `TransactionScript`.
@@ -41019,6 +41154,19 @@ ${MessageCoinFragmentFragmentDoc}`;
     return transactionSummary;
   }
 
+  // src/providers/transaction-response/getDecodedLogs.ts
+  function getDecodedLogs(receipts, mainAbi, externalAbis = {}) {
+    return receipts.reduce((logs, receipt) => {
+      if (receipt.type === ReceiptType.LogData || receipt.type === ReceiptType.Log) {
+        const interfaceToUse = new Interface(externalAbis[receipt.id] || mainAbi);
+        const data = receipt.type === ReceiptType.Log ? new BigNumberCoder("u64").encode(receipt.val0) : receipt.data;
+        const [decodedLog] = interfaceToUse.decodeLog(data, receipt.val1.toNumber());
+        logs.push(decodedLog);
+      }
+      return logs;
+    }, []);
+  }
+
   // src/providers/transaction-response/transaction-response.ts
   var TransactionResponse2 = class {
     /** Transaction ID */
@@ -41029,15 +41177,17 @@ ${MessageCoinFragmentFragmentDoc}`;
     gasUsed = bn(0);
     /** The graphql Transaction with receipts object. */
     gqlTransaction;
+    abis;
     /**
      * Constructor for `TransactionResponse`.
      *
      * @param id - The transaction ID.
      * @param provider - The provider.
      */
-    constructor(id, provider) {
+    constructor(id, provider, abis) {
       this.id = id;
       this.provider = provider;
+      this.abis = abis;
     }
     /**
      * Async constructor for `TransactionResponse`. This method can be used to create
@@ -41047,8 +41197,8 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @param id - The transaction ID.
      * @param provider - The provider.
      */
-    static async create(id, provider) {
-      const response = new TransactionResponse2(id, provider);
+    static async create(id, provider, abis) {
+      const response = new TransactionResponse2(id, provider, abis);
       await response.fetch();
       return response;
     }
@@ -41152,6 +41302,26 @@ ${MessageCoinFragmentFragmentDoc}`;
         gqlTransaction: this.gqlTransaction,
         ...transactionSummary
       };
+      let logs = [];
+      if (this.abis) {
+        logs = getDecodedLogs(
+          transactionSummary.receipts,
+          this.abis.main,
+          this.abis.otherContractsAbis
+        );
+        transactionResult.logs = logs;
+      }
+      if (transactionResult.isStatusFailure) {
+        const {
+          receipts,
+          gqlTransaction: { status }
+        } = transactionResult;
+        throw extractTxError({
+          receipts,
+          status,
+          logs
+        });
+      }
       return transactionResult;
     }
     /**
@@ -41160,32 +41330,10 @@ ${MessageCoinFragmentFragmentDoc}`;
      * @param contractsAbiMap - The contracts ABI map.
      */
     async wait(contractsAbiMap) {
-      const result = await this.waitForResult(contractsAbiMap);
-      if (result.isStatusFailure) {
-        throw new FuelError(
-          ErrorCode.TRANSACTION_FAILED,
-          `Transaction failed: ${result.gqlTransaction.status.reason}`
-        );
-      }
-      return result;
+      return this.waitForResult(contractsAbiMap);
     }
   };
 
-  // src/providers/transaction-response/getDecodedLogs.ts
-  function getDecodedLogs(receipts, abiInterface) {
-    return receipts.reduce((logs, r) => {
-      if (r.type === ReceiptType.LogData) {
-        logs.push(abiInterface.decodeLog(r.data, r.val1.toNumber(), r.id)[0]);
-      }
-      if (r.type === ReceiptType.Log) {
-        logs.push(
-          abiInterface.decodeLog(new BigNumberCoder("u64").encode(r.val0), r.val1.toNumber(), r.id)[0]
-        );
-      }
-      return logs;
-    }, []);
-  }
-
   // src/providers/utils/auto-retry-fetch.ts
   function getWaitDelay(options, retryAttemptNum) {
     const duration = options.baseDelay ?? 150;
@@ -41520,6 +41668,10 @@ ${MessageCoinFragmentFragmentDoc}`;
         await this.estimateTxDependencies(transactionRequest);
       }
       const encodedTransaction = hexlify(transactionRequest.toTransactionBytes());
+      let abis;
+      if (transactionRequest.type === TransactionType.Script) {
+        abis = transactionRequest.abis;
+      }
       if (awaitExecution) {
         const subscription = this.operations.submitAndAwait({ encodedTransaction });
         for await (const { submitAndAwait } of subscription) {
@@ -41534,14 +41686,14 @@ ${MessageCoinFragmentFragmentDoc}`;
           }
         }
         const transactionId2 = transactionRequest.getTransactionId(this.getChainId());
-        const response = new TransactionResponse2(transactionId2, this);
+        const response = new TransactionResponse2(transactionId2, this, abis);
         await response.fetch();
         return response;
       }
       const {
         submit: { id: transactionId }
       } = await this.operations.submit({ encodedTransaction });
-      return new TransactionResponse2(transactionId, this);
+      return new TransactionResponse2(transactionId, this, abis);
     }
     /**
      * Executes a transaction without actually submitting it to the chain.
@@ -41649,6 +41801,36 @@ ${MessageCoinFragmentFragmentDoc}`;
         missingContractIds
       };
     }
+    /**
+     * Estimates the transaction gas and fee based on the provided transaction request.
+     * @param transactionRequest - The transaction request object.
+     * @returns An object containing the estimated minimum gas, minimum fee, maximum gas, and maximum fee.
+     */
+    estimateTxGasAndFee(params) {
+      const { transactionRequest } = params;
+      const { gasPriceFactor, minGasPrice, maxGasPerTx } = this.getGasConfig();
+      const chainInfo = this.getChain();
+      const gasPrice = transactionRequest.gasPrice.eq(0) ? minGasPrice : transactionRequest.gasPrice;
+      transactionRequest.gasPrice = gasPrice;
+      const minGas = transactionRequest.calculateMinGas(chainInfo);
+      const minFee = calculatePriceWithFactor(minGas, gasPrice, gasPriceFactor).normalizeZeroToOne();
+      if (transactionRequest.type === TransactionType.Script) {
+        if (transactionRequest.gasLimit.eq(0)) {
+          transactionRequest.gasLimit = minGas;
+          transactionRequest.gasLimit = maxGasPerTx.sub(
+            transactionRequest.calculateMaxGas(chainInfo, minGas)
+          );
+        }
+      }
+      const maxGas = transactionRequest.calculateMaxGas(chainInfo, minGas);
+      const maxFee = calculatePriceWithFactor(maxGas, gasPrice, gasPriceFactor).normalizeZeroToOne();
+      return {
+        minGas,
+        minFee,
+        maxGas,
+        maxFee
+      };
+    }
     /**
      * Executes a signed transaction without applying the states changes
      * on the chain.
@@ -41696,17 +41878,16 @@ ${MessageCoinFragmentFragmentDoc}`;
       signatureCallback
     } = {}) {
       const txRequestClone = clone_default(transactionRequestify(transactionRequestLike));
-      const chainInfo = this.getChain();
-      const { gasPriceFactor, minGasPrice, maxGasPerTx } = this.getGasConfig();
-      const gasPrice = max(txRequestClone.gasPrice, minGasPrice);
+      const { minGasPrice } = this.getGasConfig();
+      const setGasPrice = 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 (isScriptTransaction) {
+        txRequestClone.gasLimit = bn(0);
+      }
       if (estimatePredicates) {
-        if (isScriptTransaction) {
-          txRequestClone.gasLimit = bn(0);
-        }
         if (resourcesOwner && "populateTransactionPredicateData" in resourcesOwner) {
           resourcesOwner.populateTransactionPredicateData(txRequestClone);
         }
@@ -41715,36 +41896,34 @@ ${MessageCoinFragmentFragmentDoc}`;
       if (signatureCallback && isScriptTransaction) {
         await signatureCallback(txRequestClone);
       }
-      const minGas = txRequestClone.calculateMinGas(chainInfo);
-      const maxGas = txRequestClone.calculateMaxGas(chainInfo, minGas);
+      let { maxFee, maxGas, minFee, minGas } = this.estimateTxGasAndFee({
+        transactionRequest: txRequestClone
+      });
       let receipts = [];
       let missingContractIds = [];
       let outputVariables = 0;
+      let gasUsed = bn(0);
       if (isScriptTransaction && estimateTxDependencies) {
         txRequestClone.gasPrice = bn(0);
-        txRequestClone.gasLimit = bn(maxGasPerTx.sub(maxGas).toNumber() * 0.9);
         const result = await this.estimateTxDependencies(txRequestClone);
         receipts = result.receipts;
         outputVariables = result.outputVariables;
         missingContractIds = result.missingContractIds;
+        gasUsed = isScriptTransaction ? getGasUsedFromReceipts(receipts) : gasUsed;
+        txRequestClone.gasLimit = gasUsed;
+        txRequestClone.gasPrice = setGasPrice;
+        ({ maxFee, maxGas, minFee, minGas } = this.estimateTxGasAndFee({
+          transactionRequest: txRequestClone
+        }));
       }
-      const gasUsed = isScriptTransaction ? getGasUsedFromReceipts(receipts) : minGas;
-      const usedFee = calculatePriceWithFactor(
-        gasUsed,
-        gasPrice,
-        gasPriceFactor
-      ).normalizeZeroToOne();
-      const minFee = calculatePriceWithFactor(minGas, gasPrice, gasPriceFactor).normalizeZeroToOne();
-      const maxFee = calculatePriceWithFactor(maxGas, gasPrice, gasPriceFactor).normalizeZeroToOne();
       return {
         requiredQuantities: allQuantities,
         receipts,
         gasUsed,
         minGasPrice,
-        gasPrice,
+        gasPrice: setGasPrice,
         minGas,
         maxGas,
-        usedFee,
         minFee,
         maxFee,
         estimatedInputs: txRequestClone.inputs,
@@ -44198,12 +44377,12 @@ ${MessageCoinFragmentFragmentDoc}`;
   };
 
   // ../../node_modules/.pnpm/uuid@9.0.0/node_modules/uuid/dist/esm-node/rng.js
-  var import_crypto15 = __toESM(__require("crypto"));
+  var import_crypto16 = __toESM(__require("crypto"));
   var rnds8Pool = new Uint8Array(256);
   var poolPtr = rnds8Pool.length;
   function rng() {
     if (poolPtr > rnds8Pool.length - 16) {
-      import_crypto15.default.randomFillSync(rnds8Pool);
+      import_crypto16.default.randomFillSync(rnds8Pool);
       poolPtr = 0;
     }
     return rnds8Pool.slice(poolPtr, poolPtr += 16);
@@ -44219,9 +44398,9 @@ ${MessageCoinFragmentFragmentDoc}`;
   }
 
   // ../../node_modules/.pnpm/uuid@9.0.0/node_modules/uuid/dist/esm-node/native.js
-  var import_crypto16 = __toESM(__require("crypto"));
+  var import_crypto17 = __toESM(__require("crypto"));
   var native_default = {
-    randomUUID: import_crypto16.default.randomUUID
+    randomUUID: import_crypto17.default.randomUUID
   };
 
   // ../../node_modules/.pnpm/uuid@9.0.0/node_modules/uuid/dist/esm-node/v4.js
@@ -47640,7 +47819,6 @@ ${MessageCoinFragmentFragmentDoc}`;
   // src/predicate/predicate.ts
   var Predicate = class extends Account {
     bytes;
-    predicateDataBytes = Uint8Array.from([]);
     predicateData = [];
     interface;
     /**