@fuel-ts/account 0.101.1 → 0.101.3

package/dist/test-utils.global.js

@@ -17288,8 +17288,8 @@
   function getBuiltinVersions() {
     return {
       FUEL_CORE: "0.43.1",
-      FORC: "0.68.1",
-      FUELS: "0.101.1"
+      FORC: "0.68.7",
+      FUELS: "0.101.3"
     };
   }
   __name(getBuiltinVersions, "getBuiltinVersions");
@@ -17402,6 +17402,7 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["CONNECTION_REFUSED"] = "connection-refused";
     ErrorCode2["INVALID_URL"] = "invalid-url";
     ErrorCode2["UNSUPPORTED_FEATURE"] = "unsupported-feature";
+    ErrorCode2["RESPONSE_BODY_EMPTY"] = "response-body-empty";
     ErrorCode2["INVALID_PUBLIC_KEY"] = "invalid-public-key";
     ErrorCode2["WALLET_MANAGER_ERROR"] = "wallet-manager-error";
     ErrorCode2["HD_WALLET_ERROR"] = "hd-wallet-error";
@@ -17420,6 +17421,8 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["INVALID_REQUEST"] = "invalid-request";
     ErrorCode2["INVALID_TRANSFER_AMOUNT"] = "invalid-transfer-amount";
     ErrorCode2["INSUFFICIENT_FUNDS_OR_MAX_COINS"] = "not-enough-funds-or-max-coins-reached";
+    ErrorCode2["INSUFFICIENT_FUNDS"] = "not-enough-funds";
+    ErrorCode2["MAX_COINS_REACHED"] = "max-coins-reached";
     ErrorCode2["INVALID_CREDENTIALS"] = "invalid-credentials";
     ErrorCode2["HASHER_LOCKED"] = "hasher-locked";
     ErrorCode2["GAS_PRICE_TOO_LOW"] = "gas-price-too-low";
@@ -17453,6 +17456,7 @@ This unreleased fuel-core build may include features and updates not yet support
     ErrorCode2["INVALID_PASSWORD"] = "invalid-password";
     ErrorCode2["ACCOUNT_REQUIRED"] = "account-required";
     ErrorCode2["UNLOCKED_WALLET_REQUIRED"] = "unlocked-wallet-required";
+    ErrorCode2["UNABLE_TO_CONSOLIDATE_COINS"] = "unable-to-consolidate-coins";
     ErrorCode2["NO_COINS_TO_CONSOLIDATE"] = "no-coins-to-consolidate";
     ErrorCode2["COINS_ASSET_ID_MISMATCH"] = "coins-asset-id-mismatch";
     ErrorCode2["ASSET_NOT_FOUND"] = "asset-not-found";
@@ -17494,7 +17498,7 @@ This unreleased fuel-core build may include features and updates not yet support
           `Unknown error code: ${error2.code}. Accepted codes: ${enumValues.join(", ")}.`
         );
       }
-      return new _FuelError(error2.code, error2.message);
+      return new _FuelError(error2.code, error2.message, error2.metadata, error2.rawError);
     }
     code;
     constructor(code, message, metadata = {}, rawError = null) {
@@ -20919,7 +20923,8 @@ If you are attempting to transform a hex value, please make sure it is being pas
       functions,
       loggedTypes,
       messagesTypes: abi.messagesTypes,
-      configurables
+      configurables,
+      errorCodes: abi.errorCodes
     };
     return transpiled;
   }
@@ -23342,8 +23347,9 @@ If you are attempting to transform a hex value, please make sure it is being pas
         "--consensus-key",
         "--db-type",
         "--poa-instant",
+        "--native-executor-version",
         "--min-gas-price",
-        "--native-executor-version"
+        "--starting-gas-price"
       ]);
       const snapshotDir = getFlagValueFromArgs(args, "--snapshot");
       const consensusKey = getFlagValueFromArgs(args, "--consensus-key") || defaultConsensusKey;
@@ -23567,6 +23573,11 @@ If you are attempting to transform a hex value, please make sure it is being pas
   }
   __name(_curry3, "_curry3");
 
