@fuel-ts/account 0.101.1 → 0.101.3

package/dist/index.js

@@ -88,6 +88,7 @@ __export(src_exports, {
   assemblePreConfirmationTransactionSummary: () => assemblePreConfirmationTransactionSummary,
   assembleReceiptByType: () => assembleReceiptByType,
   assembleRevertError: () => assembleRevertError,
+  assembleSignalErrorMessage: () => assembleSignalErrorMessage,
   assembleTransactionSummary: () => assembleTransactionSummary,
   assembleTransactionSummaryFromJson: () => assembleTransactionSummaryFromJson,
   assets: () => assets,
@@ -104,6 +105,8 @@ __export(src_exports, {
   calculateMinGasForTxUpload: () => calculateMinGasForTxUpload,
   calculateTXFeeForSummary: () => calculateTXFeeForSummary,
   coinQuantityfy: () => coinQuantityfy,
+  consolidateCoins: () => consolidateCoins,
+  consolidateCoinsIfRequired: () => consolidateCoinsIfRequired,
   deferPromise: () => deferPromise,
   deployScriptOrPredicate: () => deployScriptOrPredicate,
   deserializeChain: () => deserializeChain,
@@ -122,6 +125,7 @@ __export(src_exports, {
   extractTxError: () => extractTxError,
   fuelAssetsBaseUrl: () => fuelAssetsBaseUrl,
   gasUsedByInputs: () => gasUsedByInputs,
+  getAllCoins: () => getAllCoins,
   getAllDecodedLogs: () => getAllDecodedLogs,
   getAssetAmountInRequestInputs: () => getAssetAmountInRequestInputs,
   getAssetById: () => getAssetById,
@@ -927,14 +931,14 @@ var getAssetsByOwner = /* @__PURE__ */ __name(async (opts) => {
 }, "getAssetsByOwner");
 
 // src/account.ts
-var import_abi_coder7 = require("@fuel-ts/abi-coder");
-var import_address5 = require("@fuel-ts/address");
+var import_abi_coder9 = require("@fuel-ts/abi-coder");
+var import_address6 = require("@fuel-ts/address");
 var import_crypto2 = require("@fuel-ts/crypto");
-var import_errors22 = require("@fuel-ts/errors");
-var import_math22 = require("@fuel-ts/math");
-var import_transactions28 = require("@fuel-ts/transactions");
-var import_utils36 = require("@fuel-ts/utils");
-var import_ramda9 = require("ramda");
+var import_errors23 = require("@fuel-ts/errors");
+var import_math23 = require("@fuel-ts/math");
+var import_transactions29 = require("@fuel-ts/transactions");
+var import_utils37 = require("@fuel-ts/utils");
+var import_ramda10 = require("ramda");
 
 // src/providers/coin-quantity.ts
 var import_math = require("@fuel-ts/math");
@@ -975,7 +979,7 @@ var import_address3 = require("@fuel-ts/address");
 var import_errors20 = require("@fuel-ts/errors");
 var import_math19 = require("@fuel-ts/math");
 var import_transactions25 = require("@fuel-ts/transactions");
-var import_utils31 = require("@fuel-ts/utils");
+var import_utils32 = require("@fuel-ts/utils");
 var import_versions = require("@fuel-ts/versions");
 var import_graphql_request = require("graphql-request");
 var import_graphql_tag2 = __toESM(require("graphql-tag"));
@@ -2375,8 +2379,11 @@ var import_graphql = require("graphql");
 
 // src/providers/utils/handle-gql-error-message.ts
 var import_errors2 = require("@fuel-ts/errors");
+var ASSET_ID_REGEX = /[0-9a-fA-F]{32,64}/g;
 var gqlErrorMessage = {
   RPC_CONSISTENCY: /The required fuel block height is higher than the current block height. Required: \d+, Current: \d+/,
+  INSUFFICIENT_FUNDS: /the target cannot be met due to insufficient coins available for [0-9a-fA-F]{32,64}. Collected: \d+/,
+  MAX_COINS_REACHED: /the target for [0-9a-fA-F]{32,64} cannot be met due to exceeding the \d+ coin limit. Collected: \d+./,
   NOT_ENOUGH_COINS_MAX_COINS: /the target cannot be met due to no coins available or exceeding the \d+ coin limit./,
   ASSET_NOT_FOUND: /resource was not found in table/,
   MULTIPLE_CHANGE_POLICIES: /The asset ([a-fA-F0-9]{64}) has multiple change policies/,
@@ -2392,6 +2399,46 @@ var mapGqlErrorMessage = /* @__PURE__ */ __name((error) => {
       error
     );
   }
+  if (gqlErrorMessage.MAX_COINS_REACHED.test(error.message)) {
+    const matches = error.message.match(ASSET_ID_REGEX);
+    const assetId = matches ? `0x${matches[0]}` : null;
+    const owner = matches ? `0x${matches[1]}` : null;
+    let suffix = "";
+    if (assetId) {
+      suffix += `
+	Asset ID: '${assetId}'.`;
+    }
+    if (owner) {
+      suffix += `
+	Owner: '${owner}'.`;
+    }
+    return new import_errors2.FuelError(
+      import_errors2.ErrorCode.MAX_COINS_REACHED,
+      `You have too many small value coins - consider combining UTXOs.${suffix}`,
+      { assetId, owner },
+      error
+    );
+  }
+  if (gqlErrorMessage.INSUFFICIENT_FUNDS.test(error.message)) {
+    const matches = error.message.match(ASSET_ID_REGEX);
+    const assetId = matches ? `0x${matches[0]}` : null;
+    const owner = matches ? `0x${matches[1]}` : null;
+    let suffix = "";
+    if (assetId) {
+      suffix += `
+	Asset ID: '${assetId}'.`;
+    }
+    if (owner) {
+      suffix += `
+	Owner: '${owner}'.`;
+    }
+    return new import_errors2.FuelError(
+      import_errors2.ErrorCode.INSUFFICIENT_FUNDS,
+      `Insufficient funds.${suffix}`,
+      { assetId, owner },
+      error
+    );
+  }
   if (gqlErrorMessage.MULTIPLE_CHANGE_POLICIES.test(error.message)) {
     const match = error.message.match(/asset ([a-fA-F0-9]{64})/);
     const assetId = match?.[1] || "";
@@ -3482,58 +3529,98 @@ ${import_configs5.PANIC_DOC_URL}#variant.${statusReason}`;
   });
 }, "assemblePanicError");
 var stringify = /* @__PURE__ */ __name((obj) => JSON.stringify(obj, null, 2), "stringify");
-var assembleRevertError = /* @__PURE__ */ __name((receipts, logs, metadata) => {
+var assembleSignalErrorMessage = /* @__PURE__ */ __name((reasonHex, logs, metadata) => {
   let errorMessage = "The transaction reverted with an unknown reason.";
-  const revertReceipt = receipts.find(({ type }) => type === import_transactions7.ReceiptType.Revert);
   let reason = "";
-  if (revertReceipt) {
-    const reasonHex = (0, import_math7.bn)(revertReceipt.val).toHex();
-    const lastLog = logs[logs.length - 1];
-    const lastButOneLog = logs[logs.length - 2];
-    switch (reasonHex) {
-      case import_configs5.FAILED_REQUIRE_SIGNAL: {
-        reason = "require";
-        errorMessage = `The transaction reverted because a "require" statement has thrown ${logs.length ? stringify(lastLog) : "an error."}.`;
-        break;
-      }
-      case import_configs5.FAILED_ASSERT_EQ_SIGNAL: {
-        const suffix = logs.length >= 2 ? ` comparing ${stringify(lastLog)} and ${stringify(lastButOneLog)}.` : ".";
-        reason = "assert_eq";
-        errorMessage = `The transaction reverted because of an "assert_eq" statement${suffix}`;
-        break;
-      }
-      case import_configs5.FAILED_ASSERT_NE_SIGNAL: {
-        const suffix = logs.length >= 2 ? ` comparing ${stringify(lastButOneLog)} and ${stringify(lastLog)}.` : ".";
-        reason = "assert_ne";
-        errorMessage = `The transaction reverted because of an "assert_ne" statement${suffix}`;
-        break;
-      }
-      case import_configs5.FAILED_ASSERT_SIGNAL:
-        reason = "assert";
-        errorMessage = `The transaction reverted because an "assert" statement failed to evaluate to true.`;
-        break;
-      case import_configs5.FAILED_TRANSFER_TO_ADDRESS_SIGNAL:
-        reason = "MissingOutputVariable";
-        errorMessage = `The transaction reverted because it's missing an "OutputVariable".`;
-        break;
-      default:
-        throw new import_errors8.FuelError(
-          import_errors8.ErrorCode.UNKNOWN,
-          `The transaction reverted with an unknown reason: ${revertReceipt.val}`,
-          {
-            ...metadata,
-            reason: "unknown"
-          }
-        );
+  const lastLog = logs[logs.length - 1];
+  const lastButOneLog = logs[logs.length - 2];
+  switch (reasonHex) {
+    case import_configs5.FAILED_REQUIRE_SIGNAL: {
+      reason = "require";
+      errorMessage = `The transaction reverted because a "require" statement has thrown ${logs.length ? stringify(lastLog) : "an error."}.`;
+      break;
+    }
+    case import_configs5.FAILED_ASSERT_EQ_SIGNAL: {
+      const suffix = logs.length >= 2 ? ` comparing ${stringify(lastLog)} and ${stringify(lastButOneLog)}.` : ".";
+      reason = "assert_eq";
+      errorMessage = `The transaction reverted because of an "assert_eq" statement${suffix}`;
+      break;
+    }
+    case import_configs5.FAILED_ASSERT_NE_SIGNAL: {
+      const suffix = logs.length >= 2 ? ` comparing ${stringify(lastButOneLog)} and ${stringify(lastLog)}.` : ".";
+      reason = "assert_ne";
+      errorMessage = `The transaction reverted because of an "assert_ne" statement${suffix}`;
+      break;
+    }
+    case import_configs5.FAILED_ASSERT_SIGNAL:
+      reason = "assert";
+      errorMessage = `The transaction reverted because an "assert" statement failed to evaluate to true.`;
+      break;
+    case import_configs5.FAILED_TRANSFER_TO_ADDRESS_SIGNAL:
+      reason = "MissingOutputVariable";
+      errorMessage = `The transaction reverted because it's missing an "OutputVariable".`;
+      break;
+    default:
+      reason = `revert_with_log`;
+      errorMessage = `The transaction reverted because a "revert_with_log" statement has thrown ${logs.length ? stringify(lastLog) : "an error."}.`;
+      break;
+  }
+  return new import_errors8.FuelError(import_errors8.ErrorCode.SCRIPT_REVERTED, errorMessage, {
+    ...metadata,
+    reason
+  });
+}, "assembleSignalErrorMessage");
+function buildAbiErrorMessage(abiError, logs, metadata, reason) {
+  const { pos, msg } = abiError;
+  let errorMessage = "";
+  const positionMessage = pos ? `
+
+This error originated at ${JSON.stringify(pos, null, 2)}` : "";
+  if (msg) {
+    errorMessage = `A sway "panic" expression was invoked with the message: "${msg}".${positionMessage}`;
+  } else {
+    const value = logs[logs.length - 1];
+    errorMessage = `A sway "panic" expression was invoked with the value: ${JSON.stringify(value)}.${positionMessage}`;
+  }
+  return new import_errors8.FuelError(import_errors8.ErrorCode.SCRIPT_REVERTED, errorMessage, {
+    ...metadata,
+    abiError,
+    reason
+  });
+}
+__name(buildAbiErrorMessage, "buildAbiErrorMessage");
+function findErrorInAbis(statusReason, abis = []) {
+  for (const abi of abis) {
+    if (abi.errorCodes?.[statusReason]) {
+      return abi.errorCodes[statusReason];
     }
   }
+  return void 0;
+}
+__name(findErrorInAbis, "findErrorInAbis");
+var assembleRevertError = /* @__PURE__ */ __name((_receipts, logs, metadata, statusReason, abis) => {
+  const match = statusReason.match(/Revert\((\d+)\)/);
+  const reason = match?.[1] ?? statusReason;
+  const reasonHex = (0, import_math7.bn)(reason).toHex();
+  if (Object.values(import_configs5.SwaySignalErrors).includes(reasonHex)) {
+    return assembleSignalErrorMessage(reasonHex, logs, metadata);
+  }
+  let abiError;
+  if (abis) {
+    const abisArr = [abis.main, ...Object.values(abis.otherContractsAbis)];
+    abiError = findErrorInAbis(reason, abisArr);
+  }
+  if (abiError) {
+    return buildAbiErrorMessage(abiError, logs, metadata, reason);
+  }
+  const errorMessage = `The transaction reverted with reason: ${reason}.`;
   return new import_errors8.FuelError(import_errors8.ErrorCode.SCRIPT_REVERTED, errorMessage, {
     ...metadata,
     reason
   });
 }, "assembleRevertError");
 var extractTxError = /* @__PURE__ */ __name((params) => {
-  const { receipts, statusReason, logs, groupedLogs } = params;
+  const { receipts, statusReason, logs, groupedLogs, abis } = params;
   const isPanic = receipts.some(({ type }) => type === import_transactions7.ReceiptType.Panic);
   const isRevert = receipts.some(({ type }) => type === import_transactions7.ReceiptType.Revert);
   const metadata = {
@@ -3547,7 +3634,7 @@ var extractTxError = /* @__PURE__ */ __name((params) => {
   if (isPanic) {
     return assemblePanicError(statusReason, metadata);
   }
-  return assembleRevertError(receipts, logs, metadata);
+  return assembleRevertError(receipts, logs, metadata, statusReason, abis);
 }, "extractTxError");
 
 // src/providers/utils/merge-quantities.ts
@@ -4552,11 +4639,15 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
    * @deprecated Use `provider.assembleTx` instead.
    * Check the migration guide https://docs.fuel.network/guide/assembling-transactions/migration-guide.html for more information.
    */
-  async estimateAndFund(account, { signatureCallback, quantities = [] } = {}) {
+  async estimateAndFund(account, {
+    signatureCallback,
+    quantities = [],
+    skipAutoConsolidation
+  } = {}) {
     const txCost = await account.getTransactionCost(this, { signatureCallback, quantities });
     this.maxFee = txCost.maxFee;
     this.gasLimit = txCost.gasUsed;
-    await account.fund(this, txCost);
+    await account.fund(this, txCost, { skipAutoConsolidation });
     return this;
   }
   /**
@@ -5133,12 +5224,12 @@ var ResourceCache = class {
 var import_errors18 = require("@fuel-ts/errors");
 var import_math18 = require("@fuel-ts/math");
 var import_transactions23 = require("@fuel-ts/transactions");
-var import_utils28 = require("@fuel-ts/utils");
+var import_utils29 = require("@fuel-ts/utils");
 
 // src/providers/transaction-summary/assemble-transaction-summary.ts
 var import_math17 = require("@fuel-ts/math");
 var import_transactions21 = require("@fuel-ts/transactions");
-var import_utils26 = require("@fuel-ts/utils");
+var import_utils27 = require("@fuel-ts/utils");
 
 // src/providers/transaction-summary/calculate-tx-fee-for-summary.ts
 var import_math13 = require("@fuel-ts/math");
@@ -5211,6 +5302,45 @@ var import_configs11 = require("@fuel-ts/address/configs");
 var import_errors16 = require("@fuel-ts/errors");
 var import_math15 = require("@fuel-ts/math");
 var import_transactions19 = require("@fuel-ts/transactions");
+var import_utils25 = require("@fuel-ts/utils");
+
+// src/providers/transaction-summary/call.ts
+var import_abi_coder4 = require("@fuel-ts/abi-coder");
+var import_abi_coder5 = require("@fuel-ts/abi-coder");
+var getFunctionCall = /* @__PURE__ */ __name(({
+  abi,
+  receipt,
+  offset,
+  scriptData
+}) => {
+  const [functionSelector, argumentsOffset] = new import_abi_coder4.StdStringCoder().decode(scriptData, offset);
+  const abiInterface = new import_abi_coder5.Interface(abi);
+  const functionFragment = abiInterface.getFunction(functionSelector);
+  const inputs = functionFragment.jsonFn.inputs;
+  let argumentsProvided;
+  if (inputs.length) {
+    const functionArgsBytes = scriptData.slice(argumentsOffset);
+    const decodedArguments = functionFragment.decodeArguments(functionArgsBytes);
+    argumentsProvided = inputs.reduce((prev, input, index) => {
+      const value = decodedArguments?.[index];
+      const name = input.name;
+      if (name) {
+        return {
+          ...prev,
+          // reparse to remove bn
+          [name]: JSON.parse(JSON.stringify(value))
+        };
+      }
+      return prev;
+    }, {});
+  }
+  return {
+    functionSignature: functionFragment.signature,
+    functionName: functionFragment.name,
+    argumentsProvided,
+    ...receipt.amount?.isZero() ? {} : { amount: receipt.amount, assetId: receipt.assetId }
+  };
+}, "getFunctionCall");
 
 // src/providers/transaction-summary/input.ts
 var import_errors15 = require("@fuel-ts/errors");
@@ -5545,12 +5675,45 @@ function getWithdrawFromFuelOperations({
   return withdrawFromFuelOperations;
 }
 __name(getWithdrawFromFuelOperations, "getWithdrawFromFuelOperations");
-function getContractCalls(contractInput, abiMap, _receipt, _rawPayload, _maxInputs) {
-  const abi = abiMap?.[contractInput.contractID];
-  if (!abi) {
-    return [];
+function findBytesSegmentIndex(whole, segment) {
+  for (let i = 0; i <= whole.length - segment.length; i++) {
+    let match = true;
+    for (let j = 0; j < segment.length; j++) {
+      if (whole[i + j] !== segment[j]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) {
+      return i;
+    }
   }
-  return [];
+  return -1;
+}
+__name(findBytesSegmentIndex, "findBytesSegmentIndex");
+function getContractCalls(contractInput, abiMap, receipt, scriptData) {
+  const calls = [];
+  const abi = abiMap?.[contractInput.contractID];
+  if (!abi || !scriptData) {
+    return calls;
+  }
+  const bytesSegment = (0, import_utils25.concat)([
+    (0, import_utils25.arrayify)(receipt.to),
+    // Contract ID (32 bytes)
+    (0, import_math15.toBytes)(receipt.param1.toHex(), 8),
+    // Function selector offset (8 bytes)
+    (0, import_math15.toBytes)(receipt.param2.toHex(), 8)
+    // Function args offset (8 bytes)
+  ]);
+  const segmentIndex = findBytesSegmentIndex(scriptData, bytesSegment);
+  const canDecodeFunctionCall = segmentIndex !== -1;
+  if (!canDecodeFunctionCall) {
+    return calls;
+  }
+  const offset = segmentIndex + bytesSegment.length;
+  const call = getFunctionCall({ abi, receipt, offset, scriptData });
+  calls.push(call);
+  return calls;
 }
 __name(getContractCalls, "getContractCalls");
 function getAssetsSent(receipt) {
@@ -5562,14 +5725,14 @@ function getAssetsSent(receipt) {
   ];
 }
 __name(getAssetsSent, "getAssetsSent");
-function processCallReceipt(receipt, contractInput, inputs, abiMap, rawPayload, maxInputs, baseAssetId) {
+function processCallReceipt(receipt, contractInput, inputs, abiMap, scriptData, baseAssetId) {
   const assetId = receipt.assetId === import_configs11.ZeroBytes32 ? baseAssetId : receipt.assetId;
   const input = getInputFromAssetId(inputs, assetId, assetId === baseAssetId);
   if (!input) {
     return [];
   }
   const inputAddress = getInputAccountAddress(input);
-  const calls = getContractCalls(contractInput, abiMap, receipt, rawPayload, maxInputs);
+  const calls = getContractCalls(contractInput, abiMap, receipt, scriptData);
   return [
     {
       name: "Contract call" /* contractCall */,
@@ -5594,7 +5757,6 @@ function getContractCallOperations({
   receipts,
   abiMap,
   rawPayload,
-  maxInputs,
   baseAssetId
 }) {
   const contractCallReceipts = getReceiptsCall(receipts);
@@ -5604,16 +5766,15 @@ function getContractCallOperations({
     if (!contractInput) {
       return [];
     }
+    let scriptData;
+    if (rawPayload) {
+      const [transaction] = new import_transactions19.TransactionCoder().decode((0, import_utils25.arrayify)(rawPayload), 0);
+      if (transaction.type === import_transactions19.TransactionType.Script) {
+        scriptData = (0, import_utils25.arrayify)(transaction.scriptData);
+      }
+    }
     return contractCallReceipts.filter((receipt) => receipt.to === contractInput.contractID).flatMap(
-      (receipt) => processCallReceipt(
-        receipt,
-        contractInput,
-        inputs,
-        abiMap,
-        rawPayload,
-        maxInputs,
-        baseAssetId
-      )
+      (receipt) => processCallReceipt(receipt, contractInput, inputs, abiMap, scriptData, baseAssetId)
     );
   });
 }
@@ -5938,7 +6099,7 @@ function assembleTransactionSummary(params) {
     baseAssetId
   } = params;
   const gasUsed = getGasUsedFromReceipts(receipts);
-  const rawPayload = (0, import_utils26.hexlify)(transactionBytes);
+  const rawPayload = (0, import_utils27.hexlify)(transactionBytes);
   const operations = getOperations({
     transactionType: transaction.type,
     inputs: transaction.inputs || [],
@@ -5969,7 +6130,7 @@ function assembleTransactionSummary(params) {
   const burnedAssets = extractBurnedAssetsFromReceipts(receipts);
   let date;
   if (time) {
-    date = import_utils26.DateTime.fromTai64(time);
+    date = import_utils27.DateTime.fromTai64(time);
   }
   const transactionSummary = {
     id,
@@ -6030,7 +6191,7 @@ function assemblePreConfirmationTransactionSummary(params) {
     type = getTransactionTypeName(transaction.type);
     tip = (0, import_math17.bn)(transaction.policies?.find((policy) => policy.type === import_transactions21.PolicyType.Tip)?.data);
     if (receipts) {
-      const rawPayload = (0, import_utils26.hexlify)(new import_transactions21.TransactionCoder().encode(transaction));
+      const rawPayload = (0, import_utils27.hexlify)(new import_transactions21.TransactionCoder().encode(transaction));
       operations = getOperations({
         transactionType: transaction.type,
         inputs: transaction.inputs || [],
@@ -6076,7 +6237,7 @@ function assemblePreConfirmationTransactionSummary(params) {
 __name(assemblePreConfirmationTransactionSummary, "assemblePreConfirmationTransactionSummary");
 
 // src/providers/transaction-response/getAllDecodedLogs.ts
-var import_abi_coder4 = require("@fuel-ts/abi-coder");
+var import_abi_coder6 = require("@fuel-ts/abi-coder");
 var import_configs12 = require("@fuel-ts/address/configs");
 var import_transactions22 = require("@fuel-ts/transactions");
 function getAllDecodedLogs(opts) {
@@ -6096,8 +6257,8 @@ function getAllDecodedLogs(opts) {
         const isLogFromMainAbi = receipt.id === import_configs12.ZeroBytes32 || mainContract === receipt.id;
         const isDecodable = isLogFromMainAbi || externalAbis[receipt.id];
         if (isDecodable) {
-          const interfaceToUse = isLogFromMainAbi ? new import_abi_coder4.Interface(mainAbi) : new import_abi_coder4.Interface(externalAbis[receipt.id]);
-          const data = receipt.type === import_transactions22.ReceiptType.Log ? new import_abi_coder4.BigNumberCoder("u64").encode(receipt.ra) : receipt.data;
+          const interfaceToUse = isLogFromMainAbi ? new import_abi_coder6.Interface(mainAbi) : new import_abi_coder6.Interface(externalAbis[receipt.id]);
+          const data = receipt.type === import_transactions22.ReceiptType.Log ? new import_abi_coder6.BigNumberCoder("u64").encode(receipt.ra) : receipt.data;
           const [decodedLog] = interfaceToUse.decodeLog(data, receipt.rb.toString());
           logs.push(decodedLog);
           groupedLogs[receipt.id] = [...groupedLogs[receipt.id] || [], decodedLog];
@@ -6112,25 +6273,6 @@ __name(getAllDecodedLogs, "getAllDecodedLogs");
 
 // src/providers/transaction-response/transaction-response.ts
 var TransactionResponse = class _TransactionResponse {
-  /**
-   * Constructor for `TransactionResponse`.
-   *
-   * @param tx - The transaction ID or TransactionRequest.
-   * @param provider - The provider.
-   */
-  constructor(tx, provider, chainId, abis, submitTxSubscription) {
-    this.submitTxSubscription = submitTxSubscription;
-    if (typeof tx === "string") {
-      this.id = tx;
-    } else {
-      this.id = tx.getTransactionId(chainId);
-      this.request = tx;
-    }
-    this.provider = provider;
-    this.abis = abis;
-    this.waitForResult = this.waitForResult.bind(this);
-    this.waitForPreConfirmation = this.waitForPreConfirmation.bind(this);
-  }
   static {
     __name(this, "TransactionResponse");
   }
@@ -6145,9 +6287,42 @@ var TransactionResponse = class _TransactionResponse {
   request;
   status;
   abis;
+  submitTxSubscription;
   preConfirmationStatus;
   waitingForStreamData = false;
   statusResolvers = /* @__PURE__ */ new Map();
+  /**
+   * Constructor for `TransactionResponse`.
+   */
+  constructor(constructorParams, provider, chainId, abis, submitTxSubscription) {
+    let tx;
+    let _provider;
+    let _chainId;
+    let _abis;
+    if (typeof constructorParams === "object" && "provider" in constructorParams && arguments.length === 1) {
+      tx = constructorParams.transactionRequestOrId;
+      _provider = constructorParams.provider;
+      _chainId = constructorParams.chainId;
+      _abis = constructorParams.abis;
+      this.submitTxSubscription = constructorParams.submitAndAwaitSubscription;
+    } else {
+      tx = constructorParams;
+      _provider = provider;
+      _chainId = chainId;
+      _abis = abis;
+      this.submitTxSubscription = submitTxSubscription;
+    }
+    if (typeof tx === "string") {
+      this.id = tx;
+    } else {
+      this.id = tx.getTransactionId(_chainId);
+      this.request = tx;
+    }
+    this.provider = _provider;
+    this.abis = _abis;
+    this.waitForResult = this.waitForResult.bind(this);
+    this.waitForPreConfirmation = this.waitForPreConfirmation.bind(this);
+  }
   /**
    * Async constructor for `TransactionResponse`. This method can be used to create
    * an instance of `TransactionResponse` and wait for the transaction to be fetched
@@ -6196,7 +6371,7 @@ var TransactionResponse = class _TransactionResponse {
     }
     const gqlTransaction = this.gqlTransaction ?? await this.fetch();
     const { rawPayload } = gqlTransaction;
-    const bytes = (0, import_utils28.arrayify)(rawPayload);
+    const bytes = (0, import_utils29.arrayify)(rawPayload);
     const [tx] = new import_transactions23.TransactionCoder().decode(bytes, 0);
     return {
       tx,
@@ -6384,6 +6559,7 @@ var TransactionResponse = class _TransactionResponse {
       ...transactionSummary
     };
     let { logs, groupedLogs } = { logs: [], groupedLogs: {} };
+    let abis;
     if (this.abis) {
       ({ logs, groupedLogs } = getAllDecodedLogs({
         receipts: transactionSummary.receipts,
@@ -6392,6 +6568,7 @@ var TransactionResponse = class _TransactionResponse {
       }));
       transactionResult.logs = logs;
       transactionResult.groupedLogs = groupedLogs;
+      abis = this.abis;
     }
     const { receipts } = transactionResult;
     const status = this.getTransactionStatus();
@@ -6401,7 +6578,8 @@ var TransactionResponse = class _TransactionResponse {
         receipts,
         statusReason: reason,
         logs,
-        groupedLogs
+        groupedLogs,
+        abis
       });
     }
     return transactionResult;
@@ -6463,7 +6641,7 @@ var TransactionResponse = class _TransactionResponse {
 };
 
 // src/providers/transaction-response/getDecodedLogs.ts
-var import_abi_coder5 = require("@fuel-ts/abi-coder");
+var import_abi_coder7 = require("@fuel-ts/abi-coder");
 var import_configs13 = require("@fuel-ts/address/configs");
 var import_transactions24 = require("@fuel-ts/transactions");
 function getDecodedLogs(receipts, mainAbi, externalAbis = {}) {
@@ -6479,8 +6657,8 @@ function getDecodedLogs(receipts, mainAbi, externalAbis = {}) {
       const isLogFromMainAbi = receipt.id === import_configs13.ZeroBytes32 || mainContract === receipt.id;
       const isDecodable = isLogFromMainAbi || externalAbis[receipt.id];
       if (isDecodable) {
-        const interfaceToUse = isLogFromMainAbi ? new import_abi_coder5.Interface(mainAbi) : new import_abi_coder5.Interface(externalAbis[receipt.id]);
-        const data = receipt.type === import_transactions24.ReceiptType.Log ? new import_abi_coder5.BigNumberCoder("u64").encode(receipt.ra) : receipt.data;
+        const interfaceToUse = isLogFromMainAbi ? new import_abi_coder7.Interface(mainAbi) : new import_abi_coder7.Interface(externalAbis[receipt.id]);
+        const data = receipt.type === import_transactions24.ReceiptType.Log ? new import_abi_coder7.BigNumberCoder("u64").encode(receipt.ra) : receipt.data;
         const [decodedLog] = interfaceToUse.decodeLog(data, receipt.rb.toString());
         logs.push(decodedLog);
       }
@@ -6491,7 +6669,7 @@ function getDecodedLogs(receipts, mainAbi, externalAbis = {}) {
 __name(getDecodedLogs, "getDecodedLogs");
 
 // src/providers/utils/auto-retry-fetch.ts
-var import_utils30 = require("@fuel-ts/utils");
+var import_utils31 = require("@fuel-ts/utils");
 function getWaitDelay(options, retryAttemptNum) {
   const duration = options.baseDelay ?? 150;
   switch (options.backoff) {
@@ -6522,7 +6700,7 @@ function autoRetryFetch(fetchFn, options, retryAttemptNum = 0) {
         throw error;
       }
       const delay = getWaitDelay(options, retryNum);
-      await (0, import_utils30.sleep)(delay);
+      await (0, import_utils31.sleep)(delay);
       return autoRetryFetch(fetchFn, options, retryNum)(...args);
     }
   };
@@ -6662,7 +6840,7 @@ var Provider = class _Provider {
     return url.replace(/-sub$/, "");
   }
   static hasWriteOperationHappened(url) {
-    return (0, import_utils31.isDefined)(_Provider.currentBlockHeightCache[this.normalizeUrl(url)]);
+    return (0, import_utils32.isDefined)(_Provider.currentBlockHeightCache[this.normalizeUrl(url)]);
   }
   /**
    * @hidden
@@ -6684,7 +6862,15 @@ var Provider = class _Provider {
       if (_Provider.ENABLE_RPC_CONSISTENCY && _Provider.hasWriteOperationHappened(url)) {
         _Provider.applyBlockHeight(fullRequest, url);
       }
-      return _Provider.fetchAndProcessBlockHeight(url, fullRequest, options);
+      const response = await _Provider.fetchAndProcessBlockHeight(url, fullRequest, options);
+      if (response.body === null) {
+        throw new import_errors20.FuelError(
+          import_errors20.ErrorCode.RESPONSE_BODY_EMPTY,
+          "The response from the server is missing the body",
+          { timestamp: (/* @__PURE__ */ new Date()).toISOString(), request: request2, response }
+        );
+      }
+      return response;
     }, retryOptions);
   }
   static applyBlockHeight(request2, url) {
@@ -6707,24 +6893,26 @@ var Provider = class _Provider {
       baseDelay: 500
     };
     for (let retriesLeft = retryOptions.maxRetries; retriesLeft > 0; --retriesLeft) {
-      const { extensions } = await parseGraphqlResponse({
-        response,
-        isSubscription: url.endsWith("-sub")
-      });
-      _Provider.setCurrentBlockHeight(url, extensions?.current_fuel_block_height);
-      if (!extensions?.fuel_block_height_precondition_failed) {
-        break;
+      if (response.body) {
+        const { extensions } = await parseGraphqlResponse({
+          response,
+          isSubscription: url.endsWith("-sub")
+        });
+        _Provider.setCurrentBlockHeight(url, extensions?.current_fuel_block_height);
+        if (!extensions?.fuel_block_height_precondition_failed) {
+          break;
+        }
       }
       const retryAttempt = retryOptions.maxRetries - retriesLeft + 1;
       const sleepTime = getWaitDelay(retryOptions, retryAttempt);
-      await (0, import_utils31.sleep)(sleepTime);
+      await (0, import_utils32.sleep)(sleepTime);
       response = await fetchFn();
     }
     return response;
   }
   static setCurrentBlockHeight(url, height) {
     const writeOperationHappened = _Provider.hasWriteOperationHappened(url);
-    if (!(0, import_utils31.isDefined)(height) || !writeOperationHappened) {
+    if (!(0, import_utils32.isDefined)(height) || !writeOperationHappened) {
       return;
     }
     const normalizedUrl = _Provider.normalizeUrl(url);
@@ -6759,7 +6947,7 @@ var Provider = class _Provider {
       _Provider.chainInfoCache[this.urlWithoutAuth] = chain;
       _Provider.nodeInfoCache[this.urlWithoutAuth] = nodeInfo;
     }
-    if ((0, import_utils31.isDefined)(resourceCacheTTL)) {
+    if ((0, import_utils32.isDefined)(resourceCacheTTL)) {
       if (resourceCacheTTL !== -1) {
         this.cache = new ResourceCache(resourceCacheTTL);
       } else {
@@ -7122,7 +7310,7 @@ var Provider = class _Provider {
       await this.estimateTxDependencies(transactionRequest);
     }
     await this.validateTransaction(transactionRequest);
-    const encodedTransaction = (0, import_utils31.hexlify)(transactionRequest.toTransactionBytes());
+    const encodedTransaction = (0, import_utils32.hexlify)(transactionRequest.toTransactionBytes());
     let abis;
     if (isTransactionTypeScript(transactionRequest)) {
       abis = transactionRequest.abis;
@@ -7136,7 +7324,13 @@ var Provider = class _Provider {
       transactionRequest.getTransactionId(await this.getChainId())
     );
     const chainId = await this.getChainId();
-    return new TransactionResponse(transactionRequest, this, chainId, abis, subscription);
+    return new TransactionResponse({
+      transactionRequestOrId: transactionRequest,
+      provider: this,
+      chainId,
+      abis,
+      submitAndAwaitSubscription: subscription
+    });
   }
   /**
    * Executes a transaction without actually submitting it to the chain.
@@ -7153,7 +7347,7 @@ var Provider = class _Provider {
     if (estimateTxDependencies) {
       return this.estimateTxDependencies(transactionRequest);
     }
-    const encodedTransaction = (0, import_utils31.hexlify)(transactionRequest.toTransactionBytes());
+    const encodedTransaction = (0, import_utils32.hexlify)(transactionRequest.toTransactionBytes());
     const { dryRun: dryRunStatuses } = await this.operations.dryRun({
       encodedTransactions: encodedTransaction,
       utxoValidation: utxoValidation || false
@@ -7177,7 +7371,7 @@ var Provider = class _Provider {
     if (!shouldEstimatePredicates) {
       return transactionRequest;
     }
-    const encodedTransaction = (0, import_utils31.hexlify)(transactionRequest.toTransactionBytes());
+    const encodedTransaction = (0, import_utils32.hexlify)(transactionRequest.toTransactionBytes());
     const response = await this.operations.estimatePredicates({
       encodedTransaction
     });
@@ -7209,7 +7403,7 @@ var Provider = class _Provider {
       estimatePredicates
     } = await this.operations.estimatePredicatesAndGasPrice({
       blockHorizon: String(blockHorizon),
-      encodedTransaction: (0, import_utils31.hexlify)(transactionRequest.toTransactionBytes())
+      encodedTransaction: (0, import_utils32.hexlify)(transactionRequest.toTransactionBytes())
     });
     transactionRequest = this.parseEstimatePredicatesResponse(
       transactionRequest,
@@ -7247,7 +7441,7 @@ var Provider = class _Provider {
       const {
         dryRun: [{ receipts: serializedReceipts, status }]
       } = await this.operations.dryRun({
-        encodedTransactions: [(0, import_utils31.hexlify)(transactionRequest.toTransactionBytes())],
+        encodedTransactions: [(0, import_utils32.hexlify)(transactionRequest.toTransactionBytes())],
         utxoValidation: false,
         gasPrice: gasPrice.toString()
       });
@@ -7302,7 +7496,7 @@ var Provider = class _Provider {
     const serializedTransactionsMap = /* @__PURE__ */ new Map();
     allRequests.forEach((req, index) => {
       if (isTransactionTypeScript(req)) {
-        serializedTransactionsMap.set(index, (0, import_utils31.hexlify)(req.toTransactionBytes()));
+        serializedTransactionsMap.set(index, (0, import_utils32.hexlify)(req.toTransactionBytes()));
       }
     });
     let transactionsToProcess = Array.from(serializedTransactionsMap.keys());
@@ -7338,7 +7532,7 @@ var Provider = class _Provider {
             transactionRequest: request2
           });
           request2.maxFee = maxFee;
-          serializedTransactionsMap.set(requestIdx, (0, import_utils31.hexlify)(request2.toTransactionBytes()));
+          serializedTransactionsMap.set(requestIdx, (0, import_utils32.hexlify)(request2.toTransactionBytes()));
           nextRoundTransactions.push(requestIdx);
         }
       }
@@ -7359,7 +7553,7 @@ var Provider = class _Provider {
     if (estimateTxDependencies) {
       return this.estimateMultipleTxDependencies(transactionRequests);
     }
-    const encodedTransactions = transactionRequests.map((tx) => (0, import_utils31.hexlify)(tx.toTransactionBytes()));
+    const encodedTransactions = transactionRequests.map((tx) => (0, import_utils32.hexlify)(tx.toTransactionBytes()));
     const { dryRun: dryRunStatuses } = await this.operations.dryRun({
       encodedTransactions,
       utxoValidation: utxoValidation || false
@@ -7409,7 +7603,7 @@ var Provider = class _Provider {
     const chainInfo = await this.getChain();
     const { gasPriceFactor, maxGasPerTx } = await this.getGasConfig();
     const minGas = transactionRequest.calculateMinGas(chainInfo);
-    if (!(0, import_utils31.isDefined)(gasPrice)) {
+    if (!(0, import_utils32.isDefined)(gasPrice)) {
       gasPrice = await this.estimateGasPrice(10);
     }
     const minFee = calculateGasFee({
@@ -7461,7 +7655,7 @@ var Provider = class _Provider {
     if (estimateTxDependencies) {
       return this.estimateTxDependencies(transactionRequest);
     }
-    const encodedTransactions = [(0, import_utils31.hexlify)(transactionRequest.toTransactionBytes())];
+    const encodedTransactions = [(0, import_utils32.hexlify)(transactionRequest.toTransactionBytes())];
     const { dryRun: dryRunStatuses } = await this.operations.dryRun({
       encodedTransactions,
       utxoValidation: true
@@ -7624,7 +7818,7 @@ var Provider = class _Provider {
     const {
       assembleTx: { status, transaction: gqlTransaction, gasPrice }
     } = await this.operations.assembleTx({
-      tx: (0, import_utils31.hexlify)(request2.toTransactionBytes()),
+      tx: (0, import_utils32.hexlify)(request2.toTransactionBytes()),
       blockHorizon: String(blockHorizon),
       feeAddressIndex: String(feePayerIndex),
       requiredBalances,
@@ -7676,7 +7870,7 @@ var Provider = class _Provider {
         paginationLimit: RESOURCES_PAGE_SIZE_LIMIT,
         inputArgs: paginationArgs
       }),
-      filter: { owner: ownerAddress.toB256(), assetId: assetId && (0, import_utils31.hexlify)(assetId) }
+      filter: { owner: ownerAddress.toB256(), assetId: assetId && (0, import_utils32.hexlify)(assetId) }
     });
     const coins = edges.map(({ node }) => ({
       id: node.utxoId,
@@ -7708,7 +7902,7 @@ var Provider = class _Provider {
     const coinsQuery = {
       owner: ownerAddress.toB256(),
       queryPerAsset: quantities.map(coinQuantityfy).map(({ assetId, amount, max: maxPerAsset }) => ({
-        assetId: (0, import_utils31.hexlify)(assetId),
+        assetId: (0, import_utils32.hexlify)(assetId),
         amount: (amount.eqn(0) ? (0, import_math19.bn)(1) : amount).toString(10),
         max: maxPerAsset ? maxPerAsset.toString(10) : void 0
       })),
@@ -7866,7 +8060,7 @@ var Provider = class _Provider {
       },
       transactionIds: block.transactions.map((tx) => tx.id),
       transactions: block.transactions.map(
-        (tx) => new import_transactions25.TransactionCoder().decode((0, import_utils31.arrayify)(tx.rawPayload), 0)?.[0]
+        (tx) => new import_transactions25.TransactionCoder().decode((0, import_utils32.arrayify)(tx.rawPayload), 0)?.[0]
       )
     };
   }
@@ -7883,7 +8077,7 @@ var Provider = class _Provider {
     }
     try {
       return new import_transactions25.TransactionCoder().decode(
-        (0, import_utils31.arrayify)(transaction.rawPayload),
+        (0, import_utils32.arrayify)(transaction.rawPayload),
         0
       )?.[0];
     } catch (error) {
@@ -7911,7 +8105,7 @@ var Provider = class _Provider {
     const coder = new import_transactions25.TransactionCoder();
     const transactions = edges.map(({ node: { rawPayload } }) => {
       try {
-        return coder.decode((0, import_utils31.arrayify)(rawPayload), 0)[0];
+        return coder.decode((0, import_utils32.arrayify)(rawPayload), 0)[0];
       } catch (error) {
         if (error instanceof import_errors20.FuelError && error.code === import_errors20.ErrorCode.UNSUPPORTED_TRANSACTION_TYPE) {
           console.warn("Unsupported transaction type encountered");
@@ -7960,7 +8154,7 @@ var Provider = class _Provider {
   async getContractBalance(contractId, assetId) {
     const { contractBalance } = await this.operations.getContractBalance({
       contract: new import_address3.Address(contractId).toB256(),
-      asset: (0, import_utils31.hexlify)(assetId)
+      asset: (0, import_utils32.hexlify)(assetId)
     });
     return (0, import_math19.bn)(contractBalance.amount, 10);
   }
@@ -7974,7 +8168,7 @@ var Provider = class _Provider {
   async getBalance(owner, assetId) {
     const { balance } = await this.operations.getBalanceV2({
       owner: new import_address3.Address(owner).toB256(),
-      assetId: (0, import_utils31.hexlify)(assetId)
+      assetId: (0, import_utils32.hexlify)(assetId)
     });
     return (0, import_math19.bn)(balance.amountU128, 10);
   }
@@ -8179,7 +8373,7 @@ var Provider = class _Provider {
   async produceBlocks(amount, startTime) {
     const { produceBlocks: latestBlockHeight } = await this.operations.produceBlocks({
       blocksToProduce: (0, import_math19.bn)(amount).toString(10),
-      startTimestamp: startTime ? import_utils31.DateTime.fromUnixMilliseconds(startTime).toTai64() : void 0
+      startTimestamp: startTime ? import_utils32.DateTime.fromUnixMilliseconds(startTime).toTai64() : void 0
     });
     return (0, import_math19.bn)(latestBlockHeight);
   }
@@ -8231,7 +8425,11 @@ var Provider = class _Provider {
    */
   async getTransactionResponse(transactionId) {
     const chainId = await this.getChainId();
-    return new TransactionResponse(transactionId, this, chainId);
+    return new TransactionResponse({
+      transactionRequestOrId: transactionId,
+      provider: this,
+      chainId
+    });
   }
   /**
    * Returns Message for given nonce.
@@ -8282,18 +8480,21 @@ var Provider = class _Provider {
   extractDryRunError(transactionRequest, receipts, reason) {
     let logs = [];
     let groupedLogs = {};
+    let abis;
     if (transactionRequest.type === import_transactions25.TransactionType.Script && transactionRequest.abis) {
       ({ logs, groupedLogs } = getAllDecodedLogs({
         receipts,
         mainAbi: transactionRequest.abis.main,
         externalAbis: transactionRequest.abis.otherContractsAbis
       }));
+      abis = transactionRequest.abis;
     }
     return extractTxError({
       logs,
       groupedLogs,
       receipts,
-      statusReason: reason
+      statusReason: reason,
+      abis
     });
   }
   /**
@@ -8332,8 +8533,8 @@ var Provider = class _Provider {
    */
   async adjustResourcesToIgnoreForAddresses(addresses, resourcesIdsToIgnore) {
     const final = {
-      messages: resourcesIdsToIgnore?.messages?.map((nonce) => (0, import_utils31.hexlify)(nonce)) || [],
-      utxos: resourcesIdsToIgnore?.utxos?.map((id) => (0, import_utils31.hexlify)(id)) || []
+      messages: resourcesIdsToIgnore?.messages?.map((nonce) => (0, import_utils32.hexlify)(nonce)) || [],
+      utxos: resourcesIdsToIgnore?.utxos?.map((id) => (0, import_utils32.hexlify)(id)) || []
     };
     if (this.cache) {
       const cache2 = this.cache;
@@ -8365,7 +8566,7 @@ var Provider = class _Provider {
 var import_errors21 = require("@fuel-ts/errors");
 var import_math20 = require("@fuel-ts/math");
 var import_transactions26 = require("@fuel-ts/transactions");
-var import_utils33 = require("@fuel-ts/utils");
+var import_utils34 = require("@fuel-ts/utils");
 async function getTransactionSummary(params) {
   const { id, provider, abiMap } = params;
   const { transaction: gqlTransaction } = await provider.operations.getTransactionWithReceipts({
@@ -8378,7 +8579,7 @@ async function getTransactionSummary(params) {
     );
   }
   const [decodedTransaction] = new import_transactions26.TransactionCoder().decode(
-    (0, import_utils33.arrayify)(gqlTransaction.rawPayload),
+    (0, import_utils34.arrayify)(gqlTransaction.rawPayload),
     0
   );
   let txReceipts = [];
@@ -8400,7 +8601,7 @@ async function getTransactionSummary(params) {
     id: gqlTransaction.id,
     receipts,
     transaction: decodedTransaction,
-    transactionBytes: (0, import_utils33.arrayify)(gqlTransaction.rawPayload),
+    transactionBytes: (0, import_utils34.arrayify)(gqlTransaction.rawPayload),
     gqlTransactionStatus: gqlTransaction.status,
     gasPerByte: (0, import_math20.bn)(gasPerByte),
     gasPriceFactor: (0, import_math20.bn)(gasPriceFactor),
@@ -8466,7 +8667,7 @@ async function getTransactionsSummaries(params) {
   const transactions = edges.map((edge) => {
     const { node: gqlTransaction } = edge;
     const { id, rawPayload, status } = gqlTransaction;
-    const [decodedTransaction] = new import_transactions26.TransactionCoder().decode((0, import_utils33.arrayify)(rawPayload), 0);
+    const [decodedTransaction] = new import_transactions26.TransactionCoder().decode((0, import_utils34.arrayify)(rawPayload), 0);
     let txReceipts = [];
     if (gqlTransaction?.status && "receipts" in gqlTransaction.status) {
       txReceipts = gqlTransaction.status.receipts;
@@ -8476,7 +8677,7 @@ async function getTransactionsSummaries(params) {
       id,
       receipts,
       transaction: decodedTransaction,
-      transactionBytes: (0, import_utils33.arrayify)(rawPayload),
+      transactionBytes: (0, import_utils34.arrayify)(rawPayload),
       gqlTransactionStatus: status,
       abiMap,
       gasPerByte,
@@ -8502,7 +8703,7 @@ __name(getTransactionsSummaries, "getTransactionsSummaries");
 // src/providers/transaction-summary/assemble-transaction-summary-from-serialized.ts
 var import_math21 = require("@fuel-ts/math");
 var import_transactions27 = require("@fuel-ts/transactions");
-var import_utils34 = require("@fuel-ts/utils");
+var import_utils35 = require("@fuel-ts/utils");
 var assembleTransactionSummaryFromJson = /* @__PURE__ */ __name(async (opts) => {
   const { provider, transactionSummary } = opts;
   const { id, transactionBytes, gasPrice, receipts } = transactionSummary;
@@ -8514,7 +8715,7 @@ var assembleTransactionSummaryFromJson = /* @__PURE__ */ __name(async (opts) =>
       gasCosts
     }
   } = await provider.getChain();
-  const deserializedTransactionBytes = (0, import_utils34.arrayify)(transactionBytes);
+  const deserializedTransactionBytes = (0, import_utils35.arrayify)(transactionBytes);
   const [transaction] = new import_transactions27.TransactionCoder().decode(deserializedTransactionBytes, 0);
   return assembleTransactionSummary({
     id,
@@ -8559,7 +8760,12 @@ var deserializeTransactionResponseJson = /* @__PURE__ */ __name((json) => {
   } = json;
   const provider = new Provider(providerUrl, { cache: providerCache });
   const { chainId } = providerCache.chain.consensusParameters;
-  const response = new TransactionResponse(id, provider, Number(chainId), abis);
+  const response = new TransactionResponse({
+    transactionRequestOrId: id,
+    provider,
+    chainId: Number(chainId),
+    abis
+  });
   if (requestJson) {
     response.request = transactionRequestify(JSON.parse(requestJson));
   }
@@ -8576,18 +8782,166 @@ var AbstractAccount = class {
   }
 };
 
-// src/utils/formatTransferToContractScriptData.ts
-var import_abi_coder6 = require("@fuel-ts/abi-coder");
+// src/utils/consolidate-coins.ts
 var import_address4 = require("@fuel-ts/address");
-var import_utils35 = require("@fuel-ts/utils");
+var import_errors22 = require("@fuel-ts/errors");
+var import_math22 = require("@fuel-ts/math");
+var import_transactions28 = require("@fuel-ts/transactions");
+var import_ramda9 = require("ramda");
+var CONSOLIDATABLE_ERROR_CODES = [import_errors22.ErrorCode.MAX_COINS_REACHED];
+var consolidateCoinsIfRequired = /* @__PURE__ */ __name(async (opts) => {
+  const { error: errorUnknown, account, skipAutoConsolidation = false } = opts;
+  if (skipAutoConsolidation) {
+    return false;
+  }
+  const error = import_errors22.FuelError.parse(errorUnknown);
+  if (CONSOLIDATABLE_ERROR_CODES.includes(error.code)) {
+    const { assetId, owner } = error.metadata;
+    return account.startConsolidation({
+      owner,
+      assetId
+    });
+  }
+  return false;
+}, "consolidateCoinsIfRequired");
+var getAllCoins = /* @__PURE__ */ __name(async (account, assetId) => {
+  const all = [];
+  let hasNextPage = true;
+  let after;
+  while (hasNextPage) {
+    const { coins, pageInfo } = await account.getCoins(assetId, { after });
+    all.push(...coins);
+    after = coins.pop()?.id;
+    hasNextPage = pageInfo.hasNextPage;
+  }
+  return { coins: all };
+}, "getAllCoins");
+var sortCoins = /* @__PURE__ */ __name(({ coins }) => coins.sort((a, b) => b.amount.cmp(a.amount)), "sortCoins");
+var createOuputCoin = /* @__PURE__ */ __name((opts) => {
+  const { transactionId, outputs, baseAssetId } = opts;
+  const outputChangeIndex = outputs.findIndex(
+    (output) => output.type === import_transactions28.OutputType.Change && output.assetId === baseAssetId
+  );
+  if (outputChangeIndex === -1) {
+    throw new import_errors22.FuelError(import_errors22.ErrorCode.UNKNOWN, "No change output found");
+  }
+  const outputCoin = outputs[outputChangeIndex];
+  const outputIndexPadded = Number(outputChangeIndex).toString().padStart(4, "0");
+  return {
+    id: `${transactionId}${outputIndexPadded}`,
+    assetId: outputCoin.assetId,
+    amount: outputCoin.amount,
+    owner: new import_address4.Address(outputCoin.to),
+    blockCreated: (0, import_math22.bn)(0),
+    txCreatedIdx: (0, import_math22.bn)(0)
+  };
+}, "createOuputCoin");
+var consolidateCoins = /* @__PURE__ */ __name(async ({
+  account,
+  assetId
+}) => {
+  const chainInfo = await account.provider.getChain();
+  const chainId = chainInfo.consensusParameters.chainId.toNumber();
+  const gasPrice = await account.provider.estimateGasPrice(10);
+  const maxInputs = chainInfo.consensusParameters.txParameters.maxInputs.toNumber();
+  const baseAssetId = await account.provider.getBaseAssetId();
+  const isBaseAsset = assetId === baseAssetId;
+  const batchSize = maxInputs;
+  const numberOfFundingCoins = maxInputs;
+  let funding = [];
+  let dust = [];
+  if (isBaseAsset) {
+    const coins = await getAllCoins(account, baseAssetId).then(sortCoins);
+    funding = coins.slice(0, numberOfFundingCoins);
+    dust = coins.slice(numberOfFundingCoins);
+  } else {
+    funding = await getAllCoins(account, baseAssetId).then(sortCoins).then((coins) => coins.slice(0, numberOfFundingCoins));
+    dust = await getAllCoins(account, assetId).then(({ coins }) => coins);
+  }
+  if (funding.length === 0) {
+    throw new import_errors22.FuelError(
+      import_errors22.ErrorCode.INSUFFICIENT_FUNDS,
+      `Insufficient funds to consolidate.
+	Asset ID: ${baseAssetId}
+	Owner: ${account.address.toB256()}`
+    );
+  }
+  const batches = [
+    ...(0, import_ramda9.splitEvery)(batchSize, funding),
+    // We leave one coin for the funding coin
+    ...(0, import_ramda9.splitEvery)(batchSize - 1, dust)
+  ];
+  const txs = batches.map((batch) => {
+    const request2 = new ScriptTransactionRequest({
+      scriptData: "0x"
+    });
+    request2.addResources(batch);
+    return request2;
+  });
+  const submitAll = /* @__PURE__ */ __name(async (opts = {}) => {
+    const txResponses = [];
+    let previousTx;
+    for (let i = 0; i < txs.length; i++) {
+      let currentTx = txs[i];
+      const step = i + 1;
+      if (previousTx) {
+        const coin = createOuputCoin({
+          transactionId: previousTx.transactionId,
+          outputs: previousTx.outputs,
+          baseAssetId
+        });
+        currentTx.addResource(coin);
+      }
+      if ("populateTransactionPredicateData" in account && typeof account.populateTransactionPredicateData === "function") {
+        currentTx = account.populateTransactionPredicateData(currentTx);
+        currentTx = await account.provider.estimatePredicates(currentTx);
+      }
+      const fee = calculateGasFee({
+        gasPrice,
+        gas: currentTx.calculateMinGas(chainInfo),
+        priceFactor: chainInfo.consensusParameters.feeParameters.gasPriceFactor,
+        tip: currentTx.tip
+      });
+      currentTx.maxFee = fee;
+      currentTx.gasLimit = (0, import_math22.bn)(1e3);
+      opts.onTransactionStart?.({
+        tx: currentTx,
+        step,
+        assetId,
+        transactionId: currentTx.getTransactionId(chainId)
+      });
+      const response = await account.sendTransaction(currentTx);
+      const result = await response.waitForResult();
+      txResponses.push(result);
+      previousTx = {
+        transactionId: response.id,
+        outputs: result.transaction.outputs
+      };
+    }
+    return {
+      txResponses,
+      errors: []
+    };
+  }, "submitAll");
+  return {
+    txs,
+    totalFeeCost: txs.reduce((acc, request2) => acc.add(request2.maxFee), (0, import_math22.bn)(0)),
+    submitAll
+  };
+}, "consolidateCoins");
+
+// src/utils/formatTransferToContractScriptData.ts
+var import_abi_coder8 = require("@fuel-ts/abi-coder");
+var import_address5 = require("@fuel-ts/address");
+var import_utils36 = require("@fuel-ts/utils");
 var asm = __toESM(require("@fuels/vm-asm"));
 var formatTransferToContractScriptData = /* @__PURE__ */ __name((transferParams) => {
-  const numberCoder = new import_abi_coder6.BigNumberCoder("u64");
+  const numberCoder = new import_abi_coder8.BigNumberCoder("u64");
   return transferParams.reduce((acc, transferParam) => {
     const { assetId, amount, contractId } = transferParam;
     const encoded = numberCoder.encode(amount);
-    const scriptData = (0, import_utils35.concat)([new import_address4.Address(contractId).toBytes(), encoded, (0, import_utils35.arrayify)(assetId)]);
-    return (0, import_utils35.concat)([acc, scriptData]);
+    const scriptData = (0, import_utils36.concat)([new import_address5.Address(contractId).toBytes(), encoded, (0, import_utils36.arrayify)(assetId)]);
+    return (0, import_utils36.concat)([acc, scriptData]);
   }, new Uint8Array());
 }, "formatTransferToContractScriptData");
 var assembleTransferToContractScript = /* @__PURE__ */ __name(async (transferParams) => {
@@ -8595,24 +8949,24 @@ var assembleTransferToContractScript = /* @__PURE__ */ __name(async (transferPar
   await asm.initWasm();
   let script = new Uint8Array();
   transferParams.forEach((_, i) => {
-    const offset = (import_abi_coder6.CONTRACT_ID_LEN + import_abi_coder6.WORD_SIZE + import_abi_coder6.ASSET_ID_LEN) * i;
-    script = (0, import_utils35.concat)([
+    const offset = (import_abi_coder8.CONTRACT_ID_LEN + import_abi_coder8.WORD_SIZE + import_abi_coder8.ASSET_ID_LEN) * i;
+    script = (0, import_utils36.concat)([
       script,
       // Load ScriptData into register 0x10.
       asm.gtf(16, 0, asm.GTFArgs.ScriptData).to_bytes(),
       // Add the offset to 0x10 so it will point to the current contract ID, store in 0x11.
       asm.addi(17, 16, offset).to_bytes(),
       // Add CONTRACT_ID_LEN to 0x11 to point to the amount in the ScriptData, store in 0x12.
-      asm.addi(18, 17, import_abi_coder6.CONTRACT_ID_LEN).to_bytes(),
+      asm.addi(18, 17, import_abi_coder8.CONTRACT_ID_LEN).to_bytes(),
       // Load word to the amount at 0x12 into register 0x13.
       asm.lw(19, 18, 0).to_bytes(),
       // Add WORD_SIZE to 0x12 to point to the asset ID in the ScriptData, store in 0x14.
-      asm.addi(20, 18, import_abi_coder6.WORD_SIZE).to_bytes(),
+      asm.addi(20, 18, import_abi_coder8.WORD_SIZE).to_bytes(),
       // Perform the transfer using contract ID in 0x11, amount in 0x13, and asset ID in 0x14.
       asm.tr(17, 19, 20).to_bytes()
     ]);
   });
-  script = (0, import_utils35.concat)([script, asm.ret(1).to_bytes()]);
+  script = (0, import_utils36.concat)([script, asm.ret(1).to_bytes()]);
   return { script, scriptData };
 }, "assembleTransferToContractScript");
 
@@ -8657,7 +9011,7 @@ var Account = class extends AbstractAccount {
     super();
     this._provider = provider;
     this._connector = connector;
-    this.address = new import_address5.Address(address);
+    this.address = new import_address6.Address(address);
   }
   /**
    * The provider used to interact with the network.
@@ -8668,7 +9022,7 @@ var Account = class extends AbstractAccount {
    */
   get provider() {
     if (!this._provider) {
-      throw new import_errors22.FuelError(import_errors22.ErrorCode.MISSING_PROVIDER, "Provider not set");
+      throw new import_errors23.FuelError(import_errors23.ErrorCode.MISSING_PROVIDER, "Provider not set");
     }
     return this._provider;
   }
@@ -8695,10 +9049,24 @@ var Account = class extends AbstractAccount {
    *
    * @param quantities - Quantities of resources to be obtained.
    * @param resourcesIdsToIgnore - IDs of resources to be excluded from the query (optional).
+   * @param skipAutoConsolidation - Whether to skip the automatic consolidatation of coins process (optional).
    * @returns A promise that resolves to an array of Resources.
    */
-  async getResourcesToSpend(quantities, resourcesIdsToIgnore) {
-    return this.provider.getResourcesToSpend(this.address, quantities, resourcesIdsToIgnore);
+  async getResourcesToSpend(quantities, resourcesIdsToIgnore, { skipAutoConsolidation } = {}) {
+    const getResourcesToSpend = /* @__PURE__ */ __name(() => this.provider.getResourcesToSpend(this.address, quantities, resourcesIdsToIgnore), "getResourcesToSpend");
+    try {
+      return await getResourcesToSpend();
+    } catch (error) {
+      const shouldRetry = await consolidateCoinsIfRequired({
+        error,
+        account: this,
+        skipAutoConsolidation
+      });
+      if (!shouldRetry) {
+        throw error;
+      }
+      return await getResourcesToSpend();
+    }
   }
   /**
    * Retrieves coins owned by the account.
@@ -8747,7 +9115,7 @@ var Account = class extends AbstractAccount {
    * @deprecated Use provider.assembleTx instead
    * Check the migration guide https://docs.fuel.network/docs/fuels-ts/transactions/assemble-tx-migration-guide/ for more information.
    */
-  async fund(request2, params) {
+  async fund(request2, params, { skipAutoConsolidation } = {}) {
     const {
       addedSignatures,
       estimatedPredicates,
@@ -8759,9 +9127,9 @@ var Account = class extends AbstractAccount {
     const chainId = await this.provider.getChainId();
     const fee = request2.maxFee;
     const baseAssetId = await this.provider.getBaseAssetId();
-    const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || (0, import_math22.bn)(0);
+    const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || (0, import_math23.bn)(0);
     const requiredQuantitiesWithFee = addAmountToCoinQuantities({
-      amount: (0, import_math22.bn)(fee),
+      amount: (0, import_math23.bn)(fee),
       assetId: baseAssetId,
       coinQuantities: requiredQuantities
     });
@@ -8769,7 +9137,7 @@ var Account = class extends AbstractAccount {
     requiredQuantitiesWithFee.forEach(({ amount, assetId }) => {
       quantitiesDict[assetId] = {
         required: amount,
-        owned: (0, import_math22.bn)(0)
+        owned: (0, import_math23.bn)(0)
       };
     });
     request2.inputs.filter(isRequestInputResource).forEach((input) => {
@@ -8793,11 +9161,12 @@ var Account = class extends AbstractAccount {
     while (needsToBeFunded && fundingAttempts < MAX_FUNDING_ATTEMPTS) {
       const resources = await this.getResourcesToSpend(
         missingQuantities,
-        cacheRequestInputsResourcesFromOwner(request2.inputs, this.address)
+        cacheRequestInputsResourcesFromOwner(request2.inputs, this.address),
+        { skipAutoConsolidation }
       );
       request2.addResources(resources);
       request2.updatePredicateGasUsed(estimatedPredicates);
-      const requestToReestimate2 = (0, import_ramda9.clone)(request2);
+      const requestToReestimate2 = (0, import_ramda10.clone)(request2);
       if (addedSignatures) {
         Array.from({ length: addedSignatures }).forEach(
           () => requestToReestimate2.addEmptyWitness()
@@ -8830,15 +9199,15 @@ var Account = class extends AbstractAccount {
       fundingAttempts += 1;
     }
     if (needsToBeFunded) {
-      throw new import_errors22.FuelError(
-        import_errors22.ErrorCode.INSUFFICIENT_FUNDS_OR_MAX_COINS,
+      throw new import_errors23.FuelError(
+        import_errors23.ErrorCode.INSUFFICIENT_FUNDS,
         `The account ${this.address} does not have enough base asset funds to cover the transaction execution.`
       );
     }
     request2.updateState(chainId, "funded", transactionSummary);
     await this.provider.validateTransaction(request2);
     request2.updatePredicateGasUsed(estimatedPredicates);
-    const requestToReestimate = (0, import_ramda9.clone)(request2);
+    const requestToReestimate = (0, import_ramda10.clone)(request2);
     if (addedSignatures) {
       Array.from({ length: addedSignatures }).forEach(() => requestToReestimate.addEmptyWitness());
     }
@@ -8859,16 +9228,20 @@ var Account = class extends AbstractAccount {
    * @param amount - The amount of coins to transfer.
    * @param assetId - The asset ID of the coins to transfer (optional).
    * @param txParams - The transaction parameters (optional).
+   * @param skipAutoConsolidation - Whether to skip the automatic consolidatation of coins process (optional).
    * @returns A promise that resolves to the prepared transaction request.
    */
-  async createTransfer(destination, amount, assetId, txParams = {}) {
+  async createTransfer(destination, amount, assetId, txParams = {}, { skipAutoConsolidation } = {}) {
     let request2 = new ScriptTransactionRequest(txParams);
     request2 = this.addTransfer(request2, {
       destination,
       amount,
       assetId: assetId || await this.provider.getBaseAssetId()
     });
-    const { gasPrice, transactionRequest } = await this.assembleTx(request2);
+    const { gasPrice, transactionRequest } = await this.assembleTx({
+      transactionRequest: request2,
+      skipAutoConsolidation
+    });
     request2 = await setAndValidateGasAndFeeForAssembledTx({
       gasPrice,
       provider: this.provider,
@@ -8885,10 +9258,13 @@ var Account = class extends AbstractAccount {
    * @param amount - The amount of coins to transfer.
    * @param assetId - The asset ID of the coins to transfer (optional).
    * @param txParams - The transaction parameters (optional).
+   * @param skipAutoConsolidation - Whether to skip the automatic consolidatation of coins process (optional).
    * @returns A promise that resolves to the transaction response.
    */
-  async transfer(destination, amount, assetId, txParams = {}) {
-    const request2 = await this.createTransfer(destination, amount, assetId, txParams);
+  async transfer(destination, amount, assetId, txParams = {}, { skipAutoConsolidation } = {}) {
+    const request2 = await this.createTransfer(destination, amount, assetId, txParams, {
+      skipAutoConsolidation
+    });
     return this.sendTransaction(request2, { estimateTxDependencies: false });
   }
   /**
@@ -8896,12 +9272,16 @@ var Account = class extends AbstractAccount {
    *
    * @param transferParams - An array of `TransferParams` objects representing the transfers to be made.
    * @param txParams - Optional transaction parameters.
+   * @param skipAutoConsolidation - Whether to skip the automatic consolidatation of coins process (optional).
    * @returns A promise that resolves to a `TransactionResponse` object representing the transaction result.
    */
-  async batchTransfer(transferParams, txParams = {}) {
+  async batchTransfer(transferParams, txParams = {}, { skipAutoConsolidation } = {}) {
     let request2 = new ScriptTransactionRequest(txParams);
     request2 = this.addBatchTransfer(request2, transferParams);
-    const { gasPrice, transactionRequest } = await this.assembleTx(request2);
+    const { gasPrice, transactionRequest } = await this.assembleTx({
+      transactionRequest: request2,
+      skipAutoConsolidation
+    });
     request2 = await setAndValidateGasAndFeeForAssembledTx({
       gasPrice,
       provider: this.provider,
@@ -8921,7 +9301,7 @@ var Account = class extends AbstractAccount {
   addTransfer(request2, transferParams) {
     const { destination, amount, assetId } = transferParams;
     this.validateTransferAmount(amount);
-    request2.addCoinOutput(new import_address5.Address(destination), amount, assetId);
+    request2.addCoinOutput(new import_address6.Address(destination), amount, assetId);
     return request2;
   }
   /**
@@ -8948,24 +9328,27 @@ var Account = class extends AbstractAccount {
    * @param amount - The amount of coins to transfer.
    * @param assetId - The asset ID of the coins to transfer (optional).
    * @param txParams - The transaction parameters (optional).
+   * @param skipAutoConsolidation - Whether to skip the automatic consolidatation of coins process (optional).
    * @returns A promise that resolves to the transaction response.
    */
-  async transferToContract(contractId, amount, assetId, txParams = {}) {
-    return this.batchTransferToContracts([{ amount, assetId, contractId }], txParams);
+  async transferToContract(contractId, amount, assetId, txParams = {}, { skipAutoConsolidation } = {}) {
+    return this.batchTransferToContracts([{ amount, assetId, contractId }], txParams, {
+      skipAutoConsolidation
+    });
   }
-  async batchTransferToContracts(contractTransferParams, txParams = {}) {
+  async batchTransferToContracts(contractTransferParams, txParams = {}, { skipAutoConsolidation } = {}) {
     let request2 = new ScriptTransactionRequest({
       ...txParams
     });
     const quantities = [];
     const defaultAssetId = await this.provider.getBaseAssetId();
     const transferParams = contractTransferParams.map((transferParam) => {
-      const amount = (0, import_math22.bn)(transferParam.amount);
-      const contractAddress = new import_address5.Address(transferParam.contractId);
-      const assetId = transferParam.assetId ? (0, import_utils36.hexlify)(transferParam.assetId) : defaultAssetId;
+      const amount = (0, import_math23.bn)(transferParam.amount);
+      const contractAddress = new import_address6.Address(transferParam.contractId);
+      const assetId = transferParam.assetId ? (0, import_utils37.hexlify)(transferParam.assetId) : defaultAssetId;
       if (amount.lte(0)) {
-        throw new import_errors22.FuelError(
-          import_errors22.ErrorCode.INVALID_TRANSFER_AMOUNT,
+        throw new import_errors23.FuelError(
+          import_errors23.ErrorCode.INVALID_TRANSFER_AMOUNT,
           "Transfer amount must be a positive number."
         );
       }
@@ -8980,7 +9363,11 @@ var Account = class extends AbstractAccount {
     const { script, scriptData } = await assembleTransferToContractScript(transferParams);
     request2.script = script;
     request2.scriptData = scriptData;
-    const { gasPrice, transactionRequest } = await this.assembleTx(request2, quantities);
+    const { gasPrice, transactionRequest } = await this.assembleTx({
+      transactionRequest: request2,
+      quantities,
+      skipAutoConsolidation
+    });
     request2 = await setAndValidateGasAndFeeForAssembledTx({
       gasPrice,
       provider: this.provider,
@@ -8996,26 +9383,31 @@ var Account = class extends AbstractAccount {
    * @param recipient - Address of the recipient on the base chain.
    * @param amount - Amount of base asset.
    * @param txParams - The transaction parameters (optional).
+   * @param skipAutoConsolidation - Whether to skip the automatic consolidatation of coins process (optional).
    * @returns A promise that resolves to the transaction response.
    */
-  async withdrawToBaseLayer(recipient, amount, txParams = {}) {
-    const recipientAddress = new import_address5.Address(recipient);
-    const recipientDataArray = (0, import_utils36.arrayify)(
+  async withdrawToBaseLayer(recipient, amount, txParams = {}, { skipAutoConsolidation } = {}) {
+    const recipientAddress = new import_address6.Address(recipient);
+    const recipientDataArray = (0, import_utils37.arrayify)(
       "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
     );
-    const amountDataArray = (0, import_utils36.arrayify)(
-      "0x".concat((0, import_math22.bn)(amount).toHex().substring(2).padStart(16, "0"))
+    const amountDataArray = (0, import_utils37.arrayify)(
+      "0x".concat((0, import_math23.bn)(amount).toHex().substring(2).padStart(16, "0"))
     );
     const script = new Uint8Array([
-      ...(0, import_utils36.arrayify)(withdrawScript.bytes),
+      ...(0, import_utils37.arrayify)(withdrawScript.bytes),
       ...recipientDataArray,
       ...amountDataArray
     ]);
     const params = { script, ...txParams };
     const baseAssetId = await this.provider.getBaseAssetId();
     let request2 = new ScriptTransactionRequest(params);
-    const quantities = [{ amount: (0, import_math22.bn)(amount), assetId: baseAssetId }];
-    const { gasPrice, transactionRequest } = await this.assembleTx(request2, quantities);
+    const quantities = [{ amount: (0, import_math23.bn)(amount), assetId: baseAssetId }];
+    const { gasPrice, transactionRequest } = await this.assembleTx({
+      transactionRequest: request2,
+      quantities,
+      skipAutoConsolidation
+    });
     request2 = await setAndValidateGasAndFeeForAssembledTx({
       gasPrice,
       provider: this.provider,
@@ -9025,6 +9417,25 @@ var Account = class extends AbstractAccount {
     });
     return this.sendTransaction(request2);
   }
+  /**
+   * Start the consolidation process
+   *
+   * @param owner - The B256 address of the owner.
+   * @param assetId - The asset ID that requires consolidation.
+   */
+  async startConsolidation(opts) {
+    if (this._connector) {
+      await this._connector.startConsolidation(opts);
+      return false;
+    }
+    const { owner, assetId } = opts;
+    if (owner !== this.address.toB256()) {
+      return false;
+    }
+    const { submitAll } = await consolidateCoins({ account: this, assetId });
+    await submitAll();
+    return true;
+  }
   /**
    * Consolidates base asset UTXOs into fewer, larger ones.
    *
@@ -9044,6 +9455,7 @@ var Account = class extends AbstractAccount {
     const isBaseAsset = baseAssetId === assetId;
     let submitAll;
     const consolidationParams = {
+      assetId,
       coins,
       mode: params.mode,
       outputNum: params.outputNum
@@ -9051,10 +9463,7 @@ var Account = class extends AbstractAccount {
     if (isBaseAsset) {
       ({ submitAll } = await this.assembleBaseAssetConsolidationTxs(consolidationParams));
     } else {
-      throw new import_errors22.FuelError(
-        import_errors22.ErrorCode.UNSUPPORTED_FEATURE,
-        "Consolidation for non-base assets is not supported yet."
-      );
+      ({ submitAll } = await this.assembleNonBaseAssetConsolidationTxs(consolidationParams));
     }
     return submitAll();
   }
@@ -9075,7 +9484,7 @@ var Account = class extends AbstractAccount {
     this.validateConsolidationTxsCoins(coins, baseAssetId);
     const chainInfo = await this.provider.getChain();
     const maxInputsNumber = chainInfo.consensusParameters.txParameters.maxInputs.toNumber();
-    let totalFeeCost = (0, import_math22.bn)(0);
+    let totalFeeCost = (0, import_math23.bn)(0);
     const txs = [];
     const coinsBatches = splitCoinsIntoBatches(coins, maxInputsNumber);
     const gasPrice = await this.provider.estimateGasPrice(10);
@@ -9099,10 +9508,10 @@ var Account = class extends AbstractAccount {
       });
       request2.maxFee = fee;
       if (consolidateMoreThanOneCoin) {
-        const total = request2.inputs.filter(isRequestInputCoin).reduce((acc, input) => acc.add(input.amount), (0, import_math22.bn)(0));
+        const total = request2.inputs.filter(isRequestInputCoin).reduce((acc, input) => acc.add(input.amount), (0, import_math23.bn)(0));
         const amountPerNewUtxo = total.div(outputNum + 1);
         request2.outputs.forEach((output) => {
-          if (output.type === import_transactions28.OutputType.Coin) {
+          if (output.type === import_transactions29.OutputType.Coin) {
             output.amount = amountPerNewUtxo;
           }
         });
@@ -9113,6 +9522,70 @@ var Account = class extends AbstractAccount {
     const submitAll = this.prepareSubmitAll({ txs, mode });
     return { txs, totalFeeCost, submitAll };
   }
+  async assembleNonBaseAssetConsolidationTxs(params) {
+    const { assetId, coins, mode = "parallel", outputNum = 1 } = params;
+    this.validateConsolidationTxsCoins(coins, assetId);
+    const chainInfo = await this.provider.getChain();
+    const maxInputsNumber = chainInfo.consensusParameters.txParameters.maxInputs.toNumber();
+    const baseAssetId = chainInfo.consensusParameters.baseAssetId;
+    const { coins: baseAssetCoins } = await this.provider.getCoins(this.address, baseAssetId);
+    let totalFeeCost = (0, import_math23.bn)(0);
+    const txs = [];
+    const gasPrice = await this.provider.estimateGasPrice(10);
+    const consolidateMoreThanOneCoin = outputNum > 1;
+    const assetCoinBatches = splitCoinsIntoBatches(coins, maxInputsNumber);
+    assetCoinBatches.filter((batch) => batch.length > 1).forEach((coinBatch) => {
+      const request2 = new ScriptTransactionRequest({
+        script: "0x"
+      });
+      request2.addResources(coinBatch);
+      if (consolidateMoreThanOneCoin) {
+        Array.from({ length: outputNum - 1 }).forEach(() => {
+          request2.addCoinOutput(this.address, 0, assetId);
+        });
+      }
+      const minGas = request2.calculateMinGas(chainInfo);
+      const fee = calculateGasFee({
+        gasPrice,
+        gas: minGas,
+        priceFactor: chainInfo.consensusParameters.feeParameters.gasPriceFactor,
+        tip: request2.tip
+      });
+      request2.maxFee = fee;
+      if (consolidateMoreThanOneCoin) {
+        const total = request2.inputs.filter(isRequestInputCoin).reduce((acc, input) => acc.add(input.amount), (0, import_math23.bn)(0));
+        const amountPerNewUtxo = total.div(outputNum + 1);
+        request2.outputs.forEach((output) => {
+          if (output.type === import_transactions29.OutputType.Coin) {
+            output.amount = amountPerNewUtxo;
+          }
+        });
+      }
+      totalFeeCost = totalFeeCost.add(fee);
+      const baseAssetResources = [];
+      let fundingFeeTotal = (0, import_math23.bn)(0);
+      while (fundingFeeTotal.lt(fee)) {
+        const baseAssetCoin = baseAssetCoins.pop();
+        if (!baseAssetCoin) {
+          break;
+        }
+        baseAssetResources.push(baseAssetCoin);
+        fundingFeeTotal = fundingFeeTotal.add(baseAssetCoin.amount);
+      }
+      const { inputs } = request2;
+      request2.inputs = inputs.slice(0, maxInputsNumber - baseAssetResources.length);
+      const removedCoins = coinBatch.slice(maxInputsNumber - baseAssetResources.length);
+      request2.addResources(baseAssetResources);
+      const lastCoinBatch = assetCoinBatches[assetCoinBatches.length - 1];
+      lastCoinBatch.push(...removedCoins);
+      if (lastCoinBatch.length > maxInputsNumber) {
+        assetCoinBatches.push(lastCoinBatch.slice(maxInputsNumber));
+      }
+      txs.push(request2);
+    });
+    const submitAll = this.prepareSubmitAll({ txs, mode });
+    return { txs, totalFeeCost, submitAll };
+  }
   /**
    * Prepares a function to submit all transactions either sequentially or in parallel.
    *
@@ -9167,13 +9640,13 @@ var Account = class extends AbstractAccount {
    * Check the migration guide https://docs.fuel.network/docs/fuels-ts/transactions/assemble-tx-migration-guide/ for more information.
    */
   async getTransactionCost(transactionRequestLike, { signatureCallback, quantities = [], gasPrice } = {}) {
-    const txRequestClone = (0, import_ramda9.clone)(transactionRequestify(transactionRequestLike));
+    const txRequestClone = (0, import_ramda10.clone)(transactionRequestify(transactionRequestLike));
     const baseAssetId = await this.provider.getBaseAssetId();
     const coinOutputsQuantities = txRequestClone.getCoinOutputsQuantities();
     const requiredQuantities = mergeQuantities(coinOutputsQuantities, quantities);
-    const transactionFeeForDryRun = [{ assetId: baseAssetId, amount: (0, import_math22.bn)("100000000000000000") }];
+    const transactionFeeForDryRun = [{ assetId: baseAssetId, amount: (0, import_math23.bn)("100000000000000000") }];
     const findAssetInput = /* @__PURE__ */ __name((assetId) => txRequestClone.inputs.find((input) => {
-      if (input.type === import_transactions28.InputType.Coin) {
+      if (input.type === import_transactions29.InputType.Coin) {
         return input.assetId === assetId;
       }
       if (isRequestInputMessageWithoutData(input)) {
@@ -9219,7 +9692,7 @@ var Account = class extends AbstractAccount {
    */
   async signMessage(message) {
     if (!this._connector) {
-      throw new import_errors22.FuelError(import_errors22.ErrorCode.MISSING_CONNECTOR, "A connector is required to sign messages.");
+      throw new import_errors23.FuelError(import_errors23.ErrorCode.MISSING_CONNECTOR, "A connector is required to sign messages.");
     }
     return this._connector.signMessage(this.address.toString(), message);
   }
@@ -9231,8 +9704,8 @@ var Account = class extends AbstractAccount {
    */
   async signTransaction(transactionRequestLike, connectorOptions = {}) {
     if (!this._connector) {
-      throw new import_errors22.FuelError(
-        import_errors22.ErrorCode.MISSING_CONNECTOR,
+      throw new import_errors23.FuelError(
+        import_errors23.ErrorCode.MISSING_CONNECTOR,
         "A connector is required to sign transactions."
       );
     }
@@ -9297,17 +9770,17 @@ var Account = class extends AbstractAccount {
    */
   generateFakeResources(coins) {
     return coins.map((coin) => ({
-      id: (0, import_utils36.hexlify)((0, import_crypto2.randomBytes)(import_abi_coder7.UTXO_ID_LEN)),
+      id: (0, import_utils37.hexlify)((0, import_crypto2.randomBytes)(import_abi_coder9.UTXO_ID_LEN)),
       owner: this.address,
-      blockCreated: (0, import_math22.bn)(1),
-      txCreatedIdx: (0, import_math22.bn)(1),
+      blockCreated: (0, import_math23.bn)(1),
+      txCreatedIdx: (0, import_math23.bn)(1),
       ...coin
     }));
   }
   /** @hidden */
   async prepareTransactionForSend(request2) {
     const { transactionId } = request2.flag;
-    if (!(0, import_utils36.isDefined)(transactionId)) {
+    if (!(0, import_utils37.isDefined)(transactionId)) {
       return request2;
     }
     const chainId = await this.provider.getChainId();
@@ -9320,80 +9793,57 @@ var Account = class extends AbstractAccount {
   /** @hidden */
   async prepareTransactionSummary(request2) {
     const chainId = await this.provider.getChainId();
-    return (0, import_utils36.isDefined)(request2.flag.summary) ? {
+    return (0, import_utils37.isDefined)(request2.flag.summary) ? {
       ...request2.flag.summary,
       id: request2.getTransactionId(chainId),
-      transactionBytes: (0, import_utils36.hexlify)(request2.toTransactionBytes())
+      transactionBytes: (0, import_utils37.hexlify)(request2.toTransactionBytes())
     } : void 0;
   }
   /** @hidden * */
-  async assembleTx(transactionRequest, quantities = []) {
-    const outputQuantities = transactionRequest.outputs.filter((o) => o.type === import_transactions28.OutputType.Coin).map(({ amount, assetId }) => ({ assetId: String(assetId), amount: (0, import_math22.bn)(amount) }));
-    transactionRequest.gasLimit = (0, import_math22.bn)(0);
-    transactionRequest.maxFee = (0, import_math22.bn)(0);
-    const { assembledRequest, gasPrice } = await this.provider.assembleTx({
-      request: transactionRequest,
-      accountCoinQuantities: mergeQuantities(outputQuantities, quantities),
-      feePayerAccount: this
-    });
-    return { transactionRequest: assembledRequest, gasPrice };
+  async assembleTx(opts) {
+    const { transactionRequest, quantities = [], skipAutoConsolidation } = opts;
+    const outputQuantities = transactionRequest.outputs.filter((o) => o.type === import_transactions29.OutputType.Coin).map(({ amount, assetId }) => ({ assetId: String(assetId), amount: (0, import_math23.bn)(amount) }));
+    transactionRequest.gasLimit = (0, import_math23.bn)(0);
+    transactionRequest.maxFee = (0, import_math23.bn)(0);
+    const assembleTx = /* @__PURE__ */ __name(async () => {
+      const { assembledRequest, gasPrice } = await this.provider.assembleTx({
+        request: transactionRequest,
+        accountCoinQuantities: mergeQuantities(outputQuantities, quantities),
+        feePayerAccount: this
+      });
+      return { transactionRequest: assembledRequest, gasPrice };
+    }, "assembleTx");
+    try {
+      return await assembleTx();
+    } catch (error) {
+      const shouldRetry = await consolidateCoinsIfRequired({
+        error,
+        account: this,
+        skipAutoConsolidation
+      });
+      if (!shouldRetry) {
+        throw error;
+      }
+      return await assembleTx();
+    }
   }
   /** @hidden * */
   validateTransferAmount(amount) {
-    if ((0, import_math22.bn)(amount).lte(0)) {
-      throw new import_errors22.FuelError(
-        import_errors22.ErrorCode.INVALID_TRANSFER_AMOUNT,
+    if ((0, import_math23.bn)(amount).lte(0)) {
+      throw new import_errors23.FuelError(
+        import_errors23.ErrorCode.INVALID_TRANSFER_AMOUNT,
         "Transfer amount must be a positive number."
       );
     }
   }
   /** @hidden * */
-  async estimateAndFundTransaction(transactionRequest, txParams, costParams) {
-    let request2 = transactionRequest;
-    const txCost = await this.getTransactionCost(request2, costParams);
-    request2 = this.validateGasLimitAndMaxFee({
-      transactionRequest: request2,
-      gasUsed: txCost.gasUsed,
-      maxFee: txCost.maxFee,
-      txParams
-    });
-    request2 = await this.fund(request2, txCost);
-    return request2;
-  }
-  /** @hidden * */
-  validateGasLimitAndMaxFee({
-    gasUsed,
-    maxFee,
-    transactionRequest,
-    txParams: { gasLimit: setGasLimit, maxFee: setMaxFee }
-  }) {
-    const request2 = transactionRequestify(transactionRequest);
-    if (!(0, import_utils36.isDefined)(setGasLimit)) {
-      request2.gasLimit = gasUsed;
-    } else if (gasUsed.gt(setGasLimit)) {
-      throw new import_errors22.FuelError(
-        import_errors22.ErrorCode.GAS_LIMIT_TOO_LOW,
-        `Gas limit '${setGasLimit}' is lower than the required: '${gasUsed}'.`
-      );
-    }
-    if (!(0, import_utils36.isDefined)(setMaxFee)) {
-      request2.maxFee = maxFee;
-    } else if (maxFee.gt(setMaxFee)) {
-      throw new import_errors22.FuelError(
-        import_errors22.ErrorCode.MAX_FEE_TOO_LOW,
-        `Max fee '${setMaxFee}' is lower than the required: '${maxFee}'.`
-      );
-    }
-    return request2;
-  }
-  /** @hidden * */
   validateConsolidationTxsCoins(coins, assetId) {
     if (coins.length <= 1) {
-      throw new import_errors22.FuelError(import_errors22.ErrorCode.NO_COINS_TO_CONSOLIDATE, "No coins to consolidate.");
+      throw new import_errors23.FuelError(import_errors23.ErrorCode.NO_COINS_TO_CONSOLIDATE, "No coins to consolidate.");
     }
     if (!coins.every((c) => c.assetId === assetId)) {
-      throw new import_errors22.FuelError(
-        import_errors22.ErrorCode.COINS_ASSET_ID_MISMATCH,
+      throw new import_errors23.FuelError(
+        import_errors23.ErrorCode.COINS_ASSET_ID_MISMATCH,
         "All coins to consolidate must be from the same asset id."
       );
     }
@@ -9419,14 +9869,14 @@ var Account = class extends AbstractAccount {
 
 // src/wallet/base-wallet-unlocked.ts
 var import_hasher4 = require("@fuel-ts/hasher");
-var import_utils39 = require("@fuel-ts/utils");
+var import_utils40 = require("@fuel-ts/utils");
 
 // src/signer/signer.ts
-var import_address6 = require("@fuel-ts/address");
+var import_address7 = require("@fuel-ts/address");
 var import_crypto3 = require("@fuel-ts/crypto");
 var import_hasher3 = require("@fuel-ts/hasher");
-var import_math23 = require("@fuel-ts/math");
-var import_utils37 = require("@fuel-ts/utils");
+var import_math24 = require("@fuel-ts/math");
+var import_utils38 = require("@fuel-ts/utils");
 var import_secp256k1 = require("@noble/curves/secp256k1");
 var Signer = class _Signer {
   static {
@@ -9448,11 +9898,11 @@ var Signer = class _Signer {
         privateKey = `0x${privateKey}`;
       }
     }
-    const privateKeyBytes = (0, import_math23.toBytes)(privateKey, 32);
-    this.privateKey = (0, import_utils37.hexlify)(privateKeyBytes);
-    this.publicKey = (0, import_utils37.hexlify)(import_secp256k1.secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
-    this.compressedPublicKey = (0, import_utils37.hexlify)(import_secp256k1.secp256k1.getPublicKey(privateKeyBytes, true));
-    this.address = new import_address6.Address(this.publicKey);
+    const privateKeyBytes = (0, import_math24.toBytes)(privateKey, 32);
+    this.privateKey = (0, import_utils38.hexlify)(privateKeyBytes);
+    this.publicKey = (0, import_utils38.hexlify)(import_secp256k1.secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
+    this.compressedPublicKey = (0, import_utils38.hexlify)(import_secp256k1.secp256k1.getPublicKey(privateKeyBytes, true));
+    this.address = new import_address7.Address(this.publicKey);
   }
   /**
    * Sign data using the Signer instance
@@ -9465,11 +9915,11 @@ var Signer = class _Signer {
    * @returns hashed signature
    */
   sign(data) {
-    const signature = import_secp256k1.secp256k1.sign((0, import_utils37.arrayify)(data), (0, import_utils37.arrayify)(this.privateKey));
-    const r = (0, import_math23.toBytes)(`0x${signature.r.toString(16)}`, 32);
-    const s = (0, import_math23.toBytes)(`0x${signature.s.toString(16)}`, 32);
+    const signature = import_secp256k1.secp256k1.sign((0, import_utils38.arrayify)(data), (0, import_utils38.arrayify)(this.privateKey));
+    const r = (0, import_math24.toBytes)(`0x${signature.r.toString(16)}`, 32);
+    const s = (0, import_math24.toBytes)(`0x${signature.s.toString(16)}`, 32);
     s[0] |= (signature.recovery || 0) << 7;
-    return (0, import_utils37.hexlify)((0, import_utils37.concat)([r, s]));
+    return (0, import_utils38.hexlify)((0, import_utils38.concat)([r, s]));
   }
   /**
    * Add point on the current elliptic curve
@@ -9478,8 +9928,8 @@ var Signer = class _Signer {
    * @returns compressed point on the curve
    */
   addPoint(point) {
-    const p0 = import_secp256k1.secp256k1.ProjectivePoint.fromHex((0, import_utils37.arrayify)(this.compressedPublicKey));
-    const p1 = import_secp256k1.secp256k1.ProjectivePoint.fromHex((0, import_utils37.arrayify)(point));
+    const p0 = import_secp256k1.secp256k1.ProjectivePoint.fromHex((0, import_utils38.arrayify)(this.compressedPublicKey));
+    const p1 = import_secp256k1.secp256k1.ProjectivePoint.fromHex((0, import_utils38.arrayify)(point));
     const result = p0.add(p1);
     return `0x${result.toHex(true)}`;
   }
@@ -9491,16 +9941,16 @@ var Signer = class _Signer {
    * @returns public key from signature from the
    */
   static recoverPublicKey(data, signature) {
-    const signedMessageBytes = (0, import_utils37.arrayify)(signature);
+    const signedMessageBytes = (0, import_utils38.arrayify)(signature);
     const r = signedMessageBytes.slice(0, 32);
     const s = signedMessageBytes.slice(32, 64);
     const recoveryParam = (s[0] & 128) >> 7;
     s[0] &= 127;
-    const sig = new import_secp256k1.secp256k1.Signature(BigInt((0, import_utils37.hexlify)(r)), BigInt((0, import_utils37.hexlify)(s))).addRecoveryBit(
+    const sig = new import_secp256k1.secp256k1.Signature(BigInt((0, import_utils38.hexlify)(r)), BigInt((0, import_utils38.hexlify)(s))).addRecoveryBit(
       recoveryParam
     );
-    const publicKey = sig.recoverPublicKey((0, import_utils37.arrayify)(data)).toRawBytes(false).slice(1);
-    return (0, import_utils37.hexlify)(publicKey);
+    const publicKey = sig.recoverPublicKey((0, import_utils38.arrayify)(data)).toRawBytes(false).slice(1);
+    return (0, import_utils38.hexlify)(publicKey);
   }
   /**
    * Recover the address from a signature performed with [`sign`](#sign).
@@ -9510,7 +9960,7 @@ var Signer = class _Signer {
    * @returns Address from signature
    */
   static recoverAddress(data, signature) {
-    return new import_address6.Address(_Signer.recoverPublicKey(data, signature));
+    return new import_address7.Address(_Signer.recoverPublicKey(data, signature));
   }
   /**
    * Generate a random privateKey
@@ -9519,7 +9969,7 @@ var Signer = class _Signer {
    * @returns random 32-byte hashed
    */
   static generatePrivateKey(entropy) {
-    return entropy ? (0, import_hasher3.hash)((0, import_utils37.concat)([(0, import_crypto3.randomBytes)(32), (0, import_utils37.arrayify)(entropy)])) : (0, import_crypto3.randomBytes)(32);
+    return entropy ? (0, import_hasher3.hash)((0, import_utils38.concat)([(0, import_crypto3.randomBytes)(32), (0, import_utils38.arrayify)(entropy)])) : (0, import_crypto3.randomBytes)(32);
   }
   /**
    * Extended publicKey from a compact publicKey
@@ -9528,16 +9978,16 @@ var Signer = class _Signer {
    * @returns extended publicKey
    */
   static extendPublicKey(publicKey) {
-    const point = import_secp256k1.secp256k1.ProjectivePoint.fromHex((0, import_utils37.arrayify)(publicKey));
-    return (0, import_utils37.hexlify)(point.toRawBytes(false).slice(1));
+    const point = import_secp256k1.secp256k1.ProjectivePoint.fromHex((0, import_utils38.arrayify)(publicKey));
+    return (0, import_utils38.hexlify)(point.toRawBytes(false).slice(1));
   }
 };
 
 // src/wallet/keystore-wallet.ts
-var import_address7 = require("@fuel-ts/address");
+var import_address8 = require("@fuel-ts/address");
 var import_crypto4 = require("@fuel-ts/crypto");
-var import_errors23 = require("@fuel-ts/errors");
-var import_utils38 = require("@fuel-ts/utils");
+var import_errors24 = require("@fuel-ts/errors");
+var import_utils39 = require("@fuel-ts/utils");
 var DEFAULT_KDF_PARAMS_LOG_N = 13;
 var DEFAULT_KDF_PARAMS_R = 8;
 var DEFAULT_KDF_PARAMS_P = 1;
@@ -9551,7 +10001,7 @@ var removeHexPrefix = /* @__PURE__ */ __name((hexString) => {
 }, "removeHexPrefix");
 async function encryptKeystoreWallet(privateKey, address, password) {
   const privateKeyBuffer = (0, import_crypto4.bufferFromString)(removeHexPrefix(privateKey), "hex");
-  const ownerAddress = new import_address7.Address(address);
+  const ownerAddress = new import_address8.Address(address);
   const salt = (0, import_crypto4.randomBytes)(DEFAULT_KEY_SIZE);
   const key = (0, import_crypto4.scrypt)({
     password: (0, import_crypto4.bufferFromString)(password),
@@ -9614,13 +10064,13 @@ async function decryptKeystoreWallet(jsonWallet, password) {
   const macHashUint8Array = (0, import_crypto4.keccak256)(data);
   const macHash = (0, import_crypto4.stringFromBuffer)(macHashUint8Array, "hex");
   if (mac !== macHash) {
-    throw new import_errors23.FuelError(
-      import_errors23.ErrorCode.INVALID_PASSWORD,
+    throw new import_errors24.FuelError(
+      import_errors24.ErrorCode.INVALID_PASSWORD,
       "Failed to decrypt the keystore wallet, the provided password is incorrect."
     );
   }
   const buffer = await (0, import_crypto4.decryptJsonWalletData)(ciphertextBuffer, key, ivBuffer);
-  const privateKey = (0, import_utils38.hexlify)(buffer);
+  const privateKey = (0, import_utils39.hexlify)(buffer);
   return privateKey;
 }
 __name(decryptKeystoreWallet, "decryptKeystoreWallet");
@@ -9673,7 +10123,7 @@ var BaseWalletUnlocked = class extends Account {
    */
   async signMessage(message) {
     const signedMessage = await this.signer().sign((0, import_hasher4.hashMessage)(message));
-    return (0, import_utils39.hexlify)(signedMessage);
+    return (0, import_utils40.hexlify)(signedMessage);
   }
   /**
    * Signs a transaction with the wallet's private key.
@@ -9686,7 +10136,7 @@ var BaseWalletUnlocked = class extends Account {
     const chainId = await this.provider.getChainId();
     const hashedTransaction = transactionRequest.getTransactionId(chainId);
     const signature = await this.signer().sign(hashedTransaction);
-    return (0, import_utils39.hexlify)(signature);
+    return (0, import_utils40.hexlify)(signature);
   }
   /**
    * Populates a transaction with the witnesses signature.
@@ -9754,16 +10204,16 @@ var BaseWalletUnlocked = class extends Account {
 
 // src/hdwallet/hdwallet.ts
 var import_crypto6 = require("@fuel-ts/crypto");
-var import_errors26 = require("@fuel-ts/errors");
+var import_errors27 = require("@fuel-ts/errors");
 var import_hasher7 = require("@fuel-ts/hasher");
-var import_math24 = require("@fuel-ts/math");
-var import_utils43 = require("@fuel-ts/utils");
+var import_math25 = require("@fuel-ts/math");
+var import_utils44 = require("@fuel-ts/utils");
 
 // src/mnemonic/mnemonic.ts
 var import_crypto5 = require("@fuel-ts/crypto");
-var import_errors25 = require("@fuel-ts/errors");
+var import_errors26 = require("@fuel-ts/errors");
 var import_hasher6 = require("@fuel-ts/hasher");
-var import_utils41 = require("@fuel-ts/utils");
+var import_utils42 = require("@fuel-ts/utils");
 
 // src/wordlists/words/english.ts
 var english = [
@@ -11824,9 +12274,9 @@ var Language = /* @__PURE__ */ ((Language2) => {
 })(Language || {});
 
 // src/mnemonic/utils.ts
-var import_errors24 = require("@fuel-ts/errors");
+var import_errors25 = require("@fuel-ts/errors");
 var import_hasher5 = require("@fuel-ts/hasher");
-var import_utils40 = require("@fuel-ts/utils");
+var import_utils41 = require("@fuel-ts/utils");
 function getLowerMask(bits) {
   return (1 << bits) - 1;
 }
@@ -11865,7 +12315,7 @@ function entropyToMnemonicIndices(entropy) {
     }
   }
   const checksumBits = entropy.length / 4;
-  const checksum = (0, import_utils40.arrayify)((0, import_hasher5.sha256)(entropy))[0] & getUpperMask(checksumBits);
+  const checksum = (0, import_utils41.arrayify)((0, import_hasher5.sha256)(entropy))[0] & getUpperMask(checksumBits);
   indices[indices.length - 1] <<= checksumBits;
   indices[indices.length - 1] |= checksum >> 8 - checksumBits;
   return indices;
@@ -11873,13 +12323,13 @@ function entropyToMnemonicIndices(entropy) {
 __name(entropyToMnemonicIndices, "entropyToMnemonicIndices");
 function mnemonicWordsToEntropy(words, wordlist) {
   const size = Math.ceil(11 * words.length / 8);
-  const entropy = (0, import_utils40.arrayify)(new Uint8Array(size));
+  const entropy = (0, import_utils41.arrayify)(new Uint8Array(size));
   let offset = 0;
   for (let i = 0; i < words.length; i += 1) {
     const index = wordlist.indexOf(words[i].normalize("NFKD"));
     if (index === -1) {
-      throw new import_errors24.FuelError(
-        import_errors24.ErrorCode.INVALID_MNEMONIC,
+      throw new import_errors25.FuelError(
+        import_errors25.ErrorCode.INVALID_MNEMONIC,
         `Invalid mnemonic: the word '${words[i]}' is not found in the provided wordlist.`
       );
     }
@@ -11893,10 +12343,10 @@ function mnemonicWordsToEntropy(words, wordlist) {
   const entropyBits = 32 * words.length / 3;
   const checksumBits = words.length / 3;
   const checksumMask = getUpperMask(checksumBits);
-  const checksum = (0, import_utils40.arrayify)((0, import_hasher5.sha256)(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
+  const checksum = (0, import_utils41.arrayify)((0, import_hasher5.sha256)(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
   if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
-    throw new import_errors24.FuelError(
-      import_errors24.ErrorCode.INVALID_CHECKSUM,
+    throw new import_errors25.FuelError(
+      import_errors25.ErrorCode.INVALID_CHECKSUM,
       "Checksum validation failed for the provided mnemonic."
     );
   }
@@ -11905,14 +12355,14 @@ function mnemonicWordsToEntropy(words, wordlist) {
 __name(mnemonicWordsToEntropy, "mnemonicWordsToEntropy");
 
 // src/mnemonic/mnemonic.ts
-var MasterSecret = (0, import_utils41.toUtf8Bytes)("Bitcoin seed");
+var MasterSecret = (0, import_utils42.toUtf8Bytes)("Bitcoin seed");
 var MainnetPRV = "0x0488ade4";
 var TestnetPRV = "0x04358394";
 var MNEMONIC_SIZES = [12, 15, 18, 21, 24];
 function assertWordList(wordlist) {
   if (wordlist.length !== 2048) {
-    throw new import_errors25.FuelError(
-      import_errors25.ErrorCode.INVALID_WORD_LIST,
+    throw new import_errors26.FuelError(
+      import_errors26.ErrorCode.INVALID_WORD_LIST,
       `Expected word list length of 2048, but got ${wordlist.length}.`
     );
   }
@@ -11920,8 +12370,8 @@ function assertWordList(wordlist) {
 __name(assertWordList, "assertWordList");
 function assertEntropy(entropy) {
   if (entropy.length % 4 !== 0 || entropy.length < 16 || entropy.length > 32) {
-    throw new import_errors25.FuelError(
-      import_errors25.ErrorCode.INVALID_ENTROPY,
+    throw new import_errors26.FuelError(
+      import_errors26.ErrorCode.INVALID_ENTROPY,
       `Entropy should be between 16 and 32 bytes and a multiple of 4, but got ${entropy.length} bytes.`
     );
   }
@@ -11932,7 +12382,7 @@ function assertMnemonic(words) {
     const errorMsg = `Invalid mnemonic size. Expected one of [${MNEMONIC_SIZES.join(
       ", "
     )}] words, but got ${words.length}.`;
-    throw new import_errors25.FuelError(import_errors25.ErrorCode.INVALID_MNEMONIC, errorMsg);
+    throw new import_errors26.FuelError(import_errors26.ErrorCode.INVALID_MNEMONIC, errorMsg);
   }
 }
 __name(assertMnemonic, "assertMnemonic");
@@ -11975,7 +12425,7 @@ var Mnemonic = class _Mnemonic {
   static mnemonicToEntropy(phrase, wordlist = english) {
     const words = getWords(phrase);
     assertMnemonic(words);
-    return (0, import_utils41.hexlify)(mnemonicWordsToEntropy(words, wordlist));
+    return (0, import_utils42.hexlify)(mnemonicWordsToEntropy(words, wordlist));
   }
   /**
    * @param entropy - Entropy source to the mnemonic phrase.
@@ -11983,7 +12433,7 @@ var Mnemonic = class _Mnemonic {
    * @returns 64-byte array contains privateKey and chainCode as described on BIP39
    */
   static entropyToMnemonic(entropy, wordlist = english) {
-    const entropyBytes = (0, import_utils41.arrayify)(entropy);
+    const entropyBytes = (0, import_utils42.arrayify)(entropy);
     assertWordList(wordlist);
     assertEntropy(entropyBytes);
     return entropyToMnemonicIndices(entropyBytes).map((i) => wordlist[i]).join(" ");
@@ -11995,8 +12445,8 @@ var Mnemonic = class _Mnemonic {
    */
   static mnemonicToSeed(phrase, passphrase = "") {
     assertMnemonic(getWords(phrase));
-    const phraseBytes = (0, import_utils41.toUtf8Bytes)(getPhrase(phrase));
-    const salt = (0, import_utils41.toUtf8Bytes)(`mnemonic${passphrase}`);
+    const phraseBytes = (0, import_utils42.toUtf8Bytes)(getPhrase(phrase));
+    const salt = (0, import_utils42.toUtf8Bytes)(`mnemonic${passphrase}`);
     return (0, import_crypto5.pbkdf2)(phraseBytes, salt, 2048, 64, "sha512");
   }
   /**
@@ -12052,14 +12502,14 @@ var Mnemonic = class _Mnemonic {
    * @returns 64-byte array contains privateKey and chainCode as described on BIP39
    */
   static masterKeysFromSeed(seed) {
-    const seedArray = (0, import_utils41.arrayify)(seed);
+    const seedArray = (0, import_utils42.arrayify)(seed);
     if (seedArray.length < 16 || seedArray.length > 64) {
-      throw new import_errors25.FuelError(
-        import_errors25.ErrorCode.INVALID_SEED,
+      throw new import_errors26.FuelError(
+        import_errors26.ErrorCode.INVALID_SEED,
         `Seed length should be between 16 and 64 bytes, but received ${seedArray.length} bytes.`
       );
     }
-    return (0, import_utils41.arrayify)((0, import_crypto5.computeHmac)("sha512", MasterSecret, seedArray));
+    return (0, import_utils42.arrayify)((0, import_crypto5.computeHmac)("sha512", MasterSecret, seedArray));
   }
   /**
    * Get the extendKey as defined on BIP-32 from the provided seed
@@ -12070,22 +12520,22 @@ var Mnemonic = class _Mnemonic {
    */
   static seedToExtendedKey(seed, testnet = false) {
     const masterKey = _Mnemonic.masterKeysFromSeed(seed);
-    const prefix = (0, import_utils41.arrayify)(testnet ? TestnetPRV : MainnetPRV);
+    const prefix = (0, import_utils42.arrayify)(testnet ? TestnetPRV : MainnetPRV);
     const depth = "0x00";
     const fingerprint = "0x00000000";
     const index = "0x00000000";
     const chainCode = masterKey.slice(32);
     const privateKey = masterKey.slice(0, 32);
-    const extendedKey = (0, import_utils41.concat)([
+    const extendedKey = (0, import_utils42.concat)([
       prefix,
       depth,
       fingerprint,
       index,
       chainCode,
-      (0, import_utils41.concat)(["0x00", privateKey])
+      (0, import_utils42.concat)(["0x00", privateKey])
     ]);
-    const checksum = (0, import_utils41.dataSlice)((0, import_hasher6.sha256)((0, import_hasher6.sha256)(extendedKey)), 0, 4);
-    return (0, import_utils41.encodeBase58)((0, import_utils41.concat)([extendedKey, checksum]));
+    const checksum = (0, import_utils42.dataSlice)((0, import_hasher6.sha256)((0, import_hasher6.sha256)(extendedKey)), 0, 4);
+    return (0, import_utils42.encodeBase58)((0, import_utils42.concat)([extendedKey, checksum]));
   }
   /**
    *  Create a new mnemonic using a randomly generated number as entropy.
@@ -12100,7 +12550,7 @@ var Mnemonic = class _Mnemonic {
    * @returns A randomly generated mnemonic
    */
   static generate(size = 32, extraEntropy = "") {
-    const entropy = extraEntropy ? (0, import_hasher6.sha256)((0, import_utils41.concat)([(0, import_crypto5.randomBytes)(size), (0, import_utils41.arrayify)(extraEntropy)])) : (0, import_crypto5.randomBytes)(size);
+    const entropy = extraEntropy ? (0, import_hasher6.sha256)((0, import_utils42.concat)([(0, import_crypto5.randomBytes)(size), (0, import_utils42.arrayify)(extraEntropy)])) : (0, import_crypto5.randomBytes)(size);
     return _Mnemonic.entropyToMnemonic(entropy);
   }
 };
@@ -12108,12 +12558,12 @@ var mnemonic_default = Mnemonic;
 
 // src/hdwallet/hdwallet.ts
 var HARDENED_INDEX = 2147483648;
-var MainnetPRV2 = (0, import_utils43.hexlify)("0x0488ade4");
-var MainnetPUB = (0, import_utils43.hexlify)("0x0488b21e");
-var TestnetPRV2 = (0, import_utils43.hexlify)("0x04358394");
-var TestnetPUB = (0, import_utils43.hexlify)("0x043587cf");
+var MainnetPRV2 = (0, import_utils44.hexlify)("0x0488ade4");
+var MainnetPUB = (0, import_utils44.hexlify)("0x0488b21e");
+var TestnetPRV2 = (0, import_utils44.hexlify)("0x04358394");
+var TestnetPUB = (0, import_utils44.hexlify)("0x043587cf");
 function base58check(data) {
-  return (0, import_utils43.encodeBase58)((0, import_utils43.concat)([data, (0, import_utils43.dataSlice)((0, import_hasher7.sha256)((0, import_hasher7.sha256)(data)), 0, 4)]));
+  return (0, import_utils44.encodeBase58)((0, import_utils44.concat)([data, (0, import_utils44.dataSlice)((0, import_hasher7.sha256)((0, import_hasher7.sha256)(data)), 0, 4)]));
 }
 __name(base58check, "base58check");
 function getExtendedKeyPrefix(isPublic = false, testnet = false) {
@@ -12124,19 +12574,19 @@ function getExtendedKeyPrefix(isPublic = false, testnet = false) {
 }
 __name(getExtendedKeyPrefix, "getExtendedKeyPrefix");
 function isPublicExtendedKey(extendedKey) {
-  return [MainnetPUB, TestnetPUB].includes((0, import_utils43.hexlify)(extendedKey.slice(0, 4)));
+  return [MainnetPUB, TestnetPUB].includes((0, import_utils44.hexlify)(extendedKey.slice(0, 4)));
 }
 __name(isPublicExtendedKey, "isPublicExtendedKey");
 function isValidExtendedKey(extendedKey) {
   return [MainnetPRV2, TestnetPRV2, MainnetPUB, TestnetPUB].includes(
-    (0, import_utils43.hexlify)(extendedKey.slice(0, 4))
+    (0, import_utils44.hexlify)(extendedKey.slice(0, 4))
   );
 }
 __name(isValidExtendedKey, "isValidExtendedKey");
 function parsePath(path, depth = 0) {
   const components = path.split("/");
   if (components.length === 0 || components[0] === "m" && depth !== 0) {
-    throw new import_errors26.FuelError(import_errors26.ErrorCode.HD_WALLET_ERROR, `invalid path - ${path}`);
+    throw new import_errors27.FuelError(import_errors27.ErrorCode.HD_WALLET_ERROR, `invalid path - ${path}`);
   }
   if (components[0] === "m") {
     components.shift();
@@ -12152,8 +12602,8 @@ var HDWallet = class _HDWallet {
   }
   depth = 0;
   index = 0;
-  fingerprint = (0, import_utils43.hexlify)("0x00000000");
-  parentFingerprint = (0, import_utils43.hexlify)("0x00000000");
+  fingerprint = (0, import_utils44.hexlify)("0x00000000");
+  parentFingerprint = (0, import_utils44.hexlify)("0x00000000");
   privateKey;
   publicKey;
   chainCode;
@@ -12165,19 +12615,19 @@ var HDWallet = class _HDWallet {
   constructor(config) {
     if (config.privateKey) {
       const signer = new Signer(config.privateKey);
-      this.publicKey = (0, import_utils43.hexlify)(signer.compressedPublicKey);
-      this.privateKey = (0, import_utils43.hexlify)(config.privateKey);
+      this.publicKey = (0, import_utils44.hexlify)(signer.compressedPublicKey);
+      this.privateKey = (0, import_utils44.hexlify)(config.privateKey);
     } else {
       if (!config.publicKey) {
-        throw new import_errors26.FuelError(
-          import_errors26.ErrorCode.HD_WALLET_ERROR,
+        throw new import_errors27.FuelError(
+          import_errors27.ErrorCode.HD_WALLET_ERROR,
           "Both public and private Key cannot be missing. At least one should be provided."
         );
       }
-      this.publicKey = (0, import_utils43.hexlify)(config.publicKey);
+      this.publicKey = (0, import_utils44.hexlify)(config.publicKey);
     }
     this.parentFingerprint = config.parentFingerprint || this.parentFingerprint;
-    this.fingerprint = (0, import_utils43.dataSlice)((0, import_crypto6.ripemd160)((0, import_hasher7.sha256)(this.publicKey)), 0, 4);
+    this.fingerprint = (0, import_utils44.dataSlice)((0, import_crypto6.ripemd160)((0, import_hasher7.sha256)(this.publicKey)), 0, 4);
     this.depth = config.depth || this.depth;
     this.index = config.index || this.index;
     this.chainCode = config.chainCode;
@@ -12193,28 +12643,28 @@ var HDWallet = class _HDWallet {
    * @returns A new instance of HDWallet on the derived index
    */
   deriveIndex(index) {
-    const privateKey = this.privateKey && (0, import_utils43.arrayify)(this.privateKey);
-    const publicKey = (0, import_utils43.arrayify)(this.publicKey);
-    const chainCode = (0, import_utils43.arrayify)(this.chainCode);
+    const privateKey = this.privateKey && (0, import_utils44.arrayify)(this.privateKey);
+    const publicKey = (0, import_utils44.arrayify)(this.publicKey);
+    const chainCode = (0, import_utils44.arrayify)(this.chainCode);
     const data = new Uint8Array(37);
     if (index & HARDENED_INDEX) {
       if (!privateKey) {
-        throw new import_errors26.FuelError(
-          import_errors26.ErrorCode.HD_WALLET_ERROR,
+        throw new import_errors27.FuelError(
+          import_errors27.ErrorCode.HD_WALLET_ERROR,
           "Cannot derive a hardened index without a private Key."
         );
       }
       data.set(privateKey, 1);
     } else {
-      data.set((0, import_utils43.arrayify)(this.publicKey));
+      data.set((0, import_utils44.arrayify)(this.publicKey));
     }
-    data.set((0, import_math24.toBytes)(index, 4), 33);
-    const bytes = (0, import_utils43.arrayify)((0, import_crypto6.computeHmac)("sha512", chainCode, data));
+    data.set((0, import_math25.toBytes)(index, 4), 33);
+    const bytes = (0, import_utils44.arrayify)((0, import_crypto6.computeHmac)("sha512", chainCode, data));
     const IL = bytes.slice(0, 32);
     const IR = bytes.slice(32);
     if (privateKey) {
       const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
-      const ki = (0, import_math24.bn)(IL).add(privateKey).mod(N).toBytes(32);
+      const ki = (0, import_math25.bn)(IL).add(privateKey).mod(N).toBytes(32);
       return new _HDWallet({
         privateKey: ki,
         chainCode: IR,
@@ -12223,7 +12673,7 @@ var HDWallet = class _HDWallet {
         parentFingerprint: this.fingerprint
       });
     }
-    const signer = new Signer((0, import_utils43.hexlify)(IL));
+    const signer = new Signer((0, import_utils44.hexlify)(IL));
     const Ki = signer.addPoint(publicKey);
     return new _HDWallet({
       publicKey: Ki,
@@ -12252,18 +12702,18 @@ var HDWallet = class _HDWallet {
    */
   toExtendedKey(isPublic = false, testnet = false) {
     if (this.depth >= 256) {
-      throw new import_errors26.FuelError(
-        import_errors26.ErrorCode.HD_WALLET_ERROR,
+      throw new import_errors27.FuelError(
+        import_errors27.ErrorCode.HD_WALLET_ERROR,
         `Exceeded max depth of 255. Current depth: ${this.depth}.`
       );
     }
     const prefix = getExtendedKeyPrefix(this.privateKey == null || isPublic, testnet);
-    const depth = (0, import_utils43.hexlify)(Uint8Array.from([this.depth]));
+    const depth = (0, import_utils44.hexlify)(Uint8Array.from([this.depth]));
     const parentFingerprint = this.parentFingerprint;
-    const index = (0, import_math24.toHex)(this.index, 4);
+    const index = (0, import_math25.toHex)(this.index, 4);
     const chainCode = this.chainCode;
-    const key = this.privateKey != null && !isPublic ? (0, import_utils43.concat)(["0x00", this.privateKey]) : this.publicKey;
-    const extendedKey = (0, import_utils43.arrayify)((0, import_utils43.concat)([prefix, depth, parentFingerprint, index, chainCode, key]));
+    const key = this.privateKey != null && !isPublic ? (0, import_utils44.concat)(["0x00", this.privateKey]) : this.publicKey;
+    const extendedKey = (0, import_utils44.arrayify)((0, import_utils44.concat)([prefix, depth, parentFingerprint, index, chainCode, key]));
     return base58check(extendedKey);
   }
   /**
@@ -12275,34 +12725,34 @@ var HDWallet = class _HDWallet {
   static fromSeed(seed) {
     const masterKey = mnemonic_default.masterKeysFromSeed(seed);
     return new _HDWallet({
-      chainCode: (0, import_utils43.arrayify)(masterKey.slice(32)),
-      privateKey: (0, import_utils43.arrayify)(masterKey.slice(0, 32))
+      chainCode: (0, import_utils44.arrayify)(masterKey.slice(32)),
+      privateKey: (0, import_utils44.arrayify)(masterKey.slice(0, 32))
     });
   }
   static fromExtendedKey(extendedKey) {
-    const decoded = (0, import_utils43.hexlify)((0, import_math24.toBytes)((0, import_utils43.decodeBase58)(extendedKey)));
-    const bytes = (0, import_utils43.arrayify)(decoded);
+    const decoded = (0, import_utils44.hexlify)((0, import_math25.toBytes)((0, import_utils44.decodeBase58)(extendedKey)));
+    const bytes = (0, import_utils44.arrayify)(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
-      throw new import_errors26.FuelError(import_errors26.ErrorCode.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
+      throw new import_errors27.FuelError(import_errors27.ErrorCode.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
     }
     if (!validChecksum) {
-      throw new import_errors26.FuelError(import_errors26.ErrorCode.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
+      throw new import_errors27.FuelError(import_errors27.ErrorCode.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
     }
     const depth = bytes[4];
-    const parentFingerprint = (0, import_utils43.hexlify)(bytes.slice(5, 9));
-    const index = parseInt((0, import_utils43.hexlify)(bytes.slice(9, 13)).substring(2), 16);
-    const chainCode = (0, import_utils43.hexlify)(bytes.slice(13, 45));
+    const parentFingerprint = (0, import_utils44.hexlify)(bytes.slice(5, 9));
+    const index = parseInt((0, import_utils44.hexlify)(bytes.slice(9, 13)).substring(2), 16);
+    const chainCode = (0, import_utils44.hexlify)(bytes.slice(13, 45));
     const key = bytes.slice(45, 78);
     if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
-      throw new import_errors26.FuelError(
-        import_errors26.ErrorCode.HD_WALLET_ERROR,
+      throw new import_errors27.FuelError(
+        import_errors27.ErrorCode.HD_WALLET_ERROR,
         "Inconsistency detected: Depth is zero but fingerprint/index is non-zero."
       );
     }
     if (isPublicExtendedKey(bytes)) {
       if (key[0] !== 3) {
-        throw new import_errors26.FuelError(import_errors26.ErrorCode.HD_WALLET_ERROR, "Invalid public extended key.");
+        throw new import_errors27.FuelError(import_errors27.ErrorCode.HD_WALLET_ERROR, "Invalid public extended key.");
       }
       return new _HDWallet({
         publicKey: key,
@@ -12313,7 +12763,7 @@ var HDWallet = class _HDWallet {
       });
     }
     if (key[0] !== 0) {
-      throw new import_errors26.FuelError(import_errors26.ErrorCode.HD_WALLET_ERROR, "Invalid private extended key.");
+      throw new import_errors27.FuelError(import_errors27.ErrorCode.HD_WALLET_ERROR, "Invalid private extended key.");
     }
     return new _HDWallet({
       privateKey: key.slice(1),
@@ -12488,9 +12938,9 @@ var Wallet = class {
 };
 
 // src/wallet-manager/wallet-manager.ts
-var import_address10 = require("@fuel-ts/address");
+var import_address11 = require("@fuel-ts/address");
 var import_crypto7 = require("@fuel-ts/crypto");
-var import_errors29 = require("@fuel-ts/errors");
+var import_errors30 = require("@fuel-ts/errors");
 var import_events = require("events");
 
 // src/wallet-manager/storages/memory-storage.ts
@@ -12515,8 +12965,8 @@ var MemoryStorage = class {
 };
 
 // src/wallet-manager/vaults/mnemonic-vault.ts
-var import_address8 = require("@fuel-ts/address");
-var import_errors27 = require("@fuel-ts/errors");
+var import_address9 = require("@fuel-ts/address");
+var import_errors28 = require("@fuel-ts/errors");
 var MnemonicVault = class {
   static {
     __name(this, "MnemonicVault");
@@ -12567,7 +13017,7 @@ var MnemonicVault = class {
   }
   exportAccount(address) {
     let numberOfAccounts = 0;
-    const ownerAddress = new import_address8.Address(address);
+    const ownerAddress = new import_address9.Address(address);
     do {
       const wallet = Wallet.fromMnemonic(this.#secret, this.getDerivePath(numberOfAccounts));
       if (wallet.address.equals(ownerAddress)) {
@@ -12575,8 +13025,8 @@ var MnemonicVault = class {
       }
       numberOfAccounts += 1;
     } while (numberOfAccounts < this.numberOfAccounts);
-    throw new import_errors27.FuelError(
-      import_errors27.ErrorCode.WALLET_MANAGER_ERROR,
+    throw new import_errors28.FuelError(
+      import_errors28.ErrorCode.WALLET_MANAGER_ERROR,
       `Account with address '${address}' not found in derived wallets.`
     );
   }
@@ -12587,8 +13037,8 @@ var MnemonicVault = class {
 };
 
 // src/wallet-manager/vaults/privatekey-vault.ts
-var import_address9 = require("@fuel-ts/address");
-var import_errors28 = require("@fuel-ts/errors");
+var import_address10 = require("@fuel-ts/address");
+var import_errors29 = require("@fuel-ts/errors");
 var PrivateKeyVault = class {
   static {
     __name(this, "PrivateKeyVault");
@@ -12627,13 +13077,13 @@ var PrivateKeyVault = class {
     return this.getPublicAccount(wallet.privateKey);
   }
   exportAccount(address) {
-    const ownerAddress = new import_address9.Address(address);
+    const ownerAddress = new import_address10.Address(address);
     const privateKey = this.#privateKeys.find(
       (pk) => Wallet.fromPrivateKey(pk).address.equals(ownerAddress)
     );
     if (!privateKey) {
-      throw new import_errors28.FuelError(
-        import_errors28.ErrorCode.WALLET_MANAGER_ERROR,
+      throw new import_errors29.FuelError(
+        import_errors29.ErrorCode.WALLET_MANAGER_ERROR,
         `No private key found for address '${address}'.`
       );
     }
@@ -12655,7 +13105,7 @@ var ERROR_MESSAGES = {
 };
 function assert(condition, message) {
   if (!condition) {
-    throw new import_errors29.FuelError(import_errors29.ErrorCode.WALLET_MANAGER_ERROR, message);
+    throw new import_errors30.FuelError(import_errors30.ErrorCode.WALLET_MANAGER_ERROR, message);
   }
 }
 __name(assert, "assert");
@@ -12724,7 +13174,7 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
    * Create a Wallet instance for the specific account
    */
   getWallet(address) {
-    const ownerAddress = new import_address10.Address(address);
+    const ownerAddress = new import_address11.Address(address);
     const vaultState = this.#vaults.find(
       (vs) => vs.vault.getAccounts().find((a) => a.address.equals(ownerAddress))
     );
@@ -12735,7 +13185,7 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
    * Export specific account privateKey
    */
   exportPrivateKey(address) {
-    const ownerAddress = new import_address10.Address(address);
+    const ownerAddress = new import_address11.Address(address);
     assert(!this.#isLocked, ERROR_MESSAGES.wallet_not_unlocked);
     const vaultState = this.#vaults.find(
       (vs) => vs.vault.getAccounts().find((a) => a.address.equals(ownerAddress))
@@ -12876,29 +13326,29 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
 };
 
 // src/wallet-manager/types.ts
-var import_errors30 = require("@fuel-ts/errors");
+var import_errors31 = require("@fuel-ts/errors");
 var Vault = class {
   static {
     __name(this, "Vault");
   }
   static type;
   constructor(_options) {
-    throw new import_errors30.FuelError(import_errors30.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
+    throw new import_errors31.FuelError(import_errors31.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
   serialize() {
-    throw new import_errors30.FuelError(import_errors30.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
+    throw new import_errors31.FuelError(import_errors31.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
   getAccounts() {
-    throw new import_errors30.FuelError(import_errors30.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
+    throw new import_errors31.FuelError(import_errors31.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
   addAccount() {
-    throw new import_errors30.FuelError(import_errors30.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
+    throw new import_errors31.FuelError(import_errors31.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
   exportAccount(_address) {
-    throw new import_errors30.FuelError(import_errors30.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
+    throw new import_errors31.FuelError(import_errors31.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
   getWallet(_address) {
-    throw new import_errors30.FuelError(import_errors30.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
+    throw new import_errors31.FuelError(import_errors31.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
 };
 var StorageAbstract = class {
@@ -12908,19 +13358,19 @@ var StorageAbstract = class {
 };
 
 // src/predicate/predicate.ts
-var import_abi_coder9 = require("@fuel-ts/abi-coder");
-var import_address11 = require("@fuel-ts/address");
-var import_errors32 = require("@fuel-ts/errors");
-var import_utils47 = require("@fuel-ts/utils");
+var import_abi_coder11 = require("@fuel-ts/abi-coder");
+var import_address12 = require("@fuel-ts/address");
+var import_errors33 = require("@fuel-ts/errors");
+var import_utils48 = require("@fuel-ts/utils");
 
 // src/utils/deployScriptOrPredicate.ts
-var import_errors31 = require("@fuel-ts/errors");
-var import_utils45 = require("@fuel-ts/utils");
+var import_errors32 = require("@fuel-ts/errors");
+var import_utils46 = require("@fuel-ts/utils");
 
 // src/utils/predicate-script-loader-instructions.ts
-var import_abi_coder8 = require("@fuel-ts/abi-coder");
+var import_abi_coder10 = require("@fuel-ts/abi-coder");
 var import_hasher8 = require("@fuel-ts/hasher");
-var import_utils44 = require("@fuel-ts/utils");
+var import_utils45 = require("@fuel-ts/utils");
 var asm2 = __toESM(require("@fuels/vm-asm"));
 var BLOB_ID_SIZE = 32;
 var REG_ADDRESS_OF_DATA_AFTER_CODE = 16;
@@ -12930,12 +13380,12 @@ var WORD_SIZE2 = 8;
 var DATA_OFFSET_INDEX = 8;
 var CONFIGURABLE_OFFSET_INDEX = 16;
 function getBytecodeDataOffset(bytecode) {
-  const [offset] = new import_abi_coder8.BigNumberCoder("u64").decode(bytecode, DATA_OFFSET_INDEX);
+  const [offset] = new import_abi_coder10.BigNumberCoder("u64").decode(bytecode, DATA_OFFSET_INDEX);
   return offset.toNumber();
 }
 __name(getBytecodeDataOffset, "getBytecodeDataOffset");
 function getBytecodeConfigurableOffset(bytecode) {
-  const [offset] = new import_abi_coder8.BigNumberCoder("u64").decode(bytecode, CONFIGURABLE_OFFSET_INDEX);
+  const [offset] = new import_abi_coder10.BigNumberCoder("u64").decode(bytecode, CONFIGURABLE_OFFSET_INDEX);
   return offset.toNumber();
 }
 __name(getBytecodeConfigurableOffset, "getBytecodeConfigurableOffset");
@@ -13046,7 +13496,7 @@ function getPredicateScriptLoaderInstructions(originalBinary, blobId) {
       ...dataSectionLenBytes
     ]);
     return {
-      loaderBytecode: (0, import_utils44.concat)([loaderBytecode2, configurableSection]),
+      loaderBytecode: (0, import_utils45.concat)([loaderBytecode2, configurableSection]),
       blobOffset: loaderBytecode2.length
     };
   }
@@ -13090,8 +13540,8 @@ async function deployScriptOrPredicate({
   abi,
   loaderInstanceCallback
 }) {
-  const blobId = getBytecodeId((0, import_utils45.arrayify)(bytecode));
-  const configurableOffset = getBytecodeConfigurableOffset((0, import_utils45.arrayify)(bytecode));
+  const blobId = getBytecodeId((0, import_utils46.arrayify)(bytecode));
+  const configurableOffset = getBytecodeConfigurableOffset((0, import_utils46.arrayify)(bytecode));
   const byteCodeWithoutConfigurableSection = bytecode.slice(0, configurableOffset);
   const blobTxRequest = new BlobTransactionRequest({
     blobId,
@@ -13099,8 +13549,8 @@ async function deployScriptOrPredicate({
     witnesses: [byteCodeWithoutConfigurableSection]
   });
   const { loaderBytecode, blobOffset } = getPredicateScriptLoaderInstructions(
-    (0, import_utils45.arrayify)(bytecode),
-    (0, import_utils45.arrayify)(blobId)
+    (0, import_utils46.arrayify)(bytecode),
+    (0, import_utils46.arrayify)(blobId)
   );
   const newConfigurableOffsetDiff = byteCodeWithoutConfigurableSection.length - (blobOffset || 0);
   const newAbi = adjustConfigurableOffsets(abi, newConfigurableOffsetDiff);
@@ -13121,7 +13571,7 @@ async function deployScriptOrPredicate({
         throw new Error();
       }
     } catch (err) {
-      throw new import_errors31.FuelError(import_errors31.ErrorCode.TRANSACTION_FAILED, "Failed to deploy predicate chunk");
+      throw new import_errors32.FuelError(import_errors32.ErrorCode.TRANSACTION_FAILED, "Failed to deploy predicate chunk");
     }
     return loaderInstance;
   }, "waitForResult");
@@ -13135,13 +13585,13 @@ __name(deployScriptOrPredicate, "deployScriptOrPredicate");
 // src/predicate/utils/getPredicateRoot.ts
 var import_hasher9 = require("@fuel-ts/hasher");
 var import_merkle = require("@fuel-ts/merkle");
-var import_utils46 = require("@fuel-ts/utils");
+var import_utils47 = require("@fuel-ts/utils");
 var getPredicateRoot = /* @__PURE__ */ __name((bytecode) => {
   const chunkSize = 16 * 1024;
-  const bytes = (0, import_utils46.arrayify)(bytecode);
-  const chunks = (0, import_utils46.chunkAndPadBytes)(bytes, chunkSize);
-  const codeRoot = (0, import_merkle.calcRoot)(chunks.map((c) => (0, import_utils46.hexlify)(c)));
-  const predicateRoot = (0, import_hasher9.hash)((0, import_utils46.concat)(["0x4655454C", codeRoot]));
+  const bytes = (0, import_utils47.arrayify)(bytecode);
+  const chunks = (0, import_utils47.chunkAndPadBytes)(bytes, chunkSize);
+  const codeRoot = (0, import_merkle.calcRoot)(chunks.map((c) => (0, import_utils47.hexlify)(c)));
+  const predicateRoot = (0, import_hasher9.hash)((0, import_utils47.concat)(["0x4655454C", codeRoot]));
   return predicateRoot;
 }, "getPredicateRoot");
 
@@ -13176,9 +13626,9 @@ var Predicate = class _Predicate extends Account {
       abi,
       configurableConstants
     );
-    const address = new import_address11.Address(getPredicateRoot(predicateBytes));
+    const address = new import_address12.Address(getPredicateRoot(predicateBytes));
     super(address, provider);
-    this.initialBytecode = (0, import_utils47.arrayify)(bytecode);
+    this.initialBytecode = (0, import_utils48.arrayify)(bytecode);
     this.bytes = predicateBytes;
     this.interface = predicateInterface;
     this.configurableConstants = configurableConstants;
@@ -13200,8 +13650,8 @@ var Predicate = class _Predicate extends Account {
     }
     request2.inputs.filter(isRequestInputCoinOrMessage).forEach((input) => {
       if (isRequestInputResourceFromOwner(input, this.address)) {
-        input.predicate = (0, import_utils47.hexlify)(this.bytes);
-        input.predicateData = (0, import_utils47.hexlify)(this.getPredicateData());
+        input.predicate = (0, import_utils48.hexlify)(this.bytes);
+        input.predicateData = (0, import_utils48.hexlify)(this.getPredicateData());
         input.witnessIndex = 0;
       }
     });
@@ -13270,11 +13720,11 @@ var Predicate = class _Predicate extends Account {
    * @returns An object containing the new predicate bytes and interface.
    */
   static processPredicateData(bytes, jsonAbi, configurableConstants) {
-    let predicateBytes = (0, import_utils47.arrayify)(bytes);
-    const abiInterface = new import_abi_coder9.Interface(jsonAbi);
+    let predicateBytes = (0, import_utils48.arrayify)(bytes);
+    const abiInterface = new import_abi_coder11.Interface(jsonAbi);
     if (abiInterface.functions.main === void 0) {
-      throw new import_errors32.FuelError(
-        import_errors32.ErrorCode.ABI_MAIN_METHOD_MISSING,
+      throw new import_errors33.FuelError(
+        import_errors33.ErrorCode.ABI_MAIN_METHOD_MISSING,
         'Cannot use ABI without "main" function.'
       );
     }
@@ -13305,8 +13755,8 @@ var Predicate = class _Predicate extends Account {
     );
     return resources.map((resource) => ({
       ...resource,
-      predicate: (0, import_utils47.hexlify)(this.bytes),
-      predicateData: (0, import_utils47.hexlify)(this.getPredicateData())
+      predicate: (0, import_utils48.hexlify)(this.bytes),
+      predicateData: (0, import_utils48.hexlify)(this.getPredicateData())
     }));
   }
   /**
@@ -13318,8 +13768,8 @@ var Predicate = class _Predicate extends Account {
   generateFakeResources(coins) {
     return super.generateFakeResources(coins).map((coin) => ({
       ...coin,
-      predicate: (0, import_utils47.hexlify)(this.bytes),
-      predicateData: (0, import_utils47.hexlify)(this.getPredicateData())
+      predicate: (0, import_utils48.hexlify)(this.bytes),
+      predicateData: (0, import_utils48.hexlify)(this.getPredicateData())
     }));
   }
   /**
@@ -13334,15 +13784,15 @@ var Predicate = class _Predicate extends Account {
     const mutatedBytes = bytes;
     try {
       if (Object.keys(abiInterface.configurables).length === 0) {
-        throw new import_errors32.FuelError(
-          import_errors32.ErrorCode.INVALID_CONFIGURABLE_CONSTANTS,
+        throw new import_errors33.FuelError(
+          import_errors33.ErrorCode.INVALID_CONFIGURABLE_CONSTANTS,
           "Predicate has no configurable constants to be set"
         );
       }
       Object.entries(configurableConstants).forEach(([key, value]) => {
         if (!abiInterface?.configurables[key]) {
-          throw new import_errors32.FuelError(
-            import_errors32.ErrorCode.CONFIGURABLE_NOT_FOUND,
+          throw new import_errors33.FuelError(
+            import_errors33.ErrorCode.CONFIGURABLE_NOT_FOUND,
             `No configurable constant named '${key}' found in the Predicate`
           );
         }
@@ -13351,8 +13801,8 @@ var Predicate = class _Predicate extends Account {
         mutatedBytes.set(encoded, offset);
       });
     } catch (err) {
-      throw new import_errors32.FuelError(
-        import_errors32.ErrorCode.INVALID_CONFIGURABLE_CONSTANTS,
+      throw new import_errors33.FuelError(
+        import_errors33.ErrorCode.INVALID_CONFIGURABLE_CONSTANTS,
         `Error setting configurable constants: ${err.message}.`
       );
     }
@@ -13405,10 +13855,10 @@ var Predicate = class _Predicate extends Account {
 };
 
 // src/connectors/fuel.ts
-var import_errors35 = require("@fuel-ts/errors");
+var import_errors36 = require("@fuel-ts/errors");
 
 // src/connectors/fuel-connector.ts
-var import_errors33 = require("@fuel-ts/errors");
+var import_errors34 = require("@fuel-ts/errors");
 var import_events2 = require("events");
 
 // src/connectors/types/connector-types.ts
@@ -13433,6 +13883,7 @@ var FuelConnectorMethods = /* @__PURE__ */ ((FuelConnectorMethods2) => {
   FuelConnectorMethods2["addABI"] = "addABI";
   FuelConnectorMethods2["getABI"] = "getABI";
   FuelConnectorMethods2["hasABI"] = "hasABI";
+  FuelConnectorMethods2["startConsolidation"] = "startConsolidation";
   return FuelConnectorMethods2;
 })(FuelConnectorMethods || {});
 var FuelConnectorEventTypes = /* @__PURE__ */ ((FuelConnectorEventTypes2) => {
@@ -13445,6 +13896,7 @@ var FuelConnectorEventTypes = /* @__PURE__ */ ((FuelConnectorEventTypes2) => {
   FuelConnectorEventTypes2["currentNetwork"] = "currentNetwork";
   FuelConnectorEventTypes2["assets"] = "assets";
   FuelConnectorEventTypes2["abis"] = "abis";
+  FuelConnectorEventTypes2["consolidateCoins"] = "consolidateCoins";
   return FuelConnectorEventTypes2;
 })(FuelConnectorEventTypes || {});
 var FuelConnectorEventType = "FuelConnector";
@@ -13490,7 +13942,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Always true.
    */
   async ping() {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return the current version of the connector
@@ -13499,7 +13951,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns boolean - connection status.
    */
   async version() {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return true if the connector is connected
@@ -13508,7 +13960,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns The connection status.
    */
   async isConnected() {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return all the accounts authorized for the
@@ -13517,7 +13969,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns The accounts addresses strings
    */
   async accounts() {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the connection process and return
@@ -13529,7 +13981,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns boolean - connection status.
    */
   async connect() {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should disconnect the current connection and
@@ -13539,7 +13991,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns The connection status.
    */
   async disconnect() {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the sign message process and return
@@ -13551,7 +14003,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Message signature
    */
   async signMessage(_address, _message) {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the sign transaction process and return
@@ -13563,7 +14015,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Transaction signature
    */
   async signTransaction(_address, _transaction, _params) {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the send transaction process and return
@@ -13579,7 +14031,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns The transaction id or transaction response
    */
   async sendTransaction(_address, _transaction, _params) {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return the current account selected inside the connector, if the account
@@ -13590,7 +14042,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns The current account selected otherwise null.
    */
   async currentAccount() {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should add the assets metadata to the connector and return true if the asset
@@ -13604,7 +14056,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns True if the asset was added successfully
    */
   async addAssets(_assets) {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should add the asset metadata to the connector and return true if the asset
@@ -13618,7 +14070,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns True if the asset was added successfully
    */
   async addAsset(_asset) {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return all the assets added to the connector. If a connection is already established.
@@ -13626,7 +14078,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Array of assets metadata from the connector vinculated to the all accounts from a specific Wallet.
    */
   async assets() {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the add network process and return true if the network was added successfully.
@@ -13637,7 +14089,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Return true if the network was added successfully
    */
   async addNetwork(_networkUrl) {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the select network process and return true if the network has change successfully.
@@ -13648,7 +14100,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Return true if the network was added successfully
    */
   async selectNetwork(_network) {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return all the networks available from the connector. If the connection is already established.
@@ -13656,7 +14108,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Return all the networks added to the connector.
    */
   async networks() {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return the current network selected inside the connector. Even if the connection is not established.
@@ -13664,7 +14116,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Return the current network selected inside the connector.
    */
   async currentNetwork() {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should add the ABI to the connector and return true if the ABI was added successfully.
@@ -13674,7 +14126,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Return true if the ABI was added successfully.
    */
   async addABI(_contractId, _abi) {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return the ABI from the connector vinculated to the all accounts from a specific Wallet.
@@ -13683,7 +14135,7 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns The ABI if it exists, otherwise return null.
    */
   async getABI(_id) {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return true if the abi exists in the connector vinculated to the all accounts from a specific Wallet.
@@ -13692,7 +14144,16 @@ var FuelConnector = class extends import_events2.EventEmitter {
    * @returns Returns true if the abi exists or false if not.
    */
   async hasABI(_id) {
-    throw new import_errors33.FuelError(import_errors33.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+  }
+  /**
+   * Start the consolidation of coins process
+   *
+   * @param owner - The B256 address of the owner.
+   * @param assetId - The asset ID that requires consolidation.
+   */
+  async startConsolidation(_opts) {
+    throw new import_errors34.FuelError(import_errors34.FuelError.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Event listener for the connector.
@@ -13738,7 +14199,7 @@ function dispatchFuelConnectorEvent(connector) {
 __name(dispatchFuelConnectorEvent, "dispatchFuelConnectorEvent");
 
 // src/connectors/utils/promises.ts
-var import_errors34 = require("@fuel-ts/errors");
+var import_errors35 = require("@fuel-ts/errors");
 function deferPromise() {
   const defer = {};
   defer.promise = new Promise((resolve, reject) => {
@@ -13751,7 +14212,7 @@ __name(deferPromise, "deferPromise");
 async function withTimeout(promise, timeout = 1050) {
   const timeoutPromise = new Promise((resolve, reject) => {
     setTimeout(() => {
-      reject(new import_errors34.FuelError(import_errors34.FuelError.CODES.TIMEOUT_EXCEEDED, "Promise timed out"));
+      reject(new import_errors35.FuelError(import_errors35.FuelError.CODES.TIMEOUT_EXCEEDED, "Promise timed out"));
     }, timeout);
   });
   return Promise.race([timeoutPromise, promise]);
@@ -13792,7 +14253,7 @@ var Fuel = class _Fuel extends FuelConnector {
       this._targetUnsubscribe = this.setupConnectorListener();
       await connectResponse;
     } catch (error) {
-      throw new import_errors35.FuelError(import_errors35.ErrorCode.INVALID_PROVIDER, "Error initializing Fuel Connector");
+      throw new import_errors36.FuelError(import_errors36.ErrorCode.INVALID_PROVIDER, "Error initializing Fuel Connector");
     }
   }
   async init() {
@@ -13858,8 +14319,8 @@ var Fuel = class _Fuel extends FuelConnector {
     const hasConnector = await this.hasConnector();
     await this.pingConnector();
     if (!this._currentConnector || !hasConnector) {
-      throw new import_errors35.FuelError(
-        import_errors35.ErrorCode.MISSING_CONNECTOR,
+      throw new import_errors36.FuelError(
+        import_errors36.ErrorCode.MISSING_CONNECTOR,
         `No connector selected for calling ${method}. Use hasConnector before executing other methods.`
       );
     }
@@ -13923,7 +14384,7 @@ var Fuel = class _Fuel extends FuelConnector {
         cacheTime: PING_CACHE_TIME
       })();
     } catch {
-      throw new import_errors35.FuelError(import_errors35.ErrorCode.INVALID_PROVIDER, "Current connector is not available.");
+      throw new import_errors36.FuelError(import_errors36.ErrorCode.INVALID_PROVIDER, "Current connector is not available.");
     }
   }
   /**
@@ -14072,7 +14533,7 @@ var Fuel = class _Fuel extends FuelConnector {
       const currentNetwork = await this.currentNetwork();
       provider = new Provider(currentNetwork.url);
     } else {
-      throw new import_errors35.FuelError(import_errors35.ErrorCode.INVALID_PROVIDER, "Provider is not valid.");
+      throw new import_errors36.FuelError(import_errors36.ErrorCode.INVALID_PROVIDER, "Provider is not valid.");
     }
     return provider;
   }
@@ -14166,6 +14627,7 @@ var Fuel = class _Fuel extends FuelConnector {
   assemblePreConfirmationTransactionSummary,
   assembleReceiptByType,
   assembleRevertError,
+  assembleSignalErrorMessage,
   assembleTransactionSummary,
   assembleTransactionSummaryFromJson,
   assets,
@@ -14182,6 +14644,8 @@ var Fuel = class _Fuel extends FuelConnector {
   calculateMinGasForTxUpload,
   calculateTXFeeForSummary,
   coinQuantityfy,
+  consolidateCoins,
+  consolidateCoinsIfRequired,
   deferPromise,
   deployScriptOrPredicate,
   deserializeChain,
@@ -14200,6 +14664,7 @@ var Fuel = class _Fuel extends FuelConnector {
   extractTxError,
   fuelAssetsBaseUrl,
   gasUsedByInputs,
+  getAllCoins,
   getAllDecodedLogs,
   getAssetAmountInRequestInputs,
   getAssetById,