@fuel-ts/account 0.100.3 → 0.100.4

package/dist/test-utils.mjs

@@ -228,6 +228,7 @@ var launchNode = /* @__PURE__ */ __name(async ({
     const poaInstant = poaInstantFlagValue === "true" || poaInstantFlagValue === void 0;
     const nativeExecutorVersion = getFlagValueFromArgs(args, "--native-executor-version") || "0";
     const minGasPrice = getFlagValueFromArgs(args, "--min-gas-price") || "1";
+    const startingGasPrice = getFlagValueFromArgs(args, "--starting-gas-price") || "1";
     const graphQLStartSubstring = "Binding GraphQL provider to";
     const command = fuelCorePath || "fuel-core";
     const ipToUse = ip || "0.0.0.0";
@@ -269,6 +270,7 @@ var launchNode = /* @__PURE__ */ __name(async ({
         ["--port", portToUse],
         useInMemoryDb ? ["--db-type", "in-memory"] : ["--db-path", tempDir],
         ["--min-gas-price", minGasPrice],
+        ["--starting-gas-price", startingGasPrice],
         poaInstant ? ["--poa-instant", "true"] : [],
         ["--native-executor-version", nativeExecutorVersion],
         ["--consensus-key", consensusKey],
@@ -404,10 +406,10 @@ var addAmountToCoinQuantities = /* @__PURE__ */ __name((params) => {
 
 // src/providers/provider.ts
 import { Address as Address3, isB256 } from "@fuel-ts/address";
-import { ErrorCode as ErrorCode16, FuelError as FuelError19 } from "@fuel-ts/errors";
-import { bn as bn17 } from "@fuel-ts/math";
-import { InputMessageCoder as InputMessageCoder2, TransactionCoder as TransactionCoder5 } from "@fuel-ts/transactions";
-import { arrayify as arrayify13, hexlify as hexlify18, DateTime as DateTime2, isDefined as isDefined2 } from "@fuel-ts/utils";
+import { ErrorCode as ErrorCode17, FuelError as FuelError20 } from "@fuel-ts/errors";
+import { bn as bn18 } from "@fuel-ts/math";
+import { InputMessageCoder as InputMessageCoder2, TransactionCoder as TransactionCoder6, TransactionType as TransactionType11 } from "@fuel-ts/transactions";
+import { arrayify as arrayify13, hexlify as hexlify19, DateTime as DateTime2, isDefined as isDefined3, sleep as sleep2 } from "@fuel-ts/utils";
 import { checkFuelCoreVersionCompatibility, versions } from "@fuel-ts/versions";
 import { GraphQLClient } from "graphql-request";
 import gql2 from "graphql-tag";
@@ -415,6 +417,83 @@ import { clone as clone8 } from "ramda";
 
 // src/providers/__generated__/operations.ts
 import gql from "graphql-tag";
+var InputCoinFragmentDoc = gql`
+    fragment InputCoinFragment on InputCoin {
+  type: __typename
+  utxoId
+  owner
+  amount
+  assetId
+  txPointer
+  coinWitnessIndex: witnessIndex
+  predicateGasUsed
+  predicate
+  predicateData
+}
+    `;
+var InputMessageFragmentDoc = gql`
+    fragment InputMessageFragment on InputMessage {
+  type: __typename
+  sender
+  recipient
+  amount
+  nonce
+  messageWitnessIndex: witnessIndex
+  predicateGasUsed
+  data
+  predicate
+  predicateData
+}
+    `;
+var InputContractFragmentDoc = gql`
+    fragment InputContractFragment on InputContract {
+  type: __typename
+  utxoId
+  balanceRoot
+  stateRoot
+  txPointer
+  contractId
+}
+    `;
+var OutputCoinFragmentDoc = gql`
+    fragment OutputCoinFragment on CoinOutput {
+  type: __typename
+  to
+  amount
+  assetId
+}
+    `;
+var OutputContractFragmentDoc = gql`
+    fragment OutputContractFragment on ContractOutput {
+  type: __typename
+  inputIndex
+  balanceRoot
+  stateRoot
+}
+    `;
+var OutputChangeFragmentDoc = gql`
+    fragment OutputChangeFragment on ChangeOutput {
+  type: __typename
+  to
+  amount
+  assetId
+}
+    `;
+var OutputVariableFragmentDoc = gql`
+    fragment OutputVariableFragment on VariableOutput {
+  type: __typename
+  to
+  amount
+  assetId
+}
+    `;
+var OutputContractCreatedFragmentDoc = gql`
+    fragment OutputContractCreatedFragment on ContractCreated {
+  type: __typename
+  contract
+  stateRoot
+}
+    `;
 var SubmittedStatusFragmentDoc = gql`
     fragment SubmittedStatusFragment on SubmittedStatus {
   type: __typename
@@ -543,6 +622,87 @@ var SqueezedOutStatusFragmentDoc = gql`
   reason
 }
     `;
+var PreconfirmationSuccessStatusFragmentDoc = gql`
+    fragment PreconfirmationSuccessStatusFragment on PreconfirmationSuccessStatus {
+  type: __typename
+  totalGas
+  totalFee
+  resolvedOutputs {
+    utxoId
+    output {
+      type: __typename
+      ... on CoinOutput {
+        to
+        amount
+        assetId
+      }
+      ... on ContractOutput {
+        inputIndex
+        balanceRoot
+        stateRoot
+      }
+      ... on ChangeOutput {
+        to
+        amount
+        assetId
+      }
+      ... on VariableOutput {
+        to
+        amount
+        assetId
+      }
+      ... on ContractCreated {
+        contract
+        stateRoot
+      }
+    }
+  }
+  preconfirmationReceipts: receipts {
+    ...receiptFragment
+  }
+}
+    ${ReceiptFragmentDoc}`;
+var PreconfirmationFailureStatusFragmentDoc = gql`
+    fragment PreconfirmationFailureStatusFragment on PreconfirmationFailureStatus {
+  type: __typename
+  reason
+  totalGas
+  totalFee
+  resolvedOutputs {
+    utxoId
+    output {
+      type: __typename
+      ... on CoinOutput {
+        to
+        amount
+        assetId
+      }
+      ... on ContractOutput {
+        inputIndex
+        balanceRoot
+        stateRoot
+      }
+      ... on ChangeOutput {
+        to
+        amount
+        assetId
+      }
+      ... on VariableOutput {
+        to
+        amount
+        assetId
+      }
+      ... on ContractCreated {
+        contract
+        stateRoot
+      }
+    }
+  }
+  preconfirmationReceipts: receipts {
+    ...receiptFragment
+  }
+}
+    ${ReceiptFragmentDoc}`;
 var TransactionStatusSubscriptionFragmentDoc = gql`
     fragment transactionStatusSubscriptionFragment on TransactionStatus {
   ... on SubmittedStatus {
@@ -563,12 +723,20 @@ var TransactionStatusSubscriptionFragmentDoc = gql`
   ... on SqueezedOutStatus {
     ...SqueezedOutStatusFragment
   }
+  ... on PreconfirmationSuccessStatus {
+    ...PreconfirmationSuccessStatusFragment
+  }
+  ... on PreconfirmationFailureStatus {
+    ...PreconfirmationFailureStatusFragment
+  }
 }
     ${SubmittedStatusFragmentDoc}
 ${SuccessStatusWithBlockIdFragmentDoc}
 ${MalleableTransactionFieldsFragmentDoc}
 ${FailureStatusWithBlockIdFragmentDoc}
-${SqueezedOutStatusFragmentDoc}`;
+${SqueezedOutStatusFragmentDoc}
+${PreconfirmationSuccessStatusFragmentDoc}
+${PreconfirmationFailureStatusFragmentDoc}`;
 var TransactionStatusFragmentDoc = gql`
     fragment transactionStatusFragment on TransactionStatus {
   ... on SubmittedStatus {
@@ -620,6 +788,23 @@ var TransactionEstimatePredicatesFragmentDoc = gql`
   }
 }
     ${InputEstimatePredicatesFragmentDoc}`;
+var DryRunFailureAssembleTxFragmentDoc = gql`
+    fragment dryRunFailureAssembleTxFragment on DryRunFailureStatus {
+  type: __typename
+  reason
+  receipts {
+    ...receiptFragment
+  }
+}
+    ${ReceiptFragmentDoc}`;
+var DryRunSuccessAssembleTxFragmentDoc = gql`
+    fragment dryRunSuccessAssembleTxFragment on DryRunSuccessStatus {
+  type: __typename
+  receipts {
+    ...receiptFragment
+  }
+}
+    ${ReceiptFragmentDoc}`;
 var DryRunFailureStatusFragmentDoc = gql`
     fragment dryRunFailureStatusFragment on DryRunFailureStatus {
   type: __typename
@@ -976,13 +1161,21 @@ var GetTransactionWithReceiptsDocument = gql`
       ... on SqueezedOutStatus {
         ...SqueezedOutStatusFragment
       }
+      ... on PreconfirmationSuccessStatus {
+        ...PreconfirmationSuccessStatusFragment
+      }
+      ... on PreconfirmationFailureStatus {
+        ...PreconfirmationFailureStatusFragment
+      }
     }
   }
 }
     ${SubmittedStatusFragmentDoc}
 ${SuccessStatusWithBlockIdFragmentDoc}
 ${FailureStatusWithBlockIdFragmentDoc}
-${SqueezedOutStatusFragmentDoc}`;
+${SqueezedOutStatusFragmentDoc}
+${PreconfirmationSuccessStatusFragmentDoc}
+${PreconfirmationFailureStatusFragmentDoc}`;
 var GetTransactionsDocument = gql`
     query getTransactions($after: String, $before: String, $first: Int, $last: Int) {
   transactions(after: $after, before: $before, first: $first, last: $last) {
@@ -1273,6 +1466,77 @@ var GetAssetDetailsDocument = gql`
   }
 }
     `;
+var AssembleTxDocument = gql`
+    query assembleTx($tx: HexString!, $blockHorizon: U32!, $requiredBalances: [RequiredBalance!]!, $feeAddressIndex: U16!, $excludeInput: ExcludeInput, $estimatePredicates: Boolean, $reserveGas: U64) {
+  assembleTx(
+    tx: $tx
+    blockHorizon: $blockHorizon
+    requiredBalances: $requiredBalances
+    feeAddressIndex: $feeAddressIndex
+    excludeInput: $excludeInput
+    estimatePredicates: $estimatePredicates
+    reserveGas: $reserveGas
+  ) {
+    transaction {
+      id
+      inputs {
+        ... on InputCoin {
+          ...InputCoinFragment
+        }
+        ... on InputContract {
+          ...InputContractFragment
+        }
+        ... on InputMessage {
+          ...InputMessageFragment
+        }
+      }
+      outputs {
+        ... on CoinOutput {
+          ...OutputCoinFragment
+        }
+        ... on ContractOutput {
+          ...OutputContractFragment
+        }
+        ... on ChangeOutput {
+          ...OutputChangeFragment
+        }
+        ... on VariableOutput {
+          ...OutputVariableFragment
+        }
+        ... on ContractCreated {
+          ...OutputContractCreatedFragment
+        }
+      }
+      policies {
+        tip
+        witnessLimit
+        maturity
+        maxFee
+      }
+      witnesses
+      scriptGasLimit
+    }
+    status {
+      ... on DryRunFailureStatus {
+        ...dryRunFailureAssembleTxFragment
+      }
+      ... on DryRunSuccessStatus {
+        ...dryRunSuccessAssembleTxFragment
+      }
+    }
+    gasPrice
+  }
+}
+    ${InputCoinFragmentDoc}
+${InputContractFragmentDoc}
+${InputMessageFragmentDoc}
+${OutputCoinFragmentDoc}
+${OutputContractFragmentDoc}
+${OutputChangeFragmentDoc}
+${OutputVariableFragmentDoc}
+${OutputContractCreatedFragmentDoc}
+${DryRunFailureAssembleTxFragmentDoc}
+${DryRunSuccessAssembleTxFragmentDoc}`;
 var DryRunDocument = gql`
     mutation dryRun($encodedTransactions: [HexString!]!, $utxoValidation: Boolean, $gasPrice: U64) {
   dryRun(
@@ -1331,15 +1595,22 @@ var GetConsensusParametersVersionDocument = gql`
 }
     `;
 var SubmitAndAwaitStatusDocument = gql`
-    subscription submitAndAwaitStatus($encodedTransaction: HexString!) {
-  submitAndAwaitStatus(tx: $encodedTransaction) {
+    subscription submitAndAwaitStatus($encodedTransaction: HexString!, $estimatePredicates: Boolean, $includePreConfirmation: Boolean) {
+  submitAndAwaitStatus(
+    tx: $encodedTransaction
+    estimatePredicates: $estimatePredicates
+    includePreconfirmation: $includePreConfirmation
+  ) {
     ...transactionStatusSubscriptionFragment
   }
 }
     ${TransactionStatusSubscriptionFragmentDoc}`;
 var StatusChangeDocument = gql`
-    subscription statusChange($transactionId: TransactionId!) {
-  statusChange(id: $transactionId) {
+    subscription statusChange($transactionId: TransactionId!, $includePreConfirmation: Boolean) {
+  statusChange(
+    id: $transactionId
+    includePreconfirmation: $includePreConfirmation
+  ) {
     ...transactionStatusSubscriptionFragment
   }
 }
@@ -1442,6 +1713,9 @@ function getSdk(requester) {
     getAssetDetails(variables, options) {
       return requester(GetAssetDetailsDocument, variables, options);
     },
+    assembleTx(variables, options) {
+      return requester(AssembleTxDocument, variables, options);
+    },
     dryRun(variables, options) {
       return requester(DryRunDocument, variables, options);
     },
@@ -1470,36 +1744,123 @@ function getSdk(requester) {
 }
 __name(getSdk, "getSdk");
 
+// src/providers/assemble-tx-helpers.ts
+import { FuelError as FuelError2, ErrorCode } from "@fuel-ts/errors";
+import { bn as bn2 } from "@fuel-ts/math";
+import { TransactionType } from "@fuel-ts/transactions";
+import { hexlify as hexlify4, isDefined } from "@fuel-ts/utils";
+var resolveAccountForAssembleTxParams = /* @__PURE__ */ __name((account) => {
+  const assembleTxAccount = {};
+  const accountIsPredicate = "bytes" in account;
+  if (accountIsPredicate) {
+    assembleTxAccount.predicate = {
+      predicate: hexlify4(account.bytes),
+      predicateAddress: account.address.toB256(),
+      predicateData: hexlify4(account.getPredicateData())
+    };
+  } else {
+    assembleTxAccount.address = account.address.toB256();
+  }
+  return assembleTxAccount;
+}, "resolveAccountForAssembleTxParams");
+var setAndValidateGasAndFeeForAssembledTx = /* @__PURE__ */ __name(async (params) => {
+  const { gasPrice, transactionRequest, setGasLimit, setMaxFee, provider } = params;
+  const gasLimitSpecified = isDefined(setGasLimit);
+  const maxFeeSpecified = isDefined(setMaxFee);
+  const isScriptTx = transactionRequest.type === TransactionType.Script;
+  if (gasLimitSpecified && isScriptTx) {
+    const requiredGasLimit = transactionRequest.gasLimit;
+    if (bn2(setGasLimit).lt(bn2(requiredGasLimit))) {
+      throw new FuelError2(
+        ErrorCode.GAS_LIMIT_TOO_LOW,
+        `Gas limit '${setGasLimit}' is lower than the required: '${requiredGasLimit}'.`
+      );
+    }
+    transactionRequest.gasLimit = bn2(setGasLimit);
+  }
+  if (maxFeeSpecified) {
+    const requiredMaxFee = transactionRequest.maxFee;
+    if (bn2(setMaxFee).lt(requiredMaxFee)) {
+      throw new FuelError2(
+        ErrorCode.MAX_FEE_TOO_LOW,
+        `Max fee '${setMaxFee}' is lower than the required: '${requiredMaxFee}'.`
+      );
+    }
+    transactionRequest.maxFee = bn2(setMaxFee);
+  }
+  if (gasLimitSpecified && !maxFeeSpecified) {
+    const { maxFee: feeForGasPrice } = await provider.estimateTxGasAndFee({
+      transactionRequest,
+      gasPrice
+    });
+    transactionRequest.maxFee = feeForGasPrice;
+  }
+  return transactionRequest;
+}, "setAndValidateGasAndFeeForAssembledTx");
+
 // src/providers/fuel-graphql-subscriber.ts
-import { ErrorCode as ErrorCode2, FuelError as FuelError3 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode3, FuelError as FuelError4 } from "@fuel-ts/errors";
 import { print } from "graphql";
 
 // src/providers/utils/handle-gql-error-message.ts
-import { ErrorCode, FuelError as FuelError2 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode2, FuelError as FuelError3 } from "@fuel-ts/errors";
+var gqlErrorMessage = {
+  RPC_CONSISTENCY: /The required fuel block height is higher than the current block height. Required: \d+, Current: \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/,
+  DUPLICATE_CHANGE_OUTPUT_ACCOUNT: /required balances contain duplicate \(asset, account\) pair/,
+  INSUFFICIENT_FEE_AMOUNT: /InsufficientFeeAmount { expected: (\d+), provided: (\d+) }/
+};
 var mapGqlErrorMessage = /* @__PURE__ */ __name((error) => {
-  if (new RegExp("the target cannot be met due to no coins available or exceeding the \\d+ coin limit." /* NOT_ENOUGH_COINS_MAX_COINS */).test(error.message)) {
-    return new FuelError2(
-      ErrorCode.INSUFFICIENT_FUNDS_OR_MAX_COINS,
+  if (gqlErrorMessage.NOT_ENOUGH_COINS_MAX_COINS.test(error.message)) {
+    return new FuelError3(
+      ErrorCode2.INSUFFICIENT_FUNDS_OR_MAX_COINS,
       `Insufficient funds or too many small value coins. Consider combining UTXOs.`,
       {},
       error
     );
   }
-  if (new RegExp("resource was not found in table" /* ASSET_NOT_FOUND */).test(error.message)) {
-    return new FuelError2(
-      ErrorCode.ASSET_NOT_FOUND,
+  if (gqlErrorMessage.MULTIPLE_CHANGE_POLICIES.test(error.message)) {
+    const match = error.message.match(/asset ([a-fA-F0-9]{64})/);
+    const assetId = match?.[1] || "";
+    return new FuelError3(
+      ErrorCode2.CHANGE_OUTPUT_COLLISION,
+      `OutputChange address for asset 0x${assetId} differs between transaction request and assembleTx parameters.`,
+      {},
+      error
+    );
+  }
+  if (gqlErrorMessage.DUPLICATE_CHANGE_OUTPUT_ACCOUNT.test(error.message)) {
+    return new FuelError3(
+      ErrorCode2.DUPLICATE_CHANGE_OUTPUT_ACCOUNT,
+      `The parameter 'accountCoinQuantities' of assembleTx contains duplicate entries for the same assetId with different 'changeOutputAccount'.`,
+      {},
+      error
+    );
+  }
+  if (gqlErrorMessage.ASSET_NOT_FOUND.test(error.message)) {
+    return new FuelError3(
+      ErrorCode2.ASSET_NOT_FOUND,
       `Asset not found for given asset id.`,
       {},
       error
     );
   }
-  return new FuelError2(ErrorCode.INVALID_REQUEST, error.message, {}, error);
+  if (gqlErrorMessage.RPC_CONSISTENCY.test(error.message)) {
+    return new FuelError3(ErrorCode2.RPC_CONSISTENCY, error.message, {}, error);
+  }
+  if (gqlErrorMessage.INSUFFICIENT_FEE_AMOUNT.test(error.message)) {
+    const match = error.message.match(gqlErrorMessage.INSUFFICIENT_FEE_AMOUNT);
+    return new FuelError3(ErrorCode2.FUNDS_TOO_LOW, match?.[0] || error.message, {}, error);
+  }
+  return new FuelError3(ErrorCode2.INVALID_REQUEST, error.message, {}, error);
 }, "mapGqlErrorMessage");
 var mapGqlErrorWithIncompatibleNodeVersion = /* @__PURE__ */ __name((error, incompatibleNodeVersionMessage) => {
   if (!incompatibleNodeVersionMessage) {
     return error;
   }
-  return new FuelError2(
+  return new FuelError3(
     error.code,
     `${error.message}
 
@@ -1518,15 +1879,16 @@ var assertGqlResponseHasNoErrors = /* @__PURE__ */ __name((errors, incompatibleN
   }
   const errorMessage = mappedErrors.map((err) => err.message).join("\n");
   throw mapGqlErrorWithIncompatibleNodeVersion(
-    new FuelError2(ErrorCode.INVALID_REQUEST, errorMessage, {}, mappedErrors),
+    new FuelError3(ErrorCode2.INVALID_REQUEST, errorMessage, {}, mappedErrors),
     incompatibleNodeVersionMessage
   );
 }, "assertGqlResponseHasNoErrors");
 
 // src/providers/fuel-graphql-subscriber.ts
 var FuelGraphqlSubscriber = class _FuelGraphqlSubscriber {
-  constructor(stream) {
+  constructor(stream, onEvent) {
     this.stream = stream;
+    this.onEvent = onEvent;
   }
   static {
     __name(this, "FuelGraphqlSubscriber");
@@ -1534,12 +1896,13 @@ var FuelGraphqlSubscriber = class _FuelGraphqlSubscriber {
   static incompatibleNodeVersionMessage = false;
   static textDecoder = new TextDecoder();
   static async create(options) {
-    const { url, query, variables, fetchFn } = options;
+    const { url, query, variables, fetchFn, operationName, onEvent } = options;
     const response = await fetchFn(`${url}-sub`, {
       method: "POST",
       body: JSON.stringify({
         query: print(query),
-        variables
+        variables,
+        operationName
       }),
       headers: {
         "Content-Type": "application/json",
@@ -1548,39 +1911,71 @@ var FuelGraphqlSubscriber = class _FuelGraphqlSubscriber {
     });
     const [errorReader, resultReader] = response.body.tee().map((stream) => stream.getReader());
     await new _FuelGraphqlSubscriber(errorReader).next();
-    return new _FuelGraphqlSubscriber(resultReader);
+    return new _FuelGraphqlSubscriber(resultReader, onEvent);
   }
-  events = [];
-  parsingLeftover = "";
-  async next() {
+  /**
+   * This method will take a stream reader and parse the event from the stream.
+   *
+   * @param reader - The reader of the SSE stream
+   * @param parsingLeftover - The leftover string from parsing the previous event
+   * @returns The event parsed as a full GraphQL response, whether the stream is done and the leftover string after parsing
+   */
+  static async readEvent(reader, parsingLeftover = "") {
+    let text = parsingLeftover;
+    const regex = /data:.*\n\n/g;
     while (true) {
-      if (this.events.length > 0) {
-        const { data, errors } = this.events.shift();
-        assertGqlResponseHasNoErrors(errors, _FuelGraphqlSubscriber.incompatibleNodeVersionMessage);
-        return { value: data, done: false };
-      }
-      const { value, done } = await this.stream.read();
-      if (done) {
-        return { value, done };
-      }
-      const decoded = _FuelGraphqlSubscriber.textDecoder.decode(value).replace(":keep-alive-text\n\n", "");
-      if (decoded === "") {
-        continue;
-      }
-      const text = `${this.parsingLeftover}${decoded}`;
-      const regex = /data:.*\n\n/g;
       const matches = [...text.matchAll(regex)].flatMap((match) => match);
-      matches.forEach((match) => {
+      if (matches.length > 0) {
         try {
-          this.events.push(JSON.parse(match.replace(/^data:/, "")));
+          const event = JSON.parse(matches[0].replace(/^data:/, ""));
+          return {
+            event,
+            done: false,
+            parsingLeftover: text.replace(matches[0], "")
+          };
         } catch (e) {
-          throw new FuelError3(
-            ErrorCode2.STREAM_PARSING_ERROR,
+          throw new FuelError4(
+            ErrorCode3.STREAM_PARSING_ERROR,
             `Error while parsing stream data response: ${text}`
           );
         }
-      });
-      this.parsingLeftover = text.replace(matches.join(), "");
+      }
+      const { value, done } = await reader.read();
+      if (done) {
+        return { event: void 0, done, parsingLeftover: "" };
+      }
+      const decoded = _FuelGraphqlSubscriber.textDecoder.decode(value).replace(":keep-alive-text\n\n", "");
+      text += decoded;
+    }
+  }
+  events = [];
+  parsingLeftover = "";
+  /**
+   * Gets automatically called when iterating in a `for-await-of` loop.
+   * It can also be called manually.
+   *
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator/next
+   */
+  async next() {
+    while (true) {
+      const nextEvent = this.events.shift();
+      if (nextEvent) {
+        this.onEvent?.(nextEvent);
+        assertGqlResponseHasNoErrors(
+          nextEvent.errors,
+          _FuelGraphqlSubscriber.incompatibleNodeVersionMessage
+        );
+        return { value: nextEvent.data, done: false };
+      }
+      const { event, done, parsingLeftover } = await _FuelGraphqlSubscriber.readEvent(
+        this.stream,
+        this.parsingLeftover
+      );
+      this.parsingLeftover = parsingLeftover;
+      if (done) {
+        return { value: void 0, done: true };
+      }
+      this.events.push(event);
     }
   }
   /**
@@ -1595,16 +1990,16 @@ var FuelGraphqlSubscriber = class _FuelGraphqlSubscriber {
 };
 
 // src/providers/resource-cache.ts
-import { FuelError as FuelError13, ErrorCode as ErrorCode10 } from "@fuel-ts/errors";
-import { hexlify as hexlify16 } from "@fuel-ts/utils";
+import { FuelError as FuelError14, ErrorCode as ErrorCode11 } from "@fuel-ts/errors";
+import { hexlify as hexlify17 } from "@fuel-ts/utils";
 
 // src/providers/transaction-request/input.ts
 import { BYTES_32 as BYTES_322, UTXO_ID_LEN } from "@fuel-ts/abi-coder";
 import { ZeroBytes32 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode3, FuelError as FuelError4 } from "@fuel-ts/errors";
-import { bn as bn2, toNumber } from "@fuel-ts/math";
+import { ErrorCode as ErrorCode4, FuelError as FuelError5 } from "@fuel-ts/errors";
+import { bn as bn3, toNumber } from "@fuel-ts/math";
 import { InputType } from "@fuel-ts/transactions";
-import { arrayify as arrayify2, hexlify as hexlify4 } from "@fuel-ts/utils";
+import { arrayify as arrayify2, hexlify as hexlify5 } from "@fuel-ts/utils";
 var inputify = /* @__PURE__ */ __name((value) => {
   const { type } = value;
   switch (value.type) {
@@ -1613,27 +2008,27 @@ var inputify = /* @__PURE__ */ __name((value) => {
       const predicateData = arrayify2(value.predicateData ?? "0x");
       return {
         type: InputType.Coin,
-        txID: hexlify4(arrayify2(value.id).slice(0, BYTES_322)),
+        txID: hexlify5(arrayify2(value.id).slice(0, BYTES_322)),
         outputIndex: toNumber(arrayify2(value.id).slice(BYTES_322, UTXO_ID_LEN)),
-        owner: hexlify4(value.owner),
-        amount: bn2(value.amount),
-        assetId: hexlify4(value.assetId),
+        owner: hexlify5(value.owner),
+        amount: bn3(value.amount),
+        assetId: hexlify5(value.assetId),
         txPointer: {
           blockHeight: toNumber(arrayify2(value.txPointer).slice(0, 8)),
           txIndex: toNumber(arrayify2(value.txPointer).slice(8, 16))
         },
         witnessIndex: value.witnessIndex,
-        predicateGasUsed: bn2(value.predicateGasUsed),
-        predicateLength: bn2(predicate.length),
-        predicateDataLength: bn2(predicateData.length),
-        predicate: hexlify4(predicate),
-        predicateData: hexlify4(predicateData)
+        predicateGasUsed: bn3(value.predicateGasUsed),
+        predicateLength: bn3(predicate.length),
+        predicateDataLength: bn3(predicateData.length),
+        predicate: hexlify5(predicate),
+        predicateData: hexlify5(predicateData)
       };
     }
     case InputType.Contract: {
       return {
         type: InputType.Contract,
-        txID: ZeroBytes32,
+        txID: hexlify5(value.txID || ZeroBytes32),
         outputIndex: 0,
         balanceRoot: ZeroBytes32,
         stateRoot: ZeroBytes32,
@@ -1641,7 +2036,7 @@ var inputify = /* @__PURE__ */ __name((value) => {
           blockHeight: toNumber(arrayify2(value.txPointer).slice(0, 8)),
           txIndex: toNumber(arrayify2(value.txPointer).slice(8, 16))
         },
-        contractID: hexlify4(value.contractId)
+        contractID: hexlify5(value.contractId)
       };
     }
     case InputType.Message: {
@@ -1650,23 +2045,23 @@ var inputify = /* @__PURE__ */ __name((value) => {
       const data = arrayify2(value.data ?? "0x");
       return {
         type: InputType.Message,
-        sender: hexlify4(value.sender),
-        recipient: hexlify4(value.recipient),
-        amount: bn2(value.amount),
-        nonce: hexlify4(value.nonce),
+        sender: hexlify5(value.sender),
+        recipient: hexlify5(value.recipient),
+        amount: bn3(value.amount),
+        nonce: hexlify5(value.nonce),
         witnessIndex: value.witnessIndex,
-        predicateGasUsed: bn2(value.predicateGasUsed),
-        predicateLength: bn2(predicate.length),
-        predicateDataLength: bn2(predicateData.length),
-        predicate: hexlify4(predicate),
-        predicateData: hexlify4(predicateData),
-        data: hexlify4(data),
+        predicateGasUsed: bn3(value.predicateGasUsed),
+        predicateLength: bn3(predicate.length),
+        predicateDataLength: bn3(predicateData.length),
+        predicate: hexlify5(predicate),
+        predicateData: hexlify5(predicateData),
+        data: hexlify5(data),
         dataLength: data.length
       };
     }
     default: {
-      throw new FuelError4(
-        ErrorCode3.INVALID_TRANSACTION_INPUT,
+      throw new FuelError5(
+        ErrorCode4.INVALID_TRANSACTION_INPUT,
         `Invalid transaction input type: ${type}.`
       );
     }
@@ -1675,19 +2070,19 @@ var inputify = /* @__PURE__ */ __name((value) => {
 
 // src/providers/transaction-request/output.ts
 import { ZeroBytes32 as ZeroBytes322 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode4, FuelError as FuelError5 } from "@fuel-ts/errors";
-import { bn as bn3 } from "@fuel-ts/math";
+import { ErrorCode as ErrorCode5, FuelError as FuelError6 } from "@fuel-ts/errors";
+import { bn as bn4 } from "@fuel-ts/math";
 import { OutputType } from "@fuel-ts/transactions";
-import { hexlify as hexlify5 } from "@fuel-ts/utils";
+import { hexlify as hexlify6 } from "@fuel-ts/utils";
 var outputify = /* @__PURE__ */ __name((value) => {
   const { type } = value;
   switch (type) {
     case OutputType.Coin: {
       return {
         type: OutputType.Coin,
-        to: hexlify5(value.to),
-        amount: bn3(value.amount),
-        assetId: hexlify5(value.assetId)
+        to: hexlify6(value.to),
+        amount: bn4(value.amount),
+        assetId: hexlify6(value.assetId)
       };
     }
     case OutputType.Contract: {
@@ -1701,29 +2096,29 @@ var outputify = /* @__PURE__ */ __name((value) => {
     case OutputType.Change: {
       return {
         type: OutputType.Change,
-        to: hexlify5(value.to),
-        amount: bn3(0),
-        assetId: hexlify5(value.assetId)
+        to: hexlify6(value.to),
+        amount: bn4(0),
+        assetId: hexlify6(value.assetId)
       };
     }
     case OutputType.Variable: {
       return {
         type: OutputType.Variable,
-        to: ZeroBytes322,
-        amount: bn3(0),
-        assetId: ZeroBytes322
+        to: hexlify6(value.to || ZeroBytes322),
+        amount: bn4(value.amount),
+        assetId: hexlify6(value.assetId || ZeroBytes322)
       };
     }
     case OutputType.ContractCreated: {
       return {
         type: OutputType.ContractCreated,
-        contractId: hexlify5(value.contractId),
-        stateRoot: hexlify5(value.stateRoot)
+        contractId: hexlify6(value.contractId),
+        stateRoot: hexlify6(value.stateRoot)
       };
     }
     default: {
-      throw new FuelError5(
-        ErrorCode4.INVALID_TRANSACTION_INPUT,
+      throw new FuelError6(
+        ErrorCode5.INVALID_TRANSACTION_INPUT,
         `Invalid transaction output type: ${type}.`
       );
     }
@@ -1735,16 +2130,16 @@ import { UTXO_ID_LEN as UTXO_ID_LEN2 } from "@fuel-ts/abi-coder";
 import { Address as Address2, addressify } from "@fuel-ts/address";
 import { ZeroBytes32 as ZeroBytes324 } from "@fuel-ts/address/configs";
 import { randomBytes as randomBytes3 } from "@fuel-ts/crypto";
-import { FuelError as FuelError10 } from "@fuel-ts/errors";
-import { bn as bn8 } from "@fuel-ts/math";
+import { FuelError as FuelError11 } from "@fuel-ts/errors";
+import { bn as bn9 } from "@fuel-ts/math";
 import {
   PolicyType,
   TransactionCoder,
-  InputType as InputType3,
-  OutputType as OutputType3,
-  TransactionType
+  InputType as InputType4,
+  OutputType as OutputType4,
+  TransactionType as TransactionType2
 } from "@fuel-ts/transactions";
-import { concat as concat2, hexlify as hexlify10, isDefined } from "@fuel-ts/utils";
+import { concat as concat2, hexlify as hexlify11, isDefined as isDefined2 } from "@fuel-ts/utils";
 
 // src/providers/message.ts
 var isMessageCoin = /* @__PURE__ */ __name((message) => !("data" in message), "isMessageCoin");
@@ -1758,10 +2153,16 @@ import { FAILED_TRANSFER_TO_ADDRESS_SIGNAL } from "@fuel-ts/transactions/configs
 
 // src/providers/utils/serialization.ts
 import { ZeroBytes32 as ZeroBytes323 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode5, FuelError as FuelError6 } from "@fuel-ts/errors";
-import { bn as bn4 } from "@fuel-ts/math";
-import { getMintedAssetId, InputMessageCoder, ReceiptType } from "@fuel-ts/transactions";
-import { hexlify as hexlify6, arrayify as arrayify3 } from "@fuel-ts/utils";
+import { ErrorCode as ErrorCode6, FuelError as FuelError7 } from "@fuel-ts/errors";
+import { bn as bn5 } from "@fuel-ts/math";
+import {
+  getMintedAssetId,
+  InputMessageCoder,
+  InputType as InputType2,
+  OutputType as OutputType2,
+  ReceiptType
+} from "@fuel-ts/transactions";
+import { hexlify as hexlify7, arrayify as arrayify3, assertUnreachable } from "@fuel-ts/utils";
 var deserializeChain = /* @__PURE__ */ __name((chain) => {
   const { name, daHeight, consensusParameters } = chain;
   const {
@@ -1777,41 +2178,41 @@ var deserializeChain = /* @__PURE__ */ __name((chain) => {
   } = consensusParameters;
   return {
     name,
-    baseChainHeight: bn4(daHeight),
+    baseChainHeight: bn5(daHeight),
     consensusParameters: {
       version,
-      chainId: bn4(chainId),
+      chainId: bn5(chainId),
       baseAssetId,
       feeParameters: {
         version: feeParams.version,
-        gasPerByte: bn4(feeParams.gasPerByte),
-        gasPriceFactor: bn4(feeParams.gasPriceFactor)
+        gasPerByte: bn5(feeParams.gasPerByte),
+        gasPriceFactor: bn5(feeParams.gasPriceFactor)
       },
       contractParameters: {
         version: contractParams.version,
-        contractMaxSize: bn4(contractParams.contractMaxSize),
-        maxStorageSlots: bn4(contractParams.maxStorageSlots)
+        contractMaxSize: bn5(contractParams.contractMaxSize),
+        maxStorageSlots: bn5(contractParams.maxStorageSlots)
       },
       txParameters: {
         version: txParams.version,
-        maxInputs: bn4(txParams.maxInputs),
-        maxOutputs: bn4(txParams.maxOutputs),
-        maxWitnesses: bn4(txParams.maxWitnesses),
-        maxGasPerTx: bn4(txParams.maxGasPerTx),
-        maxSize: bn4(txParams.maxSize),
-        maxBytecodeSubsections: bn4(txParams.maxBytecodeSubsections)
+        maxInputs: bn5(txParams.maxInputs),
+        maxOutputs: bn5(txParams.maxOutputs),
+        maxWitnesses: bn5(txParams.maxWitnesses),
+        maxGasPerTx: bn5(txParams.maxGasPerTx),
+        maxSize: bn5(txParams.maxSize),
+        maxBytecodeSubsections: bn5(txParams.maxBytecodeSubsections)
       },
       predicateParameters: {
         version: predicateParams.version,
-        maxPredicateLength: bn4(predicateParams.maxPredicateLength),
-        maxPredicateDataLength: bn4(predicateParams.maxPredicateDataLength),
-        maxGasPerPredicate: bn4(predicateParams.maxGasPerPredicate),
-        maxMessageDataLength: bn4(predicateParams.maxMessageDataLength)
+        maxPredicateLength: bn5(predicateParams.maxPredicateLength),
+        maxPredicateDataLength: bn5(predicateParams.maxPredicateDataLength),
+        maxGasPerPredicate: bn5(predicateParams.maxGasPerPredicate),
+        maxMessageDataLength: bn5(predicateParams.maxMessageDataLength)
       },
       scriptParameters: {
         version: scriptParams.version,
-        maxScriptLength: bn4(scriptParams.maxScriptLength),
-        maxScriptDataLength: bn4(scriptParams.maxScriptDataLength)
+        maxScriptLength: bn5(scriptParams.maxScriptLength),
+        maxScriptDataLength: bn5(scriptParams.maxScriptDataLength)
       },
       gasCosts
     }
@@ -1875,8 +2276,8 @@ var serializeChain = /* @__PURE__ */ __name((chain) => {
 var deserializeNodeInfo = /* @__PURE__ */ __name((nodeInfo) => {
   const { maxDepth, maxTx, nodeVersion, utxoValidation, vmBacktrace, indexation } = nodeInfo;
   return {
-    maxDepth: bn4(maxDepth),
-    maxTx: bn4(maxTx),
+    maxDepth: bn5(maxDepth),
+    maxTx: bn5(maxTx),
     nodeVersion,
     utxoValidation,
     vmBacktrace,
@@ -1914,13 +2315,13 @@ var deserializeReceipt = /* @__PURE__ */ __name((receipt) => {
         type: ReceiptType.Call,
         id,
         to: hexOrZero(receipt?.to),
-        amount: bn4(receipt.amount),
+        amount: bn5(receipt.amount),
         assetId: hexOrZero(receipt.assetId),
-        gas: bn4(receipt.gas),
-        param1: bn4(receipt.param1),
-        param2: bn4(receipt.param2),
-        pc: bn4(receipt.pc),
-        is: bn4(receipt.is)
+        gas: bn5(receipt.gas),
+        param1: bn5(receipt.param1),
+        param2: bn5(receipt.param2),
+        pc: bn5(receipt.pc),
+        is: bn5(receipt.is)
       };
       return callReceipt;
     }
@@ -1928,9 +2329,9 @@ var deserializeReceipt = /* @__PURE__ */ __name((receipt) => {
       const returnReceipt = {
         type: ReceiptType.Return,
         id: hexOrZero(receipt.id || receipt.contractId),
-        val: bn4(receipt.val),
-        pc: bn4(receipt.pc),
-        is: bn4(receipt.is)
+        val: bn5(receipt.val),
+        pc: bn5(receipt.pc),
+        is: bn5(receipt.is)
       };
       return returnReceipt;
     }
@@ -1938,12 +2339,12 @@ var deserializeReceipt = /* @__PURE__ */ __name((receipt) => {
       const returnDataReceipt = {
         type: ReceiptType.ReturnData,
         id: hexOrZero(receipt.id || receipt.contractId),
-        ptr: bn4(receipt.ptr),
-        len: bn4(receipt.len),
+        ptr: bn5(receipt.ptr),
+        len: bn5(receipt.len),
         digest: hexOrZero(receipt.digest),
-        pc: bn4(receipt.pc),
+        pc: bn5(receipt.pc),
         data: hexOrZero(receipt.data),
-        is: bn4(receipt.is)
+        is: bn5(receipt.is)
       };
       return returnDataReceipt;
     }
@@ -1951,9 +2352,9 @@ var deserializeReceipt = /* @__PURE__ */ __name((receipt) => {
       const panicReceipt = {
         type: ReceiptType.Panic,
         id: hexOrZero(receipt.id),
-        reason: bn4(receipt.reason),
-        pc: bn4(receipt.pc),
-        is: bn4(receipt.is),
+        reason: bn5(receipt.reason),
+        pc: bn5(receipt.pc),
+        is: bn5(receipt.is),
         contractId: hexOrZero(receipt.contractId)
       };
       return panicReceipt;
@@ -1962,17 +2363,17 @@ var deserializeReceipt = /* @__PURE__ */ __name((receipt) => {
       const revertReceipt = {
         type: ReceiptType.Revert,
         id: hexOrZero(receipt.id || receipt.contractId),
-        val: bn4(receipt.ra),
-        pc: bn4(receipt.pc),
-        is: bn4(receipt.is)
+        val: bn5(receipt.ra),
+        pc: bn5(receipt.pc),
+        is: bn5(receipt.is)
       };
       return revertReceipt;
     }
     case "LOG" /* Log */: {
-      const ra = bn4(receipt.ra);
-      const rb = bn4(receipt.rb);
-      const rc = bn4(receipt.rc);
-      const rd = bn4(receipt.rd);
+      const ra = bn5(receipt.ra);
+      const rb = bn5(receipt.rb);
+      const rc = bn5(receipt.rc);
+      const rd = bn5(receipt.rd);
       const logReceipt = {
         type: ReceiptType.Log,
         id: hexOrZero(receipt.id || receipt.contractId),
@@ -1980,25 +2381,25 @@ var deserializeReceipt = /* @__PURE__ */ __name((receipt) => {
         rb,
         rc,
         rd,
-        pc: bn4(receipt.pc),
-        is: bn4(receipt.is)
+        pc: bn5(receipt.pc),
+        is: bn5(receipt.is)
       };
       return logReceipt;
     }
     case "LOG_DATA" /* LogData */: {
-      const ra = bn4(receipt.ra);
-      const rb = bn4(receipt.rb);
+      const ra = bn5(receipt.ra);
+      const rb = bn5(receipt.rb);
       const logDataReceipt = {
         type: ReceiptType.LogData,
         id: hexOrZero(receipt.id || receipt.contractId),
         ra,
         rb,
-        ptr: bn4(receipt.ptr),
-        len: bn4(receipt.len),
+        ptr: bn5(receipt.ptr),
+        len: bn5(receipt.len),
         digest: hexOrZero(receipt.digest),
-        pc: bn4(receipt.pc),
+        pc: bn5(receipt.pc),
         data: hexOrZero(receipt.data),
-        is: bn4(receipt.is)
+        is: bn5(receipt.is)
       };
       return logDataReceipt;
     }
@@ -2008,10 +2409,10 @@ var deserializeReceipt = /* @__PURE__ */ __name((receipt) => {
         type: ReceiptType.Transfer,
         id,
         to: hexOrZero(receipt.toAddress || receipt?.to),
-        amount: bn4(receipt.amount),
+        amount: bn5(receipt.amount),
         assetId: hexOrZero(receipt.assetId),
-        pc: bn4(receipt.pc),
-        is: bn4(receipt.is)
+        pc: bn5(receipt.pc),
+        is: bn5(receipt.is)
       };
       return transferReceipt;
     }
@@ -2021,18 +2422,18 @@ var deserializeReceipt = /* @__PURE__ */ __name((receipt) => {
         type: ReceiptType.TransferOut,
         id,
         to: hexOrZero(receipt.toAddress || receipt.to),
-        amount: bn4(receipt.amount),
+        amount: bn5(receipt.amount),
         assetId: hexOrZero(receipt.assetId),
-        pc: bn4(receipt.pc),
-        is: bn4(receipt.is)
+        pc: bn5(receipt.pc),
+        is: bn5(receipt.is)
       };
       return transferOutReceipt;
     }
     case "SCRIPT_RESULT" /* ScriptResult */: {
       const scriptResultReceipt = {
         type: ReceiptType.ScriptResult,
-        result: bn4(receipt.result),
-        gasUsed: bn4(receipt.gasUsed)
+        result: bn5(receipt.result),
+        gasUsed: bn5(receipt.gasUsed)
       };
       return scriptResultReceipt;
     }
@@ -2040,16 +2441,16 @@ var deserializeReceipt = /* @__PURE__ */ __name((receipt) => {
       const sender = hexOrZero(receipt.sender);
       const recipient = hexOrZero(receipt.recipient);
       const nonce = hexOrZero(receipt.nonce);
-      const amount = bn4(receipt.amount);
+      const amount = bn5(receipt.amount);
       const data = receipt.data ? arrayify3(receipt.data) : Uint8Array.from([]);
       const digest = hexOrZero(receipt.digest);
-      const len = bn4(receipt.len).toNumber();
+      const len = bn5(receipt.len).toNumber();
       const messageId = InputMessageCoder.getMessageId({
         sender,
         recipient,
         nonce,
         amount,
-        data: hexlify6(data)
+        data: hexlify7(data)
       });
       const receiptMessageOut = {
         type: ReceiptType.MessageOut,
@@ -2073,9 +2474,9 @@ var deserializeReceipt = /* @__PURE__ */ __name((receipt) => {
         subId,
         contractId,
         assetId,
-        val: bn4(receipt.val),
-        pc: bn4(receipt.pc),
-        is: bn4(receipt.is)
+        val: bn5(receipt.val),
+        pc: bn5(receipt.pc),
+        is: bn5(receipt.is)
       };
       return mintReceipt;
     }
@@ -2088,16 +2489,151 @@ var deserializeReceipt = /* @__PURE__ */ __name((receipt) => {
         subId,
         contractId,
         assetId,
-        val: bn4(receipt.val),
-        pc: bn4(receipt.pc),
-        is: bn4(receipt.is)
+        val: bn5(receipt.val),
+        pc: bn5(receipt.pc),
+        is: bn5(receipt.is)
       };
       return burnReceipt;
     }
     default:
-      throw new FuelError6(ErrorCode5.INVALID_RECEIPT_TYPE, `Invalid receipt type: ${receiptType}.`);
+      throw new FuelError7(ErrorCode6.INVALID_RECEIPT_TYPE, `Invalid receipt type: ${receiptType}.`);
   }
 }, "deserializeReceipt");
+var deserializeInput = /* @__PURE__ */ __name((input) => {
+  let parsedInput;
+  switch (input.type) {
+    case "InputCoin":
+      parsedInput = {
+        type: InputType2.Coin,
+        id: input.utxoId,
+        amount: bn5(input.amount),
+        assetId: input.assetId,
+        owner: input.owner,
+        txPointer: `0x${input.txPointer}`,
+        witnessIndex: Number(input.coinWitnessIndex),
+        predicate: input.predicate,
+        predicateData: input.predicateData,
+        predicateGasUsed: bn5(input.predicateGasUsed)
+      };
+      break;
+    case "InputMessage":
+      parsedInput = {
+        type: InputType2.Message,
+        nonce: input.nonce,
+        amount: bn5(input.amount),
+        recipient: input.recipient,
+        sender: input.sender,
+        data: input.data,
+        witnessIndex: Number(input.messageWitnessIndex),
+        predicate: input.predicate,
+        predicateData: input.predicateData,
+        predicateGasUsed: bn5(input.predicateGasUsed)
+      };
+      break;
+    case "InputContract":
+      parsedInput = {
+        type: InputType2.Contract,
+        contractId: input.contractId,
+        txPointer: `0x${input.txPointer}`,
+        txID: hexlify7(arrayify3(input.utxoId).slice(0, 32))
+      };
+      break;
+    default:
+      assertUnreachable(input);
+  }
+  return parsedInput;
+}, "deserializeInput");
+var deserializeOutput = /* @__PURE__ */ __name((output) => {
+  let parsedOutput;
+  switch (output.type) {
+    case "CoinOutput":
+      parsedOutput = {
+        type: OutputType2.Coin,
+        amount: bn5(output.amount),
+        assetId: output.assetId,
+        to: output.to
+      };
+      break;
+    case "ContractOutput":
+      parsedOutput = {
+        type: OutputType2.Contract,
+        inputIndex: Number(output.inputIndex)
+      };
+      break;
+    case "ChangeOutput":
+      parsedOutput = {
+        type: OutputType2.Change,
+        assetId: output.assetId,
+        to: output.to
+      };
+      break;
+    case "ContractCreated":
+      parsedOutput = {
+        type: OutputType2.ContractCreated,
+        stateRoot: output.stateRoot,
+        contractId: output.contract
+      };
+      break;
+    case "VariableOutput":
+      parsedOutput = {
+        type: OutputType2.Variable,
+        amount: bn5(output.amount),
+        assetId: output.assetId,
+        to: output.to
+      };
+      break;
+    default:
+      assertUnreachable(output);
+  }
+  return parsedOutput;
+}, "deserializeOutput");
+var deserializeProcessedTxOutput = /* @__PURE__ */ __name((output) => {
+  let parsedOutput;
+  switch (output.type) {
+    case "CoinOutput":
+      parsedOutput = {
+        type: OutputType2.Coin,
+        amount: bn5(output.amount),
+        assetId: output.assetId,
+        to: output.to
+      };
+      break;
+    case "ContractOutput":
+      parsedOutput = {
+        type: OutputType2.Contract,
+        inputIndex: Number(output.inputIndex),
+        balanceRoot: output.balanceRoot,
+        stateRoot: output.stateRoot
+      };
+      break;
+    case "ChangeOutput":
+      parsedOutput = {
+        type: OutputType2.Change,
+        assetId: output.assetId,
+        to: output.to,
+        amount: bn5(output.amount)
+      };
+      break;
+    case "ContractCreated":
+      parsedOutput = {
+        type: OutputType2.ContractCreated,
+        stateRoot: output.stateRoot,
+        contractId: output.contract
+      };
+      break;
+    case "VariableOutput":
+      parsedOutput = {
+        type: OutputType2.Variable,
+        amount: bn5(output.amount),
+        assetId: output.assetId,
+        to: output.to
+      };
+      break;
+    default:
+      assertUnreachable(output);
+  }
+  return parsedOutput;
+}, "deserializeProcessedTxOutput");
 
 // src/providers/utils/receipts.ts
 var doesReceiptHaveMissingOutputVariables = /* @__PURE__ */ __name((receipt) => receipt.type === ReceiptType2.Revert && receipt.val.toString("hex") === FAILED_TRANSFER_TO_ADDRESS_SIGNAL, "doesReceiptHaveMissingOutputVariables");
@@ -2119,26 +2655,26 @@ var getReceiptsWithMissingData = /* @__PURE__ */ __name((receipts) => receipts.r
 ), "getReceiptsWithMissingData");
 
 // src/providers/utils/block-explorer.ts
-import { ErrorCode as ErrorCode6, FuelError as FuelError7 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode7, FuelError as FuelError8 } from "@fuel-ts/errors";
 
 // src/providers/utils/gas.ts
-import { bn as bn5 } from "@fuel-ts/math";
+import { bn as bn6 } from "@fuel-ts/math";
 import { ReceiptType as ReceiptType3 } from "@fuel-ts/transactions";
 import { arrayify as arrayify4 } from "@fuel-ts/utils";
 var getGasUsedFromReceipts = /* @__PURE__ */ __name((receipts) => {
   const scriptResult = receipts.filter(
     (receipt) => receipt.type === ReceiptType3.ScriptResult
   );
-  const gasUsed = scriptResult.reduce((prev, receipt) => prev.add(receipt.gasUsed), bn5(0));
+  const gasUsed = scriptResult.reduce((prev, receipt) => prev.add(receipt.gasUsed), bn6(0));
   return gasUsed;
 }, "getGasUsedFromReceipts");
 function resolveGasDependentCosts(byteSize, gasDependentCost) {
-  const base = bn5(gasDependentCost.base);
-  let dependentValue = bn5(0);
+  const base = bn6(gasDependentCost.base);
+  let dependentValue = bn6(0);
   if ("unitsPerGas" in gasDependentCost) {
-    dependentValue = bn5(byteSize).div(bn5(gasDependentCost.unitsPerGas));
+    dependentValue = bn6(byteSize).div(bn6(gasDependentCost.unitsPerGas));
   } else {
-    dependentValue = bn5(byteSize).mul(bn5(gasDependentCost.gasPerUnit));
+    dependentValue = bn6(byteSize).mul(bn6(gasDependentCost.gasPerUnit));
   }
   return base.add(dependentValue);
 }
@@ -2162,18 +2698,18 @@ function gasUsedByInputs(inputs, txBytesSize, gasCosts) {
   const totalGas = chargeableInputs.reduce((total, input) => {
     if ("predicate" in input && input.predicate && input.predicate !== "0x") {
       return total.add(
-        vmInitializationCost.add(resolveGasDependentCosts(arrayify4(input.predicate).length, gasCosts.contractRoot)).add(bn5(input.predicateGasUsed))
+        vmInitializationCost.add(resolveGasDependentCosts(arrayify4(input.predicate).length, gasCosts.contractRoot)).add(bn6(input.predicateGasUsed))
       );
     }
     return total.add(gasCosts.ecr1);
-  }, bn5(0));
+  }, bn6(0));
   return totalGas;
 }
 __name(gasUsedByInputs, "gasUsedByInputs");
 function getMinGas(params) {
   const { gasCosts, gasPerByte, inputs, metadataGas, txBytesSize } = params;
   const vmInitGas = resolveGasDependentCosts(txBytesSize, gasCosts.vmInitialization);
-  const bytesGas = bn5(txBytesSize).mul(gasPerByte);
+  const bytesGas = bn6(txBytesSize).mul(gasPerByte);
   const inputsGas = gasUsedByInputs(inputs, txBytesSize, gasCosts);
   const minGas = vmInitGas.add(bytesGas).add(inputsGas).add(metadataGas).maxU64();
   return minGas;
@@ -2185,12 +2721,12 @@ function getMaxGas(params) {
     witnessesLength,
     witnessLimit,
     minGas,
-    gasLimit = bn5(0),
+    gasLimit = bn6(0),
     maxGasPerTx
   } = params;
-  let remainingAllowedWitnessGas = bn5(0);
+  let remainingAllowedWitnessGas = bn6(0);
   if (witnessLimit?.gt(0) && witnessLimit.gte(witnessesLength)) {
-    remainingAllowedWitnessGas = bn5(witnessLimit).sub(witnessesLength).mul(gasPerByte);
+    remainingAllowedWitnessGas = bn6(witnessLimit).sub(witnessesLength).mul(gasPerByte);
   }
   const maxGas = remainingAllowedWitnessGas.add(minGas).add(gasLimit);
   return maxGas.gte(maxGasPerTx) ? maxGasPerTx : maxGas;
@@ -2205,7 +2741,7 @@ function calculateMetadataGasForTxCreate({
   const contractRootGas = resolveGasDependentCosts(contractBytesSize, gasCosts.contractRoot);
   const stateRootGas = resolveGasDependentCosts(stateRootSize, gasCosts.stateRoot);
   const txIdGas = resolveGasDependentCosts(txBytesSize, gasCosts.s256);
-  const contractIdInputSize = bn5(4 + 32 + 32 + 32);
+  const contractIdInputSize = bn6(4 + 32 + 32 + 32);
   const contractIdGas = resolveGasDependentCosts(contractIdInputSize, gasCosts.s256);
   const metadataGas = contractRootGas.add(stateRootGas).add(txIdGas).add(contractIdGas);
   return metadataGas.maxU64();
@@ -2260,23 +2796,23 @@ function calculateMinGasForTxUpload({
   baseMinGas,
   subsectionSize
 }) {
-  const additionalStoragePerByte = bn5(gasCosts.newStoragePerByte).mul(subsectionSize);
-  return bn5(baseMinGas).add(additionalStoragePerByte);
+  const additionalStoragePerByte = bn6(gasCosts.newStoragePerByte).mul(subsectionSize);
+  return bn6(baseMinGas).add(additionalStoragePerByte);
 }
 __name(calculateMinGasForTxUpload, "calculateMinGasForTxUpload");
 var calculateGasFee = /* @__PURE__ */ __name((params) => {
   const { gas, gasPrice, priceFactor, tip } = params;
-  return gas.mul(gasPrice).div(priceFactor).add(bn5(tip));
+  return gas.mul(gasPrice).div(priceFactor).add(bn6(tip));
 }, "calculateGasFee");
 
 // src/providers/utils/json.ts
-import { hexlify as hexlify7 } from "@fuel-ts/utils";
+import { hexlify as hexlify8 } from "@fuel-ts/utils";
 import { clone } from "ramda";
 function normalize(object) {
   Object.keys(object).forEach((key) => {
     switch (object[key]?.constructor.name) {
       case "Uint8Array":
-        object[key] = hexlify7(object[key]);
+        object[key] = hexlify8(object[key]);
         break;
       case "Array":
         object[key] = normalize(object[key]);
@@ -2303,8 +2839,8 @@ function normalizeJSON(root) {
 __name(normalizeJSON, "normalizeJSON");
 
 // src/providers/utils/extract-tx-error.ts
-import { ErrorCode as ErrorCode7, FuelError as FuelError8 } from "@fuel-ts/errors";
-import { bn as bn6 } from "@fuel-ts/math";
+import { ErrorCode as ErrorCode8, FuelError as FuelError9 } from "@fuel-ts/errors";
+import { bn as bn7 } from "@fuel-ts/math";
 import { ReceiptType as ReceiptType4 } from "@fuel-ts/transactions";
 import {
   FAILED_REQUIRE_SIGNAL,
@@ -2324,7 +2860,7 @@ You can read more about this error at:
 
 ${PANIC_DOC_URL}#variant.${statusReason}`;
   }
-  return new FuelError8(ErrorCode7.SCRIPT_REVERTED, errorMessage, {
+  return new FuelError9(ErrorCode8.SCRIPT_REVERTED, errorMessage, {
     ...metadata,
     reason: statusReason
   });
@@ -2335,7 +2871,7 @@ var assembleRevertError = /* @__PURE__ */ __name((receipts, logs, metadata) => {
   const revertReceipt = receipts.find(({ type }) => type === ReceiptType4.Revert);
   let reason = "";
   if (revertReceipt) {
-    const reasonHex = bn6(revertReceipt.val).toHex();
+    const reasonHex = bn7(revertReceipt.val).toHex();
     const lastLog = logs[logs.length - 1];
     const lastButOneLog = logs[logs.length - 2];
     switch (reasonHex) {
@@ -2365,8 +2901,8 @@ var assembleRevertError = /* @__PURE__ */ __name((receipts, logs, metadata) => {
         errorMessage = `The transaction reverted because it's missing an "OutputVariable".`;
         break;
       default:
-        throw new FuelError8(
-          ErrorCode7.UNKNOWN,
+        throw new FuelError9(
+          ErrorCode8.UNKNOWN,
           `The transaction reverted with an unknown reason: ${revertReceipt.val}`,
           {
             ...metadata,
@@ -2375,7 +2911,7 @@ var assembleRevertError = /* @__PURE__ */ __name((receipts, logs, metadata) => {
         );
     }
   }
-  return new FuelError8(ErrorCode7.SCRIPT_REVERTED, errorMessage, {
+  return new FuelError9(ErrorCode8.SCRIPT_REVERTED, errorMessage, {
     ...metadata,
     reason
   });
@@ -2398,6 +2934,21 @@ var extractTxError = /* @__PURE__ */ __name((params) => {
   return assembleRevertError(receipts, logs, metadata);
 }, "extractTxError");
 
+// src/providers/utils/merge-quantities.ts
+var mergeQuantities = /* @__PURE__ */ __name((...coinQuantities) => {
+  const resultMap = {};
+  function addToMap({ amount, assetId }) {
+    if (resultMap[assetId]) {
+      resultMap[assetId] = resultMap[assetId].add(amount);
+    } else {
+      resultMap[assetId] = amount;
+    }
+  }
+  __name(addToMap, "addToMap");
+  coinQuantities.forEach((arr) => arr.forEach(addToMap));
+  return Object.entries(resultMap).map(([assetId, amount]) => ({ assetId, amount }));
+}, "mergeQuantities");
+
 // src/providers/transaction-request/errors.ts
 var NoWitnessAtIndexError = class extends Error {
   constructor(index) {
@@ -2412,18 +2963,18 @@ var NoWitnessAtIndexError = class extends Error {
 };
 
 // src/providers/transaction-request/helpers.ts
-import { ErrorCode as ErrorCode8, FuelError as FuelError9 } from "@fuel-ts/errors";
-import { bn as bn7 } from "@fuel-ts/math";
-import { InputType as InputType2, OutputType as OutputType2 } from "@fuel-ts/transactions";
-import { hexlify as hexlify8 } from "@fuel-ts/utils";
-var isRequestInputCoin = /* @__PURE__ */ __name((input) => input.type === InputType2.Coin, "isRequestInputCoin");
-var isRequestInputMessage = /* @__PURE__ */ __name((input) => input.type === InputType2.Message, "isRequestInputMessage");
-var isRequestInputMessageWithoutData = /* @__PURE__ */ __name((input) => input.type === InputType2.Message && bn7(input.data).isZero(), "isRequestInputMessageWithoutData");
+import { ErrorCode as ErrorCode9, FuelError as FuelError10 } from "@fuel-ts/errors";
+import { bn as bn8 } from "@fuel-ts/math";
+import { InputType as InputType3, OutputType as OutputType3 } from "@fuel-ts/transactions";
+import { hexlify as hexlify9 } from "@fuel-ts/utils";
+var isRequestInputCoin = /* @__PURE__ */ __name((input) => input.type === InputType3.Coin, "isRequestInputCoin");
+var isRequestInputMessage = /* @__PURE__ */ __name((input) => input.type === InputType3.Message, "isRequestInputMessage");
+var isRequestInputMessageWithoutData = /* @__PURE__ */ __name((input) => input.type === InputType3.Message && bn8(input.data).isZero(), "isRequestInputMessageWithoutData");
 var isRequestInputCoinOrMessage = /* @__PURE__ */ __name((input) => isRequestInputCoin(input) || isRequestInputMessage(input), "isRequestInputCoinOrMessage");
 var isRequestInputResource = /* @__PURE__ */ __name((input) => isRequestInputCoin(input) || isRequestInputMessageWithoutData(input), "isRequestInputResource");
 var getRequestInputResourceOwner = /* @__PURE__ */ __name((input) => isRequestInputCoin(input) ? input.owner : input.recipient, "getRequestInputResourceOwner");
 var isRequestInputResourceFromOwner = /* @__PURE__ */ __name((input, owner) => getRequestInputResourceOwner(input) === owner.toB256(), "isRequestInputResourceFromOwner");
-var isPredicate = /* @__PURE__ */ __name((input) => isRequestInputCoinOrMessage(input) && !!input.predicate && hexlify8(input.predicate) !== "0x", "isPredicate");
+var isPredicate = /* @__PURE__ */ __name((input) => isRequestInputCoinOrMessage(input) && !!input.predicate && hexlify9(input.predicate) !== "0x", "isPredicate");
 var getAssetAmountInRequestInputs = /* @__PURE__ */ __name((inputs, assetId, baseAsset) => inputs.filter(isRequestInputResource).reduce((acc, input) => {
   if (isRequestInputCoin(input) && input.assetId === assetId) {
     return acc.add(input.amount);
@@ -2432,7 +2983,7 @@ var getAssetAmountInRequestInputs = /* @__PURE__ */ __name((inputs, assetId, bas
     return acc.add(input.amount);
   }
   return acc;
-}, bn7(0)), "getAssetAmountInRequestInputs");
+}, bn8(0)), "getAssetAmountInRequestInputs");
 var cacheRequestInputsResourcesFromOwner = /* @__PURE__ */ __name((inputs, owner) => inputs.reduce(
   (acc, input) => {
     if (isRequestInputCoin(input) && input.owner === owner.toB256()) {
@@ -2450,11 +3001,11 @@ var cacheRequestInputsResourcesFromOwner = /* @__PURE__ */ __name((inputs, owner
 var getBurnableAssetCount = /* @__PURE__ */ __name((baseAssetId, transactionRequest) => {
   const { inputs, outputs } = transactionRequest;
   const coinInputs = new Set(inputs.filter(isRequestInputCoin).map((input) => input.assetId));
-  if (inputs.some((i) => isRequestInputMessage(i) && bn7(i.amount).gt(0))) {
+  if (inputs.some((i) => isRequestInputMessage(i) && bn8(i.amount).gt(0))) {
     coinInputs.add(baseAssetId);
   }
   const changeOutputs = new Set(
-    outputs.filter((output) => output.type === OutputType2.Change).map((output) => output.assetId)
+    outputs.filter((output) => output.type === OutputType3.Change).map((output) => output.assetId)
   );
   const difference = new Set([...coinInputs].filter((x) => !changeOutputs.has(x)));
   return difference.size;
@@ -2471,15 +3022,15 @@ var validateTransactionForAssetBurn = /* @__PURE__ */ __name((baseAssetId, trans
     "Add the relevant change outputs to the transaction to avoid burning assets.",
     "Or enable asset burn, upon sending the transaction."
   ].join("\n");
-  throw new FuelError9(ErrorCode8.ASSET_BURN_DETECTED, message);
+  throw new FuelError10(ErrorCode9.ASSET_BURN_DETECTED, message);
 }, "validateTransactionForAssetBurn");
 
 // src/providers/transaction-request/witness.ts
-import { arrayify as arrayify5, hexlify as hexlify9 } from "@fuel-ts/utils";
+import { arrayify as arrayify5, hexlify as hexlify10 } from "@fuel-ts/utils";
 var witnessify = /* @__PURE__ */ __name((value) => {
   const data = arrayify5(value);
   return {
-    data: hexlify9(data),
+    data: hexlify10(data),
     dataLength: data.length
   };
 }, "witnessify");
@@ -2526,11 +3077,11 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
     outputs,
     witnesses
   } = {}) {
-    this.tip = tip ? bn8(tip) : void 0;
+    this.tip = tip ? bn9(tip) : void 0;
     this.maturity = maturity && maturity > 0 ? maturity : void 0;
     this.expiration = expiration && expiration > 0 ? expiration : void 0;
-    this.witnessLimit = isDefined(witnessLimit) ? bn8(witnessLimit) : void 0;
-    this.maxFee = bn8(maxFee);
+    this.witnessLimit = isDefined2(witnessLimit) ? bn9(witnessLimit) : void 0;
+    this.maxFee = bn9(maxFee);
     this.inputs = inputs ?? [];
     this.outputs = outputs ?? [];
     this.witnesses = witnesses ?? [];
@@ -2539,13 +3090,13 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
     let policyTypes = 0;
     const policies = [];
     const { tip, witnessLimit, maturity, expiration } = req;
-    if (bn8(tip).gt(0)) {
+    if (bn9(tip).gt(0)) {
       policyTypes += PolicyType.Tip;
-      policies.push({ data: bn8(tip), type: PolicyType.Tip });
+      policies.push({ data: bn9(tip), type: PolicyType.Tip });
     }
-    if (isDefined(witnessLimit) && bn8(witnessLimit).gte(0)) {
+    if (isDefined2(witnessLimit) && bn9(witnessLimit).gte(0)) {
       policyTypes += PolicyType.WitnessLimit;
-      policies.push({ data: bn8(witnessLimit), type: PolicyType.WitnessLimit });
+      policies.push({ data: bn9(witnessLimit), type: PolicyType.WitnessLimit });
     }
     if (maturity && maturity > 0) {
       policyTypes += PolicyType.Maturity;
@@ -2679,7 +3230,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
    */
   getCoinInputs() {
     return this.inputs.filter(
-      (input) => input.type === InputType3.Coin
+      (input) => input.type === InputType4.Coin
     );
   }
   /**
@@ -2689,7 +3240,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
    */
   getCoinOutputs() {
     return this.outputs.filter(
-      (output) => output.type === OutputType3.Coin
+      (output) => output.type === OutputType4.Coin
     );
   }
   /**
@@ -2699,7 +3250,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
    */
   getChangeOutputs() {
     return this.outputs.filter(
-      (output) => output.type === OutputType3.Change
+      (output) => output.type === OutputType4.Change
     );
   }
   /**
@@ -2711,10 +3262,10 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
     const ownerAddress = addressify(owner);
     const found = this.inputs.find((input) => {
       switch (input.type) {
-        case InputType3.Coin:
-          return hexlify10(input.owner) === ownerAddress.toB256();
-        case InputType3.Message:
-          return hexlify10(input.recipient) === ownerAddress.toB256();
+        case InputType4.Coin:
+          return hexlify11(input.owner) === ownerAddress.toB256();
+        case InputType4.Message:
+          return hexlify11(input.recipient) === ownerAddress.toB256();
         default:
           return false;
       }
@@ -2740,7 +3291,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
     }
     const input = {
       id,
-      type: InputType3.Coin,
+      type: InputType4.Coin,
       owner: owner.toB256(),
       amount,
       assetId,
@@ -2771,7 +3322,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
     }
     const input = {
       nonce,
-      type: InputType3.Message,
+      type: InputType4.Message,
       sender: sender.toB256(),
       recipient: recipient.toB256(),
       data: isMessageCoin(message) ? "0x" : message.data,
@@ -2820,7 +3371,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
    */
   addCoinOutput(to, amount, assetId) {
     this.pushOutput({
-      type: OutputType3.Coin,
+      type: OutputType4.Coin,
       to: addressify(to).toB256(),
       amount,
       assetId
@@ -2836,7 +3387,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
   addCoinOutputs(to, quantities) {
     quantities.map(coinQuantityfy).forEach((quantity) => {
       this.pushOutput({
-        type: OutputType3.Coin,
+        type: OutputType4.Coin,
         to: addressify(to).toB256(),
         amount: quantity.amount,
         assetId: quantity.assetId
@@ -2852,11 +3403,11 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
    */
   addChangeOutput(to, assetId) {
     const changeOutput = this.getChangeOutputs().find(
-      (output) => hexlify10(output.assetId) === assetId
+      (output) => hexlify11(output.assetId) === assetId
     );
     if (!changeOutput) {
       this.pushOutput({
-        type: OutputType3.Change,
+        type: OutputType4.Change,
         to: addressify(to).toB256(),
         assetId
       });
@@ -2872,7 +3423,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
    * @hidden
    */
   metadataGas(_gasCosts) {
-    throw new FuelError10(FuelError10.CODES.NOT_IMPLEMENTED, "Not implemented");
+    throw new FuelError11(FuelError11.CODES.NOT_IMPLEMENTED, "Not implemented");
   }
   /**
    * @hidden
@@ -2929,25 +3480,25 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
       const assetInput = findAssetInput(assetId);
       let usedQuantity = quantity;
       if (assetId === baseAssetId) {
-        usedQuantity = bn8("1000000000000000000");
+        usedQuantity = bn9("1000000000000000000");
       }
       if (assetInput && "assetId" in assetInput) {
-        assetInput.id = hexlify10(randomBytes3(UTXO_ID_LEN2));
+        assetInput.id = hexlify11(randomBytes3(UTXO_ID_LEN2));
         assetInput.amount = usedQuantity;
       } else {
         this.addResources([
           {
-            id: hexlify10(randomBytes3(UTXO_ID_LEN2)),
+            id: hexlify11(randomBytes3(UTXO_ID_LEN2)),
             amount: usedQuantity,
             assetId,
             owner: resourcesOwner || Address2.fromRandom(),
-            blockCreated: bn8(1),
-            txCreatedIdx: bn8(1)
+            blockCreated: bn9(1),
+            txCreatedIdx: bn9(1)
           }
         ]);
       }
     }, "updateAssetInput");
-    updateAssetInput(baseAssetId, bn8(1e11));
+    updateAssetInput(baseAssetId, bn9(1e11));
     quantities.forEach((q) => updateAssetInput(q.assetId, q.amount));
     return this;
   }
@@ -2959,7 +3510,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
    */
   getCoinOutputsQuantities() {
     const coinsQuantities = this.getCoinOutputs().map(({ amount, assetId }) => ({
-      amount: bn8(amount),
+      amount: bn9(amount),
       assetId: assetId.toString()
     }));
     return coinsQuantities;
@@ -2991,7 +3542,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
       const correspondingInput = inputsToExtractGasUsed.find(
         (x) => isRequestInputResourceFromOwner(x, new Address2(String(owner)))
       );
-      if (correspondingInput && "predicateGasUsed" in correspondingInput && bn8(correspondingInput.predicateGasUsed).gt(0)) {
+      if (correspondingInput && "predicateGasUsed" in correspondingInput && bn9(correspondingInput.predicateGasUsed).gt(0)) {
         i.predicateGasUsed = correspondingInput.predicateGasUsed;
       }
     });
@@ -3022,34 +3573,34 @@ import { clone as clone3 } from "ramda";
 // src/providers/transaction-request/hash-transaction.ts
 import { ZeroBytes32 as ZeroBytes325 } from "@fuel-ts/address/configs";
 import { uint64ToBytesBE, sha256 } from "@fuel-ts/hasher";
-import { bn as bn9 } from "@fuel-ts/math";
-import { TransactionType as TransactionType2, InputType as InputType4, OutputType as OutputType4, TransactionCoder as TransactionCoder2 } from "@fuel-ts/transactions";
+import { bn as bn10 } from "@fuel-ts/math";
+import { TransactionType as TransactionType3, InputType as InputType5, OutputType as OutputType5, TransactionCoder as TransactionCoder2 } from "@fuel-ts/transactions";
 import { concat as concat3 } from "@fuel-ts/utils";
 import { clone as clone2 } from "ramda";
 function hashTransaction(transactionRequest, chainId) {
   const transaction = transactionRequest.toTransaction();
-  if (transaction.type === TransactionType2.Script) {
+  if (transaction.type === TransactionType3.Script) {
     transaction.receiptsRoot = ZeroBytes325;
   }
   transaction.inputs = transaction.inputs.map((input) => {
     const inputClone = clone2(input);
     switch (inputClone.type) {
       // Zero out on signing: txPointer, predicateGasUsed
-      case InputType4.Coin: {
+      case InputType5.Coin: {
         inputClone.txPointer = {
           blockHeight: 0,
           txIndex: 0
         };
-        inputClone.predicateGasUsed = bn9(0);
+        inputClone.predicateGasUsed = bn10(0);
         return inputClone;
       }
       // Zero out on signing: predicateGasUsed
-      case InputType4.Message: {
-        inputClone.predicateGasUsed = bn9(0);
+      case InputType5.Message: {
+        inputClone.predicateGasUsed = bn10(0);
         return inputClone;
       }
       // Zero out on signing: txID, outputIndex, balanceRoot, stateRoot, and txPointer
-      case InputType4.Contract: {
+      case InputType5.Contract: {
         inputClone.txPointer = {
           blockHeight: 0,
           txIndex: 0
@@ -3068,20 +3619,20 @@ function hashTransaction(transactionRequest, chainId) {
     const outputClone = clone2(output);
     switch (outputClone.type) {
       // Zero out on signing: balanceRoot, stateRoot
-      case OutputType4.Contract: {
+      case OutputType5.Contract: {
         outputClone.balanceRoot = ZeroBytes325;
         outputClone.stateRoot = ZeroBytes325;
         return outputClone;
       }
       // Zero out on signing: amount
-      case OutputType4.Change: {
-        outputClone.amount = bn9(0);
+      case OutputType5.Change: {
+        outputClone.amount = bn10(0);
         return outputClone;
       }
       // Zero out on signing: amount, to and assetId
-      case OutputType4.Variable: {
+      case OutputType5.Variable: {
         outputClone.to = ZeroBytes325;
-        outputClone.amount = bn9(0);
+        outputClone.amount = bn10(0);
         outputClone.assetId = ZeroBytes325;
         return outputClone;
       }
@@ -3106,7 +3657,7 @@ var BlobTransactionRequest = class extends BaseTransactionRequest {
     return new this(clone3(obj));
   }
   /** Type of the transaction */
-  type = TransactionType.Blob;
+  type = TransactionType2.Blob;
   /** Blob ID */
   blobId;
   /** Witness index of the bytecode to create */
@@ -3130,7 +3681,7 @@ var BlobTransactionRequest = class extends BaseTransactionRequest {
     const baseTransaction = this.getBaseTransaction();
     const { witnessIndex, blobId } = this;
     return {
-      type: TransactionType.Blob,
+      type: TransactionType2.Blob,
       ...baseTransaction,
       blobId,
       witnessIndex
@@ -3163,13 +3714,13 @@ var BlobTransactionRequest = class extends BaseTransactionRequest {
 
 // src/providers/transaction-request/create-transaction-request.ts
 import { ZeroBytes32 as ZeroBytes326 } from "@fuel-ts/address/configs";
-import { bn as bn10 } from "@fuel-ts/math";
-import { TransactionType as TransactionType3, OutputType as OutputType5 } from "@fuel-ts/transactions";
-import { arrayify as arrayify7, hexlify as hexlify12 } from "@fuel-ts/utils";
+import { bn as bn11 } from "@fuel-ts/math";
+import { TransactionType as TransactionType4, OutputType as OutputType6 } from "@fuel-ts/transactions";
+import { arrayify as arrayify7, hexlify as hexlify13 } from "@fuel-ts/utils";
 import { clone as clone4 } from "ramda";
 
 // src/providers/transaction-request/storage-slot.ts
-import { arrayify as arrayify6, hexlify as hexlify11 } from "@fuel-ts/utils";
+import { arrayify as arrayify6, hexlify as hexlify12 } from "@fuel-ts/utils";
 var getStorageValue = /* @__PURE__ */ __name((value) => {
   const v = new Uint8Array(32);
   v.set(arrayify6(value));
@@ -3186,8 +3737,8 @@ var storageSlotify = /* @__PURE__ */ __name((storageSlot) => {
     value = storageSlot.value;
   }
   return {
-    key: hexlify11(key),
-    value: hexlify11(getStorageValue(value))
+    key: hexlify12(key),
+    value: hexlify12(getStorageValue(value))
   };
 }, "storageSlotify");
 
@@ -3200,7 +3751,7 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
     return new this(clone4(obj));
   }
   /** Type of the transaction */
-  type = TransactionType3.Create;
+  type = TransactionType4.Create;
   /** Witness index of contract bytecode to create */
   bytecodeWitnessIndex;
   /** Salt */
@@ -3215,7 +3766,7 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
   constructor({ bytecodeWitnessIndex, salt, storageSlots, ...rest }) {
     super(rest);
     this.bytecodeWitnessIndex = bytecodeWitnessIndex ?? 0;
-    this.salt = hexlify12(salt ?? ZeroBytes326);
+    this.salt = hexlify13(salt ?? ZeroBytes326);
     this.storageSlots = [...storageSlots ?? []];
   }
   /**
@@ -3228,11 +3779,11 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
     const bytecodeWitnessIndex = this.bytecodeWitnessIndex;
     const storageSlots = this.storageSlots?.map(storageSlotify) ?? [];
     return {
-      type: TransactionType3.Create,
+      type: TransactionType4.Create,
       ...baseTransaction,
       bytecodeWitnessIndex,
-      storageSlotsCount: bn10(storageSlots.length),
-      salt: this.salt ? hexlify12(this.salt) : ZeroBytes326,
+      storageSlotsCount: bn11(storageSlots.length),
+      salt: this.salt ? hexlify13(this.salt) : ZeroBytes326,
       storageSlots
     };
   }
@@ -3243,7 +3794,7 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
    */
   getContractCreatedOutputs() {
     return this.outputs.filter(
-      (output) => output.type === OutputType5.ContractCreated
+      (output) => output.type === OutputType6.ContractCreated
     );
   }
   /**
@@ -3264,14 +3815,14 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
    */
   addContractCreatedOutput(contractId, stateRoot) {
     this.pushOutput({
-      type: OutputType5.ContractCreated,
+      type: OutputType6.ContractCreated,
       contractId,
       stateRoot
     });
   }
   metadataGas(gasCosts) {
     return calculateMetadataGasForTxCreate({
-      contractBytesSize: bn10(arrayify7(this.witnesses[this.bytecodeWitnessIndex] || "0x").length),
+      contractBytesSize: bn11(arrayify7(this.witnesses[this.bytecodeWitnessIndex] || "0x").length),
       gasCosts,
       stateRootSize: this.storageSlots.length,
       txBytesSize: this.byteSize()
@@ -3283,9 +3834,9 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
 import { Interface } from "@fuel-ts/abi-coder";
 import { addressify as addressify2 } from "@fuel-ts/address";
 import { ZeroBytes32 as ZeroBytes327 } from "@fuel-ts/address/configs";
-import { bn as bn11 } from "@fuel-ts/math";
-import { InputType as InputType5, OutputType as OutputType6, TransactionType as TransactionType4 } from "@fuel-ts/transactions";
-import { arrayify as arrayify9, hexlify as hexlify13 } from "@fuel-ts/utils";
+import { bn as bn12 } from "@fuel-ts/math";
+import { InputType as InputType6, OutputType as OutputType7, TransactionType as TransactionType5 } from "@fuel-ts/transactions";
+import { arrayify as arrayify9, hexlify as hexlify14 } from "@fuel-ts/utils";
 import { clone as clone5 } from "ramda";
 
 // src/providers/transaction-request/scripts.ts
@@ -3323,7 +3874,7 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
     return new this(clone5(obj));
   }
   /** Type of the transaction */
-  type = TransactionType4.Script;
+  type = TransactionType5.Script;
   /** Gas limit for transaction */
   gasLimit;
   /** Script to execute */
@@ -3338,7 +3889,7 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
    */
   constructor({ script, scriptData, gasLimit, ...rest } = {}) {
     super(rest);
-    this.gasLimit = bn11(gasLimit);
+    this.gasLimit = bn12(gasLimit);
     this.script = arrayify9(script ?? returnZeroScript.bytes);
     this.scriptData = arrayify9(scriptData ?? returnZeroScript.encodeScriptData());
     this.abis = rest.abis;
@@ -3349,6 +3900,9 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
    * @param account - The account to fund the transaction.
    * @param params - The parameters for the transaction cost.
    * @returns The current instance of the `ScriptTransactionRequest` funded.
+   *
+   * @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 = [] } = {}) {
     const txCost = await account.getTransactionCost(this, { signatureCallback, quantities });
@@ -3366,14 +3920,14 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
     const script = arrayify9(this.script ?? "0x");
     const scriptData = arrayify9(this.scriptData ?? "0x");
     return {
-      type: TransactionType4.Script,
+      type: TransactionType5.Script,
       scriptGasLimit: this.gasLimit,
       ...super.getBaseTransaction(),
-      scriptLength: bn11(script.length),
-      scriptDataLength: bn11(scriptData.length),
+      scriptLength: bn12(script.length),
+      scriptDataLength: bn12(scriptData.length),
       receiptsRoot: ZeroBytes327,
-      script: hexlify13(script),
-      scriptData: hexlify13(scriptData)
+      script: hexlify14(script),
+      scriptData: hexlify14(scriptData)
     };
   }
   /**
@@ -3383,7 +3937,7 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
    */
   getContractInputs() {
     return this.inputs.filter(
-      (input) => input.type === InputType5.Contract
+      (input) => input.type === InputType6.Contract
     );
   }
   /**
@@ -3393,7 +3947,7 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
    */
   getContractOutputs() {
     return this.outputs.filter(
-      (output) => output.type === OutputType6.Contract
+      (output) => output.type === OutputType7.Contract
     );
   }
   /**
@@ -3403,7 +3957,7 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
    */
   getVariableOutputs() {
     return this.outputs.filter(
-      (output) => output.type === OutputType6.Variable
+      (output) => output.type === OutputType7.Variable
     );
   }
   /**
@@ -3426,12 +3980,27 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
     let outputsNumber = numberOfVariables;
     while (outputsNumber) {
       this.pushOutput({
-        type: OutputType6.Variable
+        type: OutputType7.Variable
       });
       outputsNumber -= 1;
     }
     return this.outputs.length - 1;
   }
+  /**
+   * Adds a variable output to the transaction request.
+   *
+   * @param to - The recipient address as a BytesLike object. Defaults to ZeroBytes32 if not provided.
+   * @param amount - The amount to be transferred as a BigNumberish object. Defaults to 0 if not provided.
+   * @param assetId - The asset ID as a BytesLike object. Defaults to ZeroBytes32 if not provided.
+   */
+  addVariableOutput(to, amount, assetId) {
+    this.pushOutput({
+      type: OutputType7.Variable,
+      to,
+      amount,
+      assetId
+    });
+  }
   /**
    * Calculates the maximum gas for the transaction.
    *
@@ -3470,12 +4039,12 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
       return this;
     }
     const inputIndex = super.pushInput({
-      type: InputType5.Contract,
+      type: InputType6.Contract,
       contractId: contractAddress.toB256(),
       txPointer: "0x00000000000000000000000000000000"
     });
     this.pushOutput({
-      type: OutputType6.Contract,
+      type: OutputType7.Contract,
       inputIndex
     });
     return this;
@@ -3511,13 +4080,13 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
 };
 
 // src/providers/transaction-request/upgrade-transaction-request.ts
-import { FuelError as FuelError11 } from "@fuel-ts/errors";
+import { FuelError as FuelError12 } from "@fuel-ts/errors";
 import { hash as hash2 } from "@fuel-ts/hasher";
 import {
-  TransactionType as TransactionType5,
+  TransactionType as TransactionType6,
   UpgradePurposeTypeEnum
 } from "@fuel-ts/transactions";
-import { hexlify as hexlify14 } from "@fuel-ts/utils";
+import { hexlify as hexlify15 } from "@fuel-ts/utils";
 import { clone as clone6 } from "ramda";
 var UpgradeTransactionRequest = class _UpgradeTransactionRequest extends BaseTransactionRequest {
   static {
@@ -3530,7 +4099,7 @@ var UpgradeTransactionRequest = class _UpgradeTransactionRequest extends BaseTra
     return new this(clone6(obj));
   }
   /** The type of transaction */
-  type = TransactionType5.Upgrade;
+  type = TransactionType6.Upgrade;
   /** The upgrade purpose */
   upgradePurpose;
   /** Witness index of consensus */
@@ -3577,7 +4146,7 @@ var UpgradeTransactionRequest = class _UpgradeTransactionRequest extends BaseTra
   addStateTransitionUpgradePurpose(bytecodeRoot) {
     this.upgradePurpose = {
       type: UpgradePurposeTypeEnum.StateTransition,
-      data: hexlify14(bytecodeRoot)
+      data: hexlify15(bytecodeRoot)
     };
     return this;
   }
@@ -3617,14 +4186,14 @@ var UpgradeTransactionRequest = class _UpgradeTransactionRequest extends BaseTra
       upgradePurpose = {
         type: UpgradePurposeTypeEnum.StateTransition,
         data: {
-          bytecodeRoot: hexlify14(this.upgradePurpose.data)
+          bytecodeRoot: hexlify15(this.upgradePurpose.data)
         }
       };
     } else {
-      throw new FuelError11(FuelError11.CODES.NOT_IMPLEMENTED, "Invalid upgrade purpose");
+      throw new FuelError12(FuelError12.CODES.NOT_IMPLEMENTED, "Invalid upgrade purpose");
     }
     return {
-      type: TransactionType5.Upgrade,
+      type: TransactionType6.Upgrade,
       ...super.getBaseTransaction(),
       upgradePurpose
     };
@@ -3663,14 +4232,14 @@ var UpgradeTransactionRequest = class _UpgradeTransactionRequest extends BaseTra
         txBytesSize
       });
     }
-    throw new FuelError11(FuelError11.CODES.NOT_IMPLEMENTED, "Invalid upgrade purpose");
+    throw new FuelError12(FuelError12.CODES.NOT_IMPLEMENTED, "Invalid upgrade purpose");
   }
 };
 
 // src/providers/transaction-request/upload-transaction-request.ts
 import { ZeroBytes32 as ZeroBytes328 } from "@fuel-ts/address/configs";
-import { TransactionType as TransactionType6 } from "@fuel-ts/transactions";
-import { arrayify as arrayify10, hexlify as hexlify15 } from "@fuel-ts/utils";
+import { TransactionType as TransactionType7 } from "@fuel-ts/transactions";
+import { arrayify as arrayify10, hexlify as hexlify16 } from "@fuel-ts/utils";
 import { clone as clone7 } from "ramda";
 var UploadTransactionRequest = class _UploadTransactionRequest extends BaseTransactionRequest {
   static {
@@ -3683,7 +4252,7 @@ var UploadTransactionRequest = class _UploadTransactionRequest extends BaseTrans
     return new this(clone7(obj));
   }
   /** Type of the transaction */
-  type = TransactionType6.Upload;
+  type = TransactionType7.Upload;
   /** The witness index of the subsection of the bytecode. */
   witnessIndex;
   /** The subsection data. */
@@ -3732,12 +4301,12 @@ var UploadTransactionRequest = class _UploadTransactionRequest extends BaseTrans
     const baseTransaction = this.getBaseTransaction();
     const { subsectionIndex, subsectionsNumber, root, proofSet } = this.subsection;
     return {
-      type: TransactionType6.Upload,
+      type: TransactionType7.Upload,
       ...baseTransaction,
       subsectionIndex,
       subsectionsNumber,
-      root: hexlify15(root),
-      proofSet: proofSet.map(hexlify15),
+      root: hexlify16(root),
+      proofSet: proofSet.map(hexlify16),
       witnessIndex: this.witnessIndex,
       proofSetCount: proofSet.length
     };
@@ -3777,39 +4346,39 @@ var UploadTransactionRequest = class _UploadTransactionRequest extends BaseTrans
 };
 
 // src/providers/transaction-request/utils.ts
-import { ErrorCode as ErrorCode9, FuelError as FuelError12 } from "@fuel-ts/errors";
-import { TransactionType as TransactionType7 } from "@fuel-ts/transactions";
+import { ErrorCode as ErrorCode10, FuelError as FuelError13 } from "@fuel-ts/errors";
+import { TransactionType as TransactionType8 } from "@fuel-ts/transactions";
 var transactionRequestify = /* @__PURE__ */ __name((obj) => {
   if (obj instanceof ScriptTransactionRequest || obj instanceof CreateTransactionRequest || obj instanceof BlobTransactionRequest || obj instanceof UpgradeTransactionRequest || obj instanceof UploadTransactionRequest) {
     return obj;
   }
   const { type } = obj;
   switch (obj.type) {
-    case TransactionType7.Script: {
+    case TransactionType8.Script: {
       return ScriptTransactionRequest.from(obj);
     }
-    case TransactionType7.Create: {
+    case TransactionType8.Create: {
       return CreateTransactionRequest.from(obj);
     }
-    case TransactionType7.Blob: {
+    case TransactionType8.Blob: {
       return BlobTransactionRequest.from(obj);
     }
-    case TransactionType7.Upgrade: {
+    case TransactionType8.Upgrade: {
       return UpgradeTransactionRequest.from(obj);
     }
-    case TransactionType7.Upload: {
+    case TransactionType8.Upload: {
       return UploadTransactionRequest.from(obj);
     }
     default: {
-      throw new FuelError12(
-        ErrorCode9.UNSUPPORTED_TRANSACTION_TYPE,
+      throw new FuelError13(
+        ErrorCode10.UNSUPPORTED_TRANSACTION_TYPE,
         `Unsupported transaction type: ${type}.`
       );
     }
   }
 }, "transactionRequestify");
-var isTransactionTypeScript = /* @__PURE__ */ __name((request) => request.type === TransactionType7.Script, "isTransactionTypeScript");
-var isTransactionTypeCreate = /* @__PURE__ */ __name((request) => request.type === TransactionType7.Create, "isTransactionTypeCreate");
+var isTransactionTypeScript = /* @__PURE__ */ __name((request) => request.type === TransactionType8.Script, "isTransactionTypeScript");
+var isTransactionTypeCreate = /* @__PURE__ */ __name((request) => request.type === TransactionType8.Create, "isTransactionTypeCreate");
 
 // src/providers/resource-cache.ts
 var cache = /* @__PURE__ */ new Map();
@@ -3821,8 +4390,8 @@ var ResourceCache = class {
   constructor(ttl) {
     this.ttl = ttl;
     if (typeof ttl !== "number" || this.ttl <= 0) {
-      throw new FuelError13(
-        ErrorCode10.INVALID_TTL,
+      throw new FuelError14(
+        ErrorCode11.INVALID_TTL,
         `Invalid TTL: ${this.ttl}. Use a value greater than zero.`
       );
     }
@@ -3899,26 +4468,26 @@ var ResourceCache = class {
   }
   extractResourceData(input) {
     if (isRequestInputCoin(input)) {
-      return { owner: hexlify16(input.owner), key: hexlify16(input.id), type: "utxo" };
+      return { owner: hexlify17(input.owner), key: hexlify17(input.id), type: "utxo" };
     }
-    return { owner: hexlify16(input.recipient), key: hexlify16(input.nonce), type: "message" };
+    return { owner: hexlify17(input.recipient), key: hexlify17(input.nonce), type: "message" };
   }
 };
 
 // src/providers/transaction-response/transaction-response.ts
-import { ErrorCode as ErrorCode14, FuelError as FuelError17 } from "@fuel-ts/errors";
-import { bn as bn16 } from "@fuel-ts/math";
-import { OutputType as OutputType8, TransactionCoder as TransactionCoder4, TxPointerCoder } from "@fuel-ts/transactions";
-import { arrayify as arrayify12, assertUnreachable } from "@fuel-ts/utils";
+import { ErrorCode as ErrorCode15, FuelError as FuelError18 } from "@fuel-ts/errors";
+import { bn as bn17 } from "@fuel-ts/math";
+import { TransactionCoder as TransactionCoder5, TxPointerCoder } from "@fuel-ts/transactions";
+import { arrayify as arrayify12 } from "@fuel-ts/utils";
 
 // src/providers/transaction-summary/assemble-transaction-summary.ts
-import { bn as bn15 } from "@fuel-ts/math";
-import { PolicyType as PolicyType3 } from "@fuel-ts/transactions";
-import { DateTime, hexlify as hexlify17 } from "@fuel-ts/utils";
+import { bn as bn16 } from "@fuel-ts/math";
+import { PolicyType as PolicyType3, TransactionCoder as TransactionCoder4 } from "@fuel-ts/transactions";
+import { DateTime, hexlify as hexlify18 } from "@fuel-ts/utils";
 
 // src/providers/transaction-summary/calculate-tx-fee-for-summary.ts
-import { bn as bn12 } from "@fuel-ts/math";
-import { PolicyType as PolicyType2, TransactionCoder as TransactionCoder3, TransactionType as TransactionType8 } from "@fuel-ts/transactions";
+import { bn as bn13 } from "@fuel-ts/math";
+import { PolicyType as PolicyType2, TransactionCoder as TransactionCoder3, TransactionType as TransactionType9 } from "@fuel-ts/transactions";
 import { arrayify as arrayify11 } from "@fuel-ts/utils";
 var calculateTXFeeForSummary = /* @__PURE__ */ __name((params) => {
   const {
@@ -3927,19 +4496,19 @@ var calculateTXFeeForSummary = /* @__PURE__ */ __name((params) => {
     tip,
     consensusParameters: { gasCosts, feeParams, maxGasPerTx }
   } = params;
-  const gasPerByte = bn12(feeParams.gasPerByte);
-  const gasPriceFactor = bn12(feeParams.gasPriceFactor);
+  const gasPerByte = bn13(feeParams.gasPerByte);
+  const gasPriceFactor = bn13(feeParams.gasPriceFactor);
   const transactionBytes = arrayify11(rawPayload);
   const [transaction] = new TransactionCoder3().decode(transactionBytes, 0);
   const { type, witnesses, inputs, policies } = transaction;
-  let metadataGas = bn12(0);
-  let gasLimit = bn12(0);
-  if (type !== TransactionType8.Create && type !== TransactionType8.Script) {
-    return bn12(0);
+  let metadataGas = bn13(0);
+  let gasLimit = bn13(0);
+  if (type !== TransactionType9.Create && type !== TransactionType9.Script) {
+    return bn13(0);
   }
-  if (type === TransactionType8.Create) {
+  if (type === TransactionType9.Create) {
     const { bytecodeWitnessIndex, storageSlots } = transaction;
-    const contractBytesSize = bn12(arrayify11(witnesses[bytecodeWitnessIndex].data).length);
+    const contractBytesSize = bn13(arrayify11(witnesses[bytecodeWitnessIndex].data).length);
     metadataGas = calculateMetadataGasForTxCreate({
       contractBytesSize,
       gasCosts,
@@ -3958,7 +4527,7 @@ var calculateTXFeeForSummary = /* @__PURE__ */ __name((params) => {
   }
   const minGas = getMinGas({
     gasCosts,
-    gasPerByte: bn12(gasPerByte),
+    gasPerByte: bn13(gasPerByte),
     inputs,
     metadataGas,
     txBytesSize: transactionBytes.length
@@ -3984,14 +4553,14 @@ var calculateTXFeeForSummary = /* @__PURE__ */ __name((params) => {
 
 // src/providers/transaction-summary/operations.ts
 import { ZeroBytes32 as ZeroBytes329 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode12, FuelError as FuelError15 } from "@fuel-ts/errors";
-import { bn as bn13 } from "@fuel-ts/math";
-import { ReceiptType as ReceiptType5, TransactionType as TransactionType9 } from "@fuel-ts/transactions";
+import { ErrorCode as ErrorCode13, FuelError as FuelError16 } from "@fuel-ts/errors";
+import { bn as bn14 } from "@fuel-ts/math";
+import { ReceiptType as ReceiptType5, TransactionType as TransactionType10 } from "@fuel-ts/transactions";
 
 // src/providers/transaction-summary/input.ts
-import { ErrorCode as ErrorCode11, FuelError as FuelError14 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode12, FuelError as FuelError15 } from "@fuel-ts/errors";
 import { BN } from "@fuel-ts/math";
-import { InputType as InputType6 } from "@fuel-ts/transactions";
+import { InputType as InputType7 } from "@fuel-ts/transactions";
 function getInputsByTypes(inputs, types) {
   return inputs.filter((i) => types.includes(i.type));
 }
@@ -4001,23 +4570,23 @@ function getInputsByType(inputs, type) {
 }
 __name(getInputsByType, "getInputsByType");
 function getInputsCoin(inputs) {
-  return getInputsByType(inputs, InputType6.Coin);
+  return getInputsByType(inputs, InputType7.Coin);
 }
 __name(getInputsCoin, "getInputsCoin");
 function getInputsMessage(inputs) {
-  return getInputsByType(inputs, InputType6.Message);
+  return getInputsByType(inputs, InputType7.Message);
 }
 __name(getInputsMessage, "getInputsMessage");
 function getInputsCoinAndMessage(inputs) {
-  return getInputsByTypes(inputs, [InputType6.Coin, InputType6.Message]);
+  return getInputsByTypes(inputs, [InputType7.Coin, InputType7.Message]);
 }
 __name(getInputsCoinAndMessage, "getInputsCoinAndMessage");
 function isInputCoin(input) {
-  return input.type === InputType6.Coin;
+  return input.type === InputType7.Coin;
 }
 __name(isInputCoin, "isInputCoin");
 function getInputsContract(inputs) {
-  return getInputsByType(inputs, InputType6.Contract);
+  return getInputsByType(inputs, InputType7.Contract);
 }
 __name(getInputsContract, "getInputsContract");
 function findCoinInput(inputs, assetId) {
@@ -4068,9 +4637,9 @@ function getInputContractFromIndex(inputs, inputIndex) {
   if (!contractInput) {
     return void 0;
   }
-  if (contractInput.type !== InputType6.Contract) {
-    throw new FuelError14(
-      ErrorCode11.INVALID_TRANSACTION_INPUT,
+  if (contractInput.type !== InputType7.Contract) {
+    throw new FuelError15(
+      ErrorCode12.INVALID_TRANSACTION_INPUT,
       `Contract input should be of type 'contract'.`
     );
   }
@@ -4078,10 +4647,10 @@ function getInputContractFromIndex(inputs, inputIndex) {
 }
 __name(getInputContractFromIndex, "getInputContractFromIndex");
 function getInputAccountAddress(input) {
-  if (input.type === InputType6.Coin) {
+  if (input.type === InputType7.Coin) {
     return input.owner.toString();
   }
-  if (input.type === InputType6.Message) {
+  if (input.type === InputType7.Message) {
     return input.recipient.toString();
   }
   return "";
@@ -4089,25 +4658,25 @@ function getInputAccountAddress(input) {
 __name(getInputAccountAddress, "getInputAccountAddress");
 
 // src/providers/transaction-summary/output.ts
-import { OutputType as OutputType7 } from "@fuel-ts/transactions";
+import { OutputType as OutputType8 } from "@fuel-ts/transactions";
 function getOutputsByType(outputs, type) {
   return outputs.filter((o) => o.type === type);
 }
 __name(getOutputsByType, "getOutputsByType");
 function getOutputsContractCreated(outputs) {
-  return getOutputsByType(outputs, OutputType7.ContractCreated);
+  return getOutputsByType(outputs, OutputType8.ContractCreated);
 }
 __name(getOutputsContractCreated, "getOutputsContractCreated");
 function getOutputsCoin(outputs) {
-  return getOutputsByType(outputs, OutputType7.Coin);
+  return getOutputsByType(outputs, OutputType8.Coin);
 }
 __name(getOutputsCoin, "getOutputsCoin");
 function getOutputsChange(outputs) {
-  return getOutputsByType(outputs, OutputType7.Change);
+  return getOutputsByType(outputs, OutputType8.Change);
 }
 __name(getOutputsChange, "getOutputsChange");
 function getOutputsContract(outputs) {
-  return getOutputsByType(outputs, OutputType7.Contract);
+  return getOutputsByType(outputs, OutputType8.Contract);
 }
 __name(getOutputsContract, "getOutputsContract");
 
@@ -4118,21 +4687,21 @@ function getReceiptsByType(receipts, type) {
 __name(getReceiptsByType, "getReceiptsByType");
 function getTransactionTypeName(transactionType) {
   switch (transactionType) {
-    case TransactionType9.Mint:
+    case TransactionType10.Mint:
       return "Mint" /* Mint */;
-    case TransactionType9.Create:
+    case TransactionType10.Create:
       return "Create" /* Create */;
-    case TransactionType9.Script:
+    case TransactionType10.Script:
       return "Script" /* Script */;
-    case TransactionType9.Blob:
+    case TransactionType10.Blob:
       return "Blob" /* Blob */;
-    case TransactionType9.Upgrade:
+    case TransactionType10.Upgrade:
       return "Upgrade" /* Upgrade */;
-    case TransactionType9.Upload:
+    case TransactionType10.Upload:
       return "Upload" /* Upload */;
     default:
-      throw new FuelError15(
-        ErrorCode12.UNSUPPORTED_TRANSACTION_TYPE,
+      throw new FuelError16(
+        ErrorCode13.UNSUPPORTED_TRANSACTION_TYPE,
         `Unsupported transaction type: ${transactionType}.`
       );
   }
@@ -4185,7 +4754,7 @@ function mergeAssets(op1, op2) {
   assets2.forEach((asset) => {
     const existingAsset = assetMap.get(asset.assetId);
     if (existingAsset) {
-      existingAsset.amount = bn13(existingAsset.amount).add(asset.amount);
+      existingAsset.amount = bn14(existingAsset.amount).add(asset.amount);
     } else {
       assetMap.set(asset.assetId, { ...asset });
     }
@@ -4537,8 +5106,8 @@ var extractBurnedAssetsFromReceipts = /* @__PURE__ */ __name((receipts) => {
 }, "extractBurnedAssetsFromReceipts");
 
 // src/providers/transaction-summary/status.ts
-import { ErrorCode as ErrorCode13, FuelError as FuelError16 } from "@fuel-ts/errors";
-import { bn as bn14 } from "@fuel-ts/math";
+import { ErrorCode as ErrorCode14, FuelError as FuelError17 } from "@fuel-ts/errors";
+import { bn as bn15 } from "@fuel-ts/math";
 var getTransactionStatusName = /* @__PURE__ */ __name((gqlStatus) => {
   switch (gqlStatus) {
     case "FailureStatus":
@@ -4549,22 +5118,41 @@ var getTransactionStatusName = /* @__PURE__ */ __name((gqlStatus) => {
       return "submitted" /* submitted */;
     case "SqueezedOutStatus":
       return "squeezedout" /* squeezedout */;
+    case "PreconfirmationSuccessStatus":
+      return "preconfirmationSuccess" /* preconfirmationSuccess */;
+    case "PreconfirmationFailureStatus":
+      return "preconfirmationFailure" /* preconfirmationFailure */;
     default:
-      throw new FuelError16(
-        ErrorCode13.INVALID_TRANSACTION_STATUS,
+      throw new FuelError17(
+        ErrorCode14.INVALID_TRANSACTION_STATUS,
         `Invalid transaction status: ${gqlStatus}.`
       );
   }
 }, "getTransactionStatusName");
+var extractResolvedOutputs = /* @__PURE__ */ __name((serializedOutputs) => {
+  const resolvedOutputs = [];
+  serializedOutputs?.forEach(
+    ({ utxoId, output }) => resolvedOutputs.push({
+      utxoId,
+      output: deserializeProcessedTxOutput(output)
+    })
+  );
+  return resolvedOutputs;
+}, "extractResolvedOutputs");
 var processGraphqlStatus = /* @__PURE__ */ __name((gqlTransactionStatus) => {
   let time;
   let blockId;
   let status;
   let totalFee;
   let totalGas;
+  let receipts;
+  let resolvedOutputs = [];
+  let errorReason;
   let isStatusFailure = false;
   let isStatusSuccess = false;
   let isStatusPending = false;
+  let isStatusPreConfirmationSuccess = false;
+  let isStatusPreConfirmationFailure = false;
   if (gqlTransactionStatus?.type) {
     status = getTransactionStatusName(gqlTransactionStatus.type);
     switch (gqlTransactionStatus.type) {
@@ -4572,20 +5160,37 @@ var processGraphqlStatus = /* @__PURE__ */ __name((gqlTransactionStatus) => {
         time = gqlTransactionStatus.time;
         blockId = gqlTransactionStatus.block?.id;
         isStatusSuccess = true;
-        totalFee = bn14(gqlTransactionStatus.totalFee);
-        totalGas = bn14(gqlTransactionStatus.totalGas);
+        receipts = gqlTransactionStatus.receipts?.map(deserializeReceipt);
+        totalFee = bn15(gqlTransactionStatus.totalFee);
+        totalGas = bn15(gqlTransactionStatus.totalGas);
         break;
       case "FailureStatus":
         time = gqlTransactionStatus.time;
         blockId = gqlTransactionStatus.block?.id;
         isStatusFailure = true;
-        totalFee = bn14(gqlTransactionStatus.totalFee);
-        totalGas = bn14(gqlTransactionStatus.totalGas);
+        totalFee = bn15(gqlTransactionStatus.totalFee);
+        receipts = gqlTransactionStatus.receipts?.map(deserializeReceipt);
+        totalGas = bn15(gqlTransactionStatus.totalGas);
         break;
       case "SubmittedStatus":
         time = gqlTransactionStatus.time;
         isStatusPending = true;
         break;
+      case "PreconfirmationSuccessStatus":
+        isStatusPreConfirmationSuccess = true;
+        totalFee = bn15(gqlTransactionStatus.totalFee);
+        totalGas = bn15(gqlTransactionStatus.totalGas);
+        receipts = gqlTransactionStatus.preconfirmationReceipts?.map(deserializeReceipt);
+        resolvedOutputs = extractResolvedOutputs(gqlTransactionStatus.resolvedOutputs);
+        break;
+      case "PreconfirmationFailureStatus":
+        isStatusPreConfirmationFailure = true;
+        totalFee = bn15(gqlTransactionStatus.totalFee);
+        totalGas = bn15(gqlTransactionStatus.totalGas);
+        receipts = gqlTransactionStatus.preconfirmationReceipts?.map(deserializeReceipt);
+        resolvedOutputs = extractResolvedOutputs(gqlTransactionStatus.resolvedOutputs);
+        errorReason = gqlTransactionStatus.reason;
+        break;
       default:
     }
   }
@@ -4595,13 +5200,18 @@ var processGraphqlStatus = /* @__PURE__ */ __name((gqlTransactionStatus) => {
     status,
     totalFee,
     totalGas,
+    receipts,
     isStatusFailure,
     isStatusSuccess,
-    isStatusPending
+    isStatusPending,
+    isStatusPreConfirmationSuccess,
+    isStatusPreConfirmationFailure,
+    resolvedOutputs,
+    errorReason
   };
   return processedGraphqlStatus;
 }, "processGraphqlStatus");
-var getTotalFeeFromStatus = /* @__PURE__ */ __name((status) => status && "totalFee" in status ? bn14(status.totalFee) : void 0, "getTotalFeeFromStatus");
+var getTotalFeeFromStatus = /* @__PURE__ */ __name((status) => status && "totalFee" in status ? bn15(status.totalFee) : void 0, "getTotalFeeFromStatus");
 
 // src/providers/transaction-summary/assemble-transaction-summary.ts
 function assembleTransactionSummary(params) {
@@ -4621,7 +5231,7 @@ function assembleTransactionSummary(params) {
     baseAssetId
   } = params;
   const gasUsed = getGasUsedFromReceipts(receipts);
-  const rawPayload = hexlify17(transactionBytes);
+  const rawPayload = hexlify18(transactionBytes);
   const operations = getOperations({
     transactionType: transaction.type,
     inputs: transaction.inputs || [],
@@ -4633,7 +5243,7 @@ function assembleTransactionSummary(params) {
     baseAssetId
   });
   const typeName = getTransactionTypeName(transaction.type);
-  const tip = bn15(transaction.policies?.find((policy) => policy.type === PolicyType3.Tip)?.data);
+  const tip = bn16(transaction.policies?.find((policy) => policy.type === PolicyType3.Tip)?.data);
   const { isStatusFailure, isStatusPending, isStatusSuccess, blockId, status, time, totalFee } = processGraphqlStatus(gqlTransactionStatus);
   const fee = totalFee ?? calculateTXFeeForSummary({
     gasPrice,
@@ -4682,6 +5292,81 @@ function assembleTransactionSummary(params) {
   return transactionSummary;
 }
 __name(assembleTransactionSummary, "assembleTransactionSummary");
+function assemblePreConfirmationTransactionSummary(params) {
+  const { id, gqlTransactionStatus, transactionRequest, baseAssetId, maxInputs, abiMap } = params;
+  let type;
+  let operations;
+  let gasUsed;
+  let tip;
+  let transaction;
+  let mintedAssets;
+  let burnedAssets;
+  const {
+    isStatusFailure,
+    isStatusSuccess,
+    isStatusPending,
+    status,
+    receipts,
+    resolvedOutputs,
+    errorReason,
+    totalFee,
+    isStatusPreConfirmationFailure,
+    isStatusPreConfirmationSuccess
+  } = processGraphqlStatus(gqlTransactionStatus);
+  if (receipts) {
+    gasUsed = getGasUsedFromReceipts(receipts);
+    mintedAssets = extractMintedAssetsFromReceipts(receipts);
+    burnedAssets = extractBurnedAssetsFromReceipts(receipts);
+  }
+  if (transactionRequest) {
+    transaction = transactionRequest.toTransaction();
+    type = getTransactionTypeName(transaction.type);
+    tip = bn16(transaction.policies?.find((policy) => policy.type === PolicyType3.Tip)?.data);
+    if (receipts) {
+      const rawPayload = hexlify18(new TransactionCoder4().encode(transaction));
+      operations = getOperations({
+        transactionType: transaction.type,
+        inputs: transaction.inputs || [],
+        outputs: transaction.outputs || [],
+        receipts,
+        rawPayload,
+        abiMap,
+        maxInputs,
+        baseAssetId
+      });
+    }
+  }
+  const transactionSummary = {
+    id,
+    fee: totalFee,
+    type,
+    status,
+    receipts,
+    gasUsed,
+    tip,
+    isStatusPreConfirmationFailure,
+    isStatusPreConfirmationSuccess,
+    isStatusFailure,
+    isStatusSuccess,
+    isStatusPending,
+    ...transaction && {
+      isTypeMint: isTypeMint(transaction.type),
+      isTypeCreate: isTypeCreate(transaction.type),
+      isTypeScript: isTypeScript(transaction.type),
+      isTypeUpgrade: isTypeUpgrade(transaction.type),
+      isTypeUpload: isTypeUpload(transaction.type),
+      isTypeBlob: isTypeBlob(transaction.type)
+    },
+    mintedAssets,
+    burnedAssets,
+    resolvedOutputs,
+    errorReason,
+    transaction,
+    operations
+  };
+  return transactionSummary;
+}
+__name(assemblePreConfirmationTransactionSummary, "assemblePreConfirmationTransactionSummary");
 
 // src/providers/transaction-response/getAllDecodedLogs.ts
 import { Interface as Interface2, BigNumberCoder } from "@fuel-ts/abi-coder";
@@ -4717,37 +5402,6 @@ function getAllDecodedLogs(opts) {
 __name(getAllDecodedLogs, "getAllDecodedLogs");
 
 // src/providers/transaction-response/transaction-response.ts
-function mapGqlOutputsToTxOutputs(outputs) {
-  return outputs.map((o) => {
-    const obj = "amount" in o ? { ...o, amount: bn16(o.amount) } : o;
-    switch (obj.type) {
-      case "CoinOutput":
-        return { ...obj, type: OutputType8.Coin };
-      case "ContractOutput":
-        return {
-          ...obj,
-          type: OutputType8.Contract,
-          inputIndex: parseInt(obj.inputIndex, 10)
-        };
-      case "ChangeOutput":
-        return {
-          ...obj,
-          type: OutputType8.Change
-        };
-      case "VariableOutput":
-        return { ...obj, type: OutputType8.Variable };
-      case "ContractCreated":
-        return {
-          ...obj,
-          type: OutputType8.ContractCreated,
-          contractId: obj.contract
-        };
-      default:
-        return assertUnreachable(obj);
-    }
-  });
-}
-__name(mapGqlOutputsToTxOutputs, "mapGqlOutputsToTxOutputs");
 var TransactionResponse = class _TransactionResponse {
   /**
    * Constructor for `TransactionResponse`.
@@ -4757,11 +5411,16 @@ var TransactionResponse = class _TransactionResponse {
    */
   constructor(tx, provider, chainId, abis, submitTxSubscription) {
     this.submitTxSubscription = submitTxSubscription;
-    this.id = typeof tx === "string" ? tx : tx.getTransactionId(chainId);
+    if (typeof tx === "string") {
+      this.id = tx;
+    } else {
+      this.id = tx.getTransactionId(chainId);
+      this.request = tx;
+    }
     this.provider = provider;
     this.abis = abis;
-    this.request = typeof tx === "string" ? void 0 : tx;
     this.waitForResult = this.waitForResult.bind(this);
+    this.waitForPreConfirmation = this.waitForPreConfirmation.bind(this);
   }
   static {
     __name(this, "TransactionResponse");
@@ -4771,12 +5430,15 @@ var TransactionResponse = class _TransactionResponse {
   /** Current provider */
   provider;
   /** Gas used on the transaction */
-  gasUsed = bn16(0);
+  gasUsed = bn17(0);
   /** The graphql Transaction with receipts object. */
   gqlTransaction;
   request;
   status;
   abis;
+  waitingForStreamData = false;
+  statusResolvers = /* @__PURE__ */ new Map();
+  preConfirmationStatus;
   /**
    * Async constructor for `TransactionResponse`. This method can be used to create
    * an instance of `TransactionResponse` and wait for the transaction to be fetched
@@ -4808,29 +5470,38 @@ var TransactionResponse = class _TransactionResponse {
         }
         return input;
       });
-      tx.outputs = mapGqlOutputsToTxOutputs(status.transaction.outputs);
-      if ("receiptsRoot" in status.transaction) {
+      tx.outputs = status.transaction.outputs.map(deserializeProcessedTxOutput);
+      if (status.transaction.receiptsRoot) {
         tx.receiptsRoot = status.transaction.receiptsRoot;
       }
     }
   }
   async getTransaction() {
     if (this.request) {
-      const tx = this.request.toTransaction();
-      this.applyMalleableSubscriptionFields(tx);
+      const tx2 = this.request.toTransaction();
+      this.applyMalleableSubscriptionFields(tx2);
       return {
-        tx,
+        tx: tx2,
         bytes: this.request.toTransactionBytes()
       };
     }
     const gqlTransaction = this.gqlTransaction ?? await this.fetch();
+    const { rawPayload } = gqlTransaction;
+    const bytes = arrayify12(rawPayload);
+    const [tx] = new TransactionCoder5().decode(bytes, 0);
     return {
-      tx: this.decodeTransaction(gqlTransaction),
-      bytes: arrayify12(gqlTransaction.rawPayload)
+      tx,
+      bytes
     };
   }
+  /**
+   *
+   * NOTE: This method is only called within `getTransactionSummary`, which is invoked after `getTransaction`.
+   * Since `getTransaction` only resolves once the transaction has been processed,
+   * the status at this point is guaranteed to be either `SuccessStatus` or `FailureStatus`.
+   */
   getReceipts() {
-    const status = this.status ?? this.gqlTransaction?.status;
+    const status = this.getTransactionStatus();
     switch (status?.type) {
       case "SuccessStatus":
       case "FailureStatus":
@@ -4863,18 +5534,6 @@ var TransactionResponse = class _TransactionResponse {
     this.gqlTransaction = response.transaction;
     return response.transaction;
   }
-  /**
-   * Decode the raw payload of the transaction.
-   *
-   * @param transactionWithReceipts - The transaction with receipts object.
-   * @returns The decoded transaction.
-   */
-  decodeTransaction(transactionWithReceipts) {
-    return new TransactionCoder4().decode(
-      arrayify12(transactionWithReceipts.rawPayload),
-      0
-    )?.[0];
-  }
   /**
    * Retrieves the TransactionSummary. If the `gqlTransaction` is not set, it will
    * fetch it from the provider
@@ -4885,8 +5544,9 @@ var TransactionResponse = class _TransactionResponse {
   async getTransactionSummary(contractsAbiMap) {
     const { tx: transaction, bytes: transactionBytes } = await this.getTransaction();
     const { gasPerByte, gasPriceFactor, gasCosts, maxGasPerTx } = await this.provider.getGasConfig();
-    const totalFee = getTotalFeeFromStatus(this.status ?? this.gqlTransaction?.status);
-    const gasPrice = totalFee ? bn16(0) : await this.provider.getLatestGasPrice();
+    const transactionStatus = this.getTransactionStatus();
+    const totalFee = getTotalFeeFromStatus(transactionStatus);
+    const gasPrice = totalFee ? bn17(0) : await this.provider.getLatestGasPrice();
     const maxInputs = (await this.provider.getChain()).consensusParameters.txParameters.maxInputs;
     const baseAssetId = await this.provider.getBaseAssetId();
     const transactionSummary = assembleTransactionSummary({
@@ -4894,7 +5554,7 @@ var TransactionResponse = class _TransactionResponse {
       receipts: this.getReceipts(),
       transaction,
       transactionBytes,
-      gqlTransactionStatus: this.status ?? this.gqlTransaction?.status,
+      gqlTransactionStatus: transactionStatus,
       gasPerByte,
       gasPriceFactor,
       abiMap: contractsAbiMap,
@@ -4906,29 +5566,92 @@ var TransactionResponse = class _TransactionResponse {
     });
     return transactionSummary;
   }
+  async getPreConfirmationTransactionSummary(contractsAbiMap) {
+    const baseAssetId = await this.provider.getBaseAssetId();
+    const maxInputs = (await this.provider.getChain()).consensusParameters.txParameters.maxInputs;
+    const transactionSummary = assemblePreConfirmationTransactionSummary({
+      id: this.id,
+      gqlTransactionStatus: this.preConfirmationStatus || this.status,
+      baseAssetId,
+      maxInputs,
+      abiMap: contractsAbiMap,
+      transactionRequest: this.request
+    });
+    return transactionSummary;
+  }
+  resolveStatus(type) {
+    const resolvers = this.statusResolvers.get(type) || [];
+    resolvers.forEach((resolve) => resolve());
+    this.statusResolvers.delete(type);
+  }
+  async waitForStatus(type) {
+    return new Promise((resolve, reject) => {
+      const resolvers = this.statusResolvers.get(type) || [];
+      resolvers.push(() => {
+        resolve();
+      });
+      this.statusResolvers.set(type, resolvers);
+      this.waitForStatusChange().catch(reject);
+    });
+  }
+  /**
+   * Waits for the status change of the transaction.
+   * If the transaction is already in a final state, it will return immediately.
+   * If the transaction is not in a final state, it will wait for the status change.
+   * If we are already subscribed to the status change, it will return immediately.
+   */
   async waitForStatusChange() {
-    const status = this.gqlTransaction?.status?.type;
-    if (status && status !== "SubmittedStatus") {
+    const type = this.status?.type;
+    if (type && (type === "FailureStatus" || type === "SuccessStatus")) {
+      this.resolveStatus("preConfirmation");
+      this.resolveStatus("confirmation");
       return;
     }
+    if (this.waitingForStreamData) {
+      return;
+    }
+    this.waitingForStreamData = true;
     const subscription = this.submitTxSubscription ?? await this.provider.operations.statusChange({
-      transactionId: this.id
+      transactionId: this.id,
+      includePreConfirmation: true
     });
     for await (const sub of subscription) {
       const statusChange = "statusChange" in sub ? sub.statusChange : sub.submitAndAwaitStatus;
       this.status = statusChange;
       if (statusChange.type === "SqueezedOutStatus") {
-        this.unsetResourceCache();
-        throw new FuelError17(
-          ErrorCode14.TRANSACTION_SQUEEZED_OUT,
+        throw new FuelError18(
+          ErrorCode15.TRANSACTION_SQUEEZED_OUT,
           `Transaction Squeezed Out with reason: ${statusChange.reason}`
         );
       }
-      if (statusChange.type !== "SubmittedStatus") {
+      if (statusChange.type === "PreconfirmationSuccessStatus" || statusChange.type === "PreconfirmationFailureStatus") {
+        this.preConfirmationStatus = statusChange;
+        this.resolveStatus("preConfirmation");
+      }
+      if (statusChange.type === "SuccessStatus" || statusChange.type === "FailureStatus") {
+        this.resolveStatus("confirmation");
+        this.resolveStatus("preConfirmation");
+        this.waitingForStreamData = false;
         break;
       }
     }
   }
+  async waitForConfirmationStatuses() {
+    try {
+      await this.waitForStatus("confirmation");
+    } catch (error) {
+      this.unsetResourceCache();
+      throw error;
+    }
+  }
+  async waitForPreConfirmationStatuses() {
+    try {
+      await this.waitForStatus("preConfirmation");
+    } catch (error) {
+      this.unsetResourceCache();
+      throw error;
+    }
+  }
   /**
    * Assembles the result of a transaction by retrieving the transaction summary,
    * decoding logs (if available), and handling transaction failure.
@@ -4957,7 +5680,7 @@ var TransactionResponse = class _TransactionResponse {
       transactionResult.groupedLogs = groupedLogs;
     }
     const { receipts } = transactionResult;
-    const status = this.status ?? this.gqlTransaction?.status;
+    const status = this.getTransactionStatus();
     if (status?.type === "FailureStatus") {
       const { reason } = status;
       throw extractTxError({
@@ -4969,16 +5692,46 @@ var TransactionResponse = class _TransactionResponse {
     }
     return transactionResult;
   }
+  async assemblePreConfirmationResult(contractsAbiMap) {
+    const transactionSummary = await this.getPreConfirmationTransactionSummary(contractsAbiMap);
+    const transactionResult = {
+      ...transactionSummary,
+      logs: [],
+      groupedLogs: {}
+    };
+    let { logs, groupedLogs } = { logs: [], groupedLogs: {} };
+    if (this.abis && transactionSummary.receipts) {
+      ({ logs, groupedLogs } = getAllDecodedLogs({
+        receipts: transactionSummary.receipts,
+        mainAbi: this.abis.main,
+        externalAbis: this.abis.otherContractsAbis
+      }));
+      transactionResult.logs = logs;
+      transactionResult.groupedLogs = groupedLogs;
+    }
+    return transactionResult;
+  }
   /**
    * Waits for transaction to complete and returns the result.
    *
    * @returns The completed transaction result
    */
   async waitForResult(contractsAbiMap) {
-    await this.waitForStatusChange();
+    await this.waitForConfirmationStatuses();
     this.unsetResourceCache();
     return this.assembleResult(contractsAbiMap);
   }
+  /**
+   * Waits for the transaction's pre-confirmation and returns the result.
+   *
+   * @param contractsAbiMap - The contracts ABI map.
+   * @returns The pre-confirmed transaction result
+   */
+  async waitForPreConfirmation(contractsAbiMap) {
+    await this.waitForPreConfirmationStatuses();
+    this.unsetResourceCache();
+    return this.assemblePreConfirmationResult(contractsAbiMap);
+  }
   /**
    * Waits for transaction to complete and returns the result.
    *
@@ -4990,6 +5743,9 @@ var TransactionResponse = class _TransactionResponse {
   unsetResourceCache() {
     this.provider.cache?.unset(this.id);
   }
+  getTransactionStatus() {
+    return this.status ?? this.gqlTransaction?.status;
+  }
 };
 
 // src/providers/transaction-response/getDecodedLogs.ts
@@ -5036,48 +5792,49 @@ function autoRetryFetch(fetchFn, options, retryAttemptNum = 0) {
 }
 __name(autoRetryFetch, "autoRetryFetch");
 
-// src/providers/utils/helpers.ts
-var adjustResourcesToExclude = /* @__PURE__ */ __name((params) => {
-  const { userInput, cached, maxInputs } = params;
-  const final = { ...userInput };
-  let total = final.utxos.length + final.messages.length;
-  if (total >= maxInputs) {
-    return final;
-  }
-  final.utxos = [...final.utxos, ...cached.utxos.slice(0, maxInputs - total)];
-  total = final.utxos.length + final.messages.length;
-  if (total < maxInputs) {
-    final.messages = [...final.messages, ...cached.messages.slice(0, maxInputs - total)];
+// src/providers/utils/parse-graphql-response.ts
+var parseGraphqlResponse = /* @__PURE__ */ __name(async (options) => {
+  const { response, isSubscription } = options;
+  let extensions;
+  const responseClone = response.clone();
+  if (isSubscription) {
+    const reader = responseClone.body?.getReader();
+    const { event } = await FuelGraphqlSubscriber.readEvent(reader);
+    extensions = event?.extensions;
+  } else {
+    extensions = (await responseClone.json()).extensions;
   }
-  return final;
-}, "adjustResourcesToExclude");
+  return {
+    extensions
+  };
+}, "parseGraphqlResponse");
 
 // src/providers/utils/validate-pagination-args.ts
-import { FuelError as FuelError18, ErrorCode as ErrorCode15 } from "@fuel-ts/errors";
+import { FuelError as FuelError19, ErrorCode as ErrorCode16 } from "@fuel-ts/errors";
 var validatePaginationArgs = /* @__PURE__ */ __name((params) => {
   const { paginationLimit, inputArgs = {} } = params;
   const { first, last, after, before } = inputArgs;
   if (after && before) {
-    throw new FuelError18(
-      ErrorCode15.INVALID_INPUT_PARAMETERS,
+    throw new FuelError19(
+      ErrorCode16.INVALID_INPUT_PARAMETERS,
       'Pagination arguments "after" and "before" cannot be used together'
     );
   }
   if ((first || 0) > paginationLimit || (last || 0) > paginationLimit) {
-    throw new FuelError18(
-      ErrorCode15.INVALID_INPUT_PARAMETERS,
+    throw new FuelError19(
+      ErrorCode16.INVALID_INPUT_PARAMETERS,
       `Pagination limit for this query cannot exceed ${paginationLimit} items`
     );
   }
   if (first && before) {
-    throw new FuelError18(
-      ErrorCode15.INVALID_INPUT_PARAMETERS,
+    throw new FuelError19(
+      ErrorCode16.INVALID_INPUT_PARAMETERS,
       'The use of pagination argument "first" with "before" is not supported'
     );
   }
   if (last && after) {
-    throw new FuelError18(
-      ErrorCode15.INVALID_INPUT_PARAMETERS,
+    throw new FuelError19(
+      ErrorCode16.INVALID_INPUT_PARAMETERS,
       'The use of pagination argument "last" with "after" is not supported'
     );
   }
@@ -5096,22 +5853,48 @@ var NON_PAGINATED_BALANCES_SIZE = 1e4;
 var BLOCKS_PAGE_SIZE_LIMIT = 5;
 var DEFAULT_RESOURCE_CACHE_TTL = 2e4;
 var GAS_USED_MODIFIER = 1.2;
+var WRITE_OPERATIONS = [
+  "submit",
+  "submitAndAwaitStatus",
+  "produceBlocks"
+];
 var Provider = class _Provider {
   static {
     __name(this, "Provider");
   }
   operations;
   cache;
-  /** @hidden */
-  static clearChainAndNodeCaches() {
+  /**
+   * @hidden
+   * @param url - If provided, clears cache only for given url
+   */
+  static clearChainAndNodeCaches(url) {
+    if (url) {
+      delete _Provider.inflightFetchChainAndNodeInfoRequests[url];
+      delete _Provider.chainInfoCache[url];
+      delete _Provider.nodeInfoCache[url];
+      delete _Provider.currentBlockHeightCache[url];
+      return;
+    }
     _Provider.inflightFetchChainAndNodeInfoRequests = {};
     _Provider.nodeInfoCache = {};
     _Provider.chainInfoCache = {};
+    _Provider.currentBlockHeightCache = {};
   }
   /** @hidden */
   url;
   /** @hidden */
   urlWithoutAuth;
+  /**
+   * Governs whether to include the required block height in the request body
+   * for block-sensitive operations like when submitting a transaction.
+   *
+   * This ensures that the operation is executed at the correct block height,
+   * regardless of which node in the network the request is routed to.
+   *
+   * `true` by default.
+   */
+  static ENABLE_RPC_CONSISTENCY = true;
   /** @hidden */
   static inflightFetchChainAndNodeInfoRequests = {};
   /** @hidden */
@@ -5119,6 +5902,8 @@ var Provider = class _Provider {
   /** @hidden */
   static nodeInfoCache = {};
   /** @hidden */
+  static currentBlockHeightCache = {};
+  /** @hidden */
   static incompatibleNodeVersionMessage = "";
   /** @hidden */
   consensusParametersTimestamp;
@@ -5130,6 +5915,18 @@ var Provider = class _Provider {
     headers: void 0,
     cache: void 0
   };
+  static extractOperationName(body) {
+    return body?.toString().match(/"operationName":"(.+)"/)?.[1];
+  }
+  static isWriteOperation(body) {
+    return WRITE_OPERATIONS.includes(this.extractOperationName(body));
+  }
+  static normalizeUrl(url) {
+    return url.replace(/-sub$/, "");
+  }
+  static hasWriteOperationHappened(url) {
+    return isDefined3(_Provider.currentBlockHeightCache[this.normalizeUrl(url)]);
+  }
   /**
    * @hidden
    */
@@ -5147,9 +5944,57 @@ var Provider = class _Provider {
       if (options.requestMiddleware) {
         fullRequest = await options.requestMiddleware(fullRequest);
       }
-      return options.fetch ? options.fetch(url, fullRequest, options) : fetch(url, fullRequest);
+      if (_Provider.ENABLE_RPC_CONSISTENCY && _Provider.hasWriteOperationHappened(url)) {
+        _Provider.applyBlockHeight(fullRequest, url);
+      }
+      return _Provider.fetchAndProcessBlockHeight(url, fullRequest, options);
     }, retryOptions);
   }
+  static applyBlockHeight(request, url) {
+    const normalizedUrl = this.normalizeUrl(url);
+    const currentBlockHeight = _Provider.currentBlockHeightCache[normalizedUrl] ?? 0;
+    request.body = request.body?.toString().replace(/}$/, `,"extensions":{"required_fuel_block_height":${currentBlockHeight}}}`);
+  }
+  static async fetchAndProcessBlockHeight(url, request, options) {
+    const fetchFn = /* @__PURE__ */ __name(() => options.fetch ? options.fetch(url, request, options) : fetch(url, request), "fetchFn");
+    const isWriteOperation = _Provider.isWriteOperation(request.body);
+    if (isWriteOperation && !_Provider.hasWriteOperationHappened(url)) {
+      _Provider.currentBlockHeightCache[_Provider.normalizeUrl(url)] = 0;
+    }
+    let response = await fetchFn();
+    if (!_Provider.ENABLE_RPC_CONSISTENCY) {
+      return response;
+    }
+    const retryOptions = {
+      maxRetries: 5,
+      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;
+      }
+      const retryAttempt = retryOptions.maxRetries - retriesLeft + 1;
+      const sleepTime = getWaitDelay(retryOptions, retryAttempt);
+      await sleep2(sleepTime);
+      response = await fetchFn();
+    }
+    return response;
+  }
+  static setCurrentBlockHeight(url, height) {
+    const writeOperationHappened = _Provider.hasWriteOperationHappened(url);
+    if (!isDefined3(height) || !writeOperationHappened) {
+      return;
+    }
+    const normalizedUrl = _Provider.normalizeUrl(url);
+    if (height > _Provider.currentBlockHeightCache[normalizedUrl]) {
+      _Provider.currentBlockHeightCache[normalizedUrl] = height;
+    }
+  }
   /**
    * Constructor to initialize a Provider.
    *
@@ -5177,7 +6022,7 @@ var Provider = class _Provider {
       _Provider.chainInfoCache[this.urlWithoutAuth] = chain;
       _Provider.nodeInfoCache[this.urlWithoutAuth] = nodeInfo;
     }
-    if (isDefined2(resourceCacheTTL)) {
+    if (isDefined3(resourceCacheTTL)) {
       if (resourceCacheTTL !== -1) {
         this.cache = new ResourceCache(resourceCacheTTL);
       } else {
@@ -5192,7 +6037,7 @@ var Provider = class _Provider {
     try {
       parsedUrl = new URL(url);
     } catch (error) {
-      throw new FuelError19(FuelError19.CODES.INVALID_URL, "Invalid URL provided.", { url }, error);
+      throw new FuelError20(FuelError20.CODES.INVALID_URL, "Invalid URL provided.", { url }, error);
     }
     const username = parsedUrl.username;
     const password = parsedUrl.password;
@@ -5235,6 +6080,7 @@ var Provider = class _Provider {
    * Returns some helpful parameters related to gas fees.
    */
   async getGasConfig() {
+    await this.init();
     const {
       txParameters: { maxGasPerTx },
       predicateParameters: { maxGasPerPredicate },
@@ -5297,8 +6143,8 @@ var Provider = class _Provider {
       this.consensusParametersTimestamp = data.consensusParametersTimestamp;
       return data;
     }).catch((err) => {
-      const error = new FuelError19(
-        FuelError19.CODES.CONNECTION_REFUSED,
+      const error = new FuelError20(
+        FuelError20.CODES.CONNECTION_REFUSED,
         "Unable to fetch chain and node info from the network",
         { url: this.urlWithoutAuth },
         err
@@ -5359,7 +6205,14 @@ var Provider = class _Provider {
           url: this.urlWithoutAuth,
           query,
           fetchFn: /* @__PURE__ */ __name((url, requestInit) => fetchFn(url, requestInit, this.options), "fetchFn"),
-          variables: vars
+          variables: vars,
+          operationName: opDefinition.name.value,
+          onEvent: /* @__PURE__ */ __name((event) => {
+            _Provider.setCurrentBlockHeight(
+              this.urlWithoutAuth,
+              event.extensions?.current_fuel_block_height
+            );
+          }, "onEvent")
         });
       }
       return gqlClient.request(query, vars);
@@ -5407,7 +6260,7 @@ var Provider = class _Provider {
         latestBlock: { height }
       }
     } = await this.operations.getLatestBlockHeight();
-    return bn17(height);
+    return bn18(height);
   }
   /**
    * Returns the node information for the current provider network.
@@ -5463,8 +6316,8 @@ var Provider = class _Provider {
   async getAssetDetails(assetId) {
     const { assetMetadata } = await this.getNodeFeatures();
     if (!assetMetadata) {
-      throw new FuelError19(
-        ErrorCode16.UNSUPPORTED_FEATURE,
+      throw new FuelError20(
+        ErrorCode17.UNSUPPORTED_FEATURE,
         "The current node does not supports fetching asset details"
       );
     }
@@ -5473,7 +6326,7 @@ var Provider = class _Provider {
     return {
       subId,
       contractId,
-      totalSupply: bn17(totalSupply)
+      totalSupply: bn18(totalSupply)
     };
   }
   /**
@@ -5494,15 +6347,15 @@ var Provider = class _Provider {
         txParameters: { maxInputs, maxOutputs }
       }
     } = await this.getChain();
-    if (bn17(tx.inputs.length).gt(maxInputs)) {
-      throw new FuelError19(
-        ErrorCode16.MAX_INPUTS_EXCEEDED,
+    if (bn18(tx.inputs.length).gt(maxInputs)) {
+      throw new FuelError20(
+        ErrorCode17.MAX_INPUTS_EXCEEDED,
         `The transaction exceeds the maximum allowed number of inputs. Tx inputs: ${tx.inputs.length}, max inputs: ${maxInputs}`
       );
     }
-    if (bn17(tx.outputs.length).gt(maxOutputs)) {
-      throw new FuelError19(
-        ErrorCode16.MAX_OUTPUTS_EXCEEDED,
+    if (bn18(tx.outputs.length).gt(maxOutputs)) {
+      throw new FuelError20(
+        ErrorCode17.MAX_OUTPUTS_EXCEEDED,
         `The transaction exceeds the maximum allowed number of outputs. Tx outputs: ${tx.outputs.length}, max outputs: ${maxOutputs}`
       );
     }
@@ -5517,7 +6370,11 @@ var Provider = class _Provider {
    * @param sendTransactionParams - The provider send transaction parameters (optional).
    * @returns A promise that resolves to the transaction response object.
    */
-  async sendTransaction(transactionRequestLike, { estimateTxDependencies = true, enableAssetBurn } = {}) {
+  async sendTransaction(transactionRequestLike, {
+    enableAssetBurn,
+    estimateTxDependencies = true,
+    includePreConfirmation: _includePreConfirmation = true
+  } = {}) {
     const transactionRequest = transactionRequestify(transactionRequestLike);
     validateTransactionForAssetBurn(
       await this.getBaseAssetId(),
@@ -5528,12 +6385,15 @@ var Provider = class _Provider {
       await this.estimateTxDependencies(transactionRequest);
     }
     await this.validateTransaction(transactionRequest);
-    const encodedTransaction = hexlify18(transactionRequest.toTransactionBytes());
+    const encodedTransaction = hexlify19(transactionRequest.toTransactionBytes());
     let abis;
     if (isTransactionTypeScript(transactionRequest)) {
       abis = transactionRequest.abis;
     }
-    const subscription = await this.operations.submitAndAwaitStatus({ encodedTransaction });
+    const subscription = await this.operations.submitAndAwaitStatus({
+      encodedTransaction,
+      includePreConfirmation: true
+    });
     this.#cacheInputs(
       transactionRequest.inputs,
       transactionRequest.getTransactionId(await this.getChainId())
@@ -5556,7 +6416,7 @@ var Provider = class _Provider {
     if (estimateTxDependencies) {
       return this.estimateTxDependencies(transactionRequest);
     }
-    const encodedTransaction = hexlify18(transactionRequest.toTransactionBytes());
+    const encodedTransaction = hexlify19(transactionRequest.toTransactionBytes());
     const { dryRun: dryRunStatuses } = await this.operations.dryRun({
       encodedTransactions: encodedTransaction,
       utxoValidation: utxoValidation || false
@@ -5575,12 +6435,12 @@ var Provider = class _Provider {
    */
   async estimatePredicates(transactionRequest) {
     const shouldEstimatePredicates = transactionRequest.inputs.some(
-      (input) => isPredicate(input) && bn17(input.predicateGasUsed).isZero()
+      (input) => isPredicate(input) && bn18(input.predicateGasUsed).isZero()
     );
     if (!shouldEstimatePredicates) {
       return transactionRequest;
     }
-    const encodedTransaction = hexlify18(transactionRequest.toTransactionBytes());
+    const encodedTransaction = hexlify19(transactionRequest.toTransactionBytes());
     const response = await this.operations.estimatePredicates({
       encodedTransaction
     });
@@ -5601,7 +6461,7 @@ var Provider = class _Provider {
    */
   async estimatePredicatesAndGasPrice(transactionRequest, blockHorizon) {
     const shouldEstimatePredicates = transactionRequest.inputs.some(
-      (input) => isPredicate(input) && bn17(input.predicateGasUsed).isZero()
+      (input) => isPredicate(input) && bn18(input.predicateGasUsed).isZero()
     );
     if (!shouldEstimatePredicates) {
       const gasPrice2 = await this.estimateGasPrice(blockHorizon);
@@ -5612,13 +6472,13 @@ var Provider = class _Provider {
       estimatePredicates
     } = await this.operations.estimatePredicatesAndGasPrice({
       blockHorizon: String(blockHorizon),
-      encodedTransaction: hexlify18(transactionRequest.toTransactionBytes())
+      encodedTransaction: hexlify19(transactionRequest.toTransactionBytes())
     });
     transactionRequest = this.parseEstimatePredicatesResponse(
       transactionRequest,
       estimatePredicates
     );
-    return { transactionRequest, gasPrice: bn17(gasPrice) };
+    return { transactionRequest, gasPrice: bn18(gasPrice) };
   }
   /**
    * Will dryRun a transaction and check for missing dependencies.
@@ -5650,7 +6510,7 @@ var Provider = class _Provider {
       const {
         dryRun: [{ receipts: serializedReceipts, status }]
       } = await this.operations.dryRun({
-        encodedTransactions: [hexlify18(transactionRequest.toTransactionBytes())],
+        encodedTransactions: [hexlify19(transactionRequest.toTransactionBytes())],
         utxoValidation: false,
         gasPrice: gasPrice.toString()
       });
@@ -5705,7 +6565,7 @@ var Provider = class _Provider {
     const serializedTransactionsMap = /* @__PURE__ */ new Map();
     allRequests.forEach((req, index) => {
       if (isTransactionTypeScript(req)) {
-        serializedTransactionsMap.set(index, hexlify18(req.toTransactionBytes()));
+        serializedTransactionsMap.set(index, hexlify19(req.toTransactionBytes()));
       }
     });
     let transactionsToProcess = Array.from(serializedTransactionsMap.keys());
@@ -5741,7 +6601,7 @@ var Provider = class _Provider {
             transactionRequest: request
           });
           request.maxFee = maxFee;
-          serializedTransactionsMap.set(requestIdx, hexlify18(request.toTransactionBytes()));
+          serializedTransactionsMap.set(requestIdx, hexlify19(request.toTransactionBytes()));
           nextRoundTransactions.push(requestIdx);
         }
       }
@@ -5762,7 +6622,7 @@ var Provider = class _Provider {
     if (estimateTxDependencies) {
       return this.estimateMultipleTxDependencies(transactionRequests);
     }
-    const encodedTransactions = transactionRequests.map((tx) => hexlify18(tx.toTransactionBytes()));
+    const encodedTransactions = transactionRequests.map((tx) => hexlify19(tx.toTransactionBytes()));
     const { dryRun: dryRunStatuses } = await this.operations.dryRun({
       encodedTransactions,
       utxoValidation: utxoValidation || false
@@ -5810,16 +6670,16 @@ var Provider = class _Provider {
     const chainInfo = await this.getChain();
     const { gasPriceFactor, maxGasPerTx } = await this.getGasConfig();
     const minGas = transactionRequest.calculateMinGas(chainInfo);
-    if (!isDefined2(gasPrice)) {
+    if (!isDefined3(gasPrice)) {
       gasPrice = await this.estimateGasPrice(10);
     }
     const minFee = calculateGasFee({
-      gasPrice: bn17(gasPrice),
+      gasPrice: bn18(gasPrice),
       gas: minGas,
       priceFactor: gasPriceFactor,
       tip: transactionRequest.tip
     }).add(1);
-    let gasLimit = bn17(0);
+    let gasLimit = bn18(0);
     if (isTransactionTypeScript(transactionRequest)) {
       gasLimit = transactionRequest.gasLimit;
       if (transactionRequest.gasLimit.eq(0)) {
@@ -5832,7 +6692,7 @@ var Provider = class _Provider {
     }
     const maxGas = transactionRequest.calculateMaxGas(chainInfo, minGas);
     const maxFee = calculateGasFee({
-      gasPrice: bn17(gasPrice),
+      gasPrice: bn18(gasPrice),
       gas: maxGas,
       priceFactor: gasPriceFactor,
       tip: transactionRequest.tip
@@ -5862,7 +6722,7 @@ var Provider = class _Provider {
     if (estimateTxDependencies) {
       return this.estimateTxDependencies(transactionRequest);
     }
-    const encodedTransactions = [hexlify18(transactionRequest.toTransactionBytes())];
+    const encodedTransactions = [hexlify19(transactionRequest.toTransactionBytes())];
     const { dryRun: dryRunStatuses } = await this.operations.dryRun({
       encodedTransactions,
       utxoValidation: true
@@ -5885,13 +6745,16 @@ var Provider = class _Provider {
    * @param transactionCostParams - The transaction cost parameters (optional).
    *
    * @returns A promise that resolves to the transaction cost object.
+   *
+   * @deprecated Use provider.assembleTx instead
+   * Check the migration guide https://docs.fuel.network/guide/assembling-transactions/migration-guide.html for more information.
    */
   async getTransactionCost(transactionRequestLike, { signatureCallback, gasPrice: gasPriceParam } = {}) {
     const txRequestClone = clone8(transactionRequestify(transactionRequestLike));
     const updateMaxFee = txRequestClone.maxFee.eq(0);
     const isScriptTransaction = isTransactionTypeScript(txRequestClone);
     if (isScriptTransaction) {
-      txRequestClone.gasLimit = bn17(0);
+      txRequestClone.gasLimit = bn18(0);
     }
     const signedRequest = clone8(txRequestClone);
     let addedSignatures = 0;
@@ -5918,7 +6781,7 @@ var Provider = class _Provider {
     let dryRunStatus;
     let missingContractIds = [];
     let outputVariables = 0;
-    let gasUsed = bn17(0);
+    let gasUsed = bn18(0);
     txRequestClone.maxFee = maxFee;
     if (isScriptTransaction) {
       txRequestClone.gasLimit = gasLimit;
@@ -5927,11 +6790,11 @@ var Provider = class _Provider {
       }
       ({ rawReceipts, receipts, missingContractIds, outputVariables, dryRunStatus } = await this.estimateTxDependencies(txRequestClone, { gasPrice }));
       if (dryRunStatus && "reason" in dryRunStatus) {
-        throw this.extractDryRunError(txRequestClone, receipts, dryRunStatus);
+        throw this.extractDryRunError(txRequestClone, receipts, dryRunStatus.reason);
       }
       const { maxGasPerTx } = await this.getGasConfig();
       const pristineGasUsed = getGasUsedFromReceipts(receipts);
-      gasUsed = bn17(pristineGasUsed.muln(GAS_USED_MODIFIER)).max(maxGasPerTx.sub(minGas));
+      gasUsed = bn18(pristineGasUsed.muln(GAS_USED_MODIFIER)).max(maxGasPerTx.sub(minGas));
       txRequestClone.gasLimit = gasUsed;
       ({ maxFee, maxGas, minFee, minGas } = await this.estimateTxGasAndFee({
         transactionRequest: txRequestClone,
@@ -5960,6 +6823,102 @@ var Provider = class _Provider {
       transactionSummary
     };
   }
+  /**
+   * Assembles a transaction by completely estimating and funding it.
+   *
+   * @param params - Parameters used to assemble the transaction.
+   *
+   * @returns The assembled transaction request, estimated gas price, and receipts
+   */
+  async assembleTx(params) {
+    const {
+      request,
+      reserveGas,
+      resourcesIdsToIgnore,
+      feePayerAccount,
+      blockHorizon = 10,
+      estimatePredicates = true,
+      accountCoinQuantities = []
+    } = params;
+    const allAddresses = /* @__PURE__ */ new Set();
+    const baseAssetId = await this.getBaseAssetId();
+    let feePayerIndex = -1;
+    let baseAssetChange;
+    const requiredBalances = accountCoinQuantities.map((quantity, index) => {
+      const { amount, assetId, account = feePayerAccount, changeOutputAccount } = quantity;
+      const changeAccountAddress = changeOutputAccount ? changeOutputAccount.address.toB256() : account.address.toB256();
+      allAddresses.add(account.address.toB256());
+      const changePolicy = {
+        change: changeAccountAddress
+      };
+      if (assetId === baseAssetId) {
+        baseAssetChange = changePolicy.change;
+      }
+      if (account.address.equals(feePayerAccount.address)) {
+        feePayerIndex = index;
+      }
+      const requiredBalance = {
+        account: resolveAccountForAssembleTxParams(account),
+        amount: bn18(amount).toString(10),
+        assetId,
+        changePolicy
+      };
+      return requiredBalance;
+    });
+    if (feePayerIndex === -1) {
+      allAddresses.add(feePayerAccount.address.toB256());
+      const newLength = requiredBalances.push({
+        account: resolveAccountForAssembleTxParams(feePayerAccount),
+        amount: bn18(0).toString(10),
+        // Since the correct fee amount cannot be determined yet, we can use 0
+        assetId: baseAssetId,
+        changePolicy: {
+          change: baseAssetChange || feePayerAccount.address.toB256()
+        }
+      });
+      feePayerIndex = newLength - 1;
+    }
+    const excludeInput = await this.adjustResourcesToIgnoreForAddresses(
+      Array.from(allAddresses),
+      resourcesIdsToIgnore
+    );
+    const {
+      assembleTx: { status, transaction: gqlTransaction, gasPrice }
+    } = await this.operations.assembleTx({
+      tx: hexlify19(request.toTransactionBytes()),
+      blockHorizon: String(blockHorizon),
+      feeAddressIndex: String(feePayerIndex),
+      requiredBalances,
+      estimatePredicates,
+      excludeInput,
+      reserveGas: reserveGas ? reserveGas.toString(10) : void 0
+    });
+    if (status.type === "DryRunFailureStatus") {
+      const parsedReceipts = status.receipts.map(deserializeReceipt);
+      throw this.extractDryRunError(request, parsedReceipts, status.reason);
+    }
+    request.witnesses = gqlTransaction.witnesses || request.witnesses;
+    request.inputs = gqlTransaction.inputs?.map(deserializeInput) || request.inputs;
+    request.outputs = gqlTransaction.outputs?.map(deserializeOutput) || request.outputs;
+    if (gqlTransaction.policies?.maxFee) {
+      request.maxFee = bn18(gqlTransaction.policies.maxFee);
+    }
+    if (gqlTransaction.scriptGasLimit) {
+      request.gasLimit = bn18(gqlTransaction.scriptGasLimit);
+    }
+    const rawReceipts = status.receipts;
+    const chainId = await this.getChainId();
+    request.updateState(chainId, "funded", {
+      gasPrice: gasPrice.toString(),
+      receipts: rawReceipts
+    });
+    return {
+      assembledRequest: request,
+      gasPrice: bn18(gasPrice),
+      receipts: status.receipts.map(deserializeReceipt),
+      rawReceipts
+    };
+  }
   /**
    * Returns coins for the given owner.
    *
@@ -5978,15 +6937,15 @@ var Provider = class _Provider {
         paginationLimit: RESOURCES_PAGE_SIZE_LIMIT,
         inputArgs: paginationArgs
       }),
-      filter: { owner: ownerAddress.toB256(), assetId: assetId && hexlify18(assetId) }
+      filter: { owner: ownerAddress.toB256(), assetId: assetId && hexlify19(assetId) }
     });
     const coins = edges.map(({ node }) => ({
       id: node.utxoId,
       assetId: node.assetId,
-      amount: bn17(node.amount),
+      amount: bn18(node.amount),
       owner: ownerAddress,
-      blockCreated: bn17(node.blockCreated),
-      txCreatedIdx: bn17(node.txCreatedIdx)
+      blockCreated: bn18(node.blockCreated),
+      txCreatedIdx: bn18(node.txCreatedIdx)
     }));
     return {
       coins,
@@ -5998,47 +6957,32 @@ var Provider = class _Provider {
    *
    * @param owner - The address to get resources for.
    * @param quantities - The coin quantities to get.
-   * @param excludedIds - IDs of excluded resources from the selection (optional).
+   * @param resourcesIdsToIgnore - IDs of excluded resources from the selection (optional).
    * @returns A promise that resolves to the resources.
    */
-  async getResourcesToSpend(owner, quantities, excludedIds) {
+  async getResourcesToSpend(owner, quantities, resourcesIdsToIgnore) {
     const ownerAddress = new Address3(owner);
-    let idsToExclude = {
-      messages: excludedIds?.messages?.map((nonce) => hexlify18(nonce)) || [],
-      utxos: excludedIds?.utxos?.map((id) => hexlify18(id)) || []
-    };
-    if (this.cache) {
-      const cached = this.cache.getActiveData(ownerAddress.toB256());
-      if (cached.utxos.length || cached.messages.length) {
-        const {
-          consensusParameters: {
-            txParameters: { maxInputs }
-          }
-        } = await this.getChain();
-        idsToExclude = adjustResourcesToExclude({
-          userInput: idsToExclude,
-          cached,
-          maxInputs: maxInputs.toNumber()
-        });
-      }
-    }
+    const excludedIds = await this.adjustResourcesToIgnoreForAddresses(
+      [ownerAddress.b256Address],
+      resourcesIdsToIgnore
+    );
     const coinsQuery = {
       owner: ownerAddress.toB256(),
       queryPerAsset: quantities.map(coinQuantityfy).map(({ assetId, amount, max: maxPerAsset }) => ({
-        assetId: hexlify18(assetId),
-        amount: (amount.eqn(0) ? bn17(1) : amount).toString(10),
+        assetId: hexlify19(assetId),
+        amount: (amount.eqn(0) ? bn18(1) : amount).toString(10),
         max: maxPerAsset ? maxPerAsset.toString(10) : void 0
       })),
-      excludedIds: idsToExclude
+      excludedIds
     };
     const result = await this.operations.getCoinsToSpend(coinsQuery);
     const coins = result.coinsToSpend.flat().map((coin) => {
       switch (coin.type) {
         case "MessageCoin":
           return {
-            amount: bn17(coin.amount),
+            amount: bn18(coin.amount),
             assetId: coin.assetId,
-            daHeight: bn17(coin.daHeight),
+            daHeight: bn18(coin.daHeight),
             sender: new Address3(coin.sender),
             recipient: new Address3(coin.recipient),
             nonce: coin.nonce
@@ -6046,11 +6990,11 @@ var Provider = class _Provider {
         case "Coin":
           return {
             id: coin.utxoId,
-            amount: bn17(coin.amount),
+            amount: bn18(coin.amount),
             assetId: coin.assetId,
             owner: ownerAddress,
-            blockCreated: bn17(coin.blockCreated),
-            txCreatedIdx: bn17(coin.txCreatedIdx)
+            blockCreated: bn18(coin.blockCreated),
+            txCreatedIdx: bn18(coin.txCreatedIdx)
           };
         default:
           return null;
@@ -6088,7 +7032,7 @@ var Provider = class _Provider {
       block = latestBlock;
     } else {
       const isblockId = typeof idOrHeight === "string" && isB256(idOrHeight);
-      const variables = isblockId ? { blockId: idOrHeight } : { height: bn17(idOrHeight).toString(10) };
+      const variables = isblockId ? { blockId: idOrHeight } : { height: bn18(idOrHeight).toString(10) };
       const response = await this.operations.getBlock(variables);
       block = response.block;
     }
@@ -6098,11 +7042,11 @@ var Provider = class _Provider {
     const { header, height, id, transactions } = block;
     return {
       id,
-      height: bn17(height),
+      height: bn18(height),
       time: header.time,
       header: {
         applicationHash: header.applicationHash,
-        daHeight: bn17(header.daHeight),
+        daHeight: bn18(header.daHeight),
         eventInboxRoot: header.eventInboxRoot,
         messageOutboxRoot: header.messageOutboxRoot,
         prevRoot: header.prevRoot,
@@ -6130,11 +7074,11 @@ var Provider = class _Provider {
     });
     const blocks = edges.map(({ node: block }) => ({
       id: block.id,
-      height: bn17(block.height),
+      height: bn18(block.height),
       time: block.header.time,
       header: {
         applicationHash: block.header.applicationHash,
-        daHeight: bn17(block.header.daHeight),
+        daHeight: bn18(block.header.daHeight),
         eventInboxRoot: block.header.eventInboxRoot,
         messageOutboxRoot: block.header.messageOutboxRoot,
         prevRoot: block.header.prevRoot,
@@ -6155,13 +7099,13 @@ var Provider = class _Provider {
   async getBlockWithTransactions(idOrHeight) {
     let variables;
     if (typeof idOrHeight === "number") {
-      variables = { blockHeight: bn17(idOrHeight).toString(10) };
+      variables = { blockHeight: bn18(idOrHeight).toString(10) };
     } else if (idOrHeight === "latest") {
       variables = { blockHeight: (await this.getBlockNumber()).toString() };
     } else if (typeof idOrHeight === "string" && isB256(idOrHeight)) {
       variables = { blockId: idOrHeight };
     } else {
-      variables = { blockHeight: bn17(idOrHeight).toString() };
+      variables = { blockHeight: bn18(idOrHeight).toString() };
     }
     const { block } = await this.operations.getBlockWithTransactions(variables);
     if (!block) {
@@ -6169,11 +7113,11 @@ var Provider = class _Provider {
     }
     return {
       id: block.id,
-      height: bn17(block.height, 10),
+      height: bn18(block.height, 10),
       time: block.header.time,
       header: {
         applicationHash: block.header.applicationHash,
-        daHeight: bn17(block.header.daHeight),
+        daHeight: bn18(block.header.daHeight),
         eventInboxRoot: block.header.eventInboxRoot,
         messageOutboxRoot: block.header.messageOutboxRoot,
         prevRoot: block.header.prevRoot,
@@ -6183,7 +7127,7 @@ var Provider = class _Provider {
       },
       transactionIds: block.transactions.map((tx) => tx.id),
       transactions: block.transactions.map(
-        (tx) => new TransactionCoder5().decode(arrayify13(tx.rawPayload), 0)?.[0]
+        (tx) => new TransactionCoder6().decode(arrayify13(tx.rawPayload), 0)?.[0]
       )
     };
   }
@@ -6199,12 +7143,12 @@ var Provider = class _Provider {
       return null;
     }
     try {
-      return new TransactionCoder5().decode(
+      return new TransactionCoder6().decode(
         arrayify13(transaction.rawPayload),
         0
       )?.[0];
     } catch (error) {
-      if (error instanceof FuelError19 && error.code === ErrorCode16.UNSUPPORTED_TRANSACTION_TYPE) {
+      if (error instanceof FuelError20 && error.code === ErrorCode17.UNSUPPORTED_TRANSACTION_TYPE) {
         console.warn("Unsupported transaction type encountered");
         return null;
       }
@@ -6225,12 +7169,12 @@ var Provider = class _Provider {
         paginationLimit: TRANSACTIONS_PAGE_SIZE_LIMIT
       })
     });
-    const coder = new TransactionCoder5();
+    const coder = new TransactionCoder6();
     const transactions = edges.map(({ node: { rawPayload } }) => {
       try {
         return coder.decode(arrayify13(rawPayload), 0)[0];
       } catch (error) {
-        if (error instanceof FuelError19 && error.code === ErrorCode16.UNSUPPORTED_TRANSACTION_TYPE) {
+        if (error instanceof FuelError20 && error.code === ErrorCode17.UNSUPPORTED_TRANSACTION_TYPE) {
           console.warn("Unsupported transaction type encountered");
           return null;
         }
@@ -6277,9 +7221,9 @@ var Provider = class _Provider {
   async getContractBalance(contractId, assetId) {
     const { contractBalance } = await this.operations.getContractBalance({
       contract: new Address3(contractId).toB256(),
-      asset: hexlify18(assetId)
+      asset: hexlify19(assetId)
     });
-    return bn17(contractBalance.amount, 10);
+    return bn18(contractBalance.amount, 10);
   }
   /**
    * Returns the balance for the given owner for the given asset ID.
@@ -6291,9 +7235,9 @@ var Provider = class _Provider {
   async getBalance(owner, assetId) {
     const { balance } = await this.operations.getBalanceV2({
       owner: new Address3(owner).toB256(),
-      assetId: hexlify18(assetId)
+      assetId: hexlify19(assetId)
     });
-    return bn17(balance.amountU128, 10);
+    return bn18(balance.amountU128, 10);
   }
   /**
    * Returns balances for the given owner.
@@ -6320,7 +7264,7 @@ var Provider = class _Provider {
     });
     const balances = edges.map(({ node }) => ({
       assetId: node.assetId,
-      amount: bn17(node.amountU128)
+      amount: bn18(node.amountU128)
     }));
     return {
       balances,
@@ -6349,15 +7293,15 @@ var Provider = class _Provider {
         sender: node.sender,
         recipient: node.recipient,
         nonce: node.nonce,
-        amount: bn17(node.amount),
+        amount: bn18(node.amount),
         data: node.data
       }),
       sender: new Address3(node.sender),
       recipient: new Address3(node.recipient),
       nonce: node.nonce,
-      amount: bn17(node.amount),
+      amount: bn18(node.amount),
       data: InputMessageCoder2.decodeData(node.data),
-      daHeight: bn17(node.daHeight)
+      daHeight: bn18(node.daHeight)
     }));
     return {
       messages,
@@ -6379,8 +7323,8 @@ var Provider = class _Provider {
       nonce
     };
     if (commitBlockId && commitBlockHeight) {
-      throw new FuelError19(
-        ErrorCode16.INVALID_INPUT_PARAMETERS,
+      throw new FuelError20(
+        ErrorCode17.INVALID_INPUT_PARAMETERS,
         "commitBlockId and commitBlockHeight cannot be used together"
       );
     }
@@ -6411,19 +7355,19 @@ var Provider = class _Provider {
     } = result.messageProof;
     return {
       messageProof: {
-        proofIndex: bn17(messageProof.proofIndex),
+        proofIndex: bn18(messageProof.proofIndex),
         proofSet: messageProof.proofSet
       },
       blockProof: {
-        proofIndex: bn17(blockProof.proofIndex),
+        proofIndex: bn18(blockProof.proofIndex),
         proofSet: blockProof.proofSet
       },
       messageBlockHeader: {
         id: messageBlockHeader.id,
-        daHeight: bn17(messageBlockHeader.daHeight),
+        daHeight: bn18(messageBlockHeader.daHeight),
         transactionsCount: Number(messageBlockHeader.transactionsCount),
         transactionsRoot: messageBlockHeader.transactionsRoot,
-        height: bn17(messageBlockHeader.height),
+        height: bn18(messageBlockHeader.height),
         prevRoot: messageBlockHeader.prevRoot,
         time: messageBlockHeader.time,
         applicationHash: messageBlockHeader.applicationHash,
@@ -6435,10 +7379,10 @@ var Provider = class _Provider {
       },
       commitBlockHeader: {
         id: commitBlockHeader.id,
-        daHeight: bn17(commitBlockHeader.daHeight),
+        daHeight: bn18(commitBlockHeader.daHeight),
         transactionsCount: Number(commitBlockHeader.transactionsCount),
         transactionsRoot: commitBlockHeader.transactionsRoot,
-        height: bn17(commitBlockHeader.height),
+        height: bn18(commitBlockHeader.height),
         prevRoot: commitBlockHeader.prevRoot,
         time: commitBlockHeader.time,
         applicationHash: commitBlockHeader.applicationHash,
@@ -6451,7 +7395,7 @@ var Provider = class _Provider {
       sender: new Address3(sender),
       recipient: new Address3(recipient),
       nonce,
-      amount: bn17(amount),
+      amount: bn18(amount),
       data
     };
   }
@@ -6462,7 +7406,7 @@ var Provider = class _Provider {
    */
   async getLatestGasPrice() {
     const { latestGasPrice } = await this.operations.getLatestGasPrice();
-    return bn17(latestGasPrice.gasPrice);
+    return bn18(latestGasPrice.gasPrice);
   }
   /**
    * Returns the estimate gas price for the given block horizon.
@@ -6474,7 +7418,7 @@ var Provider = class _Provider {
     const { estimateGasPrice } = await this.operations.estimateGasPrice({
       blockHorizon: String(blockHorizon)
     });
-    return bn17(estimateGasPrice.gasPrice);
+    return bn18(estimateGasPrice.gasPrice);
   }
   /**
    * Returns Message Proof for given transaction id and the message id from MessageOut receipt.
@@ -6495,10 +7439,10 @@ var Provider = class _Provider {
    */
   async produceBlocks(amount, startTime) {
     const { produceBlocks: latestBlockHeight } = await this.operations.produceBlocks({
-      blocksToProduce: bn17(amount).toString(10),
+      blocksToProduce: bn18(amount).toString(10),
       startTimestamp: startTime ? DateTime2.fromUnixMilliseconds(startTime).toTai64() : void 0
     });
-    return bn17(latestBlockHeight);
+    return bn18(latestBlockHeight);
   }
   /**
    * Check if the given ID is an account.
@@ -6566,15 +7510,15 @@ var Provider = class _Provider {
         sender: rawMessage.sender,
         recipient: rawMessage.recipient,
         nonce,
-        amount: bn17(rawMessage.amount),
+        amount: bn18(rawMessage.amount),
         data: rawMessage.data
       }),
       sender: new Address3(rawMessage.sender),
       recipient: new Address3(rawMessage.recipient),
       nonce,
-      amount: bn17(rawMessage.amount),
+      amount: bn18(rawMessage.amount),
       data: InputMessageCoder2.decodeData(rawMessage.data),
-      daHeight: bn17(rawMessage.daHeight)
+      daHeight: bn18(rawMessage.daHeight)
     };
     return message;
   }
@@ -6596,11 +7540,10 @@ var Provider = class _Provider {
   /**
    * @hidden
    */
-  extractDryRunError(transactionRequest, receipts, dryRunStatus) {
-    const status = dryRunStatus;
+  extractDryRunError(transactionRequest, receipts, reason) {
     let logs = [];
     let groupedLogs = {};
-    if (transactionRequest.abis) {
+    if (transactionRequest.type === TransactionType11.Script && transactionRequest.abis) {
       ({ logs, groupedLogs } = getAllDecodedLogs({
         receipts,
         mainAbi: transactionRequest.abis.main,
@@ -6611,7 +7554,7 @@ var Provider = class _Provider {
       logs,
       groupedLogs,
       receipts,
-      statusReason: status.reason
+      statusReason: reason
     });
   }
   /**
@@ -6631,29 +7574,68 @@ var Provider = class _Provider {
   parseEstimatePredicatesResponse(transactionRequest, { inputs }) {
     if (inputs) {
       inputs.forEach((input, i) => {
-        if (input && "predicateGasUsed" in input && bn17(input.predicateGasUsed).gt(0)) {
+        if (input && "predicateGasUsed" in input && bn18(input.predicateGasUsed).gt(0)) {
           transactionRequest.inputs[i].predicateGasUsed = input.predicateGasUsed;
         }
       });
     }
     return transactionRequest;
   }
+  /**
+   * @hidden
+   *
+   * This helper adjusts the resources to be excluded for a given set of addresses.
+   * Supporting multiple addresses is important because of the `assembleTx` method,
+   * which may be invoked with different addresses. It handles both messages and UTXOs,
+   * ensuring the total number of inputs does not exceed the maximum allowed by the chain's
+   * consensus parameters. The resources specified in the `resourcesIdsToIgnore` parameter have priority
+   * over those retrieved from the cache.
+   */
+  async adjustResourcesToIgnoreForAddresses(addresses, resourcesIdsToIgnore) {
+    const final = {
+      messages: resourcesIdsToIgnore?.messages?.map((nonce) => hexlify19(nonce)) || [],
+      utxos: resourcesIdsToIgnore?.utxos?.map((id) => hexlify19(id)) || []
+    };
+    if (this.cache) {
+      const cache2 = this.cache;
+      const allCached = addresses.map((address) => cache2.getActiveData(address));
+      const {
+        consensusParameters: {
+          txParameters: { maxInputs: maxInputsBn }
+        }
+      } = await this.getChain();
+      const maxInputs = maxInputsBn.toNumber();
+      for (let i = 0; i < allCached.length; i++) {
+        let total = final.utxos.length + final.messages.length;
+        if (total >= maxInputs) {
+          break;
+        }
+        final.utxos = [...final.utxos, ...allCached[i].utxos.slice(0, maxInputs - total)];
+        total = final.utxos.length + final.messages.length;
+        if (total >= maxInputs) {
+          break;
+        }
+        final.messages = [...final.messages, ...allCached[i].messages.slice(0, maxInputs - total)];
+      }
+    }
+    return final;
+  }
 };
 
 // src/providers/transaction-summary/get-transaction-summary.ts
-import { ErrorCode as ErrorCode17, FuelError as FuelError20 } from "@fuel-ts/errors";
-import { bn as bn18 } from "@fuel-ts/math";
-import { TransactionCoder as TransactionCoder6 } from "@fuel-ts/transactions";
+import { ErrorCode as ErrorCode18, FuelError as FuelError21 } from "@fuel-ts/errors";
+import { bn as bn19 } from "@fuel-ts/math";
+import { TransactionCoder as TransactionCoder7 } from "@fuel-ts/transactions";
 import { arrayify as arrayify14 } from "@fuel-ts/utils";
 
 // src/providers/transaction-summary/assemble-transaction-summary-from-serialized.ts
-import { bn as bn19 } from "@fuel-ts/math";
-import { TransactionCoder as TransactionCoder7 } from "@fuel-ts/transactions";
+import { bn as bn20 } from "@fuel-ts/math";
+import { TransactionCoder as TransactionCoder8 } from "@fuel-ts/transactions";
 import { arrayify as arrayify15 } from "@fuel-ts/utils";
 
 // src/test-utils/test-asset-id.ts
 import { randomBytes as randomBytes4 } from "@fuel-ts/crypto";
-import { hexlify as hexlify19 } from "@fuel-ts/utils";
+import { hexlify as hexlify20 } from "@fuel-ts/utils";
 var TestAssetId = class _TestAssetId {
   constructor(value) {
     this.value = value;
@@ -6670,7 +7652,7 @@ var TestAssetId = class _TestAssetId {
   static random(count = 1) {
     const assetIds = [];
     for (let i = 0; i < count; i++) {
-      assetIds.push(new _TestAssetId(hexlify19(randomBytes4(32))));
+      assetIds.push(new _TestAssetId(hexlify20(randomBytes4(32))));
     }
     return assetIds;
   }
@@ -6678,39 +7660,24 @@ var TestAssetId = class _TestAssetId {
 
 // src/test-utils/wallet-config.ts
 import { randomBytes as randomBytes8 } from "@fuel-ts/crypto";
-import { FuelError as FuelError26 } from "@fuel-ts/errors";
-import { bn as bn22 } from "@fuel-ts/math";
-import { defaultSnapshotConfigs as defaultSnapshotConfigs2, hexlify as hexlify25 } from "@fuel-ts/utils";
+import { FuelError as FuelError27 } from "@fuel-ts/errors";
+import { bn as bn23 } from "@fuel-ts/math";
+import { defaultSnapshotConfigs as defaultSnapshotConfigs2, hexlify as hexlify26 } from "@fuel-ts/utils";
 
 // src/wallet/base-wallet-unlocked.ts
 import { hashMessage } from "@fuel-ts/hasher";
-import { hexlify as hexlify22 } from "@fuel-ts/utils";
+import { hexlify as hexlify23 } from "@fuel-ts/utils";
 
 // src/account.ts
 import { UTXO_ID_LEN as UTXO_ID_LEN3 } from "@fuel-ts/abi-coder";
 import { Address as Address5 } from "@fuel-ts/address";
 import { randomBytes as randomBytes5 } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode18, FuelError as FuelError21 } from "@fuel-ts/errors";
-import { bn as bn20 } from "@fuel-ts/math";
-import { InputType as InputType7 } from "@fuel-ts/transactions";
-import { arrayify as arrayify17, hexlify as hexlify20, isDefined as isDefined3 } from "@fuel-ts/utils";
+import { ErrorCode as ErrorCode19, FuelError as FuelError22 } from "@fuel-ts/errors";
+import { bn as bn21 } from "@fuel-ts/math";
+import { InputType as InputType8, OutputType as OutputType9 } from "@fuel-ts/transactions";
+import { arrayify as arrayify17, hexlify as hexlify21, isDefined as isDefined4 } from "@fuel-ts/utils";
 import { clone as clone9 } from "ramda";
 
-// src/providers/utils/merge-quantities.ts
-var mergeQuantities = /* @__PURE__ */ __name((...coinQuantities) => {
-  const resultMap = {};
-  function addToMap({ amount, assetId }) {
-    if (resultMap[assetId]) {
-      resultMap[assetId] = resultMap[assetId].add(amount);
-    } else {
-      resultMap[assetId] = amount;
-    }
-  }
-  __name(addToMap, "addToMap");
-  coinQuantities.forEach((arr) => arr.forEach(addToMap));
-  return Object.entries(resultMap).map(([assetId, amount]) => ({ assetId, amount }));
-}, "mergeQuantities");
-
 // src/types.ts
 var AbstractAccount = class {
   static {
@@ -6758,6 +7725,18 @@ var assembleTransferToContractScript = /* @__PURE__ */ __name(async (transferPar
   return { script, scriptData };
 }, "assembleTransferToContractScript");
 
+// src/utils/split-coins-into-batches.ts
+var splitCoinsIntoBatches = /* @__PURE__ */ __name((coins, maxBatchLength) => {
+  const batchesNum = Math.ceil(coins.length / maxBatchLength);
+  const batches = [];
+  for (let i = 0; i < batchesNum; i += 1) {
+    const batchStart = i * maxBatchLength;
+    const batchEnd = (i + 1) * maxBatchLength;
+    batches.push(coins.slice(batchStart, batchEnd));
+  }
+  return batches;
+}, "splitCoinsIntoBatches");
+
 // src/account.ts
 var MAX_FUNDING_ATTEMPTS = 5;
 var Account = class extends AbstractAccount {
@@ -6798,7 +7777,7 @@ var Account = class extends AbstractAccount {
    */
   get provider() {
     if (!this._provider) {
-      throw new FuelError21(ErrorCode18.MISSING_PROVIDER, "Provider not set");
+      throw new FuelError22(ErrorCode19.MISSING_PROVIDER, "Provider not set");
     }
     return this._provider;
   }
@@ -6824,11 +7803,11 @@ var Account = class extends AbstractAccount {
    * Retrieves resources satisfying the spend query for the account.
    *
    * @param quantities - Quantities of resources to be obtained.
-   * @param excludedIds - IDs of resources to be excluded from the query (optional).
+   * @param resourcesIdsToIgnore - IDs of resources to be excluded from the query (optional).
    * @returns A promise that resolves to an array of Resources.
    */
-  async getResourcesToSpend(quantities, excludedIds) {
-    return this.provider.getResourcesToSpend(this.address, quantities, excludedIds);
+  async getResourcesToSpend(quantities, resourcesIdsToIgnore) {
+    return this.provider.getResourcesToSpend(this.address, quantities, resourcesIdsToIgnore);
   }
   /**
    * Retrieves coins owned by the account.
@@ -6873,6 +7852,9 @@ var Account = class extends AbstractAccount {
    * @param request - The transaction request to fund.
    * @param params - The estimated transaction parameters.
    * @returns A promise that resolves to the funded transaction request.
+   *
+   * @deprecated Use provider.assembleTx instead
+   * Check the migration guide https://docs.fuel.network/guide/assembling-transactions/migration-guide.html for more information.
    */
   async fund(request, params) {
     const {
@@ -6886,9 +7868,9 @@ var Account = class extends AbstractAccount {
     const chainId = await this.provider.getChainId();
     const fee = request.maxFee;
     const baseAssetId = await this.provider.getBaseAssetId();
-    const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || bn20(0);
+    const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || bn21(0);
     const requiredQuantitiesWithFee = addAmountToCoinQuantities({
-      amount: bn20(fee),
+      amount: bn21(fee),
       assetId: baseAssetId,
       coinQuantities: requiredQuantities
     });
@@ -6896,7 +7878,7 @@ var Account = class extends AbstractAccount {
     requiredQuantitiesWithFee.forEach(({ amount, assetId }) => {
       quantitiesDict[assetId] = {
         required: amount,
-        owned: bn20(0)
+        owned: bn21(0)
       };
     });
     request.inputs.filter(isRequestInputResource).forEach((input) => {
@@ -6957,8 +7939,8 @@ var Account = class extends AbstractAccount {
       fundingAttempts += 1;
     }
     if (needsToBeFunded) {
-      throw new FuelError21(
-        ErrorCode18.INSUFFICIENT_FUNDS_OR_MAX_COINS,
+      throw new FuelError22(
+        ErrorCode19.INSUFFICIENT_FUNDS_OR_MAX_COINS,
         `The account ${this.address} does not have enough base asset funds to cover the transaction execution.`
       );
     }
@@ -6995,7 +7977,14 @@ var Account = class extends AbstractAccount {
       amount,
       assetId: assetId || await this.provider.getBaseAssetId()
     });
-    request = await this.estimateAndFundTransaction(request, txParams);
+    const { gasPrice, transactionRequest } = await this.assembleTx(request);
+    request = await setAndValidateGasAndFeeForAssembledTx({
+      gasPrice,
+      provider: this.provider,
+      transactionRequest,
+      setGasLimit: txParams?.gasLimit,
+      setMaxFee: txParams?.maxFee
+    });
     return request;
   }
   /**
@@ -7021,7 +8010,14 @@ var Account = class extends AbstractAccount {
   async batchTransfer(transferParams, txParams = {}) {
     let request = new ScriptTransactionRequest(txParams);
     request = this.addBatchTransfer(request, transferParams);
-    request = await this.estimateAndFundTransaction(request, txParams);
+    const { gasPrice, transactionRequest } = await this.assembleTx(request);
+    request = await setAndValidateGasAndFeeForAssembledTx({
+      gasPrice,
+      provider: this.provider,
+      transactionRequest,
+      setGasLimit: txParams?.gasLimit,
+      setMaxFee: txParams?.maxFee
+    });
     return this.sendTransaction(request, { estimateTxDependencies: false });
   }
   /**
@@ -7073,12 +8069,12 @@ var Account = class extends AbstractAccount {
     const quantities = [];
     const defaultAssetId = await this.provider.getBaseAssetId();
     const transferParams = contractTransferParams.map((transferParam) => {
-      const amount = bn20(transferParam.amount);
+      const amount = bn21(transferParam.amount);
       const contractAddress = new Address5(transferParam.contractId);
-      const assetId = transferParam.assetId ? hexlify20(transferParam.assetId) : defaultAssetId;
+      const assetId = transferParam.assetId ? hexlify21(transferParam.assetId) : defaultAssetId;
       if (amount.lte(0)) {
-        throw new FuelError21(
-          ErrorCode18.INVALID_TRANSFER_AMOUNT,
+        throw new FuelError22(
+          ErrorCode19.INVALID_TRANSFER_AMOUNT,
           "Transfer amount must be a positive number."
         );
       }
@@ -7093,7 +8089,14 @@ var Account = class extends AbstractAccount {
     const { script, scriptData } = await assembleTransferToContractScript(transferParams);
     request.script = script;
     request.scriptData = scriptData;
-    request = await this.estimateAndFundTransaction(request, txParams, { quantities });
+    const { gasPrice, transactionRequest } = await this.assembleTx(request, quantities);
+    request = await setAndValidateGasAndFeeForAssembledTx({
+      gasPrice,
+      provider: this.provider,
+      transactionRequest,
+      setGasLimit: txParams?.gasLimit,
+      setMaxFee: txParams?.maxFee
+    });
     return this.sendTransaction(request);
   }
   /**
@@ -7110,7 +8113,7 @@ var Account = class extends AbstractAccount {
       "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
     );
     const amountDataArray = arrayify17(
-      "0x".concat(bn20(amount).toHex().substring(2).padStart(16, "0"))
+      "0x".concat(bn21(amount).toHex().substring(2).padStart(16, "0"))
     );
     const script = new Uint8Array([
       ...arrayify17(withdrawScript.bytes),
@@ -7120,17 +8123,145 @@ var Account = class extends AbstractAccount {
     const params = { script, ...txParams };
     const baseAssetId = await this.provider.getBaseAssetId();
     let request = new ScriptTransactionRequest(params);
-    const quantities = [{ amount: bn20(amount), assetId: baseAssetId }];
-    const txCost = await this.getTransactionCost(request, { quantities });
-    request = this.validateGasLimitAndMaxFee({
-      transactionRequest: request,
-      gasUsed: txCost.gasUsed,
-      maxFee: txCost.maxFee,
-      txParams
+    const quantities = [{ amount: bn21(amount), assetId: baseAssetId }];
+    const { gasPrice, transactionRequest } = await this.assembleTx(request, quantities);
+    request = await setAndValidateGasAndFeeForAssembledTx({
+      gasPrice,
+      provider: this.provider,
+      transactionRequest,
+      setGasLimit: txParams?.gasLimit,
+      setMaxFee: txParams?.maxFee
     });
-    await this.fund(request, txCost);
     return this.sendTransaction(request);
   }
+  /**
+   * Consolidates base asset UTXOs into fewer, larger ones.
+   *
+   * Retrieves a limited number of base asset coins (as defined by `Provider.RESOURCES_PAGE_SIZE_LIMIT`),
+   * assembles consolidation transactions, and submits them to the network.
+   *
+   * Note: This method currently supports only the base asset.
+   *
+   * @param params - The parameters for coin consolidation, including the asset ID, mode, and output number.
+   * @returns A promise that resolves to the response of the submitted transactions.
+   * @throws Will throw an error if the asset is not a base asset as non-base asset consolidation is not implemented.
+   */
+  async consolidateCoins(params) {
+    const { assetId } = params;
+    const { coins } = await this.getCoins(assetId);
+    const baseAssetId = await this.provider.getBaseAssetId();
+    const isBaseAsset = baseAssetId === assetId;
+    let submitAll;
+    const consolidationParams = {
+      coins,
+      mode: params.mode,
+      outputNum: params.outputNum
+    };
+    if (isBaseAsset) {
+      ({ submitAll } = await this.assembleBaseAssetConsolidationTxs(consolidationParams));
+    } else {
+      throw new FuelError22(
+        ErrorCode19.UNSUPPORTED_FEATURE,
+        "Consolidation for non-base assets is not supported yet."
+      );
+    }
+    return submitAll();
+  }
+  /**
+   * Assembles transactions for consolidating base asset coins into fewer UTXOs.
+   *
+   * This method splits the provided coins into batches and creates transaction requests
+   * to consolidate them. It calculates the necessary fee and sets up the transactions
+   * to be submitted either in parallel (default) or sequentially.
+   *
+   * @param params - The parameters for assembling base asset consolidation transactions.
+   *
+   * @returns An object containing the assembled transactions, the total fee cost, and a callback to submit all transactions.
+   */
+  async assembleBaseAssetConsolidationTxs(params) {
+    const { coins, mode = "parallel", outputNum = 1 } = params;
+    const baseAssetId = await this.provider.getBaseAssetId();
+    this.validateConsolidationTxsCoins(coins, baseAssetId);
+    const chainInfo = await this.provider.getChain();
+    const maxInputsNumber = chainInfo.consensusParameters.txParameters.maxInputs.toNumber();
+    let totalFeeCost = bn21(0);
+    const txs = [];
+    const coinsBatches = splitCoinsIntoBatches(coins, maxInputsNumber);
+    const gasPrice = await this.provider.estimateGasPrice(10);
+    const consolidateMoreThanOneCoin = outputNum > 1;
+    coinsBatches.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, baseAssetId);
+        });
+      }
+      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), bn21(0));
+        const amountPerNewUtxo = total.div(outputNum + 1);
+        request.outputs.forEach((output) => {
+          if (output.type === OutputType9.Coin) {
+            output.amount = amountPerNewUtxo;
+          }
+        });
+      }
+      totalFeeCost = totalFeeCost.add(fee);
+      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.
+   *
+   * @param params - The parameters for preparing the submitAll callback.
+   *
+   * @returns A callback that, when called, submits all transactions and returns their results and any errors encountered.
+   */
+  prepareSubmitAll = /* @__PURE__ */ __name((params) => {
+    const { txs, mode = "sequential" } = params;
+    return async () => {
+      const txResponses = [];
+      const errors = [];
+      if (mode === "sequential") {
+        for (const tx of txs) {
+          try {
+            const submit = await this.sendTransaction(tx);
+            const response = await submit.waitForResult();
+            txResponses.push(response);
+          } catch (error) {
+            errors.push(error);
+          }
+        }
+      } else {
+        const results = await Promise.allSettled(
+          txs.map(async (tx) => {
+            const submit = await this.sendTransaction(tx);
+            return submit.waitForResult();
+          })
+        );
+        results.forEach((result) => {
+          if (result.status === "fulfilled") {
+            txResponses.push(result.value);
+          } else {
+            errors.push(result.reason);
+          }
+        });
+      }
+      return { txResponses, errors };
+    };
+  }, "prepareSubmitAll");
   /**
    * Returns a transaction cost to enable user
    * to set gasLimit and also reserve balance amounts
@@ -7140,15 +8271,18 @@ var Account = class extends AbstractAccount {
    * @param transactionCostParams - The transaction cost parameters (optional).
    *
    * @returns A promise that resolves to the transaction cost object.
+   *
+   * @deprecated Use provider.assembleTx instead
+   * Check the migration guide https://docs.fuel.network/guide/assembling-transactions/migration-guide.html for more information.
    */
   async getTransactionCost(transactionRequestLike, { signatureCallback, quantities = [], gasPrice } = {}) {
     const txRequestClone = clone9(transactionRequestify(transactionRequestLike));
     const baseAssetId = await this.provider.getBaseAssetId();
     const coinOutputsQuantities = txRequestClone.getCoinOutputsQuantities();
     const requiredQuantities = mergeQuantities(coinOutputsQuantities, quantities);
-    const transactionFeeForDryRun = [{ assetId: baseAssetId, amount: bn20("100000000000000000") }];
+    const transactionFeeForDryRun = [{ assetId: baseAssetId, amount: bn21("100000000000000000") }];
     const findAssetInput = /* @__PURE__ */ __name((assetId) => txRequestClone.inputs.find((input) => {
-      if (input.type === InputType7.Coin) {
+      if (input.type === InputType8.Coin) {
         return input.assetId === assetId;
       }
       if (isRequestInputMessageWithoutData(input)) {
@@ -7194,7 +8328,7 @@ var Account = class extends AbstractAccount {
    */
   async signMessage(message) {
     if (!this._connector) {
-      throw new FuelError21(ErrorCode18.MISSING_CONNECTOR, "A connector is required to sign messages.");
+      throw new FuelError22(ErrorCode19.MISSING_CONNECTOR, "A connector is required to sign messages.");
     }
     return this._connector.signMessage(this.address.toString(), message);
   }
@@ -7206,8 +8340,8 @@ var Account = class extends AbstractAccount {
    */
   async signTransaction(transactionRequestLike) {
     if (!this._connector) {
-      throw new FuelError21(
-        ErrorCode18.MISSING_CONNECTOR,
+      throw new FuelError22(
+        ErrorCode19.MISSING_CONNECTOR,
         "A connector is required to sign transactions."
       );
     }
@@ -7271,17 +8405,17 @@ var Account = class extends AbstractAccount {
    */
   generateFakeResources(coins) {
     return coins.map((coin) => ({
-      id: hexlify20(randomBytes5(UTXO_ID_LEN3)),
+      id: hexlify21(randomBytes5(UTXO_ID_LEN3)),
       owner: this.address,
-      blockCreated: bn20(1),
-      txCreatedIdx: bn20(1),
+      blockCreated: bn21(1),
+      txCreatedIdx: bn21(1),
       ...coin
     }));
   }
   /** @hidden */
   async prepareTransactionForSend(request) {
     const { transactionId } = request.flag;
-    if (!isDefined3(transactionId)) {
+    if (!isDefined4(transactionId)) {
       return request;
     }
     const chainId = await this.provider.getChainId();
@@ -7294,17 +8428,29 @@ var Account = class extends AbstractAccount {
   /** @hidden */
   async prepareTransactionSummary(request) {
     const chainId = await this.provider.getChainId();
-    return isDefined3(request.flag.summary) ? {
+    return isDefined4(request.flag.summary) ? {
       ...request.flag.summary,
       id: request.getTransactionId(chainId),
-      transactionBytes: hexlify20(request.toTransactionBytes())
+      transactionBytes: hexlify21(request.toTransactionBytes())
     } : 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 };
+  }
+  /** @hidden * */
   validateTransferAmount(amount) {
-    if (bn20(amount).lte(0)) {
-      throw new FuelError21(
-        ErrorCode18.INVALID_TRANSFER_AMOUNT,
+    if (bn21(amount).lte(0)) {
+      throw new FuelError22(
+        ErrorCode19.INVALID_TRANSFER_AMOUNT,
         "Transfer amount must be a positive number."
       );
     }
@@ -7330,24 +8476,36 @@ var Account = class extends AbstractAccount {
     txParams: { gasLimit: setGasLimit, maxFee: setMaxFee }
   }) {
     const request = transactionRequestify(transactionRequest);
-    if (!isDefined3(setGasLimit)) {
+    if (!isDefined4(setGasLimit)) {
       request.gasLimit = gasUsed;
     } else if (gasUsed.gt(setGasLimit)) {
-      throw new FuelError21(
-        ErrorCode18.GAS_LIMIT_TOO_LOW,
+      throw new FuelError22(
+        ErrorCode19.GAS_LIMIT_TOO_LOW,
         `Gas limit '${setGasLimit}' is lower than the required: '${gasUsed}'.`
       );
     }
-    if (!isDefined3(setMaxFee)) {
+    if (!isDefined4(setMaxFee)) {
       request.maxFee = maxFee;
     } else if (maxFee.gt(setMaxFee)) {
-      throw new FuelError21(
-        ErrorCode18.MAX_FEE_TOO_LOW,
+      throw new FuelError22(
+        ErrorCode19.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 FuelError22(ErrorCode19.NO_COINS_TO_CONSOLIDATE, "No coins to consolidate.");
+    }
+    if (!coins.every((c) => c.assetId === assetId)) {
+      throw new FuelError22(
+        ErrorCode19.COINS_ASSET_ID_MISMATCH,
+        "All coins to consolidate must be from the same asset id."
+      );
+    }
+  }
 };
 
 // src/wallet/keystore-wallet.ts
@@ -7362,8 +8520,8 @@ import {
   encryptJsonWalletData,
   randomUUID as randomUUID2
 } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode19, FuelError as FuelError22 } from "@fuel-ts/errors";
-import { hexlify as hexlify21 } from "@fuel-ts/utils";
+import { ErrorCode as ErrorCode20, FuelError as FuelError23 } from "@fuel-ts/errors";
+import { hexlify as hexlify22 } from "@fuel-ts/utils";
 var DEFAULT_KDF_PARAMS_LOG_N = 13;
 var DEFAULT_KDF_PARAMS_R = 8;
 var DEFAULT_KDF_PARAMS_P = 1;
@@ -7440,13 +8598,13 @@ async function decryptKeystoreWallet(jsonWallet, password) {
   const macHashUint8Array = keccak256(data);
   const macHash = stringFromBuffer(macHashUint8Array, "hex");
   if (mac !== macHash) {
-    throw new FuelError22(
-      ErrorCode19.INVALID_PASSWORD,
+    throw new FuelError23(
+      ErrorCode20.INVALID_PASSWORD,
       "Failed to decrypt the keystore wallet, the provided password is incorrect."
     );
   }
   const buffer = await decryptJsonWalletData(ciphertextBuffer, key, ivBuffer);
-  const privateKey = hexlify21(buffer);
+  const privateKey = hexlify22(buffer);
   return privateKey;
 }
 __name(decryptKeystoreWallet, "decryptKeystoreWallet");
@@ -7499,7 +8657,7 @@ var BaseWalletUnlocked = class extends Account {
    */
   async signMessage(message) {
     const signedMessage = await this.signer().sign(hashMessage(message));
-    return hexlify22(signedMessage);
+    return hexlify23(signedMessage);
   }
   /**
    * Signs a transaction with the wallet's private key.
@@ -7512,7 +8670,7 @@ var BaseWalletUnlocked = class extends Account {
     const chainId = await this.provider.getChainId();
     const hashedTransaction = transactionRequest.getTransactionId(chainId);
     const signature = await this.signer().sign(hashedTransaction);
-    return hexlify22(signature);
+    return hexlify23(signature);
   }
   /**
    * Populates a transaction with the witnesses signature.
@@ -7580,16 +8738,16 @@ var BaseWalletUnlocked = class extends Account {
 
 // src/hdwallet/hdwallet.ts
 import { computeHmac as computeHmac2, ripemd160 } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode22, FuelError as FuelError25 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode23, FuelError as FuelError26 } from "@fuel-ts/errors";
 import { sha256 as sha2564 } from "@fuel-ts/hasher";
-import { bn as bn21, toBytes as toBytes2, toHex } from "@fuel-ts/math";
-import { arrayify as arrayify20, hexlify as hexlify24, concat as concat6, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58 } from "@fuel-ts/utils";
+import { bn as bn22, toBytes as toBytes2, toHex } from "@fuel-ts/math";
+import { arrayify as arrayify20, hexlify as hexlify25, concat as concat6, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58 } from "@fuel-ts/utils";
 
 // src/mnemonic/mnemonic.ts
 import { randomBytes as randomBytes7, pbkdf2, computeHmac } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode21, FuelError as FuelError24 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode22, FuelError as FuelError25 } from "@fuel-ts/errors";
 import { sha256 as sha2563 } from "@fuel-ts/hasher";
-import { arrayify as arrayify19, hexlify as hexlify23, concat as concat5, dataSlice, encodeBase58, toUtf8Bytes } from "@fuel-ts/utils";
+import { arrayify as arrayify19, hexlify as hexlify24, concat as concat5, dataSlice, encodeBase58, toUtf8Bytes } from "@fuel-ts/utils";
 
 // src/wordlists/words/english.ts
 var english = [
@@ -9644,7 +10802,7 @@ var english = [
 ];
 
 // src/mnemonic/utils.ts
-import { ErrorCode as ErrorCode20, FuelError as FuelError23 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode21, FuelError as FuelError24 } from "@fuel-ts/errors";
 import { sha256 as sha2562 } from "@fuel-ts/hasher";
 import { arrayify as arrayify18 } from "@fuel-ts/utils";
 function getLowerMask(bits) {
@@ -9698,8 +10856,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(
-        ErrorCode20.INVALID_MNEMONIC,
+      throw new FuelError24(
+        ErrorCode21.INVALID_MNEMONIC,
         `Invalid mnemonic: the word '${words[i]}' is not found in the provided wordlist.`
       );
     }
@@ -9715,8 +10873,8 @@ function mnemonicWordsToEntropy(words, wordlist) {
   const checksumMask = getUpperMask(checksumBits);
   const checksum = arrayify18(sha2562(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
   if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
-    throw new FuelError23(
-      ErrorCode20.INVALID_CHECKSUM,
+    throw new FuelError24(
+      ErrorCode21.INVALID_CHECKSUM,
       "Checksum validation failed for the provided mnemonic."
     );
   }
@@ -9731,8 +10889,8 @@ var TestnetPRV = "0x04358394";
 var MNEMONIC_SIZES = [12, 15, 18, 21, 24];
 function assertWordList(wordlist) {
   if (wordlist.length !== 2048) {
-    throw new FuelError24(
-      ErrorCode21.INVALID_WORD_LIST,
+    throw new FuelError25(
+      ErrorCode22.INVALID_WORD_LIST,
       `Expected word list length of 2048, but got ${wordlist.length}.`
     );
   }
@@ -9740,8 +10898,8 @@ function assertWordList(wordlist) {
 __name(assertWordList, "assertWordList");
 function assertEntropy(entropy) {
   if (entropy.length % 4 !== 0 || entropy.length < 16 || entropy.length > 32) {
-    throw new FuelError24(
-      ErrorCode21.INVALID_ENTROPY,
+    throw new FuelError25(
+      ErrorCode22.INVALID_ENTROPY,
       `Entropy should be between 16 and 32 bytes and a multiple of 4, but got ${entropy.length} bytes.`
     );
   }
@@ -9752,7 +10910,7 @@ function assertMnemonic(words) {
     const errorMsg = `Invalid mnemonic size. Expected one of [${MNEMONIC_SIZES.join(
       ", "
     )}] words, but got ${words.length}.`;
-    throw new FuelError24(ErrorCode21.INVALID_MNEMONIC, errorMsg);
+    throw new FuelError25(ErrorCode22.INVALID_MNEMONIC, errorMsg);
   }
 }
 __name(assertMnemonic, "assertMnemonic");
@@ -9795,7 +10953,7 @@ var Mnemonic = class _Mnemonic {
   static mnemonicToEntropy(phrase, wordlist = english) {
     const words = getWords(phrase);
     assertMnemonic(words);
-    return hexlify23(mnemonicWordsToEntropy(words, wordlist));
+    return hexlify24(mnemonicWordsToEntropy(words, wordlist));
   }
   /**
    * @param entropy - Entropy source to the mnemonic phrase.
@@ -9874,8 +11032,8 @@ var Mnemonic = class _Mnemonic {
   static masterKeysFromSeed(seed) {
     const seedArray = arrayify19(seed);
     if (seedArray.length < 16 || seedArray.length > 64) {
-      throw new FuelError24(
-        ErrorCode21.INVALID_SEED,
+      throw new FuelError25(
+        ErrorCode22.INVALID_SEED,
         `Seed length should be between 16 and 64 bytes, but received ${seedArray.length} bytes.`
       );
     }
@@ -9928,10 +11086,10 @@ var mnemonic_default = Mnemonic;
 
 // src/hdwallet/hdwallet.ts
 var HARDENED_INDEX = 2147483648;
-var MainnetPRV2 = hexlify24("0x0488ade4");
-var MainnetPUB = hexlify24("0x0488b21e");
-var TestnetPRV2 = hexlify24("0x04358394");
-var TestnetPUB = hexlify24("0x043587cf");
+var MainnetPRV2 = hexlify25("0x0488ade4");
+var MainnetPUB = hexlify25("0x0488b21e");
+var TestnetPRV2 = hexlify25("0x04358394");
+var TestnetPUB = hexlify25("0x043587cf");
 function base58check(data) {
   return encodeBase582(concat6([data, dataSlice2(sha2564(sha2564(data)), 0, 4)]));
 }
@@ -9944,19 +11102,19 @@ function getExtendedKeyPrefix(isPublic = false, testnet = false) {
 }
 __name(getExtendedKeyPrefix, "getExtendedKeyPrefix");
 function isPublicExtendedKey(extendedKey) {
-  return [MainnetPUB, TestnetPUB].includes(hexlify24(extendedKey.slice(0, 4)));
+  return [MainnetPUB, TestnetPUB].includes(hexlify25(extendedKey.slice(0, 4)));
 }
 __name(isPublicExtendedKey, "isPublicExtendedKey");
 function isValidExtendedKey(extendedKey) {
   return [MainnetPRV2, TestnetPRV2, MainnetPUB, TestnetPUB].includes(
-    hexlify24(extendedKey.slice(0, 4))
+    hexlify25(extendedKey.slice(0, 4))
   );
 }
 __name(isValidExtendedKey, "isValidExtendedKey");
 function parsePath(path2, depth = 0) {
   const components = path2.split("/");
   if (components.length === 0 || components[0] === "m" && depth !== 0) {
-    throw new FuelError25(ErrorCode22.HD_WALLET_ERROR, `invalid path - ${path2}`);
+    throw new FuelError26(ErrorCode23.HD_WALLET_ERROR, `invalid path - ${path2}`);
   }
   if (components[0] === "m") {
     components.shift();
@@ -9972,8 +11130,8 @@ var HDWallet = class _HDWallet {
   }
   depth = 0;
   index = 0;
-  fingerprint = hexlify24("0x00000000");
-  parentFingerprint = hexlify24("0x00000000");
+  fingerprint = hexlify25("0x00000000");
+  parentFingerprint = hexlify25("0x00000000");
   privateKey;
   publicKey;
   chainCode;
@@ -9985,16 +11143,16 @@ var HDWallet = class _HDWallet {
   constructor(config) {
     if (config.privateKey) {
       const signer = new Signer(config.privateKey);
-      this.publicKey = hexlify24(signer.compressedPublicKey);
-      this.privateKey = hexlify24(config.privateKey);
+      this.publicKey = hexlify25(signer.compressedPublicKey);
+      this.privateKey = hexlify25(config.privateKey);
     } else {
       if (!config.publicKey) {
-        throw new FuelError25(
-          ErrorCode22.HD_WALLET_ERROR,
+        throw new FuelError26(
+          ErrorCode23.HD_WALLET_ERROR,
           "Both public and private Key cannot be missing. At least one should be provided."
         );
       }
-      this.publicKey = hexlify24(config.publicKey);
+      this.publicKey = hexlify25(config.publicKey);
     }
     this.parentFingerprint = config.parentFingerprint || this.parentFingerprint;
     this.fingerprint = dataSlice2(ripemd160(sha2564(this.publicKey)), 0, 4);
@@ -10019,8 +11177,8 @@ var HDWallet = class _HDWallet {
     const data = new Uint8Array(37);
     if (index & HARDENED_INDEX) {
       if (!privateKey) {
-        throw new FuelError25(
-          ErrorCode22.HD_WALLET_ERROR,
+        throw new FuelError26(
+          ErrorCode23.HD_WALLET_ERROR,
           "Cannot derive a hardened index without a private Key."
         );
       }
@@ -10034,7 +11192,7 @@ var HDWallet = class _HDWallet {
     const IR = bytes.slice(32);
     if (privateKey) {
       const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
-      const ki = bn21(IL).add(privateKey).mod(N).toBytes(32);
+      const ki = bn22(IL).add(privateKey).mod(N).toBytes(32);
       return new _HDWallet({
         privateKey: ki,
         chainCode: IR,
@@ -10043,7 +11201,7 @@ var HDWallet = class _HDWallet {
         parentFingerprint: this.fingerprint
       });
     }
-    const signer = new Signer(hexlify24(IL));
+    const signer = new Signer(hexlify25(IL));
     const Ki = signer.addPoint(publicKey);
     return new _HDWallet({
       publicKey: Ki,
@@ -10072,13 +11230,13 @@ var HDWallet = class _HDWallet {
    */
   toExtendedKey(isPublic = false, testnet = false) {
     if (this.depth >= 256) {
-      throw new FuelError25(
-        ErrorCode22.HD_WALLET_ERROR,
+      throw new FuelError26(
+        ErrorCode23.HD_WALLET_ERROR,
         `Exceeded max depth of 255. Current depth: ${this.depth}.`
       );
     }
     const prefix = getExtendedKeyPrefix(this.privateKey == null || isPublic, testnet);
-    const depth = hexlify24(Uint8Array.from([this.depth]));
+    const depth = hexlify25(Uint8Array.from([this.depth]));
     const parentFingerprint = this.parentFingerprint;
     const index = toHex(this.index, 4);
     const chainCode = this.chainCode;
@@ -10100,29 +11258,29 @@ var HDWallet = class _HDWallet {
     });
   }
   static fromExtendedKey(extendedKey) {
-    const decoded = hexlify24(toBytes2(decodeBase58(extendedKey)));
+    const decoded = hexlify25(toBytes2(decodeBase58(extendedKey)));
     const bytes = arrayify20(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
-      throw new FuelError25(ErrorCode22.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
+      throw new FuelError26(ErrorCode23.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
     }
     if (!validChecksum) {
-      throw new FuelError25(ErrorCode22.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
+      throw new FuelError26(ErrorCode23.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
     }
     const depth = bytes[4];
-    const parentFingerprint = hexlify24(bytes.slice(5, 9));
-    const index = parseInt(hexlify24(bytes.slice(9, 13)).substring(2), 16);
-    const chainCode = hexlify24(bytes.slice(13, 45));
+    const parentFingerprint = hexlify25(bytes.slice(5, 9));
+    const index = parseInt(hexlify25(bytes.slice(9, 13)).substring(2), 16);
+    const chainCode = hexlify25(bytes.slice(13, 45));
     const key = bytes.slice(45, 78);
     if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
-      throw new FuelError25(
-        ErrorCode22.HD_WALLET_ERROR,
+      throw new FuelError26(
+        ErrorCode23.HD_WALLET_ERROR,
         "Inconsistency detected: Depth is zero but fingerprint/index is non-zero."
       );
     }
     if (isPublicExtendedKey(bytes)) {
       if (key[0] !== 3) {
-        throw new FuelError25(ErrorCode22.HD_WALLET_ERROR, "Invalid public extended key.");
+        throw new FuelError26(ErrorCode23.HD_WALLET_ERROR, "Invalid public extended key.");
       }
       return new _HDWallet({
         publicKey: key,
@@ -10133,7 +11291,7 @@ var HDWallet = class _HDWallet {
       });
     }
     if (key[0] !== 0) {
-      throw new FuelError25(ErrorCode22.HD_WALLET_ERROR, "Invalid private extended key.");
+      throw new FuelError26(ErrorCode23.HD_WALLET_ERROR, "Invalid private extended key.");
     }
     return new _HDWallet({
       privateKey: key.slice(1),
@@ -10369,13 +11527,13 @@ var WalletsConfig = class _WalletsConfig {
       assetIds.forEach((assetId) => {
         for (let index = 0; index < coinsPerAsset; index++) {
           coins.push({
-            amount: bn22(amountPerCoin).toString(),
+            amount: bn23(amountPerCoin).toString(),
             asset_id: assetId,
             owner: walletAddress,
             tx_pointer_block_height: 0,
             tx_pointer_tx_idx: 0,
             output_index: 0,
-            tx_id: hexlify25(randomBytes8(32))
+            tx_id: hexlify26(randomBytes8(32))
           });
         }
       });
@@ -10389,26 +11547,26 @@ var WalletsConfig = class _WalletsConfig {
     amountPerCoin
   }) {
     if (Array.isArray(wallets) && wallets.length === 0 || typeof wallets === "number" && wallets <= 0) {
-      throw new FuelError26(
-        FuelError26.CODES.INVALID_INPUT_PARAMETERS,
+      throw new FuelError27(
+        FuelError27.CODES.INVALID_INPUT_PARAMETERS,
         "Number of wallets must be greater than zero."
       );
     }
     if (Array.isArray(assets) && assets.length === 0 || typeof assets === "number" && assets <= 0) {
-      throw new FuelError26(
-        FuelError26.CODES.INVALID_INPUT_PARAMETERS,
+      throw new FuelError27(
+        FuelError27.CODES.INVALID_INPUT_PARAMETERS,
         "Number of assets per wallet must be greater than zero."
       );
     }
     if (coinsPerAsset <= 0) {
-      throw new FuelError26(
-        FuelError26.CODES.INVALID_INPUT_PARAMETERS,
+      throw new FuelError27(
+        FuelError27.CODES.INVALID_INPUT_PARAMETERS,
         "Number of coins per asset must be greater than zero."
       );
     }
-    if (bn22(amountPerCoin).lt(0)) {
-      throw new FuelError26(
-        FuelError26.CODES.INVALID_INPUT_PARAMETERS,
+    if (bn23(amountPerCoin).lt(0)) {
+      throw new FuelError27(
+        FuelError27.CODES.INVALID_INPUT_PARAMETERS,
         "Amount per coin must be greater than or equal to zero."
       );
     }
@@ -10446,23 +11604,26 @@ async function setupTestProviderAndWallets({
     ),
     port: nodeOptions.port || "0"
   };
-  let cleanup;
+  let killNode;
   let url;
   if (launchNodeServerPort) {
     const serverUrl = `http://localhost:${launchNodeServerPort}`;
     url = await (await fetch(serverUrl, { method: "POST", body: JSON.stringify(launchNodeOptions) })).text();
-    cleanup = /* @__PURE__ */ __name(() => {
+    killNode = /* @__PURE__ */ __name(() => {
       fetch(`${serverUrl}/cleanup/${url}`);
-    }, "cleanup");
+    }, "killNode");
   } else {
     const settings = await launchNode(launchNodeOptions);
     url = settings.url;
-    cleanup = settings.cleanup;
+    killNode = settings.cleanup;
   }
+  const cleanup = /* @__PURE__ */ __name(() => {
+    Provider.clearChainAndNodeCaches(url);
+    killNode();
+  }, "cleanup");
   let provider;
   try {
     provider = new Provider(url, providerOptions);
-    await provider.init();
   } catch (err) {
     cleanup();
     throw err;
@@ -10483,8 +11644,8 @@ __name(setupTestProviderAndWallets, "setupTestProviderAndWallets");
 // src/test-utils/test-message.ts
 import { Address as Address7 } from "@fuel-ts/address";
 import { randomBytes as randomBytes9 } from "@fuel-ts/crypto";
-import { bn as bn23 } from "@fuel-ts/math";
-import { hexlify as hexlify26 } from "@fuel-ts/utils";
+import { bn as bn24 } from "@fuel-ts/math";
+import { hexlify as hexlify27 } from "@fuel-ts/utils";
 var TestMessage = class {
   static {
     __name(this, "TestMessage");
@@ -10504,7 +11665,7 @@ var TestMessage = class {
   constructor({
     sender = Address7.fromRandom(),
     recipient = Address7.fromRandom(),
-    nonce = hexlify26(randomBytes9(32)),
+    nonce = hexlify27(randomBytes9(32)),
     amount = 1e6,
     data = "",
     // Will default to empty data in order to be a spendable message
@@ -10523,7 +11684,7 @@ var TestMessage = class {
       sender: this.sender.toB256(),
       recipient: recipient?.toB256() ?? this.recipient.toB256(),
       nonce: this.nonce,
-      amount: bn23(this.amount).toNumber(),
+      amount: bn24(this.amount).toNumber(),
       data,
       da_height: this.da_height
     };