+  // ../../node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_isArray.js
+  var isArray_default = Array.isArray || /* @__PURE__ */ __name(function _isArray(val) {
+    return val != null && val.length >= 0 && Object.prototype.toString.call(val) === "[object Array]";
+  }, "_isArray");
+
   // ../../node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_has.js
   function _has(prop, obj) {
     return Object.prototype.hasOwnProperty.call(obj, prop);
@@ -23697,6 +23708,25 @@ If you are attempting to transform a hex value, please make sure it is being pas
   }, "clone"));
   var clone_default = clone;
 
+  // ../../node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/internal/_checkForMethod.js
+  function _checkForMethod(methodname, fn) {
+    return function() {
+      var length = arguments.length;
+      if (length === 0) {
+        return fn();
+      }
+      var obj = arguments[length - 1];
+      return isArray_default(obj) || typeof obj[methodname] !== "function" ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));
+    };
+  }
+  __name(_checkForMethod, "_checkForMethod");
+
+  // ../../node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/slice.js
+  var slice = /* @__PURE__ */ _curry3(/* @__PURE__ */ _checkForMethod("slice", /* @__PURE__ */ __name(function slice2(fromIndex, toIndex, list) {
+    return Array.prototype.slice.call(list, fromIndex, toIndex);
+  }, "slice")));
+  var slice_default = slice;
+
   // ../../node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/mergeWithKey.js
   var mergeWithKey = /* @__PURE__ */ _curry3(/* @__PURE__ */ __name(function mergeWithKey2(fn, l, r) {
     var result = {};
@@ -23737,6 +23767,20 @@ If you are attempting to transform a hex value, please make sure it is being pas
   }, "mergeDeepRight"));
   var mergeDeepRight_default = mergeDeepRight;
 
+  // ../../node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/splitEvery.js
+  var splitEvery = /* @__PURE__ */ _curry2(/* @__PURE__ */ __name(function splitEvery2(n, list) {
+    if (n <= 0) {
+      throw new Error("First argument to splitEvery must be a positive integer");
+    }
+    var result = [];
+    var idx = 0;
+    while (idx < list.length) {
+      result.push(slice_default(idx, idx += n, list));
+    }
+    return result;
+  }, "splitEvery"));
+  var splitEvery_default = splitEvery;
+
   // src/providers/coin-quantity.ts
   var coinQuantityfy = /* @__PURE__ */ __name((coinQuantityLike) => {
     let assetId;
@@ -30393,8 +30437,11 @@ ${DryRunSuccessAssembleTxFragmentDoc}`;
   }, "setAndValidateGasAndFeeForAssembledTx");
 
   // src/providers/utils/handle-gql-error-message.ts
+  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/,
@@ -30410,6 +30457,46 @@ ${DryRunSuccessAssembleTxFragmentDoc}`;
         error2
       );
     }
+    if (gqlErrorMessage.MAX_COINS_REACHED.test(error2.message)) {
+      const matches = error2.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 FuelError(
+        ErrorCode.MAX_COINS_REACHED,
+        `You have too many small value coins - consider combining UTXOs.${suffix}`,
+        { assetId, owner },
+        error2
+      );
+    }
+    if (gqlErrorMessage.INSUFFICIENT_FUNDS.test(error2.message)) {
+      const matches = error2.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 FuelError(
+        ErrorCode.INSUFFICIENT_FUNDS,
+        `Insufficient funds.${suffix}`,
+        { assetId, owner },
+        error2
+      );
+    }
     if (gqlErrorMessage.MULTIPLE_CHANGE_POLICIES.test(error2.message)) {
       const match = error2.message.match(/asset ([a-fA-F0-9]{64})/);
       const assetId = match?.[1] || "";
@@ -30719,6 +30806,7 @@ ${incompatibleNodeVersionMessage}`,
   var FAILED_ASSERT_EQ_SIGNAL = "0xffffffffffff0003";
   var FAILED_ASSERT_SIGNAL = "0xffffffffffff0004";
   var FAILED_ASSERT_NE_SIGNAL = "0xffffffffffff0005";
+  var REVERT_WITH_LOG_SIGNAL = "0xffffffffffff0006";
   var PANIC_REASONS = [
     "ArithmeticError",
     "ArithmeticOverflow",
@@ -30787,6 +30875,14 @@ ${incompatibleNodeVersionMessage}`,
     "WitnessNotFound"
   ];
   var PANIC_DOC_URL = "https://docs.rs/fuel-asm/latest/fuel_asm/enum.PanicReason.html";
