@fuel-ts/account 0.0.0-pr-1788-20240222094224 → 0.0.0-pr-1864-20240312141036

package/dist/test-utils.mjs

@@ -25,7 +25,7 @@ import { hexlify as hexlify15 } from "@fuel-ts/utils";
 // src/account.ts
 import { Address as Address3 } from "@fuel-ts/address";
 import { BaseAssetId as BaseAssetId3 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode13, FuelError as FuelError14 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode14, FuelError as FuelError14 } from "@fuel-ts/errors";
 import { AbstractAccount } from "@fuel-ts/interfaces";
 import { bn as bn16 } from "@fuel-ts/math";
 import { arrayify as arrayify14 } from "@fuel-ts/utils";
@@ -68,7 +68,7 @@ var addAmountToAsset = (params) => {
 
 // src/providers/provider.ts
 import { Address as Address2 } from "@fuel-ts/address";
-import { ErrorCode as ErrorCode11, FuelError as FuelError12 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode12, FuelError as FuelError12 } from "@fuel-ts/errors";
 import { BN, bn as bn14, max } from "@fuel-ts/math";
 import {
   InputType as InputType6,
@@ -76,7 +76,7 @@ import {
   InputMessageCoder,
   TransactionCoder as TransactionCoder5
 } from "@fuel-ts/transactions";
-import { arrayify as arrayify11, hexlify as hexlify12 } from "@fuel-ts/utils";
+import { arrayify as arrayify11, hexlify as hexlify12, DateTime as DateTime2 } from "@fuel-ts/utils";
 import { checkFuelCoreVersionCompatibility } from "@fuel-ts/versions";
 import { equalBytes } from "@noble/curves/abstract/utils";
 import { Network } from "ethers";
@@ -144,6 +144,9 @@ var TransactionStatusFragmentFragmentDoc = gql`
     time
     reason
   }
+  ... on SqueezedOutStatus {
+    reason
+  }
 }
     `;
 var TransactionFragmentFragmentDoc = gql`
@@ -886,72 +889,77 @@ function getSdk(requester) {
 }
 
 // src/providers/fuel-graphql-subscriber.ts
-import { FuelError } from "@fuel-ts/errors";
+import { ErrorCode, FuelError } from "@fuel-ts/errors";
 import { print } from "graphql";
-var _FuelSubscriptionStream = class {
-  readable;
-  writable;
-  readableStreamController;
-  constructor() {
-    this.readable = new ReadableStream({
-      start: (controller) => {
-        this.readableStreamController = controller;
-      }
-    });
-    this.writable = new WritableStream({
-      write: (bytes) => {
-        const text = _FuelSubscriptionStream.textDecoder.decode(bytes);
-        if (text.startsWith("data:")) {
-          const { data, errors } = JSON.parse(text.split("data:")[1]);
-          if (Array.isArray(errors)) {
-            this.readableStreamController.enqueue(
-              new FuelError(
-                FuelError.CODES.INVALID_REQUEST,
-                errors.map((err) => err.message).join("\n\n")
-              )
-            );
-          } else {
-            this.readableStreamController.enqueue(data);
-          }
-        }
+var _FuelGraphqlSubscriber = class {
+  constructor(options) {
+    this.options = options;
+  }
+  stream;
+  async setStream() {
+    const { url, query, variables, fetchFn } = this.options;
+    const response = await fetchFn(`${url}-sub`, {
+      method: "POST",
+      body: JSON.stringify({
+        query: print(query),
+        variables
+      }),
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
       }
     });
+    this.stream = response.body.getReader();
   }
-};
-var FuelSubscriptionStream = _FuelSubscriptionStream;
-__publicField(FuelSubscriptionStream, "textDecoder", new TextDecoder());
-async function* fuelGraphQLSubscriber({
-  url,
-  variables,
-  query,
-  fetchFn
-}) {
-  const response = await fetchFn(`${url}-sub`, {
-    method: "POST",
-    body: JSON.stringify({
-      query: print(query),
-      variables
-    }),
-    headers: {
-      "Content-Type": "application/json",
-      Accept: "text/event-stream"
-    }
-  });
-  const subscriptionStreamReader = response.body.pipeThrough(new FuelSubscriptionStream()).getReader();
-  while (true) {
-    const { value, done } = await subscriptionStreamReader.read();
-    if (value instanceof FuelError) {
-      throw value;
+  async next() {
+    if (!this.stream) {
+      await this.setStream();
     }
-    yield value;
-    if (done) {
-      break;
+    while (true) {
+      const { value, done } = await this.stream.read();
+      if (done) {
+        return { value, done };
+      }
+      const text = _FuelGraphqlSubscriber.textDecoder.decode(value);
+      if (!text.startsWith("data:")) {
+        continue;
+      }
+      let data;
+      let errors;
+      try {
+        ({ data, errors } = JSON.parse(text.replace(/^data:/, "")));
+      } catch (e) {
+        throw new FuelError(
+          ErrorCode.STREAM_PARSING_ERROR,
+          `Error while parsing stream data response: ${text}`
+        );
+      }
+      if (Array.isArray(errors)) {
+        throw new FuelError(
+          FuelError.CODES.INVALID_REQUEST,
+          errors.map((err) => err.message).join("\n\n")
+        );
+      }
+      return { value: data, done: false };
     }
   }
-}
+  /**
+   * Gets called when `break` is called in a `for-await-of` loop.
+   */
+  async return() {
+    await this.stream.cancel();
+    this.stream.releaseLock();
+    return { done: true, value: void 0 };
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+var FuelGraphqlSubscriber = _FuelGraphqlSubscriber;
+__publicField(FuelGraphqlSubscriber, "textDecoder", new TextDecoder());
 
 // src/providers/memory-cache.ts
-import { ErrorCode, FuelError as FuelError2 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode2, FuelError as FuelError2 } from "@fuel-ts/errors";
 import { hexlify as hexlify2 } from "@fuel-ts/utils";
 var cache = {};
 var DEFAULT_TTL_IN_MS = 30 * 1e3;
@@ -961,7 +969,7 @@ var MemoryCache = class {
     this.ttl = ttlInMs;
     if (typeof ttlInMs !== "number" || this.ttl <= 0) {
       throw new FuelError2(
-        ErrorCode.INVALID_TTL,
+        ErrorCode2.INVALID_TTL,
         `Invalid TTL: ${this.ttl}. Use a value greater than zero.`
       );
     }
@@ -1011,7 +1019,7 @@ var MemoryCache = class {
 
 // src/providers/transaction-request/input.ts
 import { ZeroBytes32 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode2, FuelError as FuelError3 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode3, FuelError as FuelError3 } from "@fuel-ts/errors";
 import { bn as bn2, toNumber } from "@fuel-ts/math";
 import { InputType } from "@fuel-ts/transactions";
 import { arrayify, hexlify as hexlify3 } from "@fuel-ts/utils";
@@ -1077,7 +1085,7 @@ var inputify = (value) => {
     }
     default: {
       throw new FuelError3(
-        ErrorCode2.INVALID_TRANSACTION_INPUT,
+        ErrorCode3.INVALID_TRANSACTION_INPUT,
         `Invalid transaction input type: ${type}.`
       );
     }
@@ -1086,7 +1094,7 @@ var inputify = (value) => {
 
 // src/providers/transaction-request/output.ts
 import { ZeroBytes32 as ZeroBytes322 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode3, FuelError as FuelError4 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode4, FuelError as FuelError4 } from "@fuel-ts/errors";
 import { bn as bn3 } from "@fuel-ts/math";
 import { OutputType } from "@fuel-ts/transactions";
 import { hexlify as hexlify4 } from "@fuel-ts/utils";
@@ -1134,7 +1142,7 @@ var outputify = (value) => {
     }
     default: {
       throw new FuelError4(
-        ErrorCode3.INVALID_TRANSACTION_INPUT,
+        ErrorCode4.INVALID_TRANSACTION_INPUT,
         `Invalid transaction output type: ${type}.`
       );
     }
@@ -1159,7 +1167,7 @@ var isCoin = (resource) => "id" in resource;
 
 // src/providers/utils/receipts.ts
 import { ZeroBytes32 as ZeroBytes323 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode4, FuelError as FuelError5 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode5, FuelError as FuelError5 } from "@fuel-ts/errors";
 import { bn as bn4 } from "@fuel-ts/math";
 import {
   ReceiptBurnCoder,
@@ -1364,12 +1372,12 @@ function assembleReceiptByType(receipt) {
       return burnReceipt;
     }
     default:
-      throw new FuelError5(ErrorCode4.INVALID_RECEIPT_TYPE, `Invalid receipt type: ${receiptType}.`);
+      throw new FuelError5(ErrorCode5.INVALID_RECEIPT_TYPE, `Invalid receipt type: ${receiptType}.`);
   }
 }
 
 // src/providers/utils/block-explorer.ts
-import { ErrorCode as ErrorCode5, FuelError as FuelError6 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode6, FuelError as FuelError6 } from "@fuel-ts/errors";
 
 // src/providers/utils/gas.ts
 import { bn as bn5 } from "@fuel-ts/math";
@@ -1487,9 +1495,6 @@ function sleep(time) {
   });
 }
 
-// src/providers/utils/time.ts
-var fromUnixToTai64 = (unixTimestampMs) => (BigInt(unixTimestampMs) + BigInt(2 ** 62) + BigInt(10)).toString();
-
 // src/providers/transaction-request/errors.ts
 var NoWitnessAtIndexError = class extends Error {
   constructor(index) {
@@ -1731,7 +1736,7 @@ var BaseTransactionRequest = class {
       txPointer: "0x00000000000000000000000000000000",
       witnessIndex,
       predicate: predicate?.bytes,
-      predicateData: predicate?.predicateData
+      predicateData: predicate?.predicateDataBytes
     };
     this.pushInput(input);
     this.addChangeOutput(owner, assetId);
@@ -1764,7 +1769,7 @@ var BaseTransactionRequest = class {
       amount,
       witnessIndex,
       predicate: predicate?.bytes,
-      predicateData: predicate?.predicateData
+      predicateData: predicate?.predicateDataBytes
     };
     this.pushInput(input);
     this.addChangeOutput(recipient, assetId);
@@ -1979,8 +1984,6 @@ var BaseTransactionRequest = class {
     this.inputs.forEach((i) => {
       let correspondingInput;
       switch (i.type) {
-        case InputType2.Contract:
-          return;
         case InputType2.Coin:
           correspondingInput = inputs.find((x) => x.type === InputType2.Coin && x.owner === i.owner);
           break;
@@ -1990,7 +1993,7 @@ var BaseTransactionRequest = class {
           );
           break;
         default:
-          break;
+          return;
       }
       if (correspondingInput && "predicateGasUsed" in correspondingInput && bn6(correspondingInput.predicateGasUsed).gt(0)) {
         i.predicate = correspondingInput.predicate;
@@ -2009,11 +2012,10 @@ import { arrayify as arrayify6, hexlify as hexlify9 } from "@fuel-ts/utils";
 
 // src/providers/transaction-request/hash-transaction.ts
 import { ZeroBytes32 as ZeroBytes325 } from "@fuel-ts/address/configs";
-import { uint64ToBytesBE } from "@fuel-ts/hasher";
+import { uint64ToBytesBE, sha256 } from "@fuel-ts/hasher";
 import { bn as bn7 } from "@fuel-ts/math";
 import { TransactionType as TransactionType2, InputType as InputType3, OutputType as OutputType3, TransactionCoder as TransactionCoder2 } from "@fuel-ts/transactions";
 import { concat as concat2 } from "@fuel-ts/utils";
-import { sha256 } from "ethers";
 import { clone as clone2 } from "ramda";
 function hashTransaction(transactionRequest, chainId) {
   const transaction = transactionRequest.toTransaction();
@@ -2400,7 +2402,7 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
 };
 
 // src/providers/transaction-request/utils.ts
-import { ErrorCode as ErrorCode6, FuelError as FuelError7 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode7, FuelError as FuelError7 } from "@fuel-ts/errors";
 import { TransactionType as TransactionType5 } from "@fuel-ts/transactions";
 var transactionRequestify = (obj) => {
   if (obj instanceof ScriptTransactionRequest || obj instanceof CreateTransactionRequest) {
@@ -2415,19 +2417,19 @@ var transactionRequestify = (obj) => {
       return CreateTransactionRequest.from(obj);
     }
     default: {
-      throw new FuelError7(ErrorCode6.INVALID_TRANSACTION_TYPE, `Invalid transaction type: ${type}.`);
+      throw new FuelError7(ErrorCode7.INVALID_TRANSACTION_TYPE, `Invalid transaction type: ${type}.`);
     }
   }
 };
 
 // src/providers/transaction-response/transaction-response.ts
-import { ErrorCode as ErrorCode10, FuelError as FuelError11 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode11, FuelError as FuelError11 } from "@fuel-ts/errors";
 import { bn as bn13 } from "@fuel-ts/math";
 import { TransactionCoder as TransactionCoder4 } from "@fuel-ts/transactions";
 import { arrayify as arrayify10 } from "@fuel-ts/utils";
 
 // src/providers/transaction-summary/assemble-transaction-summary.ts
-import { hexlify as hexlify11 } from "@fuel-ts/utils";
+import { DateTime, hexlify as hexlify11 } from "@fuel-ts/utils";
 
 // src/providers/transaction-summary/calculate-transaction-fee.ts
 import { bn as bn10 } from "@fuel-ts/math";
@@ -2502,15 +2504,9 @@ var calculateTransactionFee = (params) => {
   };
 };
 
-// src/providers/transaction-summary/date.ts
-import { TAI64 } from "tai64";
-var fromTai64ToDate = (tai64Timestamp) => {
-  const timestamp = TAI64.fromString(tai64Timestamp, 10).toUnix();
-  return new Date(timestamp * 1e3);
-};
-
 // src/providers/transaction-summary/operations.ts
-import { ErrorCode as ErrorCode8, FuelError as FuelError9 } from "@fuel-ts/errors";
+import { ZeroBytes32 as ZeroBytes328 } from "@fuel-ts/address/configs";
+import { ErrorCode as ErrorCode9, FuelError as FuelError9 } from "@fuel-ts/errors";
 import { bn as bn12 } from "@fuel-ts/math";
 import { ReceiptType as ReceiptType3, TransactionType as TransactionType7 } from "@fuel-ts/transactions";
 
@@ -2559,7 +2555,7 @@ var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
 };
 
 // src/providers/transaction-summary/input.ts
-import { ErrorCode as ErrorCode7, FuelError as FuelError8 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode8, FuelError as FuelError8 } from "@fuel-ts/errors";
 import { InputType as InputType5 } from "@fuel-ts/transactions";
 function getInputsByTypes(inputs, types) {
   return inputs.filter((i) => types.includes(i.type));
@@ -2598,7 +2594,7 @@ function getInputContractFromIndex(inputs, inputIndex) {
   }
   if (contractInput.type !== InputType5.Contract) {
     throw new FuelError8(
-      ErrorCode7.INVALID_TRANSACTION_INPUT,
+      ErrorCode8.INVALID_TRANSACTION_INPUT,
       `Contract input should be of type 'contract'.`
     );
   }
@@ -2646,7 +2642,7 @@ function getTransactionTypeName(transactionType) {
       return "Script" /* Script */;
     default:
       throw new FuelError9(
-        ErrorCode8.INVALID_TRANSACTION_TYPE,
+        ErrorCode9.INVALID_TRANSACTION_TYPE,
         `Invalid transaction type: ${transactionType}.`
       );
   }
@@ -2706,36 +2702,6 @@ function addOperation(operations, toAdd) {
   }
   return allOperations;
 }
-function getReceiptsTransferOut(receipts) {
-  return getReceiptsByType(receipts, ReceiptType3.TransferOut);
-}
-function getContractTransferOperations({ receipts }) {
-  const transferOutReceipts = getReceiptsTransferOut(receipts);
-  const contractTransferOperations = transferOutReceipts.reduce(
-    (prevContractTransferOps, receipt) => {
-      const newContractTransferOps = addOperation(prevContractTransferOps, {
-        name: "Contract transfer" /* contractTransfer */,
-        from: {
-          type: 0 /* contract */,
-          address: receipt.from
-        },
-        to: {
-          type: 1 /* account */,
-          address: receipt.to
-        },
-        assetsSent: [
-          {
-            amount: receipt.amount,
-            assetId: receipt.assetId
-          }
-        ]
-      });
-      return newContractTransferOps;
-    },
-    []
-  );
-  return contractTransferOperations;
-}
 function getWithdrawFromFuelOperations({
   inputs,
   receipts
@@ -2833,70 +2799,77 @@ function getContractCallOperations({
   }, []);
   return contractCallOperations;
 }
+function extractTransferOperationFromReceipt(receipt, contractInputs, changeOutputs) {
+  const { to: toAddress, assetId, amount } = receipt;
+  let { from: fromAddress } = receipt;
+  const toType = contractInputs.some((input) => input.contractID === toAddress) ? 0 /* contract */ : 1 /* account */;
+  if (ZeroBytes328 === fromAddress) {
+    const change = changeOutputs.find((output) => output.assetId === assetId);
+    fromAddress = change?.to || fromAddress;
+  }
+  const fromType = contractInputs.some((input) => input.contractID === fromAddress) ? 0 /* contract */ : 1 /* account */;
+  return {
+    name: "Transfer asset" /* transfer */,
+    from: {
+      type: fromType,
+      address: fromAddress
+    },
+    to: {
+      type: toType,
+      address: toAddress
+    },
+    assetsSent: [
+      {
+        assetId: assetId.toString(),
+        amount
+      }
+    ]
+  };
+}
 function getTransferOperations({
   inputs,
   outputs,
   receipts
 }) {
+  let operations = [];
   const coinOutputs = getOutputsCoin(outputs);
-  const [transferReceipt] = getReceiptsByType(
+  const contractInputs = getInputsContract(inputs);
+  const changeOutputs = getOutputsChange(outputs);
+  coinOutputs.forEach((output) => {
+    const { amount, assetId, to } = output;
+    const changeOutput = changeOutputs.find((change) => change.assetId === assetId);
+    if (changeOutput) {
+      operations = addOperation(operations, {
+        name: "Transfer asset" /* transfer */,
+        from: {
+          type: 1 /* account */,
+          address: changeOutput.to
+        },
+        to: {
+          type: 1 /* account */,
+          address: to
+        },
+        assetsSent: [
+          {
+            assetId,
+            amount
+          }
+        ]
+      });
+    }
+  });
+  const transferReceipts = getReceiptsByType(
     receipts,
     ReceiptType3.Transfer
   );
-  let operations = [];
-  if (transferReceipt) {
-    const changeOutputs = getOutputsChange(outputs);
-    changeOutputs.forEach((output) => {
-      const { assetId } = output;
-      const [contractInput] = getInputsContract(inputs);
-      const utxo = getInputFromAssetId(inputs, assetId);
-      if (utxo && contractInput) {
-        const inputAddress = getInputAccountAddress(utxo);
-        operations = addOperation(operations, {
-          name: "Transfer asset" /* transfer */,
-          from: {
-            type: 1 /* account */,
-            address: inputAddress
-          },
-          to: {
-            type: 0 /* contract */,
-            address: contractInput.contractID
-          },
-          assetsSent: [
-            {
-              assetId: assetId.toString(),
-              amount: transferReceipt.amount
-            }
-          ]
-        });
-      }
-    });
-  } else {
-    coinOutputs.forEach((output) => {
-      const input = getInputFromAssetId(inputs, output.assetId);
-      if (input) {
-        const inputAddress = getInputAccountAddress(input);
-        const operationToAdd = {
-          name: "Transfer asset" /* transfer */,
-          from: {
-            type: 1 /* account */,
-            address: inputAddress
-          },
-          to: {
-            type: 1 /* account */,
-            address: output.to.toString()
-          },
-          assetsSent: [
-            {
-              assetId: output.assetId.toString(),
-              amount: output.amount
-            }
-          ]
-        };
-        operations = addOperation(operations, operationToAdd);
-      }
-    });
-  }
+  const transferOutReceipts = getReceiptsByType(
+    receipts,
+    ReceiptType3.TransferOut
+  );
+  [...transferReceipts, ...transferOutReceipts].forEach((receipt) => {
+    const operation = extractTransferOperationFromReceipt(receipt, contractInputs, changeOutputs);
+    operations = addOperation(operations, operation);
+  });
   return operations;
 }
 function getPayProducerOperations(outputs) {
@@ -2969,7 +2942,6 @@ function getOperations({
         rawPayload,
         maxInputs
       }),
-      ...getContractTransferOperations({ receipts }),
       ...getWithdrawFromFuelOperations({ inputs, receipts })
     ];
   }
@@ -3027,7 +2999,7 @@ var extractBurnedAssetsFromReceipts = (receipts) => {
 };
 
 // src/providers/transaction-summary/status.ts
-import { ErrorCode as ErrorCode9, FuelError as FuelError10 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode10, FuelError as FuelError10 } from "@fuel-ts/errors";
 var getTransactionStatusName = (gqlStatus) => {
   switch (gqlStatus) {
     case "FailureStatus":
@@ -3040,7 +3012,7 @@ var getTransactionStatusName = (gqlStatus) => {
       return "squeezedout" /* squeezedout */;
     default:
       throw new FuelError10(
-        ErrorCode9.INVALID_TRANSACTION_STATUS,
+        ErrorCode10.INVALID_TRANSACTION_STATUS,
         `Invalid transaction status: ${gqlStatus}.`
       );
   }
@@ -3125,7 +3097,7 @@ function assembleTransactionSummary(params) {
   const burnedAssets = extractBurnedAssetsFromReceipts(receipts);
   let date;
   if (time) {
-    date = fromTai64ToDate(time);
+    date = DateTime.fromTai64(time);
   }
   const transactionSummary = {
     id,
@@ -3260,6 +3232,12 @@ var TransactionResponse = class {
       transactionId: this.id
     });
     for await (const { statusChange } of subscription) {
+      if (statusChange.type === "SqueezedOutStatus") {
+        throw new FuelError11(
+          ErrorCode11.TRANSACTION_SQUEEZED_OUT,
+          `Transaction Squeezed Out with reason: ${statusChange.reason}`
+        );
+      }
       if (statusChange.type !== "SubmittedStatus") {
         break;
       }
@@ -3289,7 +3267,7 @@ var TransactionResponse = class {
     const result = await this.waitForResult(contractsAbiMap);
     if (result.isStatusFailure) {
       throw new FuelError11(
-        ErrorCode10.TRANSACTION_FAILED,
+        ErrorCode11.TRANSACTION_FAILED,
         `Transaction failed: ${result.gqlTransaction.status.reason}`
       );
     }
@@ -3298,7 +3276,7 @@ var TransactionResponse = class {
 };
 
 // src/providers/transaction-response/getDecodedLogs.ts
-import { U64Coder } from "@fuel-ts/abi-coder";
+import { BigNumberCoder } from "@fuel-ts/abi-coder";
 import { ReceiptType as ReceiptType5 } from "@fuel-ts/transactions";
 
 // src/providers/utils/auto-retry-fetch.ts
@@ -3424,14 +3402,15 @@ var _Provider = class {
   }
   static getFetchFn(options) {
     const { retryOptions, timeout } = options;
-    return autoRetryFetch((...args) => {
-      if (options.fetch) {
-        return options.fetch(...args);
-      }
+    return autoRetryFetch(async (...args) => {
       const url = args[0];
       const request = args[1];
       const signal = timeout ? AbortSignal.timeout(timeout) : void 0;
-      return fetch(url, { ...request, signal });
+      let fullRequest = { ...request, signal };
+      if (options.requestMiddleware) {
+        fullRequest = await options.requestMiddleware(fullRequest);
+      }
+      return options.fetch ? options.fetch(url, fullRequest, options) : fetch(url, fullRequest);
     }, retryOptions);
   }
   /**
@@ -3451,7 +3430,7 @@ var _Provider = class {
     const chain = _Provider.chainInfoCache[this.url];
     if (!chain) {
       throw new FuelError12(
-        ErrorCode11.CHAIN_INFO_CACHE_EMPTY,
+        ErrorCode12.CHAIN_INFO_CACHE_EMPTY,
         "Chain info cache is empty. Make sure you have called `Provider.create` to initialize the provider."
       );
     }
@@ -3464,7 +3443,7 @@ var _Provider = class {
     const node = _Provider.nodeInfoCache[this.url];
     if (!node) {
       throw new FuelError12(
-        ErrorCode11.NODE_INFO_CACHE_EMPTY,
+        ErrorCode12.NODE_INFO_CACHE_EMPTY,
         "Node info cache is empty. Make sure you have called `Provider.create` to initialize the provider."
       );
     }
@@ -3531,7 +3510,7 @@ var _Provider = class {
       const opDefinition = query.definitions.find((x) => x.kind === "OperationDefinition");
       const isSubscription = opDefinition?.operation === "subscription";
       if (isSubscription) {
-        return fuelGraphQLSubscriber({
+        return new FuelGraphqlSubscriber({
           url: this.url,
           query,
           fetchFn: (url, requestInit) => fetchFn(url, requestInit, this.options),
@@ -3637,6 +3616,12 @@ var _Provider = class {
     if (awaitExecution) {
       const subscription = this.operations.submitAndAwait({ encodedTransaction });
       for await (const { submitAndAwait } of subscription) {
+        if (submitAndAwait.type === "SqueezedOutStatus") {
+          throw new FuelError12(
+            ErrorCode12.TRANSACTION_SQUEEZED_OUT,
+            `Transaction Squeezed Out with reason: ${submitAndAwait.reason}`
+          );
+        }
         if (submitAndAwait.type !== "SubmittedStatus") {
           break;
         }
@@ -3723,11 +3708,15 @@ var _Provider = class {
   async estimateTxDependencies(transactionRequest) {
     if (transactionRequest.type === TransactionType8.Create) {
       return {
-        receipts: []
+        receipts: [],
+        outputVariables: 0,
+        missingContractIds: []
       };
     }
     await this.estimatePredicates(transactionRequest);
     let receipts = [];
+    const missingContractIds = [];
+    let outputVariables = 0;
     for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
       const { dryRun: gqlReceipts } = await this.operations.dryRun({
         encodedTransaction: hexlify12(transactionRequest.toTransactionBytes()),
@@ -3737,16 +3726,20 @@ var _Provider = class {
       const { missingOutputVariables, missingOutputContractIds } = getReceiptsWithMissingData(receipts);
       const hasMissingOutputs = missingOutputVariables.length !== 0 || missingOutputContractIds.length !== 0;
       if (hasMissingOutputs) {
+        outputVariables += missingOutputVariables.length;
         transactionRequest.addVariableOutputs(missingOutputVariables.length);
         missingOutputContractIds.forEach(({ contractId }) => {
           transactionRequest.addContractInputAndOutput(Address2.fromString(contractId));
+          missingContractIds.push(contractId);
         });
       } else {
         break;
       }
     }
     return {
-      receipts
+      receipts,
+      outputVariables,
+      missingContractIds
     };
   }
   /**
@@ -3814,11 +3807,15 @@ var _Provider = class {
     const minGas = txRequestClone.calculateMinGas(chainInfo);
     const maxGas = txRequestClone.calculateMaxGas(chainInfo, minGas);
     let receipts = [];
+    let missingContractIds = [];
+    let outputVariables = 0;
     if (isScriptTransaction && estimateTxDependencies) {
       txRequestClone.gasPrice = bn14(0);
       txRequestClone.gasLimit = bn14(maxGasPerTx.sub(maxGas).toNumber() * 0.9);
       const result = await this.estimateTxDependencies(txRequestClone);
       receipts = result.receipts;
+      outputVariables = result.outputVariables;
+      missingContractIds = result.missingContractIds;
     }
     const gasUsed = isScriptTransaction ? getGasUsedFromReceipts(receipts) : minGas;
     const usedFee = calculatePriceWithFactor(
@@ -3840,7 +3837,8 @@ var _Provider = class {
       minFee,
       maxFee,
       estimatedInputs: txRequestClone.inputs,
-      estimatedOutputs: txRequestClone.outputs
+      outputVariables,
+      missingContractIds
     };
   }
   async getResourcesForTransaction(owner, transactionRequestLike, forwardingQuantities = []) {
@@ -4134,7 +4132,7 @@ var _Provider = class {
     };
     if (commitBlockId && commitBlockHeight) {
       throw new FuelError12(
-        ErrorCode11.INVALID_INPUT_PARAMETERS,
+        ErrorCode12.INVALID_INPUT_PARAMETERS,
         "commitBlockId and commitBlockHeight cannot be used together"
       );
     }
@@ -4220,13 +4218,13 @@ var _Provider = class {
    * Lets you produce blocks with custom timestamps and the block number of the last block produced.
    *
    * @param amount - The amount of blocks to produce
-   * @param startTime - The UNIX timestamp to set for the first produced block
+   * @param startTime - The UNIX timestamp (milliseconds) to set for the first produced block
    * @returns A promise that resolves to the block number of the last produced block.
    */
   async produceBlocks(amount, startTime) {
     const { produceBlocks: latestBlockHeight } = await this.operations.produceBlocks({
       blocksToProduce: bn14(amount).toString(10),
-      startTimestamp: startTime ? fromUnixToTai64(startTime) : void 0
+      startTimestamp: startTime ? DateTime2.fromUnixMilliseconds(startTime).toTai64() : void 0
     });
     return bn14(latestBlockHeight);
   }
@@ -4251,7 +4249,7 @@ __publicField(Provider, "chainInfoCache", {});
 __publicField(Provider, "nodeInfoCache", {});
 
 // src/providers/transaction-summary/get-transaction-summary.ts
-import { ErrorCode as ErrorCode12, FuelError as FuelError13 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode13, FuelError as FuelError13 } from "@fuel-ts/errors";
 import { bn as bn15 } from "@fuel-ts/math";
 import { TransactionCoder as TransactionCoder6 } from "@fuel-ts/transactions";
 import { arrayify as arrayify12 } from "@fuel-ts/utils";
@@ -4302,13 +4300,13 @@ var assets = [
 ];
 
 // src/utils/formatTransferToContractScriptData.ts
-import { U64Coder as U64Coder2 } from "@fuel-ts/abi-coder";
+import { BigNumberCoder as BigNumberCoder2 } from "@fuel-ts/abi-coder";
 import { BN as BN2 } from "@fuel-ts/math";
 import { arrayify as arrayify13 } from "@fuel-ts/utils";
 import * as asm from "@fuels/vm-asm";
 var formatTransferToContractScriptData = (params) => {
   const { assetId, amountToTransfer, hexlifiedContractId } = params;
-  const numberCoder = new U64Coder2();
+  const numberCoder = new BigNumberCoder2("u64");
   const encoded = numberCoder.encode(new BN2(amountToTransfer).toNumber());
   const scriptData = Uint8Array.from([
     ...arrayify13(hexlifiedContractId),
@@ -4369,7 +4367,7 @@ var Account = class extends AbstractAccount {
    */
   get provider() {
     if (!this._provider) {
-      throw new FuelError14(ErrorCode13.MISSING_PROVIDER, "Provider not set");
+      throw new FuelError14(ErrorCode14.MISSING_PROVIDER, "Provider not set");
     }
     return this._provider;
   }
@@ -4422,7 +4420,7 @@ var Account = class extends AbstractAccount {
         break;
       }
       throw new FuelError14(
-        ErrorCode13.NOT_SUPPORTED,
+        ErrorCode14.NOT_SUPPORTED,
         `Wallets containing more than ${pageSize} coins exceed the current supported limit.`
       );
     }
@@ -4448,7 +4446,7 @@ var Account = class extends AbstractAccount {
         break;
       }
       throw new FuelError14(
-        ErrorCode13.NOT_SUPPORTED,
+        ErrorCode14.NOT_SUPPORTED,
         `Wallets containing more than ${pageSize} messages exceed the current supported limit.`
       );
     }
@@ -4484,7 +4482,7 @@ var Account = class extends AbstractAccount {
         break;
       }
       throw new FuelError14(
-        ErrorCode13.NOT_SUPPORTED,
+        ErrorCode14.NOT_SUPPORTED,
         `Wallets containing more than ${pageSize} balances exceed the current supported limit.`
       );
     }
@@ -4589,6 +4587,12 @@ var Account = class extends AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async transfer(destination, amount, assetId = BaseAssetId3, txParams = {}) {
+    if (bn16(amount).lte(0)) {
+      throw new FuelError14(
+        ErrorCode14.INVALID_TRANSFER_AMOUNT,
+        "Transfer amount must be a positive number."
+      );
+    }
     const request = await this.createTransfer(destination, amount, assetId, txParams);
     return this.sendTransaction(request, { estimateTxDependencies: false });
   }
@@ -4602,6 +4606,12 @@ var Account = class extends AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async transferToContract(contractId, amount, assetId = BaseAssetId3, txParams = {}) {
+    if (bn16(amount).lte(0)) {
+      throw new FuelError14(
+        ErrorCode14.INVALID_TRANSFER_AMOUNT,
+        "Transfer amount must be a positive number."
+      );
+    }
     const contractAddress = Address3.fromAddressOrString(contractId);
     const { minGasPrice } = this.provider.getGasConfig();
     const params = { gasPrice: minGasPrice, ...txParams };
@@ -4671,7 +4681,7 @@ var Account = class extends AbstractAccount {
   }
   async signMessage(message) {
     if (!this._connector) {
-      throw new FuelError14(ErrorCode13.MISSING_CONNECTOR, "A connector is required to sign messages.");
+      throw new FuelError14(ErrorCode14.MISSING_CONNECTOR, "A connector is required to sign messages.");
     }
     return this._connector.signMessage(this.address.toString(), message);
   }
@@ -4717,13 +4727,13 @@ var Account = class extends AbstractAccount {
   }) {
     if (minGasPrice.gt(gasPrice)) {
       throw new FuelError14(
-        ErrorCode13.GAS_PRICE_TOO_LOW,
+        ErrorCode14.GAS_PRICE_TOO_LOW,
         `Gas price '${gasPrice}' is lower than the required: '${minGasPrice}'.`
       );
     }
     if (gasUsed.gt(gasLimit)) {
       throw new FuelError14(
-        ErrorCode13.GAS_LIMIT_TOO_LOW,
+        ErrorCode14.GAS_LIMIT_TOO_LOW,
         `Gas limit '${gasLimit}' is lower than the required: '${gasUsed}'.`
       );
     }
@@ -4850,7 +4860,7 @@ import {
   decryptJsonWalletData,
   encryptJsonWalletData
 } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode14, FuelError as FuelError15 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode15, FuelError as FuelError15 } from "@fuel-ts/errors";
 import { hexlify as hexlify14 } from "@fuel-ts/utils";
 import { v4 as uuidv4 } from "uuid";
 var DEFAULT_KDF_PARAMS_LOG_N = 13;
@@ -4929,7 +4939,7 @@ async function decryptKeystoreWallet(jsonWallet, password) {
   const macHash = stringFromBuffer(macHashUint8Array, "hex");
   if (mac !== macHash) {
     throw new FuelError15(
-      ErrorCode14.INVALID_PASSWORD,
+      ErrorCode15.INVALID_PASSWORD,
       "Failed to decrypt the keystore wallet, the provided password is incorrect."
     );
   }
@@ -5051,24 +5061,18 @@ var BaseWalletUnlocked = class extends Account {
 __publicField(BaseWalletUnlocked, "defaultPath", "m/44'/1179993420'/0'/0/0");
 
 // src/hdwallet/hdwallet.ts
-import { ErrorCode as ErrorCode17, FuelError as FuelError18 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode18, FuelError as FuelError18 } from "@fuel-ts/errors";
+import { sha256 as sha2564 } from "@fuel-ts/hasher";
 import { bn as bn17, toBytes as toBytes2, toHex } from "@fuel-ts/math";
 import { arrayify as arrayify18, hexlify as hexlify17, concat as concat5 } from "@fuel-ts/utils";
-import {
-  toBeHex,
-  dataSlice as dataSlice2,
-  encodeBase58 as encodeBase582,
-  decodeBase58,
-  sha256 as sha2564,
-  computeHmac as computeHmac2,
-  ripemd160
-} from "ethers";
+import { toBeHex, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58, computeHmac as computeHmac2, ripemd160 } from "ethers";
 
 // src/mnemonic/mnemonic.ts
 import { randomBytes as randomBytes3 } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode16, FuelError as FuelError17 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode17, FuelError as FuelError17 } from "@fuel-ts/errors";
+import { sha256 as sha2563 } from "@fuel-ts/hasher";
 import { arrayify as arrayify17, hexlify as hexlify16, concat as concat4 } from "@fuel-ts/utils";
-import { dataSlice, pbkdf2, sha256 as sha2563, computeHmac, encodeBase58 } from "ethers";
+import { dataSlice, pbkdf2, computeHmac, encodeBase58 } from "ethers";
 
 // src/wordlists/words/english.ts
 var english = [
@@ -7123,9 +7127,9 @@ var english = [
 ];
 
 // src/mnemonic/utils.ts
-import { ErrorCode as ErrorCode15, FuelError as FuelError16 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode16, FuelError as FuelError16 } from "@fuel-ts/errors";
+import { sha256 as sha2562 } from "@fuel-ts/hasher";
 import { arrayify as arrayify16 } from "@fuel-ts/utils";
-import { sha256 as sha2562 } from "ethers";
 function toUtf8Bytes(stri) {
   const str = stri.normalize("NFKD");
   const result = [];
@@ -7141,7 +7145,7 @@ function toUtf8Bytes(stri) {
       const c2 = str.charCodeAt(i);
       if (i >= str.length || (c2 & 64512) !== 56320) {
         throw new FuelError16(
-          ErrorCode15.INVALID_INPUT_PARAMETERS,
+          ErrorCode16.INVALID_INPUT_PARAMETERS,
           "Invalid UTF-8 in the input string."
         );
       }
@@ -7205,7 +7209,7 @@ function mnemonicWordsToEntropy(words, wordlist) {
     const index = wordlist.indexOf(words[i].normalize("NFKD"));
     if (index === -1) {
       throw new FuelError16(
-        ErrorCode15.INVALID_MNEMONIC,
+        ErrorCode16.INVALID_MNEMONIC,
         `Invalid mnemonic: the word '${words[i]}' is not found in the provided wordlist.`
       );
     }
@@ -7222,7 +7226,7 @@ function mnemonicWordsToEntropy(words, wordlist) {
   const checksum = arrayify16(sha2562(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
   if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
     throw new FuelError16(
-      ErrorCode15.INVALID_CHECKSUM,
+      ErrorCode16.INVALID_CHECKSUM,
       "Checksum validation failed for the provided mnemonic."
     );
   }
@@ -7237,7 +7241,7 @@ var MNEMONIC_SIZES = [12, 15, 18, 21, 24];
 function assertWordList(wordlist) {
   if (wordlist.length !== 2048) {
     throw new FuelError17(
-      ErrorCode16.INVALID_WORD_LIST,
+      ErrorCode17.INVALID_WORD_LIST,
       `Expected word list length of 2048, but got ${wordlist.length}.`
     );
   }
@@ -7245,7 +7249,7 @@ function assertWordList(wordlist) {
 function assertEntropy(entropy) {
   if (entropy.length % 4 !== 0 || entropy.length < 16 || entropy.length > 32) {
     throw new FuelError17(
-      ErrorCode16.INVALID_ENTROPY,
+      ErrorCode17.INVALID_ENTROPY,
       `Entropy should be between 16 and 32 bytes and a multiple of 4, but got ${entropy.length} bytes.`
     );
   }
@@ -7255,7 +7259,7 @@ function assertMnemonic(words) {
     const errorMsg = `Invalid mnemonic size. Expected one of [${MNEMONIC_SIZES.join(
       ", "
     )}] words, but got ${words.length}.`;
-    throw new FuelError17(ErrorCode16.INVALID_MNEMONIC, errorMsg);
+    throw new FuelError17(ErrorCode17.INVALID_MNEMONIC, errorMsg);
   }
 }
 var Mnemonic = class {
@@ -7374,7 +7378,7 @@ var Mnemonic = class {
     const seedArray = arrayify17(seed);
     if (seedArray.length < 16 || seedArray.length > 64) {
       throw new FuelError17(
-        ErrorCode16.INVALID_SEED,
+        ErrorCode17.INVALID_SEED,
         `Seed length should be between 16 and 64 bytes, but received ${seedArray.length} bytes.`
       );
     }
@@ -7451,7 +7455,7 @@ function isValidExtendedKey(extendedKey) {
 function parsePath(path2, depth = 0) {
   const components = path2.split("/");
   if (components.length === 0 || components[0] === "m" && depth !== 0) {
-    throw new FuelError18(ErrorCode17.HD_WALLET_ERROR, `invalid path - ${path2}`);
+    throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, `invalid path - ${path2}`);
   }
   if (components[0] === "m") {
     components.shift();
@@ -7481,7 +7485,7 @@ var HDWallet = class {
     } else {
       if (!config.publicKey) {
         throw new FuelError18(
-          ErrorCode17.HD_WALLET_ERROR,
+          ErrorCode18.HD_WALLET_ERROR,
           "Both public and private Key cannot be missing. At least one should be provided."
         );
       }
@@ -7511,7 +7515,7 @@ var HDWallet = class {
     if (index & HARDENED_INDEX) {
       if (!privateKey) {
         throw new FuelError18(
-          ErrorCode17.HD_WALLET_ERROR,
+          ErrorCode18.HD_WALLET_ERROR,
           "Cannot derive a hardened index without a private Key."
         );
       }
@@ -7564,7 +7568,7 @@ var HDWallet = class {
   toExtendedKey(isPublic = false, testnet = false) {
     if (this.depth >= 256) {
       throw new FuelError18(
-        ErrorCode17.HD_WALLET_ERROR,
+        ErrorCode18.HD_WALLET_ERROR,
         `Exceeded max depth of 255. Current depth: ${this.depth}.`
       );
     }
@@ -7595,10 +7599,10 @@ var HDWallet = class {
     const bytes = arrayify18(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
-      throw new FuelError18(ErrorCode17.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
+      throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
     }
     if (!validChecksum) {
-      throw new FuelError18(ErrorCode17.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
+      throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
     }
     const depth = bytes[4];
     const parentFingerprint = hexlify17(bytes.slice(5, 9));
@@ -7607,13 +7611,13 @@ var HDWallet = class {
     const key = bytes.slice(45, 78);
     if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
       throw new FuelError18(
-        ErrorCode17.HD_WALLET_ERROR,
+        ErrorCode18.HD_WALLET_ERROR,
         "Inconsistency detected: Depth is zero but fingerprint/index is non-zero."
       );
     }
     if (isPublicExtendedKey(bytes)) {
       if (key[0] !== 3) {
-        throw new FuelError18(ErrorCode17.HD_WALLET_ERROR, "Invalid public extended key.");
+        throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Invalid public extended key.");
       }
       return new HDWallet({
         publicKey: key,
@@ -7624,7 +7628,7 @@ var HDWallet = class {
       });
     }
     if (key[0] !== 0) {
-      throw new FuelError18(ErrorCode17.HD_WALLET_ERROR, "Invalid private extended key.");
+      throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Invalid private extended key.");
     }
     return new HDWallet({
       privateKey: key.slice(1),