feat: use submitAndAwait graphql endpoint

apps/docs-snippets/src/utils.ts

@@ -46,10 +46,7 @@ export const getTestWallet = async (seedQuantities?: CoinQuantityLike[]) => {
   await genesisWallet.fund(request, requiredQuantities, minFee);
 
   // execute the transaction, transferring resources to the test wallet
-  const response = await genesisWallet.sendTransaction(request);
-
-  // wait for the transaction to be confirmed
-  await response.wait();
+  await genesisWallet.sendTransaction(request, { awaitExecution: true });
 
   // return the test wallet
   return testWallet;

packages/contract/src/contract-factory.ts

@@ -152,8 +152,9 @@ export default class ContractFactory {
     transactionRequest.maxFee = this.account.provider.getGasConfig().maxGasPerTx;
 
     await this.account.fund(transactionRequest, requiredQuantities, maxFee);
-    const response = await this.account.sendTransaction(transactionRequest);
-    await response.wait();
+    await this.account.sendTransaction(transactionRequest, {
+      awaitExecution: true,
+    });
 
     return new Contract(contractId, this.interface, this.account);
   }

packages/fuel-gauge/src/await-execution.test.ts

@@ -0,0 +1,114 @@
+import { launchNode } from '@fuel-ts/wallet/test-utils';
+import {
+  Provider,
+  WalletUnlocked,
+  randomBytes,
+  Wallet,
+  BaseAssetId,
+  FUEL_NETWORK_URL,
+} from 'fuels';
+
+import { getSetupContract } from './utils';
+
+/**
+ * @group node
+ */
+describe('await-execution', () => {
+  test('awaiting execution of a transaction on the provider works', async () => {
+    const { cleanup, ip, port } = await launchNode({
+      args: ['--poa-interval-period', '400ms'],
+    });
+    const nodeProvider = await Provider.create(`http://${ip}:${port}/graphql`);
+
+    const genesisWallet = new WalletUnlocked(
+      process.env.GENESIS_SECRET || randomBytes(32),
+      nodeProvider
+    );
+
+    const destination = Wallet.generate({ provider: nodeProvider });
+
+    const transfer = await genesisWallet.createTransfer(destination.address, 100, BaseAssetId, {
+      gasPrice: nodeProvider.getGasConfig().minGasPrice,
+      gasLimit: 10_000,
+    });
+
+    transfer.updateWitnessByOwner(
+      genesisWallet.address,
+      await genesisWallet.signTransaction(transfer)
+    );
+
+    const response = await nodeProvider.sendTransaction(transfer, { awaitExecution: true });
+
+    expect(response.gqlTransaction?.status?.type).toBe('SuccessStatus');
+
+    cleanup();
+  });
+  test('calling contracts with awaitExecution works', async () => {
+    const contract = await getSetupContract('coverage-contract')();
+    const sendTransactionSpy = vi.spyOn(contract.provider, 'sendTransaction');
+    const gasPrice = contract.provider.getGasConfig().minGasPrice;
+
+    const { value } = await contract.functions
+      .echo_u8(3)
+      .txParams({ gasPrice, gasLimit: 10_000 })
+      .call({ awaitExecution: true });
+    expect(value).toBe(3);
+
+    expect(sendTransactionSpy).toHaveBeenCalledTimes(1);
+    const awaitExecutionArg = sendTransactionSpy.mock.calls[0][1];
+    expect(awaitExecutionArg).toMatchObject({ awaitExecution: true });
+  });
+
+  test('transferring funds with awaitExecution works', async () => {
+    const provider = await Provider.create(FUEL_NETWORK_URL);
+    const genesisWallet = new WalletUnlocked(
+      process.env.GENESIS_SECRET || randomBytes(32),
+      provider
+    );
+
+    const sendTransactionSpy = vi.spyOn(provider, 'sendTransaction');
+
+    const destination = Wallet.generate({ provider });
+
+    await genesisWallet.transfer(
+      destination.address,
+      100,
+      BaseAssetId,
+      {
+        gasPrice: provider.getGasConfig().minGasPrice,
+        gasLimit: 10_000,
+      },
+      { awaitExecution: true }
+    );
+
+    expect(sendTransactionSpy).toHaveBeenCalledTimes(1);
+    const awaitExecutionArg = sendTransactionSpy.mock.calls[0][1];
+    expect(awaitExecutionArg).toMatchObject({ awaitExecution: true });
+  });
+
+  test('withdrawToBaseLayer works with awaitExecution', async () => {
+    const provider = await Provider.create(FUEL_NETWORK_URL);
+    const genesisWallet = new WalletUnlocked(
+      process.env.GENESIS_SECRET || randomBytes(32),
+      provider
+    );
+
+    const sendTransactionSpy = vi.spyOn(provider, 'sendTransaction');
+
+    const destination = Wallet.generate({ provider });
+
+    await genesisWallet.withdrawToBaseLayer(
+      destination.address,
+      100,
+      {
+        gasPrice: provider.getGasConfig().minGasPrice,
+        gasLimit: 10_000,
+      },
+      { awaitExecution: true }
+    );
+
+    expect(sendTransactionSpy).toHaveBeenCalledTimes(1);
+    const awaitExecutionArg = sendTransactionSpy.mock.calls[0][1];
+    expect(awaitExecutionArg).toMatchObject({ awaitExecution: true });
+  });
+});

packages/fuel-gauge/src/predicate/utils/predicate/fundPredicate.ts

@@ -17,8 +17,7 @@ export const fundPredicate = async <T extends InputValue[]>(
   request.gasLimit = gasUsed;
   await wallet.fund(request, requiredQuantities, minFee);
 
-  const tx = await wallet.sendTransaction(request);
-  await tx.waitForResult();
+  await wallet.sendTransaction(request, { awaitExecution: true });
 
   return predicate.getBalance();
 };

packages/interfaces/src/index.ts

@@ -60,7 +60,7 @@ export abstract class AbstractAccount {
   abstract address: AbstractAddress;
   abstract provider: unknown;
   abstract getResourcesToSpend(quantities: any[], options?: any): any;
-  abstract sendTransaction(transactionRequest: any): any;
+  abstract sendTransaction(transactionRequest: any, options?: any): any;
   abstract simulateTransaction(transactionRequest: any): any;
   abstract fund(transactionRequest: any, quantities: any, fee: any): Promise<void>;
 }
@@ -74,7 +74,7 @@ export abstract class AbstractProgram {
   };
 
   abstract provider: {
-    sendTransaction(transactionRequest: any): any;
+    sendTransaction(transactionRequest: any, options?: any): any;
   } | null;
 }
 