+  var SwaySignalErrors = {
+    FAILED_REQUIRE_SIGNAL,
+    FAILED_TRANSFER_TO_ADDRESS_SIGNAL,
+    FAILED_ASSERT_EQ_SIGNAL,
+    FAILED_ASSERT_SIGNAL,
+    FAILED_ASSERT_NE_SIGNAL,
+    REVERT_WITH_LOG_SIGNAL
+  };
 
   // src/providers/utils/serialization.ts
   var deserializeChain = /* @__PURE__ */ __name((chain) => {
@@ -31474,58 +31570,98 @@ ${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: type3 }) => type3 === ReceiptType.Revert);
     let reason = "";
-    if (revertReceipt) {
-      const reasonHex = bn(revertReceipt.val).toHex();
-      const lastLog = logs[logs.length - 1];
-      const lastButOneLog = logs[logs.length - 2];
-      switch (reasonHex) {
-        case FAILED_REQUIRE_SIGNAL: {
-          reason = "require";
-          errorMessage = `The transaction reverted because a "require" statement has thrown ${logs.length ? stringify(lastLog) : "an error."}.`;
-          break;
-        }
-        case 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 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 FAILED_ASSERT_SIGNAL:
-          reason = "assert";
-          errorMessage = `The transaction reverted because an "assert" statement failed to evaluate to true.`;
-          break;
-        case FAILED_TRANSFER_TO_ADDRESS_SIGNAL:
-          reason = "MissingOutputVariable";
-          errorMessage = `The transaction reverted because it's missing an "OutputVariable".`;
-          break;
-        default:
-          throw new FuelError(
-            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 FAILED_REQUIRE_SIGNAL: {
+        reason = "require";
+        errorMessage = `The transaction reverted because a "require" statement has thrown ${logs.length ? stringify(lastLog) : "an error."}.`;
+        break;
+      }
+      case 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 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 FAILED_ASSERT_SIGNAL:
+        reason = "assert";
+        errorMessage = `The transaction reverted because an "assert" statement failed to evaluate to true.`;
+        break;
+      case FAILED_TRANSFER_TO_ADDRESS_SIGNAL:
+        reason = "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 FuelError(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 FuelError(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 = bn(reason).toHex();
+    if (Object.values(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 FuelError(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: type3 }) => type3 === ReceiptType.Panic);
     const isRevert = receipts.some(({ type: type3 }) => type3 === ReceiptType.Revert);
     const metadata = {
@@ -31539,7 +31675,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     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
@@ -32480,11 +32616,15 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @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;
     }
     /**
@@ -33099,6 +33239,42 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     return maxFee;
   }, "calculateTXFeeForSummary");
 
+  // src/providers/transaction-summary/call.ts
+  var getFunctionCall = /* @__PURE__ */ __name(({
+    abi,
+    receipt,
+    offset,
+    scriptData
+  }) => {
+    const [functionSelector, argumentsOffset] = new StdStringCoder().decode(scriptData, offset);
+    const abiInterface = new 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
   function getInputsByTypes(inputs, types) {
     return inputs.filter((i) => types.includes(i.type));
@@ -33377,12 +33553,45 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     return withdrawFromFuelOperations;
   }
   __name(getWithdrawFromFuelOperations, "getWithdrawFromFuelOperations");
-  function getContractCalls(contractInput, abiMap, _receipt, _rawPayload, _maxInputs) {
+  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 -1;
+  }
+  __name(findBytesSegmentIndex, "findBytesSegmentIndex");
+  function getContractCalls(contractInput, abiMap, receipt, scriptData) {
+    const calls = [];
     const abi = abiMap?.[contractInput.contractID];
-    if (!abi) {
-      return [];
+    if (!abi || !scriptData) {
+      return calls;
+    }
+    const bytesSegment = concat([
+      arrayify(receipt.to),
+      // Contract ID (32 bytes)
+      toBytes(receipt.param1.toHex(), 8),
+      // Function selector offset (8 bytes)
+      toBytes(receipt.param2.toHex(), 8)
+      // Function args offset (8 bytes)
+    ]);
+    const segmentIndex = findBytesSegmentIndex(scriptData, bytesSegment);
+    const canDecodeFunctionCall = segmentIndex !== -1;
+    if (!canDecodeFunctionCall) {
+      return calls;
     }
-    return [];
+    const offset = segmentIndex + bytesSegment.length;
+    const call = getFunctionCall({ abi, receipt, offset, scriptData });
+    calls.push(call);
+    return calls;
   }
   __name(getContractCalls, "getContractCalls");
   function getAssetsSent(receipt) {
@@ -33394,14 +33603,14 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     ];
   }
   __name(getAssetsSent, "getAssetsSent");
-  function processCallReceipt(receipt, contractInput, inputs, abiMap, rawPayload, maxInputs, baseAssetId) {
+  function processCallReceipt(receipt, contractInput, inputs, abiMap, scriptData, baseAssetId) {
     const assetId = receipt.assetId === 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 */,
@@ -33426,7 +33635,6 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     receipts,
     abiMap,
     rawPayload,
-    maxInputs,
     baseAssetId
   }) {
     const contractCallReceipts = getReceiptsCall(receipts);
@@ -33436,16 +33644,15 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       if (!contractInput) {
         return [];
       }
+      let scriptData;
+      if (rawPayload) {
+        const [transaction] = new TransactionCoder().decode(arrayify(rawPayload), 0);
+        if (transaction.type === TransactionType.Script) {
+          scriptData = 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)
       );
     });
   }
@@ -33937,25 +34144,6 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
 
   // 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");
     }
@@ -33970,9 +34158,42 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     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
@@ -34209,6 +34430,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
         ...transactionSummary
       };
       let { logs, groupedLogs } = { logs: [], groupedLogs: {} };
+      let abis;
       if (this.abis) {
         ({ logs, groupedLogs } = getAllDecodedLogs({
           receipts: transactionSummary.receipts,
@@ -34217,6 +34439,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
         }));
         transactionResult.logs = logs;
         transactionResult.groupedLogs = groupedLogs;
+        abis = this.abis;
       }
       const { receipts } = transactionResult;
       const status = this.getTransactionStatus();
@@ -34226,7 +34449,8 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
           receipts,
           statusReason: reason,
           logs,
-          groupedLogs
+          groupedLogs,
+          abis
         });
       }
       return transactionResult;
