@fuel-ts/account 0.0.0-pr-1788-20240222094224 → 0.75.0

package/dist/test-utils.mjs

@@ -888,67 +888,63 @@ function getSdk(requester) {
 // src/providers/fuel-graphql-subscriber.ts
 import { 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"
+  async next() {
+    if (!this.stream) {
+      await this.setStream();
     }
-  });
-  const subscriptionStreamReader = response.body.pipeThrough(new FuelSubscriptionStream()).getReader();
-  while (true) {
-    const { value, done } = await subscriptionStreamReader.read();
-    if (value instanceof FuelError) {
-      throw value;
-    }
-    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;
+      }
+      const { data, errors } = JSON.parse(text.split("data:")[1]);
+      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";
@@ -1979,8 +1975,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 +1984,7 @@ var BaseTransactionRequest = class {
           );
           break;
         default:
-          break;
+          return;
       }
       if (correspondingInput && "predicateGasUsed" in correspondingInput && bn6(correspondingInput.predicateGasUsed).gt(0)) {
         i.predicate = correspondingInput.predicate;
@@ -2510,6 +2504,7 @@ var fromTai64ToDate = (tai64Timestamp) => {
 };
 
 // src/providers/transaction-summary/operations.ts
+import { ZeroBytes32 as ZeroBytes328 } from "@fuel-ts/address/configs";
 import { ErrorCode as ErrorCode8, 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";
@@ -2706,36 +2701,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 +2798,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 +2941,6 @@ function getOperations({
         rawPayload,
         maxInputs
       }),
-      ...getContractTransferOperations({ receipts }),
       ...getWithdrawFromFuelOperations({ inputs, receipts })
     ];
   }
@@ -3531,7 +3502,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),
@@ -3723,11 +3694,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 +3712,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 +3793,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 +3823,8 @@ var _Provider = class {
       minFee,
       maxFee,
       estimatedInputs: txRequestClone.inputs,
-      estimatedOutputs: txRequestClone.outputs
+      outputVariables,
+      missingContractIds
     };
   }
   async getResourcesForTransaction(owner, transactionRequestLike, forwardingQuantities = []) {