packages/predicate/src/predicate.ts

@@ -14,6 +14,7 @@ import type { BigNumberish } from '@fuel-ts/math';
 import type {
   CallResult,
   Provider,
+  ProviderSendTxParams,
   TransactionRequest,
   TransactionRequestLike,
   TransactionResponse,
@@ -113,9 +114,12 @@ export class Predicate<ARGS extends InputValue[]> extends Account implements Abs
    * @param transactionRequestLike - The transaction request-like object.
    * @returns A promise that resolves to the transaction response.
    */
-  sendTransaction(transactionRequestLike: TransactionRequestLike): Promise<TransactionResponse> {
+  sendTransaction(
+    transactionRequestLike: TransactionRequestLike,
+    options?: Pick<ProviderSendTxParams, 'awaitExecution'>
+  ): Promise<TransactionResponse> {
     const transactionRequest = this.populateTransactionPredicateData(transactionRequestLike);
-    return super.sendTransaction(transactionRequest);
+    return super.sendTransaction(transactionRequest, options);
   }
 
   /**

packages/program/src/functions/base-invocation-scope.ts

@@ -4,7 +4,7 @@ import { ErrorCode, FuelError } from '@fuel-ts/errors';
 import type { AbstractContract, AbstractProgram } from '@fuel-ts/interfaces';
 import type { BN } from '@fuel-ts/math';
 import { bn, toNumber } from '@fuel-ts/math';
-import type { Provider, CoinQuantity } from '@fuel-ts/providers';
+import type { Provider, CoinQuantity, ProviderSendTxParams } from '@fuel-ts/providers';
 import { ScriptTransactionRequest } from '@fuel-ts/providers';
 import { InputType } from '@fuel-ts/transactions';
 import type { BaseWalletUnlocked } from '@fuel-ts/wallet';
@@ -288,7 +288,9 @@ export class BaseInvocationScope<TReturn = any> {
    *
    * @returns The result of the function invocation.
    */
-  async call<T = TReturn>(): Promise<FunctionInvocationResult<T>> {
+  async call<T = TReturn>(
+    options?: Pick<ProviderSendTxParams, 'awaitExecution'>
+  ): Promise<FunctionInvocationResult<T>> {
     assert(this.program.account, 'Wallet is required!');
 
     const transactionRequest = await this.getTransactionRequest();
@@ -297,7 +299,7 @@ export class BaseInvocationScope<TReturn = any> {
 
     await this.fundWithRequiredCoins(maxFee);
 
-    const response = await this.program.account.sendTransaction(transactionRequest);
+    const response = await this.program.account.sendTransaction(transactionRequest, options);
 
     return FunctionInvocationResult.build<T>(
       this.functionInvocationScopes,

packages/providers/src/provider.ts

@@ -251,7 +251,16 @@ export type ProviderCallParams = UTXOValidationParams & EstimateTransactionParam
 /**
  * Provider Send transaction params
  */
-export type ProviderSendTxParams = EstimateTransactionParams;
+export type ProviderSendTxParams = EstimateTransactionParams & {
+  /**
+   * By default, the promise will resolve immediately after the transaction is submitted.
+   *
+   * If set to true, the promise will resolve only when the transaction changes status
+   * from `SubmittedStatus` to one of `SuccessStatus`, `FailureStatus` or `SqueezedOutStatus`.
+   *
+   */
+  awaitExecution?: boolean;
+};
 
 /**
  * URL - Consensus Params mapping.
@@ -564,7 +573,7 @@ export default class Provider {
   // #region Provider-sendTransaction
   async sendTransaction(
     transactionRequestLike: TransactionRequestLike,
-    { estimateTxDependencies = true }: ProviderSendTxParams = {}
+    { estimateTxDependencies = true, awaitExecution = false }: ProviderSendTxParams = {}
   ): Promise<TransactionResponse> {
     const transactionRequest = transactionRequestify(transactionRequestLike);
     this.#cacheInputs(transactionRequest.inputs);
@@ -573,7 +582,6 @@ export default class Provider {
     }
     // #endregion Provider-sendTransaction
 
-    const encodedTransaction = hexlify(transactionRequest.toTransactionBytes());
     const { gasUsed, minGasPrice } = await this.getTransactionCost(transactionRequest, [], {
       estimateTxDependencies: false,
       estimatePredicates: false,
@@ -595,12 +603,27 @@ export default class Provider {
       );
     }
 
+    const encodedTransaction = hexlify(transactionRequest.toTransactionBytes());
+
+    if (awaitExecution) {
+      const subscription = this.operations.submitAndAwait({ encodedTransaction });
+      for await (const { submitAndAwait } of subscription) {
+        if (submitAndAwait.type === 'SuccessStatus') {
+          break;
+        }
+      }
+
+      const transactionId = transactionRequest.getTransactionId(this.getChainId());
+      const response = new TransactionResponse(transactionId, this);
+      await response.fetch();
+      return response;
+    }
+
     const {
       submit: { id: transactionId },
     } = await this.operations.submit({ encodedTransaction });
 
-    const response = new TransactionResponse(transactionId, this);
-    return response;
+    return new TransactionResponse(transactionId, this);
   }
 
   /**

packages/providers/src/transaction-response/transaction-response.ts

@@ -197,14 +197,12 @@ export class TransactionResponse {
     return transactionSummary;
   }
 
-  /**
-   * Waits for transaction to complete and returns the result.
-   *
-   * @returns The completed transaction result
-   */
-  async waitForResult<TTransactionType = void>(
-    contractsAbiMap?: AbiMap
-  ): Promise<TransactionResult<TTransactionType>> {
+  private async waitForStatusChange() {
+    const status = this.gqlTransaction?.status?.type;
+    if (status && status !== 'SubmittedStatus') {
+      return;
+    }
+
     const subscription = this.provider.operations.statusChange({
       transactionId: this.id,
     });
@@ -216,6 +214,17 @@ export class TransactionResponse {
     }
 
     await this.fetch();
+  }
+
+  /**
+   * Waits for transaction to complete and returns the result.
+   *
+   * @returns The completed transaction result
+   */
+  async waitForResult<TTransactionType = void>(
+    contractsAbiMap?: AbiMap
+  ): Promise<TransactionResult<TTransactionType>> {
+    await this.waitForStatusChange();
 
     const transactionSummary = await this.getTransactionSummary<TTransactionType>(contractsAbiMap);
 

packages/wallet/src/account.test.ts

@@ -333,7 +333,7 @@ describe('Account', () => {
     );
 
     expect(sendTransactionSpy).toHaveBeenCalledTimes(1);
-    expect(sendTransactionSpy).toHaveBeenCalledWith(request);
+    expect(sendTransactionSpy).toHaveBeenCalledWith(request, undefined);
   });
 
   it('should execute withdrawToBaseLayer just fine', async () => {
@@ -392,7 +392,7 @@ describe('Account', () => {
     expect(scriptTransactionRequest).toHaveBeenCalledTimes(1);
 
     expect(sendTransaction).toHaveBeenCalledTimes(1);
-    expect(sendTransaction).toHaveBeenCalledWith(request);
+    expect(sendTransaction).toHaveBeenCalledWith(request, undefined);
 
     expect(getTransactionCost).toHaveBeenCalledTimes(1);
     expect(fund).toHaveBeenCalledTimes(1);
@@ -405,7 +405,7 @@ describe('Account', () => {
     expect(scriptTransactionRequest).toHaveBeenCalledTimes(2);
 
     expect(sendTransaction).toHaveBeenCalledTimes(2);
-    expect(sendTransaction).toHaveBeenCalledWith(request);
+    expect(sendTransaction).toHaveBeenCalledWith(request, undefined);
   });
 
   it('should execute sendTransaction just fine', async () => {