@@ -34479,7 +34703,15 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
         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 FuelError(
+            ErrorCode.RESPONSE_BODY_EMPTY,
+            "The response from the server is missing the body",
+            { timestamp: (/* @__PURE__ */ new Date()).toISOString(), request, response }
+          );
+        }
+        return response;
       }, retryOptions);
     }
     static applyBlockHeight(request, url) {
@@ -34502,13 +34734,15 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
         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);
@@ -34931,7 +35165,13 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
         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.
@@ -36026,7 +36266,11 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      */
     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.
@@ -36077,18 +36321,21 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     extractDryRunError(transactionRequest, receipts, reason) {
       let logs = [];
       let groupedLogs = {};
+      let abis;
       if (transactionRequest.type === 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
       });
     }
     /**
@@ -36186,6 +36433,149 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
     }
   };
 
+  // src/utils/consolidate-coins.ts
+  var CONSOLIDATABLE_ERROR_CODES = [ErrorCode.MAX_COINS_REACHED];
+  var consolidateCoinsIfRequired = /* @__PURE__ */ __name(async (opts) => {
+    const { error: errorUnknown, account, skipAutoConsolidation = false } = opts;
+    if (skipAutoConsolidation) {
+      return false;
+    }
+    const error2 = FuelError.parse(errorUnknown);
+    if (CONSOLIDATABLE_ERROR_CODES.includes(error2.code)) {
+      const { assetId, owner } = error2.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 === OutputType.Change && output.assetId === baseAssetId
+    );
+    if (outputChangeIndex === -1) {
+      throw new FuelError(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 Address(outputCoin.to),
+      blockCreated: bn(0),
+      txCreatedIdx: 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 FuelError(
+        ErrorCode.INSUFFICIENT_FUNDS,
+        `Insufficient funds to consolidate.
+	Asset ID: ${baseAssetId}
+	Owner: ${account.address.toB256()}`
+      );
+    }
+    const batches = [
+      ...splitEvery_default(batchSize, funding),
+      // We leave one coin for the funding coin
+      ...splitEvery_default(batchSize - 1, dust)
+    ];
+    const txs = batches.map((batch) => {
+      const request = new ScriptTransactionRequest({
+        scriptData: "0x"
+      });
+      request.addResources(batch);
+      return request;
+    });
+    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 = 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, request) => acc.add(request.maxFee), bn(0)),
+      submitAll
+    };
+  }, "consolidateCoins");
+
   // src/utils/formatTransferToContractScriptData.ts
   var asm = __toESM(require_node());
   var formatTransferToContractScriptData = /* @__PURE__ */ __name((transferParams) => {
@@ -36302,10 +36692,24 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      *
      * @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 (error2) {
+        const shouldRetry = await consolidateCoinsIfRequired({
+          error: error2,
+          account: this,
+          skipAutoConsolidation
+        });
+        if (!shouldRetry) {
+          throw error2;
+        }
+        return await getResourcesToSpend();
+      }
     }
     /**
      * Retrieves coins owned by the account.
@@ -36354,7 +36758,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @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(request, params) {
+    async fund(request, params, { skipAutoConsolidation } = {}) {
       const {
         addedSignatures,
         estimatedPredicates,
@@ -36400,7 +36804,8 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       while (needsToBeFunded && fundingAttempts < MAX_FUNDING_ATTEMPTS) {
         const resources = await this.getResourcesToSpend(
           missingQuantities,
-          cacheRequestInputsResourcesFromOwner(request.inputs, this.address)
+          cacheRequestInputsResourcesFromOwner(request.inputs, this.address),
+          { skipAutoConsolidation }
         );
         request.addResources(resources);
         request.updatePredicateGasUsed(estimatedPredicates);
@@ -36438,7 +36843,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       }
       if (needsToBeFunded) {
         throw new FuelError(
-          ErrorCode.INSUFFICIENT_FUNDS_OR_MAX_COINS,
+          ErrorCode.INSUFFICIENT_FUNDS,
           `The account ${this.address} does not have enough base asset funds to cover the transaction execution.`
         );
       }
@@ -36466,16 +36871,20 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @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 request = new ScriptTransactionRequest(txParams);
       request = this.addTransfer(request, {
         destination,
         amount,
         assetId: assetId || await this.provider.getBaseAssetId()
       });
-      const { gasPrice, transactionRequest } = await this.assembleTx(request);
+      const { gasPrice, transactionRequest } = await this.assembleTx({
+        transactionRequest: request,
+        skipAutoConsolidation
+      });
       request = await setAndValidateGasAndFeeForAssembledTx({
         gasPrice,
         provider: this.provider,
@@ -36492,10 +36901,13 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @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 request = await this.createTransfer(destination, amount, assetId, txParams);
+    async transfer(destination, amount, assetId, txParams = {}, { skipAutoConsolidation } = {}) {
+      const request = await this.createTransfer(destination, amount, assetId, txParams, {
+        skipAutoConsolidation
+      });
       return this.sendTransaction(request, { estimateTxDependencies: false });
     }
     /**
@@ -36503,12 +36915,16 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      *
      * @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 request = new ScriptTransactionRequest(txParams);
       request = this.addBatchTransfer(request, transferParams);
-      const { gasPrice, transactionRequest } = await this.assembleTx(request);
+      const { gasPrice, transactionRequest } = await this.assembleTx({
+        transactionRequest: request,
+        skipAutoConsolidation
+      });
       request = await setAndValidateGasAndFeeForAssembledTx({
         gasPrice,
         provider: this.provider,
@@ -36555,12 +36971,15 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @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 request = new ScriptTransactionRequest({
         ...txParams
       });
@@ -36587,7 +37006,11 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       const { script, scriptData } = await assembleTransferToContractScript(transferParams);
       request.script = script;
       request.scriptData = scriptData;
-      const { gasPrice, transactionRequest } = await this.assembleTx(request, quantities);
+      const { gasPrice, transactionRequest } = await this.assembleTx({
+        transactionRequest: request,
+        quantities,
+        skipAutoConsolidation
+      });
       request = await setAndValidateGasAndFeeForAssembledTx({
         gasPrice,
         provider: this.provider,
@@ -36603,9 +37026,10 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
      * @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 = {}) {
+    async withdrawToBaseLayer(recipient, amount, txParams = {}, { skipAutoConsolidation } = {}) {
       const recipientAddress = new Address(recipient);
       const recipientDataArray = arrayify(
         "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
@@ -36622,7 +37046,11 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       const baseAssetId = await this.provider.getBaseAssetId();
       let request = new ScriptTransactionRequest(params);
       const quantities = [{ amount: bn(amount), assetId: baseAssetId }];
-      const { gasPrice, transactionRequest } = await this.assembleTx(request, quantities);
+      const { gasPrice, transactionRequest } = await this.assembleTx({
+        transactionRequest: request,
+        quantities,
+        skipAutoConsolidation
+      });
       request = await setAndValidateGasAndFeeForAssembledTx({
         gasPrice,
         provider: this.provider,
@@ -36632,6 +37060,25 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       });
       return this.sendTransaction(request);
     }
+    /**
+     * 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.
      *
@@ -36651,6 +37098,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       const isBaseAsset = baseAssetId === assetId;
       let submitAll;
       const consolidationParams = {
+        assetId,
         coins,
         mode: params.mode,
         outputNum: params.outputNum
@@ -36658,10 +37106,7 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       if (isBaseAsset) {
         ({ submitAll } = await this.assembleBaseAssetConsolidationTxs(consolidationParams));
       } else {
-        throw new FuelError(
-          ErrorCode.UNSUPPORTED_FEATURE,
-          "Consolidation for non-base assets is not supported yet."
-        );
+        ({ submitAll } = await this.assembleNonBaseAssetConsolidationTxs(consolidationParams));
       }
       return submitAll();
     }
@@ -36720,6 +37165,70 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       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 = 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 request = new ScriptTransactionRequest({
+          script: "0x"
+        });
+        request.addResources(coinBatch);
+        if (consolidateMoreThanOneCoin) {
+          Array.from({ length: outputNum - 1 }).forEach(() => {
+            request.addCoinOutput(this.address, 0, assetId);
+          });
+        }
+        const minGas = request.calculateMinGas(chainInfo);
+        const fee = calculateGasFee({
+          gasPrice,
+          gas: minGas,
+          priceFactor: chainInfo.consensusParameters.feeParameters.gasPriceFactor,
+          tip: request.tip
+        });
+        request.maxFee = fee;
+        if (consolidateMoreThanOneCoin) {
+          const total = request.inputs.filter(isRequestInputCoin).reduce((acc, input) => acc.add(input.amount), bn(0));
+          const amountPerNewUtxo = total.div(outputNum + 1);
+          request.outputs.forEach((output) => {
+            if (output.type === OutputType.Coin) {
+              output.amount = amountPerNewUtxo;
+            }
+          });
+        }
+        totalFeeCost = totalFeeCost.add(fee);
+        const baseAssetResources = [];
+        let fundingFeeTotal = bn(0);
+        while (fundingFeeTotal.lt(fee)) {
+          const baseAssetCoin = baseAssetCoins.pop();
+          if (!baseAssetCoin) {
+            break;
+          }
+          baseAssetResources.push(baseAssetCoin);
+          fundingFeeTotal = fundingFeeTotal.add(baseAssetCoin.amount);
+        }
+        const { inputs } = request;
+        request.inputs = inputs.slice(0, maxInputsNumber - baseAssetResources.length);
+        const removedCoins = coinBatch.slice(maxInputsNumber - baseAssetResources.length);
+        request.addResources(baseAssetResources);
+        const lastCoinBatch = assetCoinBatches[assetCoinBatches.length - 1];
+        lastCoinBatch.push(...removedCoins);
+        if (lastCoinBatch.length > maxInputsNumber) {
+          assetCoinBatches.push(lastCoinBatch.slice(maxInputsNumber));
+        }
+        txs.push(request);
+      });
+      const submitAll = this.prepareSubmitAll({ txs, mode });
+      return { txs, totalFeeCost, submitAll };
+    }
     /**
      * Prepares a function to submit all transactions either sequentially or in parallel.
      *
@@ -36934,16 +37443,32 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       } : void 0;
     }
     /** @hidden * */
-    async assembleTx(transactionRequest, quantities = []) {
+    async assembleTx(opts) {
+      const { transactionRequest, quantities = [], skipAutoConsolidation } = opts;
       const outputQuantities = transactionRequest.outputs.filter((o) => o.type === OutputType.Coin).map(({ amount, assetId }) => ({ assetId: String(assetId), amount: bn(amount) }));
       transactionRequest.gasLimit = bn(0);
       transactionRequest.maxFee = bn(0);
-      const { assembledRequest, gasPrice } = await this.provider.assembleTx({
-        request: transactionRequest,
-        accountCoinQuantities: mergeQuantities(outputQuantities, quantities),
-        feePayerAccount: this
-      });
-      return { transactionRequest: assembledRequest, gasPrice };
+      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 (error2) {
+        const shouldRetry = await consolidateCoinsIfRequired({
+          error: error2,
+          account: this,
+          skipAutoConsolidation
+        });
+        if (!shouldRetry) {
+          throw error2;
+        }
+        return await assembleTx();
+      }
     }
     /** @hidden * */
     validateTransferAmount(amount) {
@@ -36955,45 +37480,6 @@ ${PANIC_DOC_URL}#variant.${statusReason}`;
       }
     }
     /** @hidden * */
-    async estimateAndFundTransaction(transactionRequest, txParams, costParams) {
-      let request = transactionRequest;
-      const txCost = await this.getTransactionCost(request, costParams);
-      request = this.validateGasLimitAndMaxFee({
-        transactionRequest: request,
-        gasUsed: txCost.gasUsed,
-        maxFee: txCost.maxFee,
-        txParams
-      });
-      request = await this.fund(request, txCost);
-      return request;
-    }
-    /** @hidden * */
-    validateGasLimitAndMaxFee({
-      gasUsed,
-      maxFee,
-      transactionRequest,
-      txParams: { gasLimit: setGasLimit, maxFee: setMaxFee }
-    }) {
-      const request = transactionRequestify(transactionRequest);
-      if (!isDefined(setGasLimit)) {
-        request.gasLimit = gasUsed;
-      } else if (gasUsed.gt(setGasLimit)) {
-        throw new FuelError(
-          ErrorCode.GAS_LIMIT_TOO_LOW,
-          `Gas limit '${setGasLimit}' is lower than the required: '${gasUsed}'.`
-        );
-      }
-      if (!isDefined(setMaxFee)) {
-        request.maxFee = maxFee;
-      } else if (maxFee.gt(setMaxFee)) {
-        throw new FuelError(
-          ErrorCode.MAX_FEE_TOO_LOW,
-          `Max fee '${setMaxFee}' is lower than the required: '${maxFee}'.`
-        );
-      }
-      return request;
-    }
-    /** @hidden * */
     validateConsolidationTxsCoins(coins, assetId) {
       if (coins.length <= 1) {
         throw new FuelError(ErrorCode.NO_COINS_TO_CONSOLIDATE, "No coins to consolidate.");