@fuel-ts/account 0.79.0 → 0.81.0

package/dist/test-utils.mjs

@@ -25,9 +25,9 @@ import { hexlify as hexlify15 } from "@fuel-ts/utils";
 // src/account.ts
 import { Address as Address3 } from "@fuel-ts/address";
 import { BaseAssetId as BaseAssetId3 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode14, FuelError as FuelError14 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode15, FuelError as FuelError15 } from "@fuel-ts/errors";
 import { AbstractAccount } from "@fuel-ts/interfaces";
-import { bn as bn16 } from "@fuel-ts/math";
+import { bn as bn17 } from "@fuel-ts/math";
 import { arrayify as arrayify14 } from "@fuel-ts/utils";
 
 // src/providers/coin-quantity.ts
@@ -68,8 +68,8 @@ var addAmountToAsset = (params) => {
 
 // src/providers/provider.ts
 import { Address as Address2 } from "@fuel-ts/address";
-import { ErrorCode as ErrorCode12, FuelError as FuelError12 } from "@fuel-ts/errors";
-import { BN, bn as bn14, max } from "@fuel-ts/math";
+import { ErrorCode as ErrorCode13, FuelError as FuelError13 } from "@fuel-ts/errors";
+import { BN, bn as bn15, max } from "@fuel-ts/math";
 import {
   InputType as InputType6,
   TransactionType as TransactionType8,
@@ -911,36 +911,45 @@ var _FuelGraphqlSubscriber = class {
     });
     this.stream = response.body.getReader();
   }
