@fuel-ts/account 0.101.2 → 0.101.3

package/dist/index.mjs

@@ -705,11 +705,11 @@ var getAssetsByOwner = /* @__PURE__ */ __name(async (opts) => {
 
 // src/account.ts
 import { UTXO_ID_LEN as UTXO_ID_LEN3 } from "@fuel-ts/abi-coder";
-import { Address as Address4 } from "@fuel-ts/address";
+import { Address as Address5 } from "@fuel-ts/address";
 import { randomBytes as randomBytes2 } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode19, FuelError as FuelError21 } from "@fuel-ts/errors";
-import { bn as bn21 } from "@fuel-ts/math";
-import { InputType as InputType8, OutputType as OutputType9 } from "@fuel-ts/transactions";
+import { ErrorCode as ErrorCode20, FuelError as FuelError22 } from "@fuel-ts/errors";
+import { bn as bn22 } from "@fuel-ts/math";
+import { InputType as InputType8, OutputType as OutputType10 } from "@fuel-ts/transactions";
 import { arrayify as arrayify17, hexlify as hexlify18, isDefined as isDefined4 } from "@fuel-ts/utils";
 import { clone as clone9 } from "ramda";
 
@@ -2152,8 +2152,11 @@ import { print } from "graphql";
 
 // src/providers/utils/handle-gql-error-message.ts
 import { ErrorCode as ErrorCode2, FuelError as FuelError2 } from "@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/,
@@ -2169,6 +2172,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 FuelError2(
+      ErrorCode2.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 FuelError2(
+      ErrorCode2.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] || "";
@@ -3335,6 +3378,7 @@ This error originated at ${JSON.stringify(pos, null, 2)}` : "";
   }
   return new FuelError8(ErrorCode8.SCRIPT_REVERTED, errorMessage, {
     ...metadata,
+    abiError,
     reason
   });
 }
@@ -4389,11 +4433,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;
   }
   /**
@@ -6022,25 +6070,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");
   }
@@ -6055,9 +6084,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
@@ -6597,7 +6659,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 FuelError19(
+          ErrorCode17.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) {
@@ -6620,13 +6690,15 @@ 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);
@@ -7049,7 +7121,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.
@@ -8144,7 +8222,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.
@@ -8475,7 +8557,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));
   }
@@ -8492,9 +8579,157 @@ var AbstractAccount = class {
   }
 };
 
+// src/utils/consolidate-coins.ts
+import { Address as Address3 } from "@fuel-ts/address";
+import { ErrorCode as ErrorCode19, FuelError as FuelError21 } from "@fuel-ts/errors";
+import { bn as bn21 } from "@fuel-ts/math";
+import { OutputType as OutputType9 } from "@fuel-ts/transactions";
+import { splitEvery } from "ramda";
+var CONSOLIDATABLE_ERROR_CODES = [ErrorCode19.MAX_COINS_REACHED];
+var consolidateCoinsIfRequired = /* @__PURE__ */ __name(async (opts) => {
+  const { error: errorUnknown, account, skipAutoConsolidation = false } = opts;
+  if (skipAutoConsolidation) {
+    return false;
+  }
+  const error = FuelError21.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 === OutputType9.Change && output.assetId === baseAssetId
+  );
+  if (outputChangeIndex === -1) {
+    throw new FuelError21(ErrorCode19.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 Address3(outputCoin.to),
+    blockCreated: bn21(0),
+    txCreatedIdx: bn21(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 FuelError21(
+      ErrorCode19.INSUFFICIENT_FUNDS,
+      `Insufficient funds to consolidate.
+	Asset ID: ${baseAssetId}
+	Owner: ${account.address.toB256()}`
+    );
+  }
+  const batches = [
+    ...splitEvery(batchSize, funding),
+    // We leave one coin for the funding coin
+    ...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 = bn21(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), bn21(0)),
+    submitAll
+  };
+}, "consolidateCoins");
+
 // src/utils/formatTransferToContractScriptData.ts
 import { ASSET_ID_LEN, BigNumberCoder as BigNumberCoder3, CONTRACT_ID_LEN, WORD_SIZE } from "@fuel-ts/abi-coder";
-import { Address as Address3 } from "@fuel-ts/address";
+import { Address as Address4 } from "@fuel-ts/address";
 import { arrayify as arrayify16, concat as concat4 } from "@fuel-ts/utils";
 import * as asm from "@fuels/vm-asm";
 var formatTransferToContractScriptData = /* @__PURE__ */ __name((transferParams) => {
@@ -8502,7 +8737,7 @@ var formatTransferToContractScriptData = /* @__PURE__ */ __name((transferParams)
   return transferParams.reduce((acc, transferParam) => {
     const { assetId, amount, contractId } = transferParam;
     const encoded = numberCoder.encode(amount);
-    const scriptData = concat4([new Address3(contractId).toBytes(), encoded, arrayify16(assetId)]);
+    const scriptData = concat4([new Address4(contractId).toBytes(), encoded, arrayify16(assetId)]);
     return concat4([acc, scriptData]);
   }, new Uint8Array());
 }, "formatTransferToContractScriptData");
@@ -8573,7 +8808,7 @@ var Account = class extends AbstractAccount {
     super();
     this._provider = provider;
     this._connector = connector;
-    this.address = new Address4(address);
+    this.address = new Address5(address);
   }
   /**
    * The provider used to interact with the network.
@@ -8584,7 +8819,7 @@ var Account = class extends AbstractAccount {
    */
   get provider() {
     if (!this._provider) {
-      throw new FuelError21(ErrorCode19.MISSING_PROVIDER, "Provider not set");
+      throw new FuelError22(ErrorCode20.MISSING_PROVIDER, "Provider not set");
     }
     return this._provider;
   }
@@ -8611,10 +8846,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.
@@ -8663,7 +8912,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,
@@ -8675,9 +8924,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 || bn21(0);
+    const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || bn22(0);
     const requiredQuantitiesWithFee = addAmountToCoinQuantities({
-      amount: bn21(fee),
+      amount: bn22(fee),
       assetId: baseAssetId,
       coinQuantities: requiredQuantities
     });
@@ -8685,7 +8934,7 @@ var Account = class extends AbstractAccount {
     requiredQuantitiesWithFee.forEach(({ amount, assetId }) => {
       quantitiesDict[assetId] = {
         required: amount,
-        owned: bn21(0)
+        owned: bn22(0)
       };
     });
     request2.inputs.filter(isRequestInputResource).forEach((input) => {
@@ -8709,7 +8958,8 @@ 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);
@@ -8746,8 +8996,8 @@ var Account = class extends AbstractAccount {
       fundingAttempts += 1;
     }
     if (needsToBeFunded) {
-      throw new FuelError21(
-        ErrorCode19.INSUFFICIENT_FUNDS_OR_MAX_COINS,
+      throw new FuelError22(
+        ErrorCode20.INSUFFICIENT_FUNDS,
         `The account ${this.address} does not have enough base asset funds to cover the transaction execution.`
       );
     }
@@ -8775,16 +9025,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,
@@ -8801,10 +9055,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 });
   }
   /**
@@ -8812,12 +9069,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,
@@ -8837,7 +9098,7 @@ var Account = class extends AbstractAccount {
   addTransfer(request2, transferParams) {
     const { destination, amount, assetId } = transferParams;
     this.validateTransferAmount(amount);
-    request2.addCoinOutput(new Address4(destination), amount, assetId);
+    request2.addCoinOutput(new Address5(destination), amount, assetId);
     return request2;
   }
   /**
@@ -8864,24 +9125,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 = bn21(transferParam.amount);
-      const contractAddress = new Address4(transferParam.contractId);
+      const amount = bn22(transferParam.amount);
+      const contractAddress = new Address5(transferParam.contractId);
       const assetId = transferParam.assetId ? hexlify18(transferParam.assetId) : defaultAssetId;
       if (amount.lte(0)) {
-        throw new FuelError21(
-          ErrorCode19.INVALID_TRANSFER_AMOUNT,
+        throw new FuelError22(
+          ErrorCode20.INVALID_TRANSFER_AMOUNT,
           "Transfer amount must be a positive number."
         );
       }
@@ -8896,7 +9160,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,
@@ -8912,15 +9180,16 @@ 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 Address4(recipient);
+  async withdrawToBaseLayer(recipient, amount, txParams = {}, { skipAutoConsolidation } = {}) {
+    const recipientAddress = new Address5(recipient);
     const recipientDataArray = arrayify17(
       "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
     );
     const amountDataArray = arrayify17(
-      "0x".concat(bn21(amount).toHex().substring(2).padStart(16, "0"))
+      "0x".concat(bn22(amount).toHex().substring(2).padStart(16, "0"))
     );
     const script = new Uint8Array([
       ...arrayify17(withdrawScript.bytes),
@@ -8930,8 +9199,12 @@ var Account = class extends AbstractAccount {
     const params = { script, ...txParams };
     const baseAssetId = await this.provider.getBaseAssetId();
     let request2 = new ScriptTransactionRequest(params);
-    const quantities = [{ amount: bn21(amount), assetId: baseAssetId }];
-    const { gasPrice, transactionRequest } = await this.assembleTx(request2, quantities);
+    const quantities = [{ amount: bn22(amount), assetId: baseAssetId }];
+    const { gasPrice, transactionRequest } = await this.assembleTx({
+      transactionRequest: request2,
+      quantities,
+      skipAutoConsolidation
+    });
     request2 = await setAndValidateGasAndFeeForAssembledTx({
       gasPrice,
       provider: this.provider,
@@ -8941,6 +9214,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.
    *
@@ -8960,6 +9252,7 @@ var Account = class extends AbstractAccount {
     const isBaseAsset = baseAssetId === assetId;
     let submitAll;
     const consolidationParams = {
+      assetId,
       coins,
       mode: params.mode,
       outputNum: params.outputNum
@@ -8967,10 +9260,7 @@ var Account = class extends AbstractAccount {
     if (isBaseAsset) {
       ({ submitAll } = await this.assembleBaseAssetConsolidationTxs(consolidationParams));
     } else {
-      throw new FuelError21(
-        ErrorCode19.UNSUPPORTED_FEATURE,
-        "Consolidation for non-base assets is not supported yet."
-      );
+      ({ submitAll } = await this.assembleNonBaseAssetConsolidationTxs(consolidationParams));
     }
     return submitAll();
   }
@@ -8991,7 +9281,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 = bn21(0);
+    let totalFeeCost = bn22(0);
     const txs = [];
     const coinsBatches = splitCoinsIntoBatches(coins, maxInputsNumber);
     const gasPrice = await this.provider.estimateGasPrice(10);
@@ -9015,10 +9305,10 @@ var Account = class extends AbstractAccount {
       });
       request2.maxFee = fee;
       if (consolidateMoreThanOneCoin) {
-        const total = request2.inputs.filter(isRequestInputCoin).reduce((acc, input) => acc.add(input.amount), bn21(0));
+        const total = request2.inputs.filter(isRequestInputCoin).reduce((acc, input) => acc.add(input.amount), bn22(0));
         const amountPerNewUtxo = total.div(outputNum + 1);
         request2.outputs.forEach((output) => {
-          if (output.type === OutputType9.Coin) {
+          if (output.type === OutputType10.Coin) {
             output.amount = amountPerNewUtxo;
           }
         });
@@ -9029,6 +9319,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 = bn22(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), bn22(0));
+        const amountPerNewUtxo = total.div(outputNum + 1);
+        request2.outputs.forEach((output) => {
+          if (output.type === OutputType10.Coin) {
+            output.amount = amountPerNewUtxo;
+          }
+        });
+      }
+      totalFeeCost = totalFeeCost.add(fee);
+      const baseAssetResources = [];
+      let fundingFeeTotal = bn22(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.
    *
@@ -9087,7 +9441,7 @@ var Account = class extends AbstractAccount {
     const baseAssetId = await this.provider.getBaseAssetId();
     const coinOutputsQuantities = txRequestClone.getCoinOutputsQuantities();
     const requiredQuantities = mergeQuantities(coinOutputsQuantities, quantities);
-    const transactionFeeForDryRun = [{ assetId: baseAssetId, amount: bn21("100000000000000000") }];
+    const transactionFeeForDryRun = [{ assetId: baseAssetId, amount: bn22("100000000000000000") }];
     const findAssetInput = /* @__PURE__ */ __name((assetId) => txRequestClone.inputs.find((input) => {
       if (input.type === InputType8.Coin) {
         return input.assetId === assetId;
@@ -9135,7 +9489,7 @@ var Account = class extends AbstractAccount {
    */
   async signMessage(message) {
     if (!this._connector) {
-      throw new FuelError21(ErrorCode19.MISSING_CONNECTOR, "A connector is required to sign messages.");
+      throw new FuelError22(ErrorCode20.MISSING_CONNECTOR, "A connector is required to sign messages.");
     }
     return this._connector.signMessage(this.address.toString(), message);
   }
@@ -9147,8 +9501,8 @@ var Account = class extends AbstractAccount {
    */
   async signTransaction(transactionRequestLike, connectorOptions = {}) {
     if (!this._connector) {
-      throw new FuelError21(
-        ErrorCode19.MISSING_CONNECTOR,
+      throw new FuelError22(
+        ErrorCode20.MISSING_CONNECTOR,
         "A connector is required to sign transactions."
       );
     }
@@ -9215,8 +9569,8 @@ var Account = class extends AbstractAccount {
     return coins.map((coin) => ({
       id: hexlify18(randomBytes2(UTXO_ID_LEN3)),
       owner: this.address,
-      blockCreated: bn21(1),
-      txCreatedIdx: bn21(1),
+      blockCreated: bn22(1),
+      txCreatedIdx: bn22(1),
       ...coin
     }));
   }
@@ -9243,73 +9597,50 @@ var Account = class extends AbstractAccount {
     } : void 0;
   }
   /** @hidden * */
-  async assembleTx(transactionRequest, quantities = []) {
-    const outputQuantities = transactionRequest.outputs.filter((o) => o.type === OutputType9.Coin).map(({ amount, assetId }) => ({ assetId: String(assetId), amount: bn21(amount) }));
-    transactionRequest.gasLimit = bn21(0);
-    transactionRequest.maxFee = bn21(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 === OutputType10.Coin).map(({ amount, assetId }) => ({ assetId: String(assetId), amount: bn22(amount) }));
+    transactionRequest.gasLimit = bn22(0);
+    transactionRequest.maxFee = bn22(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 (bn21(amount).lte(0)) {
-      throw new FuelError21(
-        ErrorCode19.INVALID_TRANSFER_AMOUNT,
+    if (bn22(amount).lte(0)) {
+      throw new FuelError22(
+        ErrorCode20.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 (!isDefined4(setGasLimit)) {
-      request2.gasLimit = gasUsed;
-    } else if (gasUsed.gt(setGasLimit)) {
-      throw new FuelError21(
-        ErrorCode19.GAS_LIMIT_TOO_LOW,
-        `Gas limit '${setGasLimit}' is lower than the required: '${gasUsed}'.`
-      );
-    }
-    if (!isDefined4(setMaxFee)) {
-      request2.maxFee = maxFee;
-    } else if (maxFee.gt(setMaxFee)) {
-      throw new FuelError21(
-        ErrorCode19.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 FuelError21(ErrorCode19.NO_COINS_TO_CONSOLIDATE, "No coins to consolidate.");
+      throw new FuelError22(ErrorCode20.NO_COINS_TO_CONSOLIDATE, "No coins to consolidate.");
     }
     if (!coins.every((c) => c.assetId === assetId)) {
-      throw new FuelError21(
-        ErrorCode19.COINS_ASSET_ID_MISMATCH,
+      throw new FuelError22(
+        ErrorCode20.COINS_ASSET_ID_MISMATCH,
         "All coins to consolidate must be from the same asset id."
       );
     }
@@ -9338,7 +9669,7 @@ import { hashMessage } from "@fuel-ts/hasher";
 import { hexlify as hexlify21 } from "@fuel-ts/utils";
 
 // src/signer/signer.ts
-import { Address as Address5 } from "@fuel-ts/address";
+import { Address as Address6 } from "@fuel-ts/address";
 import { randomBytes as randomBytes3 } from "@fuel-ts/crypto";
 import { hash as hash2 } from "@fuel-ts/hasher";
 import { toBytes as toBytes2 } from "@fuel-ts/math";
@@ -9368,7 +9699,7 @@ var Signer = class _Signer {
     this.privateKey = hexlify19(privateKeyBytes);
     this.publicKey = hexlify19(secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
     this.compressedPublicKey = hexlify19(secp256k1.getPublicKey(privateKeyBytes, true));
-    this.address = new Address5(this.publicKey);
+    this.address = new Address6(this.publicKey);
   }
   /**
    * Sign data using the Signer instance
@@ -9426,7 +9757,7 @@ var Signer = class _Signer {
    * @returns Address from signature
    */
   static recoverAddress(data, signature) {
-    return new Address5(_Signer.recoverPublicKey(data, signature));
+    return new Address6(_Signer.recoverPublicKey(data, signature));
   }
   /**
    * Generate a random privateKey
@@ -9450,7 +9781,7 @@ var Signer = class _Signer {
 };
 
 // src/wallet/keystore-wallet.ts
-import { Address as Address6 } from "@fuel-ts/address";
+import { Address as Address7 } from "@fuel-ts/address";
 import {
   bufferFromString,
   keccak256,
@@ -9461,7 +9792,7 @@ import {
   encryptJsonWalletData,
   randomUUID
 } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode20, FuelError as FuelError22 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode21, FuelError as FuelError23 } from "@fuel-ts/errors";
 import { hexlify as hexlify20 } from "@fuel-ts/utils";
 var DEFAULT_KDF_PARAMS_LOG_N = 13;
 var DEFAULT_KDF_PARAMS_R = 8;
@@ -9476,7 +9807,7 @@ var removeHexPrefix = /* @__PURE__ */ __name((hexString) => {
 }, "removeHexPrefix");
 async function encryptKeystoreWallet(privateKey, address, password) {
   const privateKeyBuffer = bufferFromString(removeHexPrefix(privateKey), "hex");
-  const ownerAddress = new Address6(address);
+  const ownerAddress = new Address7(address);
   const salt = randomBytes4(DEFAULT_KEY_SIZE);
   const key = scrypt({
     password: bufferFromString(password),
@@ -9539,8 +9870,8 @@ async function decryptKeystoreWallet(jsonWallet, password) {
   const macHashUint8Array = keccak256(data);
   const macHash = stringFromBuffer(macHashUint8Array, "hex");
   if (mac !== macHash) {
-    throw new FuelError22(
-      ErrorCode20.INVALID_PASSWORD,
+    throw new FuelError23(
+      ErrorCode21.INVALID_PASSWORD,
       "Failed to decrypt the keystore wallet, the provided password is incorrect."
     );
   }
@@ -9679,14 +10010,14 @@ var BaseWalletUnlocked = class extends Account {
 
 // src/hdwallet/hdwallet.ts
 import { computeHmac as computeHmac2, ripemd160 } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode23, FuelError as FuelError25 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode24, FuelError as FuelError26 } from "@fuel-ts/errors";
 import { sha256 as sha2564 } from "@fuel-ts/hasher";
-import { bn as bn22, toBytes as toBytes3, toHex } from "@fuel-ts/math";
+import { bn as bn23, toBytes as toBytes3, toHex } from "@fuel-ts/math";
 import { arrayify as arrayify21, hexlify as hexlify23, concat as concat7, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58 } from "@fuel-ts/utils";
 
 // src/mnemonic/mnemonic.ts
 import { randomBytes as randomBytes5, pbkdf2, computeHmac } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode22, FuelError as FuelError24 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode23, FuelError as FuelError25 } from "@fuel-ts/errors";
 import { sha256 as sha2563 } from "@fuel-ts/hasher";
 import { arrayify as arrayify20, hexlify as hexlify22, concat as concat6, dataSlice, encodeBase58, toUtf8Bytes } from "@fuel-ts/utils";
 
@@ -11749,7 +12080,7 @@ var Language = /* @__PURE__ */ ((Language2) => {
 })(Language || {});
 
 // src/mnemonic/utils.ts
-import { ErrorCode as ErrorCode21, FuelError as FuelError23 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode22, FuelError as FuelError24 } from "@fuel-ts/errors";
 import { sha256 as sha2562 } from "@fuel-ts/hasher";
 import { arrayify as arrayify19 } from "@fuel-ts/utils";
 function getLowerMask(bits) {
@@ -11803,8 +12134,8 @@ function mnemonicWordsToEntropy(words, wordlist) {
   for (let i = 0; i < words.length; i += 1) {
     const index = wordlist.indexOf(words[i].normalize("NFKD"));
     if (index === -1) {
-      throw new FuelError23(
-        ErrorCode21.INVALID_MNEMONIC,
+      throw new FuelError24(
+        ErrorCode22.INVALID_MNEMONIC,
         `Invalid mnemonic: the word '${words[i]}' is not found in the provided wordlist.`
       );
     }
@@ -11820,8 +12151,8 @@ function mnemonicWordsToEntropy(words, wordlist) {
   const checksumMask = getUpperMask(checksumBits);
   const checksum = arrayify19(sha2562(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
   if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
-    throw new FuelError23(
-      ErrorCode21.INVALID_CHECKSUM,
+    throw new FuelError24(
+      ErrorCode22.INVALID_CHECKSUM,
       "Checksum validation failed for the provided mnemonic."
     );
   }
@@ -11836,8 +12167,8 @@ var TestnetPRV = "0x04358394";
 var MNEMONIC_SIZES = [12, 15, 18, 21, 24];
 function assertWordList(wordlist) {
   if (wordlist.length !== 2048) {
-    throw new FuelError24(
-      ErrorCode22.INVALID_WORD_LIST,
+    throw new FuelError25(
+      ErrorCode23.INVALID_WORD_LIST,
       `Expected word list length of 2048, but got ${wordlist.length}.`
     );
   }
@@ -11845,8 +12176,8 @@ function assertWordList(wordlist) {
 __name(assertWordList, "assertWordList");
 function assertEntropy(entropy) {
   if (entropy.length % 4 !== 0 || entropy.length < 16 || entropy.length > 32) {
-    throw new FuelError24(
-      ErrorCode22.INVALID_ENTROPY,
+    throw new FuelError25(
+      ErrorCode23.INVALID_ENTROPY,
       `Entropy should be between 16 and 32 bytes and a multiple of 4, but got ${entropy.length} bytes.`
     );
   }
@@ -11857,7 +12188,7 @@ function assertMnemonic(words) {
     const errorMsg = `Invalid mnemonic size. Expected one of [${MNEMONIC_SIZES.join(
       ", "
     )}] words, but got ${words.length}.`;
-    throw new FuelError24(ErrorCode22.INVALID_MNEMONIC, errorMsg);
+    throw new FuelError25(ErrorCode23.INVALID_MNEMONIC, errorMsg);
   }
 }
 __name(assertMnemonic, "assertMnemonic");
@@ -11979,8 +12310,8 @@ var Mnemonic = class _Mnemonic {
   static masterKeysFromSeed(seed) {
     const seedArray = arrayify20(seed);
     if (seedArray.length < 16 || seedArray.length > 64) {
-      throw new FuelError24(
-        ErrorCode22.INVALID_SEED,
+      throw new FuelError25(
+        ErrorCode23.INVALID_SEED,
         `Seed length should be between 16 and 64 bytes, but received ${seedArray.length} bytes.`
       );
     }
@@ -12061,7 +12392,7 @@ __name(isValidExtendedKey, "isValidExtendedKey");
 function parsePath(path, depth = 0) {
   const components = path.split("/");
   if (components.length === 0 || components[0] === "m" && depth !== 0) {
-    throw new FuelError25(ErrorCode23.HD_WALLET_ERROR, `invalid path - ${path}`);
+    throw new FuelError26(ErrorCode24.HD_WALLET_ERROR, `invalid path - ${path}`);
   }
   if (components[0] === "m") {
     components.shift();
@@ -12094,8 +12425,8 @@ var HDWallet = class _HDWallet {
       this.privateKey = hexlify23(config.privateKey);
     } else {
       if (!config.publicKey) {
-        throw new FuelError25(
-          ErrorCode23.HD_WALLET_ERROR,
+        throw new FuelError26(
+          ErrorCode24.HD_WALLET_ERROR,
           "Both public and private Key cannot be missing. At least one should be provided."
         );
       }
@@ -12124,8 +12455,8 @@ var HDWallet = class _HDWallet {
     const data = new Uint8Array(37);
     if (index & HARDENED_INDEX) {
       if (!privateKey) {
-        throw new FuelError25(
-          ErrorCode23.HD_WALLET_ERROR,
+        throw new FuelError26(
+          ErrorCode24.HD_WALLET_ERROR,
           "Cannot derive a hardened index without a private Key."
         );
       }
@@ -12139,7 +12470,7 @@ var HDWallet = class _HDWallet {
     const IR = bytes.slice(32);
     if (privateKey) {
       const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
-      const ki = bn22(IL).add(privateKey).mod(N).toBytes(32);
+      const ki = bn23(IL).add(privateKey).mod(N).toBytes(32);
       return new _HDWallet({
         privateKey: ki,
         chainCode: IR,
@@ -12177,8 +12508,8 @@ var HDWallet = class _HDWallet {
    */
   toExtendedKey(isPublic = false, testnet = false) {
     if (this.depth >= 256) {
-      throw new FuelError25(
-        ErrorCode23.HD_WALLET_ERROR,
+      throw new FuelError26(
+        ErrorCode24.HD_WALLET_ERROR,
         `Exceeded max depth of 255. Current depth: ${this.depth}.`
       );
     }
@@ -12209,10 +12540,10 @@ var HDWallet = class _HDWallet {
     const bytes = arrayify21(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
-      throw new FuelError25(ErrorCode23.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
+      throw new FuelError26(ErrorCode24.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
     }
     if (!validChecksum) {
-      throw new FuelError25(ErrorCode23.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
+      throw new FuelError26(ErrorCode24.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
     }
     const depth = bytes[4];
     const parentFingerprint = hexlify23(bytes.slice(5, 9));
@@ -12220,14 +12551,14 @@ var HDWallet = class _HDWallet {
     const chainCode = hexlify23(bytes.slice(13, 45));
     const key = bytes.slice(45, 78);
     if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
-      throw new FuelError25(
-        ErrorCode23.HD_WALLET_ERROR,
+      throw new FuelError26(
+        ErrorCode24.HD_WALLET_ERROR,
         "Inconsistency detected: Depth is zero but fingerprint/index is non-zero."
       );
     }
     if (isPublicExtendedKey(bytes)) {
       if (key[0] !== 3) {
-        throw new FuelError25(ErrorCode23.HD_WALLET_ERROR, "Invalid public extended key.");
+        throw new FuelError26(ErrorCode24.HD_WALLET_ERROR, "Invalid public extended key.");
       }
       return new _HDWallet({
         publicKey: key,
@@ -12238,7 +12569,7 @@ var HDWallet = class _HDWallet {
       });
     }
     if (key[0] !== 0) {
-      throw new FuelError25(ErrorCode23.HD_WALLET_ERROR, "Invalid private extended key.");
+      throw new FuelError26(ErrorCode24.HD_WALLET_ERROR, "Invalid private extended key.");
     }
     return new _HDWallet({
       privateKey: key.slice(1),
@@ -12413,9 +12744,9 @@ var Wallet = class {
 };
 
 // src/wallet-manager/wallet-manager.ts
-import { Address as Address9 } from "@fuel-ts/address";
+import { Address as Address10 } from "@fuel-ts/address";
 import { encrypt, decrypt } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode26, FuelError as FuelError28 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode27, FuelError as FuelError29 } from "@fuel-ts/errors";
 import { EventEmitter } from "events";
 
 // src/wallet-manager/storages/memory-storage.ts
@@ -12440,8 +12771,8 @@ var MemoryStorage = class {
 };
 
 // src/wallet-manager/vaults/mnemonic-vault.ts
-import { Address as Address7 } from "@fuel-ts/address";
-import { ErrorCode as ErrorCode24, FuelError as FuelError26 } from "@fuel-ts/errors";
+import { Address as Address8 } from "@fuel-ts/address";
+import { ErrorCode as ErrorCode25, FuelError as FuelError27 } from "@fuel-ts/errors";
 var MnemonicVault = class {
   static {
     __name(this, "MnemonicVault");
@@ -12492,7 +12823,7 @@ var MnemonicVault = class {
   }
   exportAccount(address) {
     let numberOfAccounts = 0;
-    const ownerAddress = new Address7(address);
+    const ownerAddress = new Address8(address);
     do {
       const wallet = Wallet.fromMnemonic(this.#secret, this.getDerivePath(numberOfAccounts));
       if (wallet.address.equals(ownerAddress)) {
@@ -12500,8 +12831,8 @@ var MnemonicVault = class {
       }
       numberOfAccounts += 1;
     } while (numberOfAccounts < this.numberOfAccounts);
-    throw new FuelError26(
-      ErrorCode24.WALLET_MANAGER_ERROR,
+    throw new FuelError27(
+      ErrorCode25.WALLET_MANAGER_ERROR,
       `Account with address '${address}' not found in derived wallets.`
     );
   }
@@ -12512,8 +12843,8 @@ var MnemonicVault = class {
 };
 
 // src/wallet-manager/vaults/privatekey-vault.ts
-import { Address as Address8 } from "@fuel-ts/address";
-import { ErrorCode as ErrorCode25, FuelError as FuelError27 } from "@fuel-ts/errors";
+import { Address as Address9 } from "@fuel-ts/address";
+import { ErrorCode as ErrorCode26, FuelError as FuelError28 } from "@fuel-ts/errors";
 var PrivateKeyVault = class {
   static {
     __name(this, "PrivateKeyVault");
@@ -12552,13 +12883,13 @@ var PrivateKeyVault = class {
     return this.getPublicAccount(wallet.privateKey);
   }
   exportAccount(address) {
-    const ownerAddress = new Address8(address);
+    const ownerAddress = new Address9(address);
     const privateKey = this.#privateKeys.find(
       (pk) => Wallet.fromPrivateKey(pk).address.equals(ownerAddress)
     );
     if (!privateKey) {
-      throw new FuelError27(
-        ErrorCode25.WALLET_MANAGER_ERROR,
+      throw new FuelError28(
+        ErrorCode26.WALLET_MANAGER_ERROR,
         `No private key found for address '${address}'.`
       );
     }
@@ -12580,7 +12911,7 @@ var ERROR_MESSAGES = {
 };
 function assert(condition, message) {
   if (!condition) {
-    throw new FuelError28(ErrorCode26.WALLET_MANAGER_ERROR, message);
+    throw new FuelError29(ErrorCode27.WALLET_MANAGER_ERROR, message);
   }
 }
 __name(assert, "assert");
@@ -12649,7 +12980,7 @@ var WalletManager = class _WalletManager extends EventEmitter {
    * Create a Wallet instance for the specific account
    */
   getWallet(address) {
-    const ownerAddress = new Address9(address);
+    const ownerAddress = new Address10(address);
     const vaultState = this.#vaults.find(
       (vs) => vs.vault.getAccounts().find((a) => a.address.equals(ownerAddress))
     );
@@ -12660,7 +12991,7 @@ var WalletManager = class _WalletManager extends EventEmitter {
    * Export specific account privateKey
    */
   exportPrivateKey(address) {
-    const ownerAddress = new Address9(address);
+    const ownerAddress = new Address10(address);
     assert(!this.#isLocked, ERROR_MESSAGES.wallet_not_unlocked);
     const vaultState = this.#vaults.find(
       (vs) => vs.vault.getAccounts().find((a) => a.address.equals(ownerAddress))
@@ -12801,29 +13132,29 @@ var WalletManager = class _WalletManager extends EventEmitter {
 };
 
 // src/wallet-manager/types.ts
-import { ErrorCode as ErrorCode27, FuelError as FuelError29 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode28, FuelError as FuelError30 } from "@fuel-ts/errors";
 var Vault = class {
   static {
     __name(this, "Vault");
   }
   static type;
   constructor(_options) {
-    throw new FuelError29(ErrorCode27.NOT_IMPLEMENTED, "Not implemented.");
+    throw new FuelError30(ErrorCode28.NOT_IMPLEMENTED, "Not implemented.");
   }
   serialize() {
-    throw new FuelError29(ErrorCode27.NOT_IMPLEMENTED, "Not implemented.");
+    throw new FuelError30(ErrorCode28.NOT_IMPLEMENTED, "Not implemented.");
   }
   getAccounts() {
-    throw new FuelError29(ErrorCode27.NOT_IMPLEMENTED, "Not implemented.");
+    throw new FuelError30(ErrorCode28.NOT_IMPLEMENTED, "Not implemented.");
   }
   addAccount() {
-    throw new FuelError29(ErrorCode27.NOT_IMPLEMENTED, "Not implemented.");
+    throw new FuelError30(ErrorCode28.NOT_IMPLEMENTED, "Not implemented.");
   }
   exportAccount(_address) {
-    throw new FuelError29(ErrorCode27.NOT_IMPLEMENTED, "Not implemented.");
+    throw new FuelError30(ErrorCode28.NOT_IMPLEMENTED, "Not implemented.");
   }
   getWallet(_address) {
-    throw new FuelError29(ErrorCode27.NOT_IMPLEMENTED, "Not implemented.");
+    throw new FuelError30(ErrorCode28.NOT_IMPLEMENTED, "Not implemented.");
   }
 };
 var StorageAbstract = class {
@@ -12834,12 +13165,12 @@ var StorageAbstract = class {
 
 // src/predicate/predicate.ts
 import { Interface as Interface5 } from "@fuel-ts/abi-coder";
-import { Address as Address10 } from "@fuel-ts/address";
-import { ErrorCode as ErrorCode29, FuelError as FuelError31 } from "@fuel-ts/errors";
+import { Address as Address11 } from "@fuel-ts/address";
+import { ErrorCode as ErrorCode30, FuelError as FuelError32 } from "@fuel-ts/errors";
 import { arrayify as arrayify24, hexlify as hexlify25 } from "@fuel-ts/utils";
 
 // src/utils/deployScriptOrPredicate.ts
-import { FuelError as FuelError30, ErrorCode as ErrorCode28 } from "@fuel-ts/errors";
+import { FuelError as FuelError31, ErrorCode as ErrorCode29 } from "@fuel-ts/errors";
 import { arrayify as arrayify22 } from "@fuel-ts/utils";
 
 // src/utils/predicate-script-loader-instructions.ts
@@ -13046,7 +13377,7 @@ async function deployScriptOrPredicate({
         throw new Error();
       }
     } catch (err) {
-      throw new FuelError30(ErrorCode28.TRANSACTION_FAILED, "Failed to deploy predicate chunk");
+      throw new FuelError31(ErrorCode29.TRANSACTION_FAILED, "Failed to deploy predicate chunk");
     }
     return loaderInstance;
   }, "waitForResult");
@@ -13101,7 +13432,7 @@ var Predicate = class _Predicate extends Account {
       abi,
       configurableConstants
     );
-    const address = new Address10(getPredicateRoot(predicateBytes));
+    const address = new Address11(getPredicateRoot(predicateBytes));
     super(address, provider);
     this.initialBytecode = arrayify24(bytecode);
     this.bytes = predicateBytes;
@@ -13198,8 +13529,8 @@ var Predicate = class _Predicate extends Account {
     let predicateBytes = arrayify24(bytes);
     const abiInterface = new Interface5(jsonAbi);
     if (abiInterface.functions.main === void 0) {
-      throw new FuelError31(
-        ErrorCode29.ABI_MAIN_METHOD_MISSING,
+      throw new FuelError32(
+        ErrorCode30.ABI_MAIN_METHOD_MISSING,
         'Cannot use ABI without "main" function.'
       );
     }
@@ -13259,15 +13590,15 @@ var Predicate = class _Predicate extends Account {
     const mutatedBytes = bytes;
     try {
       if (Object.keys(abiInterface.configurables).length === 0) {
-        throw new FuelError31(
-          ErrorCode29.INVALID_CONFIGURABLE_CONSTANTS,
+        throw new FuelError32(
+          ErrorCode30.INVALID_CONFIGURABLE_CONSTANTS,
           "Predicate has no configurable constants to be set"
         );
       }
       Object.entries(configurableConstants).forEach(([key, value]) => {
         if (!abiInterface?.configurables[key]) {
-          throw new FuelError31(
-            ErrorCode29.CONFIGURABLE_NOT_FOUND,
+          throw new FuelError32(
+            ErrorCode30.CONFIGURABLE_NOT_FOUND,
             `No configurable constant named '${key}' found in the Predicate`
           );
         }
@@ -13276,8 +13607,8 @@ var Predicate = class _Predicate extends Account {
         mutatedBytes.set(encoded, offset);
       });
     } catch (err) {
-      throw new FuelError31(
-        ErrorCode29.INVALID_CONFIGURABLE_CONSTANTS,
+      throw new FuelError32(
+        ErrorCode30.INVALID_CONFIGURABLE_CONSTANTS,
         `Error setting configurable constants: ${err.message}.`
       );
     }
@@ -13330,10 +13661,10 @@ var Predicate = class _Predicate extends Account {
 };
 
 // src/connectors/fuel.ts
-import { ErrorCode as ErrorCode30, FuelError as FuelError34 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode31, FuelError as FuelError35 } from "@fuel-ts/errors";
 
 // src/connectors/fuel-connector.ts
-import { FuelError as FuelError32 } from "@fuel-ts/errors";
+import { FuelError as FuelError33 } from "@fuel-ts/errors";
 import { EventEmitter as EventEmitter2 } from "events";
 
 // src/connectors/types/connector-types.ts
@@ -13358,6 +13689,7 @@ var FuelConnectorMethods = /* @__PURE__ */ ((FuelConnectorMethods2) => {
   FuelConnectorMethods2["addABI"] = "addABI";
   FuelConnectorMethods2["getABI"] = "getABI";
   FuelConnectorMethods2["hasABI"] = "hasABI";
+  FuelConnectorMethods2["startConsolidation"] = "startConsolidation";
   return FuelConnectorMethods2;
 })(FuelConnectorMethods || {});
 var FuelConnectorEventTypes = /* @__PURE__ */ ((FuelConnectorEventTypes2) => {
@@ -13370,6 +13702,7 @@ var FuelConnectorEventTypes = /* @__PURE__ */ ((FuelConnectorEventTypes2) => {
   FuelConnectorEventTypes2["currentNetwork"] = "currentNetwork";
   FuelConnectorEventTypes2["assets"] = "assets";
   FuelConnectorEventTypes2["abis"] = "abis";
+  FuelConnectorEventTypes2["consolidateCoins"] = "consolidateCoins";
   return FuelConnectorEventTypes2;
 })(FuelConnectorEventTypes || {});
 var FuelConnectorEventType = "FuelConnector";
@@ -13415,7 +13748,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns Always true.
    */
   async ping() {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return the current version of the connector
@@ -13424,7 +13757,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns boolean - connection status.
    */
   async version() {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return true if the connector is connected
@@ -13433,7 +13766,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns The connection status.
    */
   async isConnected() {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return all the accounts authorized for the
@@ -13442,7 +13775,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns The accounts addresses strings
    */
   async accounts() {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the connection process and return
@@ -13454,7 +13787,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns boolean - connection status.
    */
   async connect() {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should disconnect the current connection and
@@ -13464,7 +13797,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns The connection status.
    */
   async disconnect() {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the sign message process and return
@@ -13476,7 +13809,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns Message signature
    */
   async signMessage(_address, _message) {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the sign transaction process and return
@@ -13488,7 +13821,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns Transaction signature
    */
   async signTransaction(_address, _transaction, _params) {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the send transaction process and return
@@ -13504,7 +13837,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns The transaction id or transaction response
    */
   async sendTransaction(_address, _transaction, _params) {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return the current account selected inside the connector, if the account
@@ -13515,7 +13848,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns The current account selected otherwise null.
    */
   async currentAccount() {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should add the assets metadata to the connector and return true if the asset
@@ -13529,7 +13862,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns True if the asset was added successfully
    */
   async addAssets(_assets) {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should add the asset metadata to the connector and return true if the asset
@@ -13543,7 +13876,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns True if the asset was added successfully
    */
   async addAsset(_asset) {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return all the assets added to the connector. If a connection is already established.
@@ -13551,7 +13884,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns Array of assets metadata from the connector vinculated to the all accounts from a specific Wallet.
    */
   async assets() {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the add network process and return true if the network was added successfully.
@@ -13562,7 +13895,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns Return true if the network was added successfully
    */
   async addNetwork(_networkUrl) {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should start the select network process and return true if the network has change successfully.
@@ -13573,7 +13906,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns Return true if the network was added successfully
    */
   async selectNetwork(_network) {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return all the networks available from the connector. If the connection is already established.
@@ -13581,7 +13914,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns Return all the networks added to the connector.
    */
   async networks() {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return the current network selected inside the connector. Even if the connection is not established.
@@ -13589,7 +13922,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns Return the current network selected inside the connector.
    */
   async currentNetwork() {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should add the ABI to the connector and return true if the ABI was added successfully.
@@ -13599,7 +13932,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns Return true if the ABI was added successfully.
    */
   async addABI(_contractId, _abi) {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Should return the ABI from the connector vinculated to the all accounts from a specific Wallet.
@@ -13608,7 +13941,7 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns The ABI if it exists, otherwise return null.
    */
   async getABI(_id) {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.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.
@@ -13617,7 +13950,16 @@ var FuelConnector = class extends EventEmitter2 {
    * @returns Returns true if the abi exists or false if not.
    */
   async hasABI(_id) {
-    throw new FuelError32(FuelError32.CODES.NOT_IMPLEMENTED, "Method not implemented.");
+    throw new FuelError33(FuelError33.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 FuelError33(FuelError33.CODES.NOT_IMPLEMENTED, "Method not implemented.");
   }
   /**
    * Event listener for the connector.
@@ -13663,7 +14005,7 @@ function dispatchFuelConnectorEvent(connector) {
 __name(dispatchFuelConnectorEvent, "dispatchFuelConnectorEvent");
 
 // src/connectors/utils/promises.ts
-import { FuelError as FuelError33 } from "@fuel-ts/errors";
+import { FuelError as FuelError34 } from "@fuel-ts/errors";
 function deferPromise() {
   const defer = {};
   defer.promise = new Promise((resolve, reject) => {
@@ -13676,7 +14018,7 @@ __name(deferPromise, "deferPromise");
 async function withTimeout(promise, timeout = 1050) {
   const timeoutPromise = new Promise((resolve, reject) => {
     setTimeout(() => {
-      reject(new FuelError33(FuelError33.CODES.TIMEOUT_EXCEEDED, "Promise timed out"));
+      reject(new FuelError34(FuelError34.CODES.TIMEOUT_EXCEEDED, "Promise timed out"));
     }, timeout);
   });
   return Promise.race([timeoutPromise, promise]);
@@ -13717,7 +14059,7 @@ var Fuel = class _Fuel extends FuelConnector {
       this._targetUnsubscribe = this.setupConnectorListener();
       await connectResponse;
     } catch (error) {
-      throw new FuelError34(ErrorCode30.INVALID_PROVIDER, "Error initializing Fuel Connector");
+      throw new FuelError35(ErrorCode31.INVALID_PROVIDER, "Error initializing Fuel Connector");
     }
   }
   async init() {
@@ -13783,8 +14125,8 @@ var Fuel = class _Fuel extends FuelConnector {
     const hasConnector = await this.hasConnector();
     await this.pingConnector();
     if (!this._currentConnector || !hasConnector) {
-      throw new FuelError34(
-        ErrorCode30.MISSING_CONNECTOR,
+      throw new FuelError35(
+        ErrorCode31.MISSING_CONNECTOR,
         `No connector selected for calling ${method}. Use hasConnector before executing other methods.`
       );
     }
@@ -13848,7 +14190,7 @@ var Fuel = class _Fuel extends FuelConnector {
         cacheTime: PING_CACHE_TIME
       })();
     } catch {
-      throw new FuelError34(ErrorCode30.INVALID_PROVIDER, "Current connector is not available.");
+      throw new FuelError35(ErrorCode31.INVALID_PROVIDER, "Current connector is not available.");
     }
   }
   /**
@@ -13997,7 +14339,7 @@ var Fuel = class _Fuel extends FuelConnector {
       const currentNetwork = await this.currentNetwork();
       provider = new Provider(currentNetwork.url);
     } else {
-      throw new FuelError34(ErrorCode30.INVALID_PROVIDER, "Provider is not valid.");
+      throw new FuelError35(ErrorCode31.INVALID_PROVIDER, "Provider is not valid.");
     }
     return provider;
   }
@@ -14107,6 +14449,8 @@ export {
   calculateMinGasForTxUpload,
   calculateTXFeeForSummary,
   coinQuantityfy,
+  consolidateCoins,
+  consolidateCoinsIfRequired,
   deferPromise,
   deployScriptOrPredicate,
   deserializeChain,
@@ -14125,6 +14469,7 @@ export {
   extractTxError,
   fuelAssetsBaseUrl,
   gasUsedByInputs,
+  getAllCoins,
   getAllDecodedLogs,
   getAssetAmountInRequestInputs,
   getAssetById,