+  events = [];
+  parsingLeftover = "";
   async next() {
     if (!this.stream) {
       await this.setStream();
     }
     while (true) {
+      if (this.events.length > 0) {
+        const { data, errors } = this.events.shift();
+        if (Array.isArray(errors)) {
+          throw new FuelError(
+            FuelError.CODES.INVALID_REQUEST,
+            errors.map((err) => err.message).join("\n\n")
+          );
+        }
+        return { value: data, done: false };
+      }
       const { value, done } = await this.stream.read();
       if (done) {
         return { value, done };
       }
-      const text = _FuelGraphqlSubscriber.textDecoder.decode(value);
-      if (!text.startsWith("data:")) {
+      const decoded = _FuelGraphqlSubscriber.textDecoder.decode(value).replace(":keep-alive-text\n\n", "");
+      if (decoded === "") {
         continue;
       }
-      let data;
-      let errors;
-      try {
-        ({ data, errors } = JSON.parse(text.replace(/^data:/, "")));
-      } catch (e) {
-        throw new FuelError(
-          ErrorCode.STREAM_PARSING_ERROR,
-          `Error while parsing stream data response: ${text}`
-        );
-      }
-      if (Array.isArray(errors)) {
-        throw new FuelError(
-          FuelError.CODES.INVALID_REQUEST,
-          errors.map((err) => err.message).join("\n\n")
-        );
-      }
-      return { value: data, done: false };
+      const text = `${this.parsingLeftover}${decoded}`;
+      const regex = /data:.*\n\n/g;
+      const matches = [...text.matchAll(regex)].flatMap((match) => match);
+      matches.forEach((match) => {
+        try {
+          this.events.push(JSON.parse(match.replace(/^data:/, "")));
+        } catch (e) {
+          throw new FuelError(
+            ErrorCode.STREAM_PARSING_ERROR,
+            `Error while parsing stream data response: ${text}`
+          );
+        }
+      });
+      this.parsingLeftover = text.replace(matches.join(), "");
     }
   }
   /**
@@ -1018,6 +1027,7 @@ var MemoryCache = class {
 };
 
 // src/providers/transaction-request/input.ts
+import { BYTES_32, UTXO_ID_LEN } from "@fuel-ts/abi-coder";
 import { ZeroBytes32 } from "@fuel-ts/address/configs";
 import { ErrorCode as ErrorCode3, FuelError as FuelError3 } from "@fuel-ts/errors";
 import { bn as bn2, toNumber } from "@fuel-ts/math";
@@ -1031,8 +1041,8 @@ var inputify = (value) => {
       const predicateData = arrayify(value.predicateData ?? "0x");
       return {
         type: InputType.Coin,
-        txID: hexlify3(arrayify(value.id).slice(0, 32)),
-        outputIndex: arrayify(value.id)[32],
+        txID: hexlify3(arrayify(value.id).slice(0, BYTES_32)),
+        outputIndex: toNumber(arrayify(value.id).slice(BYTES_32, UTXO_ID_LEN)),
         owner: hexlify3(value.owner),
         amount: bn2(value.amount),
         assetId: hexlify3(value.assetId),
@@ -1150,9 +1160,11 @@ var outputify = (value) => {
 };
 
 // src/providers/transaction-request/transaction-request.ts
+import { UTXO_ID_LEN as UTXO_ID_LEN2 } from "@fuel-ts/abi-coder";
 import { Address, addressify } from "@fuel-ts/address";
 import { BaseAssetId as BaseAssetId2, ZeroBytes32 as ZeroBytes324 } from "@fuel-ts/address/configs";
-import { bn as bn6 } from "@fuel-ts/math";
+import { randomBytes } from "@fuel-ts/crypto";
+import { bn as bn7 } from "@fuel-ts/math";
 import {
   PolicyType,
   TransactionCoder,
@@ -1495,6 +1507,86 @@ function sleep(time) {
   });
 }
 
+// src/providers/utils/extract-tx-error.ts
+import { ErrorCode as ErrorCode7, FuelError as FuelError7 } from "@fuel-ts/errors";
+import { bn as bn6 } from "@fuel-ts/math";
+import { ReceiptType as ReceiptType3 } from "@fuel-ts/transactions";
+import {
+  FAILED_REQUIRE_SIGNAL,
+  FAILED_ASSERT_EQ_SIGNAL,
+  FAILED_ASSERT_NE_SIGNAL,
+  FAILED_ASSERT_SIGNAL,
+  FAILED_TRANSFER_TO_ADDRESS_SIGNAL as FAILED_TRANSFER_TO_ADDRESS_SIGNAL2,
+  PANIC_REASONS,
+  PANIC_DOC_URL
+} from "@fuel-ts/transactions/configs";
+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 stringify = (obj) => JSON.stringify(obj, null, 2);
+var assembleRevertError = (receipts, logs) => {
+  let errorMessage = "The transaction reverted with an unknown reason.";
+  const revertReceipt = receipts.find(({ type }) => type === ReceiptType3.Revert);
+  let reason = "";
+  if (revertReceipt) {
+    const reasonHex = bn6(revertReceipt.val).toHex();
+    switch (reasonHex) {
+      case FAILED_REQUIRE_SIGNAL: {
+        reason = "require";
+        errorMessage = `The transaction reverted because a "require" statement has thrown ${logs.length ? stringify(logs[0]) : "an error."}.`;
+        break;
+      }
+      case FAILED_ASSERT_EQ_SIGNAL: {
+        const sufix = logs.length >= 2 ? ` comparing ${stringify(logs[1])} and ${stringify(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 ${stringify(logs[1])} and ${stringify(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_SIGNAL2:
+        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 }) => type === ReceiptType3.Panic);
+  const isRevert = receipts.some(({ type }) => type === ReceiptType3.Revert);
+  const { errorMessage, reason } = status?.type === "FailureStatus" && isPanic ? assemblePanicError(status) : assembleRevertError(receipts, logs);
+  const metadata = {
+    logs,
+    receipts,
+    panic: isPanic,
+    revert: isRevert,
+    reason
+  };
+  return new FuelError7(ErrorCode7.SCRIPT_REVERTED, errorMessage, metadata);
+};
+
 // src/providers/transaction-request/errors.ts
 var NoWitnessAtIndexError = class extends Error {
   constructor(index) {
@@ -1545,10 +1637,10 @@ var BaseTransactionRequest = class {
     outputs,
     witnesses
   } = {}) {
-    this.gasPrice = bn6(gasPrice);
+    this.gasPrice = bn7(gasPrice);
     this.maturity = maturity ?? 0;
-    this.witnessLimit = witnessLimit ? bn6(witnessLimit) : void 0;
-    this.maxFee = maxFee ? bn6(maxFee) : void 0;
+    this.witnessLimit = witnessLimit ? bn7(witnessLimit) : void 0;
+    this.maxFee = maxFee ? bn7(maxFee) : void 0;
     this.inputs = inputs ?? [];
     this.outputs = outputs ?? [];
     this.witnesses = witnesses ?? [];
@@ -1764,8 +1856,7 @@ var BaseTransactionRequest = class {
       assetId,
       txPointer: "0x00000000000000000000000000000000",
       witnessIndex,
-      predicate: predicate?.bytes,
-      predicateData: predicate?.predicateDataBytes
+      predicate: predicate?.bytes
     };
     this.pushInput(input);
     this.addChangeOutput(owner, assetId);
@@ -1797,8 +1888,7 @@ var BaseTransactionRequest = class {
       recipient: recipient.toB256(),
       amount,
       witnessIndex,
-      predicate: predicate?.bytes,
-      predicateData: predicate?.predicateDataBytes
+      predicate: predicate?.bytes
     };
     this.pushInput(input);
     this.addChangeOutput(recipient, assetId);
@@ -1953,12 +2043,6 @@ var BaseTransactionRequest = class {
    * @param quantities - CoinQuantity Array.
    */
   fundWithFakeUtxos(quantities, resourcesOwner) {
-    let idCounter = 0;
-    const generateId = () => {
-      const counterString = String(idCounter++);
-      const id = ZeroBytes324.slice(0, -counterString.length).concat(counterString);
-      return id;
-    };
     const findAssetInput = (assetId) => this.inputs.find((input) => {
       if ("assetId" in input) {
         return input.assetId === assetId;
@@ -1968,23 +2052,23 @@ var BaseTransactionRequest = class {
     const updateAssetInput = (assetId, quantity) => {
       const assetInput = findAssetInput(assetId);
       if (assetInput && "assetId" in assetInput) {
-        assetInput.id = generateId();
+        assetInput.id = hexlify7(randomBytes(UTXO_ID_LEN2));
         assetInput.amount = quantity;
       } else {
         this.addResources([
           {
-            id: generateId(),
+            id: hexlify7(randomBytes(UTXO_ID_LEN2)),
             amount: quantity,
             assetId,
             owner: resourcesOwner || Address.fromRandom(),
             maturity: 0,
-            blockCreated: bn6(1),
-            txCreatedIdx: bn6(1)
+            blockCreated: bn7(1),
+            txCreatedIdx: bn7(1)
           }
         ]);
       }
     };
-    updateAssetInput(BaseAssetId2, bn6(1e11));
+    updateAssetInput(BaseAssetId2, bn7(1e11));
     quantities.forEach((q) => updateAssetInput(q.assetId, q.amount));
   }
   /**
@@ -1995,7 +2079,7 @@ var BaseTransactionRequest = class {
    */
   getCoinOutputsQuantities() {
     const coinsQuantities = this.getCoinOutputs().map(({ amount, assetId }) => ({
-      amount: bn6(amount),
+      amount: bn7(amount),
       assetId: assetId.toString()
     }));
     return coinsQuantities;
@@ -2024,7 +2108,7 @@ var BaseTransactionRequest = class {
         default:
           return;
       }
-      if (correspondingInput && "predicateGasUsed" in correspondingInput && bn6(correspondingInput.predicateGasUsed).gt(0)) {
+      if (correspondingInput && "predicateGasUsed" in correspondingInput && bn7(correspondingInput.predicateGasUsed).gt(0)) {
         i.predicate = correspondingInput.predicate;
         i.predicateData = correspondingInput.predicateData;
         i.predicateGasUsed = correspondingInput.predicateGasUsed;
@@ -2035,14 +2119,14 @@ var BaseTransactionRequest = class {
 
 // src/providers/transaction-request/create-transaction-request.ts
 import { ZeroBytes32 as ZeroBytes326 } from "@fuel-ts/address/configs";
-import { bn as bn8 } from "@fuel-ts/math";
+import { bn as bn9 } from "@fuel-ts/math";
 import { TransactionType as TransactionType3, OutputType as OutputType4 } from "@fuel-ts/transactions";
 import { arrayify as arrayify6, hexlify as hexlify9 } from "@fuel-ts/utils";
 
 // src/providers/transaction-request/hash-transaction.ts
 import { ZeroBytes32 as ZeroBytes325 } from "@fuel-ts/address/configs";
 import { uint64ToBytesBE, sha256 } from "@fuel-ts/hasher";
-import { bn as bn7 } from "@fuel-ts/math";
+import { bn as bn8 } from "@fuel-ts/math";
 import { TransactionType as TransactionType2, InputType as InputType3, OutputType as OutputType3, TransactionCoder as TransactionCoder2 } from "@fuel-ts/transactions";
 import { concat as concat2 } from "@fuel-ts/utils";
 import { clone as clone2 } from "ramda";
@@ -2059,11 +2143,11 @@ function hashTransaction(transactionRequest, chainId) {
           blockHeight: 0,
           txIndex: 0
         };
-        inputClone.predicateGasUsed = bn7(0);
+        inputClone.predicateGasUsed = bn8(0);
         return inputClone;
       }
       case InputType3.Message: {
-        inputClone.predicateGasUsed = bn7(0);
+        inputClone.predicateGasUsed = bn8(0);
         return inputClone;
       }
       case InputType3.Contract: {
@@ -2090,12 +2174,12 @@ function hashTransaction(transactionRequest, chainId) {
         return outputClone;
       }
       case OutputType3.Change: {
-        outputClone.amount = bn7(0);
+        outputClone.amount = bn8(0);
         return outputClone;
       }
       case OutputType3.Variable: {
         outputClone.to = ZeroBytes325;
-        outputClone.amount = bn7(0);
+        outputClone.amount = bn8(0);
         outputClone.assetId = ZeroBytes325;
         return outputClone;
       }
@@ -2219,7 +2303,7 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
   }
   metadataGas(gasCosts) {
     return calculateMetadataGasForTxCreate({
-      contractBytesSize: bn8(arrayify6(this.witnesses[this.bytecodeWitnessIndex] || "0x").length),
+      contractBytesSize: bn9(arrayify6(this.witnesses[this.bytecodeWitnessIndex] || "0x").length),
       gasCosts,
       stateRootSize: this.storageSlots.length,
       txBytesSize: this.byteSize()
@@ -2231,7 +2315,7 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
 import { Interface } from "@fuel-ts/abi-coder";
 import { addressify as addressify2 } from "@fuel-ts/address";
 import { ZeroBytes32 as ZeroBytes327 } from "@fuel-ts/address/configs";
-import { bn as bn9 } from "@fuel-ts/math";
+import { bn as bn10 } from "@fuel-ts/math";
 import { InputType as InputType4, OutputType as OutputType5, TransactionType as TransactionType4 } from "@fuel-ts/transactions";
 import { arrayify as arrayify8, hexlify as hexlify10 } from "@fuel-ts/utils";
 
@@ -2285,7 +2369,7 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
    */
   constructor({ script, scriptData, gasLimit, ...rest } = {}) {
     super(rest);
-    this.gasLimit = bn9(gasLimit);
+    this.gasLimit = bn10(gasLimit);
     this.script = arrayify8(script ?? returnZeroScript.bytes);
     this.scriptData = arrayify8(scriptData ?? returnZeroScript.encodeScriptData());
     this.abis = rest.abis;
@@ -2433,7 +2517,7 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
 };
 
 // src/providers/transaction-request/utils.ts
-import { ErrorCode as ErrorCode7, FuelError as FuelError7 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode8, FuelError as FuelError8 } from "@fuel-ts/errors";
 import { TransactionType as TransactionType5 } from "@fuel-ts/transactions";
 var transactionRequestify = (obj) => {
   if (obj instanceof ScriptTransactionRequest || obj instanceof CreateTransactionRequest) {
@@ -2448,14 +2532,14 @@ var transactionRequestify = (obj) => {
       return CreateTransactionRequest.from(obj);
     }
     default: {
-      throw new FuelError7(ErrorCode7.INVALID_TRANSACTION_TYPE, `Invalid transaction type: ${type}.`);
+      throw new FuelError8(ErrorCode8.INVALID_TRANSACTION_TYPE, `Invalid transaction type: ${type}.`);
     }
   }
 };
 
 // src/providers/transaction-response/transaction-response.ts
-import { ErrorCode as ErrorCode11, FuelError as FuelError11 } from "@fuel-ts/errors";
-import { bn as bn13 } from "@fuel-ts/math";
+import { ErrorCode as ErrorCode12, FuelError as FuelError12 } from "@fuel-ts/errors";
+import { bn as bn14 } from "@fuel-ts/math";
 import { TransactionCoder as TransactionCoder4 } from "@fuel-ts/transactions";
 import { arrayify as arrayify10 } from "@fuel-ts/utils";
 
@@ -2463,7 +2547,7 @@ import { arrayify as arrayify10 } from "@fuel-ts/utils";
 import { DateTime, hexlify as hexlify11 } from "@fuel-ts/utils";
 
 // src/providers/transaction-summary/calculate-transaction-fee.ts
-import { bn as bn10 } from "@fuel-ts/math";
+import { bn as bn11 } from "@fuel-ts/math";
 import { PolicyType as PolicyType2, TransactionCoder as TransactionCoder3, TransactionType as TransactionType6 } from "@fuel-ts/transactions";
 import { arrayify as arrayify9 } from "@fuel-ts/utils";
 var calculateTransactionFee = (params) => {
@@ -2472,24 +2556,24 @@ var calculateTransactionFee = (params) => {
     rawPayload,
     consensusParameters: { gasCosts, feeParams }
   } = params;
-  const gasPerByte = bn10(feeParams.gasPerByte);
-  const gasPriceFactor = bn10(feeParams.gasPriceFactor);
+  const gasPerByte = bn11(feeParams.gasPerByte);
+  const gasPriceFactor = bn11(feeParams.gasPriceFactor);
   const transactionBytes = arrayify9(rawPayload);
   const [transaction] = new TransactionCoder3().decode(transactionBytes, 0);
   if (transaction.type === TransactionType6.Mint) {
     return {
-      fee: bn10(0),
-      minFee: bn10(0),
-      maxFee: bn10(0),
-      feeFromGasUsed: bn10(0)
+      fee: bn11(0),
+      minFee: bn11(0),
+      maxFee: bn11(0),
+      feeFromGasUsed: bn11(0)
     };
   }
   const { type, witnesses, inputs, policies } = transaction;
-  let metadataGas = bn10(0);
-  let gasLimit = bn10(0);
+  let metadataGas = bn11(0);
+  let gasLimit = bn11(0);
   if (type === TransactionType6.Create) {
     const { bytecodeWitnessIndex, storageSlots } = transaction;
-    const contractBytesSize = bn10(arrayify9(witnesses[bytecodeWitnessIndex].data).length);
+    const contractBytesSize = bn11(arrayify9(witnesses[bytecodeWitnessIndex].data).length);
     metadataGas = calculateMetadataGasForTxCreate({
       contractBytesSize,
       gasCosts,
@@ -2508,12 +2592,12 @@ var calculateTransactionFee = (params) => {
   }
   const minGas = getMinGas({
     gasCosts,
-    gasPerByte: bn10(gasPerByte),
+    gasPerByte: bn11(gasPerByte),
     inputs,
     metadataGas,
     txBytesSize: transactionBytes.length
   });
-  const gasPrice = bn10(policies.find((policy) => policy.type === PolicyType2.GasPrice)?.data);
+  const gasPrice = bn11(policies.find((policy) => policy.type === PolicyType2.GasPrice)?.data);
   const witnessLimit = policies.find((policy) => policy.type === PolicyType2.WitnessLimit)?.data;
   const witnessesLength = witnesses.reduce((acc, wit) => acc + wit.dataLength, 0);
   const maxGas = getMaxGas({
@@ -2537,13 +2621,13 @@ var calculateTransactionFee = (params) => {
 
 // src/providers/transaction-summary/operations.ts
 import { ZeroBytes32 as ZeroBytes328 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode9, FuelError as FuelError9 } from "@fuel-ts/errors";
-import { bn as bn12 } from "@fuel-ts/math";
-import { ReceiptType as ReceiptType3, TransactionType as TransactionType7 } from "@fuel-ts/transactions";
+import { ErrorCode as ErrorCode10, FuelError as FuelError10 } from "@fuel-ts/errors";
+import { bn as bn13 } from "@fuel-ts/math";
+import { ReceiptType as ReceiptType4, TransactionType as TransactionType7 } from "@fuel-ts/transactions";
 
 // src/providers/transaction-summary/call.ts
 import { Interface as Interface2, calculateVmTxMemory } from "@fuel-ts/abi-coder";
-import { bn as bn11 } from "@fuel-ts/math";
+import { bn as bn12 } from "@fuel-ts/math";
 var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
   const abiInterface = new Interface2(abi);
   const callFunctionSelector = receipt.param1.toHex(8);
@@ -2552,7 +2636,7 @@ var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
   let encodedArgs;
   if (functionFragment.isInputDataPointer) {
     if (rawPayload) {
-      const argsOffset = bn11(receipt.param2).sub(calculateVmTxMemory({ maxInputs: maxInputs.toNumber() })).toNumber();
+      const argsOffset = bn12(receipt.param2).sub(calculateVmTxMemory({ maxInputs: maxInputs.toNumber() })).toNumber();
       encodedArgs = `0x${rawPayload.slice(2).slice(argsOffset * 2)}`;
     }
   } else {
@@ -2586,7 +2670,7 @@ var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
 };
 
 // src/providers/transaction-summary/input.ts
-import { ErrorCode as ErrorCode8, FuelError as FuelError8 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode9, FuelError as FuelError9 } from "@fuel-ts/errors";
 import { InputType as InputType5 } from "@fuel-ts/transactions";
 function getInputsByTypes(inputs, types) {
   return inputs.filter((i) => types.includes(i.type));
@@ -2624,8 +2708,8 @@ function getInputContractFromIndex(inputs, inputIndex) {
     return void 0;
   }
   if (contractInput.type !== InputType5.Contract) {
-    throw new FuelError8(
-      ErrorCode8.INVALID_TRANSACTION_INPUT,
+    throw new FuelError9(
+      ErrorCode9.INVALID_TRANSACTION_INPUT,
       `Contract input should be of type 'contract'.`
     );
   }
@@ -2672,8 +2756,8 @@ function getTransactionTypeName(transactionType) {
     case TransactionType7.Script:
       return "Script" /* Script */;
     default:
-      throw new FuelError9(
-        ErrorCode9.INVALID_TRANSACTION_TYPE,
+      throw new FuelError10(
+        ErrorCode10.INVALID_TRANSACTION_TYPE,
         `Invalid transaction type: ${transactionType}.`
       );
   }
@@ -2692,10 +2776,10 @@ function isTypeScript(transactionType) {
   return isType(transactionType, "Script" /* Script */);
 }
 function getReceiptsCall(receipts) {
-  return getReceiptsByType(receipts, ReceiptType3.Call);
+  return getReceiptsByType(receipts, ReceiptType4.Call);
 }
 function getReceiptsMessageOut(receipts) {
-  return getReceiptsByType(receipts, ReceiptType3.MessageOut);
+  return getReceiptsByType(receipts, ReceiptType4.MessageOut);
 }
 var mergeAssets = (op1, op2) => {
   const assets1 = op1.assetsSent || [];
@@ -2708,7 +2792,7 @@ var mergeAssets = (op1, op2) => {
     if (!matchingAsset) {
       return asset1;
     }
-    const mergedAmount = bn12(asset1.amount).add(matchingAsset.amount);
+    const mergedAmount = bn13(asset1.amount).add(matchingAsset.amount);
     return { ...asset1, amount: mergedAmount };
   });
   return mergedAssets.concat(filteredAssets);
@@ -2891,11 +2975,11 @@ function getTransferOperations({
   });
   const transferReceipts = getReceiptsByType(
     receipts,
-    ReceiptType3.Transfer
+    ReceiptType4.Transfer
   );
   const transferOutReceipts = getReceiptsByType(
     receipts,
-    ReceiptType3.TransferOut
+    ReceiptType4.TransferOut
   );
   [...transferReceipts, ...transferOutReceipts].forEach((receipt) => {
     const operation = extractTransferOperationFromReceipt(receipt, contractInputs, changeOutputs);
@@ -2980,17 +3064,17 @@ function getOperations({
 }
 
 // src/providers/transaction-summary/receipt.ts
-import { ReceiptType as ReceiptType4 } from "@fuel-ts/transactions";
+import { ReceiptType as ReceiptType5 } from "@fuel-ts/transactions";
 var processGqlReceipt = (gqlReceipt) => {
   const receipt = assembleReceiptByType(gqlReceipt);
   switch (receipt.type) {
-    case ReceiptType4.ReturnData: {
+    case ReceiptType5.ReturnData: {
       return {
         ...receipt,
         data: gqlReceipt.data || "0x"
       };
     }
-    case ReceiptType4.LogData: {
+    case ReceiptType5.LogData: {
       return {
         ...receipt,
         data: gqlReceipt.data || "0x"
@@ -3003,7 +3087,7 @@ var processGqlReceipt = (gqlReceipt) => {
 var extractMintedAssetsFromReceipts = (receipts) => {
   const mintedAssets = [];
   receipts.forEach((receipt) => {
-    if (receipt.type === ReceiptType4.Mint) {
+    if (receipt.type === ReceiptType5.Mint) {
       mintedAssets.push({
         subId: receipt.subId,
         contractId: receipt.contractId,
@@ -3017,7 +3101,7 @@ var extractMintedAssetsFromReceipts = (receipts) => {
 var extractBurnedAssetsFromReceipts = (receipts) => {
   const burnedAssets = [];
   receipts.forEach((receipt) => {
-    if (receipt.type === ReceiptType4.Burn) {
+    if (receipt.type === ReceiptType5.Burn) {
       burnedAssets.push({
         subId: receipt.subId,
         contractId: receipt.contractId,
@@ -3030,7 +3114,7 @@ var extractBurnedAssetsFromReceipts = (receipts) => {
 };
 
 // src/providers/transaction-summary/status.ts
-import { ErrorCode as ErrorCode10, FuelError as FuelError10 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode11, FuelError as FuelError11 } from "@fuel-ts/errors";
 var getTransactionStatusName = (gqlStatus) => {
   switch (gqlStatus) {
     case "FailureStatus":
@@ -3042,8 +3126,8 @@ var getTransactionStatusName = (gqlStatus) => {
     case "SqueezedOutStatus":
       return "squeezedout" /* squeezedout */;
     default:
-      throw new FuelError10(
-        ErrorCode10.INVALID_TRANSACTION_STATUS,
+      throw new FuelError11(
+        ErrorCode11.INVALID_TRANSACTION_STATUS,
         `Invalid transaction status: ${gqlStatus}.`
       );
   }
@@ -3156,12 +3240,12 @@ function assembleTransactionSummary(params) {
 
 // src/providers/transaction-response/getDecodedLogs.ts
 import { Interface as Interface3, BigNumberCoder } from "@fuel-ts/abi-coder";
-import { ReceiptType as ReceiptType5 } from "@fuel-ts/transactions";
+import { ReceiptType as ReceiptType6 } from "@fuel-ts/transactions";
 function getDecodedLogs(receipts, mainAbi, externalAbis = {}) {
   return receipts.reduce((logs, receipt) => {
-    if (receipt.type === ReceiptType5.LogData || receipt.type === ReceiptType5.Log) {
+    if (receipt.type === ReceiptType6.LogData || receipt.type === ReceiptType6.Log) {
       const interfaceToUse = new Interface3(externalAbis[receipt.id] || mainAbi);
-      const data = receipt.type === ReceiptType5.Log ? new BigNumberCoder("u64").encode(receipt.val0) : receipt.data;
+      const data = receipt.type === ReceiptType6.Log ? new BigNumberCoder("u64").encode(receipt.val0) : receipt.data;
       const [decodedLog] = interfaceToUse.decodeLog(data, receipt.val1.toNumber());
       logs.push(decodedLog);
     }
@@ -3176,7 +3260,7 @@ var TransactionResponse = class {
   /** Current provider */
   provider;
   /** Gas used on the transaction */
-  gasUsed = bn13(0);
+  gasUsed = bn14(0);
   /** The graphql Transaction with receipts object. */
   gqlTransaction;
   abis;
@@ -3281,8 +3365,8 @@ var TransactionResponse = class {
     });
     for await (const { statusChange } of subscription) {
       if (statusChange.type === "SqueezedOutStatus") {
-        throw new FuelError11(
-          ErrorCode11.TRANSACTION_SQUEEZED_OUT,
+        throw new FuelError12(
+          ErrorCode12.TRANSACTION_SQUEEZED_OUT,
           `Transaction Squeezed Out with reason: ${statusChange.reason}`
         );
       }
@@ -3304,14 +3388,26 @@ var TransactionResponse = class {
       gqlTransaction: this.gqlTransaction,
       ...transactionSummary
     };
+    let logs = [];
     if (this.abis) {
-      const logs = getDecodedLogs(
+      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;
   }
   /**
@@ -3320,14 +3416,7 @@ var TransactionResponse = class {
    * @param contractsAbiMap - The contracts ABI map.
    */
   async wait(contractsAbiMap) {
-    const result = await this.waitForResult(contractsAbiMap);
-    if (result.isStatusFailure) {
-      throw new FuelError11(
-        ErrorCode11.TRANSACTION_FAILED,
-        `Transaction failed: ${result.gqlTransaction.status.reason}`
-      );
-    }
-    return result;
+    return this.waitForResult(contractsAbiMap);
   }
 };
 
@@ -3389,29 +3478,29 @@ var processGqlChain = (chain) => {
   const { contractParams, feeParams, predicateParams, scriptParams, txParams, gasCosts } = consensusParameters;
   return {
     name,
-    baseChainHeight: bn14(daHeight),
+    baseChainHeight: bn15(daHeight),
     consensusParameters: {
-      contractMaxSize: bn14(contractParams.contractMaxSize),
-      maxInputs: bn14(txParams.maxInputs),
-      maxOutputs: bn14(txParams.maxOutputs),
-      maxWitnesses: bn14(txParams.maxWitnesses),
-      maxGasPerTx: bn14(txParams.maxGasPerTx),
-      maxScriptLength: bn14(scriptParams.maxScriptLength),
-      maxScriptDataLength: bn14(scriptParams.maxScriptDataLength),
-      maxStorageSlots: bn14(contractParams.maxStorageSlots),
-      maxPredicateLength: bn14(predicateParams.maxPredicateLength),
-      maxPredicateDataLength: bn14(predicateParams.maxPredicateDataLength),
-      maxGasPerPredicate: bn14(predicateParams.maxGasPerPredicate),
-      gasPriceFactor: bn14(feeParams.gasPriceFactor),
-      gasPerByte: bn14(feeParams.gasPerByte),
-      maxMessageDataLength: bn14(predicateParams.maxMessageDataLength),
-      chainId: bn14(consensusParameters.chainId),
+      contractMaxSize: bn15(contractParams.contractMaxSize),
+      maxInputs: bn15(txParams.maxInputs),
+      maxOutputs: bn15(txParams.maxOutputs),
+      maxWitnesses: bn15(txParams.maxWitnesses),
+      maxGasPerTx: bn15(txParams.maxGasPerTx),
+      maxScriptLength: bn15(scriptParams.maxScriptLength),
+      maxScriptDataLength: bn15(scriptParams.maxScriptDataLength),
+      maxStorageSlots: bn15(contractParams.maxStorageSlots),
+      maxPredicateLength: bn15(predicateParams.maxPredicateLength),
+      maxPredicateDataLength: bn15(predicateParams.maxPredicateDataLength),
+      maxGasPerPredicate: bn15(predicateParams.maxGasPerPredicate),
+      gasPriceFactor: bn15(feeParams.gasPriceFactor),
+      gasPerByte: bn15(feeParams.gasPerByte),
+      maxMessageDataLength: bn15(predicateParams.maxMessageDataLength),
+      chainId: bn15(consensusParameters.chainId),
       gasCosts
     },
     gasCosts,
     latestBlock: {
       id: latestBlock.id,
-      height: bn14(latestBlock.header.height),
+      height: bn15(latestBlock.header.height),
       time: latestBlock.header.time,
       transactions: latestBlock.transactions.map((i) => ({
         id: i.id
@@ -3481,8 +3570,8 @@ var _Provider = class {
   getChain() {
     const chain = _Provider.chainInfoCache[this.url];
     if (!chain) {
-      throw new FuelError12(
-        ErrorCode12.CHAIN_INFO_CACHE_EMPTY,
+      throw new FuelError13(
+        ErrorCode13.CHAIN_INFO_CACHE_EMPTY,
         "Chain info cache is empty. Make sure you have called `Provider.create` to initialize the provider."
       );
     }
@@ -3494,8 +3583,8 @@ var _Provider = class {
   getNode() {
     const node = _Provider.nodeInfoCache[this.url];
     if (!node) {
-      throw new FuelError12(
-        ErrorCode12.NODE_INFO_CACHE_EMPTY,
+      throw new FuelError13(
+        ErrorCode13.NODE_INFO_CACHE_EMPTY,
         "Node info cache is empty. Make sure you have called `Provider.create` to initialize the provider."
       );
     }
@@ -3542,8 +3631,8 @@ var _Provider = class {
   static ensureClientVersionIsSupported(nodeInfo) {
     const { isMajorSupported, isMinorSupported, supportedVersion } = checkFuelCoreVersionCompatibility(nodeInfo.nodeVersion);
     if (!isMajorSupported || !isMinorSupported) {
-      throw new FuelError12(
-        FuelError12.CODES.UNSUPPORTED_FUEL_CLIENT_VERSION,
+      throw new FuelError13(
+        FuelError13.CODES.UNSUPPORTED_FUEL_CLIENT_VERSION,
         `Fuel client version: ${nodeInfo.nodeVersion}, Supported version: ${supportedVersion}`
       );
     }
@@ -3606,7 +3695,7 @@ var _Provider = class {
    */
   async getBlockNumber() {
     const { chain } = await this.operations.getChain();
-    return bn14(chain.latestBlock.header.height, 10);
+    return bn15(chain.latestBlock.header.height, 10);
   }
   /**
    * Returns the chain information.
@@ -3616,9 +3705,9 @@ var _Provider = class {
   async fetchNode() {
     const { nodeInfo } = await this.operations.getNodeInfo();
     const processedNodeInfo = {
-      maxDepth: bn14(nodeInfo.maxDepth),
-      maxTx: bn14(nodeInfo.maxTx),
-      minGasPrice: bn14(nodeInfo.minGasPrice),
+      maxDepth: bn15(nodeInfo.maxDepth),
+      maxTx: bn15(nodeInfo.maxTx),
+      minGasPrice: bn15(nodeInfo.minGasPrice),
       nodeVersion: nodeInfo.nodeVersion,
       utxoValidation: nodeInfo.utxoValidation,
       vmBacktrace: nodeInfo.vmBacktrace,
@@ -3673,8 +3762,8 @@ var _Provider = class {
       const subscription = this.operations.submitAndAwait({ encodedTransaction });
       for await (const { submitAndAwait } of subscription) {
         if (submitAndAwait.type === "SqueezedOutStatus") {
-          throw new FuelError12(
-            ErrorCode12.TRANSACTION_SQUEEZED_OUT,
+          throw new FuelError13(
+            ErrorCode13.TRANSACTION_SQUEEZED_OUT,
             `Transaction Squeezed Out with reason: ${submitAndAwait.reason}`
           );
         }
@@ -3741,7 +3830,7 @@ var _Provider = class {
     } = response;
     if (inputs) {
       inputs.forEach((input, index) => {
-        if ("predicateGasUsed" in input && bn14(input.predicateGasUsed).gt(0)) {
+        if ("predicateGasUsed" in input && bn15(input.predicateGasUsed).gt(0)) {
           transactionRequest.inputs[index].predicateGasUsed = input.predicateGasUsed;
         }
       });
@@ -3798,6 +3887,36 @@ var _Provider = class {
       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 === TransactionType8.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.
@@ -3845,17 +3964,16 @@ var _Provider = class {
     signatureCallback
   } = {}) {
     const txRequestClone = clone3(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 === TransactionType8.Script;
     const coinOutputsQuantities = txRequestClone.getCoinOutputsQuantities();
     const allQuantities = mergeQuantities(coinOutputsQuantities, forwardingQuantities);
     txRequestClone.fundWithFakeUtxos(allQuantities, resourcesOwner?.address);
+    if (isScriptTransaction) {
+      txRequestClone.gasLimit = bn15(0);
+    }
     if (estimatePredicates) {
-      if (isScriptTransaction) {
-        txRequestClone.gasLimit = bn14(0);
-      }
       if (resourcesOwner && "populateTransactionPredicateData" in resourcesOwner) {
         resourcesOwner.populateTransactionPredicateData(txRequestClone);
       }
@@ -3864,36 +3982,34 @@ var _Provider = class {
     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 = bn15(0);
     if (isScriptTransaction && estimateTxDependencies) {
-      txRequestClone.gasPrice = bn14(0);
-      txRequestClone.gasLimit = bn14(maxGasPerTx.sub(maxGas).toNumber() * 0.9);
+      txRequestClone.gasPrice = bn15(0);
       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,
@@ -3933,11 +4049,11 @@ var _Provider = class {
     return coins.map((coin) => ({
       id: coin.utxoId,
       assetId: coin.assetId,
-      amount: bn14(coin.amount),
+      amount: bn15(coin.amount),
       owner: Address2.fromAddressOrString(coin.owner),
-      maturity: bn14(coin.maturity).toNumber(),
-      blockCreated: bn14(coin.blockCreated),
-      txCreatedIdx: bn14(coin.txCreatedIdx)
+      maturity: bn15(coin.maturity).toNumber(),
+      blockCreated: bn15(coin.blockCreated),
+      txCreatedIdx: bn15(coin.txCreatedIdx)
     }));
   }
   /**
@@ -3974,9 +4090,9 @@ var _Provider = class {
       switch (coin.__typename) {
         case "MessageCoin":
           return {
-            amount: bn14(coin.amount),
+            amount: bn15(coin.amount),
             assetId: coin.assetId,
-            daHeight: bn14(coin.daHeight),
+            daHeight: bn15(coin.daHeight),
             sender: Address2.fromAddressOrString(coin.sender),
             recipient: Address2.fromAddressOrString(coin.recipient),
             nonce: coin.nonce
@@ -3984,12 +4100,12 @@ var _Provider = class {
         case "Coin":
           return {
             id: coin.utxoId,
-            amount: bn14(coin.amount),
+            amount: bn15(coin.amount),
             assetId: coin.assetId,
             owner: Address2.fromAddressOrString(coin.owner),
-            maturity: bn14(coin.maturity).toNumber(),
-            blockCreated: bn14(coin.blockCreated),
-            txCreatedIdx: bn14(coin.txCreatedIdx)
+            maturity: bn15(coin.maturity).toNumber(),
+            blockCreated: bn15(coin.blockCreated),
+            txCreatedIdx: bn15(coin.txCreatedIdx)
           };
         default:
           return null;
@@ -4006,13 +4122,13 @@ var _Provider = class {
   async getBlock(idOrHeight) {
     let variables;
     if (typeof idOrHeight === "number") {
-      variables = { height: bn14(idOrHeight).toString(10) };
+      variables = { height: bn15(idOrHeight).toString(10) };
     } else if (idOrHeight === "latest") {
       variables = { height: (await this.getBlockNumber()).toString(10) };
     } else if (idOrHeight.length === 66) {
       variables = { blockId: idOrHeight };
     } else {
-      variables = { blockId: bn14(idOrHeight).toString(10) };
+      variables = { blockId: bn15(idOrHeight).toString(10) };
     }
     const { block } = await this.operations.getBlock(variables);
     if (!block) {
@@ -4020,7 +4136,7 @@ var _Provider = class {
     }
     return {
       id: block.id,
-      height: bn14(block.header.height),
+      height: bn15(block.header.height),
       time: block.header.time,
       transactionIds: block.transactions.map((tx) => tx.id)
     };
@@ -4035,7 +4151,7 @@ var _Provider = class {
     const { blocks: fetchedData } = await this.operations.getBlocks(params);
     const blocks = fetchedData.edges.map(({ node: block }) => ({
       id: block.id,
-      height: bn14(block.header.height),
+      height: bn15(block.header.height),
       time: block.header.time,
       transactionIds: block.transactions.map((tx) => tx.id)
     }));
@@ -4050,7 +4166,7 @@ var _Provider = class {
   async getBlockWithTransactions(idOrHeight) {
     let variables;
     if (typeof idOrHeight === "number") {
-      variables = { blockHeight: bn14(idOrHeight).toString(10) };
+      variables = { blockHeight: bn15(idOrHeight).toString(10) };
     } else if (idOrHeight === "latest") {
       variables = { blockHeight: (await this.getBlockNumber()).toString() };
     } else {
@@ -4062,7 +4178,7 @@ var _Provider = class {
     }
     return {
       id: block.id,
-      height: bn14(block.header.height, 10),
+      height: bn15(block.header.height, 10),
       time: block.header.time,
       transactionIds: block.transactions.map((tx) => tx.id),
       transactions: block.transactions.map(
@@ -4111,7 +4227,7 @@ var _Provider = class {
       contract: Address2.fromAddressOrString(contractId).toB256(),
       asset: hexlify12(assetId)
     });
-    return bn14(contractBalance.amount, 10);
+    return bn15(contractBalance.amount, 10);
   }
   /**
    * Returns the balance for the given owner for the given asset ID.
@@ -4125,7 +4241,7 @@ var _Provider = class {
       owner: Address2.fromAddressOrString(owner).toB256(),
       assetId: hexlify12(assetId)
     });
-    return bn14(balance.amount, 10);
+    return bn15(balance.amount, 10);
   }
   /**
    * Returns balances for the given owner.
@@ -4143,7 +4259,7 @@ var _Provider = class {
     const balances = result.balances.edges.map((edge) => edge.node);
     return balances.map((balance) => ({
       assetId: balance.assetId,
-      amount: bn14(balance.amount)
+      amount: bn15(balance.amount)
     }));
   }
   /**
@@ -4165,15 +4281,15 @@ var _Provider = class {
         sender: message.sender,
         recipient: message.recipient,
         nonce: message.nonce,
-        amount: bn14(message.amount),
+        amount: bn15(message.amount),
         data: message.data
       }),
       sender: Address2.fromAddressOrString(message.sender),
       recipient: Address2.fromAddressOrString(message.recipient),
       nonce: message.nonce,
-      amount: bn14(message.amount),
+      amount: bn15(message.amount),
       data: InputMessageCoder.decodeData(message.data),
-      daHeight: bn14(message.daHeight)
+      daHeight: bn15(message.daHeight)
     }));
   }
   /**
@@ -4191,8 +4307,8 @@ var _Provider = class {
       nonce
     };
     if (commitBlockId && commitBlockHeight) {
-      throw new FuelError12(
-        ErrorCode12.INVALID_INPUT_PARAMETERS,
+      throw new FuelError13(
+        ErrorCode13.INVALID_INPUT_PARAMETERS,
         "commitBlockId and commitBlockHeight cannot be used together"
       );
     }
@@ -4226,41 +4342,41 @@ var _Provider = class {
     } = result.messageProof;
     return {
       messageProof: {
-        proofIndex: bn14(messageProof.proofIndex),
+        proofIndex: bn15(messageProof.proofIndex),
         proofSet: messageProof.proofSet
       },
       blockProof: {
-        proofIndex: bn14(blockProof.proofIndex),
+        proofIndex: bn15(blockProof.proofIndex),
         proofSet: blockProof.proofSet
       },
       messageBlockHeader: {
         id: messageBlockHeader.id,
-        daHeight: bn14(messageBlockHeader.daHeight),
-        transactionsCount: bn14(messageBlockHeader.transactionsCount),
+        daHeight: bn15(messageBlockHeader.daHeight),
+        transactionsCount: bn15(messageBlockHeader.transactionsCount),
         transactionsRoot: messageBlockHeader.transactionsRoot,
-        height: bn14(messageBlockHeader.height),
+        height: bn15(messageBlockHeader.height),
         prevRoot: messageBlockHeader.prevRoot,
         time: messageBlockHeader.time,
         applicationHash: messageBlockHeader.applicationHash,
         messageReceiptRoot: messageBlockHeader.messageReceiptRoot,
-        messageReceiptCount: bn14(messageBlockHeader.messageReceiptCount)
+        messageReceiptCount: bn15(messageBlockHeader.messageReceiptCount)
       },
       commitBlockHeader: {
         id: commitBlockHeader.id,
-        daHeight: bn14(commitBlockHeader.daHeight),
-        transactionsCount: bn14(commitBlockHeader.transactionsCount),
+        daHeight: bn15(commitBlockHeader.daHeight),
+        transactionsCount: bn15(commitBlockHeader.transactionsCount),
         transactionsRoot: commitBlockHeader.transactionsRoot,
-        height: bn14(commitBlockHeader.height),
+        height: bn15(commitBlockHeader.height),
         prevRoot: commitBlockHeader.prevRoot,
         time: commitBlockHeader.time,
         applicationHash: commitBlockHeader.applicationHash,
         messageReceiptRoot: commitBlockHeader.messageReceiptRoot,
-        messageReceiptCount: bn14(commitBlockHeader.messageReceiptCount)
+        messageReceiptCount: bn15(commitBlockHeader.messageReceiptCount)
       },
       sender: Address2.fromAddressOrString(sender),
       recipient: Address2.fromAddressOrString(recipient),
       nonce,
-      amount: bn14(amount),
+      amount: bn15(amount),
       data
     };
   }
@@ -4283,10 +4399,10 @@ var _Provider = class {
    */
   async produceBlocks(amount, startTime) {
     const { produceBlocks: latestBlockHeight } = await this.operations.produceBlocks({
-      blocksToProduce: bn14(amount).toString(10),
+      blocksToProduce: bn15(amount).toString(10),
       startTimestamp: startTime ? DateTime2.fromUnixMilliseconds(startTime).toTai64() : void 0
     });
-    return bn14(latestBlockHeight);
+    return bn15(latestBlockHeight);
   }
   // eslint-disable-next-line @typescript-eslint/require-await
   async getTransactionResponse(transactionId) {
@@ -4309,8 +4425,8 @@ __publicField(Provider, "chainInfoCache", {});
 __publicField(Provider, "nodeInfoCache", {});
 
 // src/providers/transaction-summary/get-transaction-summary.ts
-import { ErrorCode as ErrorCode13, FuelError as FuelError13 } from "@fuel-ts/errors";
-import { bn as bn15 } from "@fuel-ts/math";
+import { ErrorCode as ErrorCode14, FuelError as FuelError14 } from "@fuel-ts/errors";
+import { bn as bn16 } from "@fuel-ts/math";
 import { TransactionCoder as TransactionCoder6 } from "@fuel-ts/transactions";
 import { arrayify as arrayify12 } from "@fuel-ts/utils";
 
@@ -4427,7 +4543,7 @@ var Account = class extends AbstractAccount {
    */
   get provider() {
     if (!this._provider) {
-      throw new FuelError14(ErrorCode14.MISSING_PROVIDER, "Provider not set");
+      throw new FuelError15(ErrorCode15.MISSING_PROVIDER, "Provider not set");
     }
     return this._provider;
   }
@@ -4479,8 +4595,8 @@ var Account = class extends AbstractAccount {
       if (!hasNextPage) {
         break;
       }
-      throw new FuelError14(
-        ErrorCode14.NOT_SUPPORTED,
+      throw new FuelError15(
+        ErrorCode15.NOT_SUPPORTED,
         `Wallets containing more than ${pageSize} coins exceed the current supported limit.`
       );
     }
@@ -4505,8 +4621,8 @@ var Account = class extends AbstractAccount {
       if (!hasNextPage) {
         break;
       }
-      throw new FuelError14(
-        ErrorCode14.NOT_SUPPORTED,
+      throw new FuelError15(
+        ErrorCode15.NOT_SUPPORTED,
         `Wallets containing more than ${pageSize} messages exceed the current supported limit.`
       );
     }
@@ -4541,8 +4657,8 @@ var Account = class extends AbstractAccount {
       if (!hasNextPage) {
         break;
       }
-      throw new FuelError14(
-        ErrorCode14.NOT_SUPPORTED,
+      throw new FuelError15(
+        ErrorCode15.NOT_SUPPORTED,
         `Wallets containing more than ${pageSize} balances exceed the current supported limit.`
       );
     }
@@ -4558,7 +4674,7 @@ var Account = class extends AbstractAccount {
    */
   async fund(request, coinQuantities, fee) {
     const updatedQuantities = addAmountToAsset({
-      amount: bn16(fee),
+      amount: bn17(fee),
       assetId: BaseAssetId3,
       coinQuantities
     });
@@ -4566,7 +4682,7 @@ var Account = class extends AbstractAccount {
     updatedQuantities.forEach(({ amount, assetId }) => {
       quantitiesDict[assetId] = {
         required: amount,
-        owned: bn16(0)
+        owned: bn17(0)
       };
     });
     const cachedUtxos = [];
@@ -4579,7 +4695,7 @@ var Account = class extends AbstractAccount {
         if (isCoin2) {
           const assetId = String(input.assetId);
           if (input.owner === owner && quantitiesDict[assetId]) {
-            const amount = bn16(input.amount);
+            const amount = bn17(input.amount);
             quantitiesDict[assetId].owned = quantitiesDict[assetId].owned.add(amount);
             cachedUtxos.push(input.id);
           }
@@ -4625,8 +4741,8 @@ var Account = class extends AbstractAccount {
       estimateTxDependencies: true,
       resourcesOwner: this
     });
-    request.gasPrice = bn16(txParams.gasPrice ?? minGasPrice);
-    request.gasLimit = bn16(txParams.gasLimit ?? gasUsed);
+    request.gasPrice = bn17(txParams.gasPrice ?? minGasPrice);
+    request.gasLimit = bn17(txParams.gasLimit ?? gasUsed);
     this.validateGas({
       gasUsed,
       gasPrice: request.gasPrice,
@@ -4647,9 +4763,9 @@ var Account = class extends AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async transfer(destination, amount, assetId = BaseAssetId3, txParams = {}) {
-    if (bn16(amount).lte(0)) {
-      throw new FuelError14(
-        ErrorCode14.INVALID_TRANSFER_AMOUNT,
+    if (bn17(amount).lte(0)) {
+      throw new FuelError15(
+        ErrorCode15.INVALID_TRANSFER_AMOUNT,
         "Transfer amount must be a positive number."
       );
     }
@@ -4666,9 +4782,9 @@ var Account = class extends AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async transferToContract(contractId, amount, assetId = BaseAssetId3, txParams = {}) {
-    if (bn16(amount).lte(0)) {
-      throw new FuelError14(
-        ErrorCode14.INVALID_TRANSFER_AMOUNT,
+    if (bn17(amount).lte(0)) {
+      throw new FuelError15(
+        ErrorCode15.INVALID_TRANSFER_AMOUNT,
         "Transfer amount must be a positive number."
       );
     }
@@ -4677,7 +4793,7 @@ var Account = class extends AbstractAccount {
     const params = { gasPrice: minGasPrice, ...txParams };
     const { script, scriptData } = await assembleTransferToContractScript({
       hexlifiedContractId: contractAddress.toB256(),
-      amountToTransfer: bn16(amount),
+      amountToTransfer: bn17(amount),
       assetId
     });
     const request = new ScriptTransactionRequest({
@@ -4688,9 +4804,9 @@ var Account = class extends AbstractAccount {
     request.addContractInputAndOutput(contractAddress);
     const { maxFee, requiredQuantities, gasUsed } = await this.provider.getTransactionCost(
       request,
-      [{ amount: bn16(amount), assetId: String(assetId) }]
+      [{ amount: bn17(amount), assetId: String(assetId) }]
     );
-    request.gasLimit = bn16(params.gasLimit ?? gasUsed);
+    request.gasLimit = bn17(params.gasLimit ?? gasUsed);
     this.validateGas({
       gasUsed,
       gasPrice: request.gasPrice,
@@ -4715,7 +4831,7 @@ var Account = class extends AbstractAccount {
       "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
     );
     const amountDataArray = arrayify14(
-      "0x".concat(bn16(amount).toHex().substring(2).padStart(16, "0"))
+      "0x".concat(bn17(amount).toHex().substring(2).padStart(16, "0"))
     );
     const script = new Uint8Array([
       ...arrayify14(withdrawScript.bytes),
@@ -4724,12 +4840,12 @@ var Account = class extends AbstractAccount {
     ]);
     const params = { script, gasPrice: minGasPrice, ...txParams };
     const request = new ScriptTransactionRequest(params);
-    const forwardingQuantities = [{ amount: bn16(amount), assetId: BaseAssetId3 }];
+    const forwardingQuantities = [{ amount: bn17(amount), assetId: BaseAssetId3 }];
     const { requiredQuantities, maxFee, gasUsed } = await this.provider.getTransactionCost(
       request,
       forwardingQuantities
     );
-    request.gasLimit = bn16(params.gasLimit ?? gasUsed);
+    request.gasLimit = bn17(params.gasLimit ?? gasUsed);
     this.validateGas({
       gasUsed,
       gasPrice: request.gasPrice,
@@ -4741,7 +4857,7 @@ var Account = class extends AbstractAccount {
   }
   async signMessage(message) {
     if (!this._connector) {
-      throw new FuelError14(ErrorCode14.MISSING_CONNECTOR, "A connector is required to sign messages.");
+      throw new FuelError15(ErrorCode15.MISSING_CONNECTOR, "A connector is required to sign messages.");
     }
     return this._connector.signMessage(this.address.toString(), message);
   }
@@ -4753,8 +4869,8 @@ var Account = class extends AbstractAccount {
    */
   async signTransaction(transactionRequestLike) {
     if (!this._connector) {
-      throw new FuelError14(
-        ErrorCode14.MISSING_CONNECTOR,
+      throw new FuelError15(
+        ErrorCode15.MISSING_CONNECTOR,
         "A connector is required to sign transactions."
       );
     }
@@ -4801,14 +4917,14 @@ var Account = class extends AbstractAccount {
     minGasPrice
   }) {
     if (minGasPrice.gt(gasPrice)) {
-      throw new FuelError14(
-        ErrorCode14.GAS_PRICE_TOO_LOW,
+      throw new FuelError15(
+        ErrorCode15.GAS_PRICE_TOO_LOW,
         `Gas price '${gasPrice}' is lower than the required: '${minGasPrice}'.`
       );
     }
     if (gasUsed.gt(gasLimit)) {
-      throw new FuelError14(
-        ErrorCode14.GAS_LIMIT_TOO_LOW,
+      throw new FuelError15(
+        ErrorCode15.GAS_LIMIT_TOO_LOW,
         `Gas limit '${gasLimit}' is lower than the required: '${gasUsed}'.`
       );
     }
@@ -4817,7 +4933,7 @@ var Account = class extends AbstractAccount {
 
 // src/signer/signer.ts
 import { Address as Address4 } from "@fuel-ts/address";
-import { randomBytes } from "@fuel-ts/crypto";
+import { randomBytes as randomBytes2 } from "@fuel-ts/crypto";
 import { hash } from "@fuel-ts/hasher";
 import { toBytes } from "@fuel-ts/math";
 import { hexlify as hexlify13, concat as concat3, arrayify as arrayify15 } from "@fuel-ts/utils";
@@ -4910,7 +5026,7 @@ var Signer = class {
    * @returns random 32-byte hashed
    */
   static generatePrivateKey(entropy) {
-    return entropy ? hash(concat3([randomBytes(32), arrayify15(entropy)])) : randomBytes(32);
+    return entropy ? hash(concat3([randomBytes2(32), arrayify15(entropy)])) : randomBytes2(32);
   }
   /**
    * Extended publicKey from a compact publicKey
@@ -4929,13 +5045,13 @@ import { Address as Address5 } from "@fuel-ts/address";
 import {
   bufferFromString,
   keccak256,
-  randomBytes as randomBytes2,
+  randomBytes as randomBytes3,
   scrypt,
   stringFromBuffer,
   decryptJsonWalletData,
   encryptJsonWalletData
 } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode15, FuelError as FuelError15 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode16, FuelError as FuelError16 } from "@fuel-ts/errors";
 import { hexlify as hexlify14 } from "@fuel-ts/utils";
 import { v4 as uuidv4 } from "uuid";
 var DEFAULT_KDF_PARAMS_LOG_N = 13;
@@ -4952,7 +5068,7 @@ var removeHexPrefix = (hexString) => {
 async function encryptKeystoreWallet(privateKey, address, password) {
   const privateKeyBuffer = bufferFromString(removeHexPrefix(privateKey), "hex");
   const ownerAddress = Address5.fromAddressOrString(address);
-  const salt = randomBytes2(DEFAULT_KEY_SIZE);
+  const salt = randomBytes3(DEFAULT_KEY_SIZE);
   const key = scrypt({
     password: bufferFromString(password),
     salt,
@@ -4961,7 +5077,7 @@ async function encryptKeystoreWallet(privateKey, address, password) {
     r: DEFAULT_KDF_PARAMS_R,
     p: DEFAULT_KDF_PARAMS_P
   });
-  const iv = randomBytes2(DEFAULT_IV_SIZE);
+  const iv = randomBytes3(DEFAULT_IV_SIZE);
   const ciphertext = await encryptJsonWalletData(privateKeyBuffer, key, iv);
   const data = Uint8Array.from([...key.subarray(16, 32), ...ciphertext]);
   const macHashUint8Array = keccak256(data);
@@ -5013,8 +5129,8 @@ async function decryptKeystoreWallet(jsonWallet, password) {
   const macHashUint8Array = keccak256(data);
   const macHash = stringFromBuffer(macHashUint8Array, "hex");
   if (mac !== macHash) {
-    throw new FuelError15(
-      ErrorCode15.INVALID_PASSWORD,
+    throw new FuelError16(
+      ErrorCode16.INVALID_PASSWORD,
       "Failed to decrypt the keystore wallet, the provided password is incorrect."
     );
   }
@@ -5136,15 +5252,15 @@ var BaseWalletUnlocked = class extends Account {
 __publicField(BaseWalletUnlocked, "defaultPath", "m/44'/1179993420'/0'/0/0");
 
 // src/hdwallet/hdwallet.ts
-import { ErrorCode as ErrorCode18, FuelError as FuelError18 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode19, FuelError as FuelError19 } from "@fuel-ts/errors";
 import { sha256 as sha2564 } from "@fuel-ts/hasher";
-import { bn as bn17, toBytes as toBytes2, toHex } from "@fuel-ts/math";
+import { bn as bn18, toBytes as toBytes2, toHex } from "@fuel-ts/math";
 import { arrayify as arrayify18, hexlify as hexlify17, concat as concat5 } from "@fuel-ts/utils";
 import { toBeHex, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58, computeHmac as computeHmac2, ripemd160 } from "ethers";
 
 // src/mnemonic/mnemonic.ts
-import { randomBytes as randomBytes3 } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode17, FuelError as FuelError17 } from "@fuel-ts/errors";
+import { randomBytes as randomBytes4 } from "@fuel-ts/crypto";
+import { ErrorCode as ErrorCode18, FuelError as FuelError18 } from "@fuel-ts/errors";
 import { sha256 as sha2563 } from "@fuel-ts/hasher";
 import { arrayify as arrayify17, hexlify as hexlify16, concat as concat4 } from "@fuel-ts/utils";
 import { dataSlice, pbkdf2, computeHmac, encodeBase58 } from "ethers";
@@ -7202,7 +7318,7 @@ var english = [
 ];
 
 // src/mnemonic/utils.ts
-import { ErrorCode as ErrorCode16, FuelError as FuelError16 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode17, FuelError as FuelError17 } from "@fuel-ts/errors";
 import { sha256 as sha2562 } from "@fuel-ts/hasher";
 import { arrayify as arrayify16 } from "@fuel-ts/utils";
 function toUtf8Bytes(stri) {
@@ -7219,8 +7335,8 @@ function toUtf8Bytes(stri) {
       i += 1;
       const c2 = str.charCodeAt(i);
       if (i >= str.length || (c2 & 64512) !== 56320) {
-        throw new FuelError16(
-          ErrorCode16.INVALID_INPUT_PARAMETERS,
+        throw new FuelError17(
+          ErrorCode17.INVALID_INPUT_PARAMETERS,
           "Invalid UTF-8 in the input string."
         );
       }
@@ -7283,8 +7399,8 @@ function mnemonicWordsToEntropy(words, wordlist) {
   for (let i = 0; i < words.length; i += 1) {
     const index = wordlist.indexOf(words[i].normalize("NFKD"));
     if (index === -1) {
-      throw new FuelError16(
-        ErrorCode16.INVALID_MNEMONIC,
+      throw new FuelError17(
+        ErrorCode17.INVALID_MNEMONIC,
         `Invalid mnemonic: the word '${words[i]}' is not found in the provided wordlist.`
       );
     }
@@ -7300,8 +7416,8 @@ function mnemonicWordsToEntropy(words, wordlist) {
   const checksumMask = getUpperMask(checksumBits);
   const checksum = arrayify16(sha2562(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
   if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
-    throw new FuelError16(
-      ErrorCode16.INVALID_CHECKSUM,
+    throw new FuelError17(
+      ErrorCode17.INVALID_CHECKSUM,
       "Checksum validation failed for the provided mnemonic."
     );
   }
@@ -7315,16 +7431,16 @@ var TestnetPRV = "0x04358394";
 var MNEMONIC_SIZES = [12, 15, 18, 21, 24];
 function assertWordList(wordlist) {
   if (wordlist.length !== 2048) {
-    throw new FuelError17(
-      ErrorCode17.INVALID_WORD_LIST,
+    throw new FuelError18(
+      ErrorCode18.INVALID_WORD_LIST,
       `Expected word list length of 2048, but got ${wordlist.length}.`
     );
   }
 }
 function assertEntropy(entropy) {
   if (entropy.length % 4 !== 0 || entropy.length < 16 || entropy.length > 32) {
-    throw new FuelError17(
-      ErrorCode17.INVALID_ENTROPY,
+    throw new FuelError18(
+      ErrorCode18.INVALID_ENTROPY,
       `Entropy should be between 16 and 32 bytes and a multiple of 4, but got ${entropy.length} bytes.`
     );
   }
@@ -7334,7 +7450,7 @@ function assertMnemonic(words) {
     const errorMsg = `Invalid mnemonic size. Expected one of [${MNEMONIC_SIZES.join(
       ", "
     )}] words, but got ${words.length}.`;
-    throw new FuelError17(ErrorCode17.INVALID_MNEMONIC, errorMsg);
+    throw new FuelError18(ErrorCode18.INVALID_MNEMONIC, errorMsg);
   }
 }
 var Mnemonic = class {
@@ -7452,8 +7568,8 @@ var Mnemonic = class {
   static masterKeysFromSeed(seed) {
     const seedArray = arrayify17(seed);
     if (seedArray.length < 16 || seedArray.length > 64) {
-      throw new FuelError17(
-        ErrorCode17.INVALID_SEED,
+      throw new FuelError18(
+        ErrorCode18.INVALID_SEED,
         `Seed length should be between 16 and 64 bytes, but received ${seedArray.length} bytes.`
       );
     }
@@ -7498,7 +7614,7 @@ var Mnemonic = class {
    * @returns A randomly generated mnemonic
    */
   static generate(size = 32, extraEntropy = "") {
-    const entropy = extraEntropy ? sha2563(concat4([randomBytes3(size), arrayify17(extraEntropy)])) : randomBytes3(size);
+    const entropy = extraEntropy ? sha2563(concat4([randomBytes4(size), arrayify17(extraEntropy)])) : randomBytes4(size);
     return Mnemonic.entropyToMnemonic(entropy);
   }
 };
@@ -7530,7 +7646,7 @@ function isValidExtendedKey(extendedKey) {
 function parsePath(path2, depth = 0) {
   const components = path2.split("/");
   if (components.length === 0 || components[0] === "m" && depth !== 0) {
-    throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, `invalid path - ${path2}`);
+    throw new FuelError19(ErrorCode19.HD_WALLET_ERROR, `invalid path - ${path2}`);
   }
   if (components[0] === "m") {
     components.shift();
@@ -7559,8 +7675,8 @@ var HDWallet = class {
       this.privateKey = hexlify17(config.privateKey);
     } else {
       if (!config.publicKey) {
-        throw new FuelError18(
-          ErrorCode18.HD_WALLET_ERROR,
+        throw new FuelError19(
+          ErrorCode19.HD_WALLET_ERROR,
           "Both public and private Key cannot be missing. At least one should be provided."
         );
       }
@@ -7589,8 +7705,8 @@ var HDWallet = class {
     const data = new Uint8Array(37);
     if (index & HARDENED_INDEX) {
       if (!privateKey) {
-        throw new FuelError18(
-          ErrorCode18.HD_WALLET_ERROR,
+        throw new FuelError19(
+          ErrorCode19.HD_WALLET_ERROR,
           "Cannot derive a hardened index without a private Key."
         );
       }
@@ -7604,7 +7720,7 @@ var HDWallet = class {
     const IR = bytes.slice(32);
     if (privateKey) {
       const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
-      const ki = bn17(IL).add(privateKey).mod(N).toBytes(32);
+      const ki = bn18(IL).add(privateKey).mod(N).toBytes(32);
       return new HDWallet({
         privateKey: ki,
         chainCode: IR,
@@ -7642,8 +7758,8 @@ var HDWallet = class {
    */
   toExtendedKey(isPublic = false, testnet = false) {
     if (this.depth >= 256) {
-      throw new FuelError18(
-        ErrorCode18.HD_WALLET_ERROR,
+      throw new FuelError19(
+        ErrorCode19.HD_WALLET_ERROR,
         `Exceeded max depth of 255. Current depth: ${this.depth}.`
       );
     }
@@ -7674,10 +7790,10 @@ var HDWallet = class {
     const bytes = arrayify18(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
-      throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
+      throw new FuelError19(ErrorCode19.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
     }
     if (!validChecksum) {
-      throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
+      throw new FuelError19(ErrorCode19.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
     }
     const depth = bytes[4];
     const parentFingerprint = hexlify17(bytes.slice(5, 9));
@@ -7685,14 +7801,14 @@ var HDWallet = class {
     const chainCode = hexlify17(bytes.slice(13, 45));
     const key = bytes.slice(45, 78);
     if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
-      throw new FuelError18(
-        ErrorCode18.HD_WALLET_ERROR,
+      throw new FuelError19(
+        ErrorCode19.HD_WALLET_ERROR,
         "Inconsistency detected: Depth is zero but fingerprint/index is non-zero."
       );
     }
     if (isPublicExtendedKey(bytes)) {
       if (key[0] !== 3) {
-        throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Invalid public extended key.");
+        throw new FuelError19(ErrorCode19.HD_WALLET_ERROR, "Invalid public extended key.");
       }
       return new HDWallet({
         publicKey: key,
@@ -7703,7 +7819,7 @@ var HDWallet = class {
       });
     }
     if (key[0] !== 0) {
-      throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Invalid private extended key.");
+      throw new FuelError19(ErrorCode19.HD_WALLET_ERROR, "Invalid private extended key.");
     }
     return new HDWallet({
       privateKey: key.slice(1),
@@ -7869,10 +7985,10 @@ __publicField(Wallet, "fromExtendedKey", WalletUnlocked.fromExtendedKey);
 __publicField(Wallet, "fromEncryptedJson", WalletUnlocked.fromEncryptedJson);
 
 // src/test-utils/seedTestWallet.ts
-import { randomBytes as randomBytes4 } from "@fuel-ts/crypto";
+import { randomBytes as randomBytes5 } from "@fuel-ts/crypto";
 var seedTestWallet = async (wallet, quantities) => {
   const genesisWallet = new WalletUnlocked(
-    process.env.GENESIS_SECRET || randomBytes4(32),
+    process.env.GENESIS_SECRET || randomBytes5(32),
     wallet.provider
   );
   const resources = await genesisWallet.getResourcesToSpend(quantities);