Make preconfirmation optional on API endpoints

.changes/changed/2925.md

@@ -0,0 +1 @@
+Make preconfirmation optional on API endpoints.

crates/client/assets/schema.sdl

@@ -1334,7 +1334,11 @@ type Subscription {
 		"""
 		The ID of the transaction
 		"""
-		id: TransactionId!
+		id: TransactionId!,
+		"""
+		If true, accept to receive the preconfirmation status
+		"""
+		allowPreconfirmation: Boolean
 	): TransactionStatus!
 	"""
 	Submits transaction to the `TxPool` and await either success or failure.
@@ -1343,9 +1347,9 @@ type Subscription {
 	"""
 	Submits the transaction to the `TxPool` and returns a stream of events.
 	Compared to the `submitAndAwait`, the stream also contains
-	`SubmittedStatus` as an intermediate state.
+	`SubmittedStatus` and potentially preconfirmation as an intermediate state.
 	"""
-	submitAndAwaitStatus(tx: HexString!, estimatePredicates: Boolean): TransactionStatus!
+	submitAndAwaitStatus(tx: HexString!, estimatePredicates: Boolean, allowPreconfirmation: Boolean): TransactionStatus!
 	contractStorageSlots(contractId: ContractId!): StorageSlot!
 	contractStorageBalances(contractId: ContractId!): ContractBalance!
 }
@@ -1387,7 +1391,7 @@ type Transaction {
 	outputContract: ContractOutput
 	witnesses: [HexString!]
 	receiptsRoot: Bytes32
-	status: TransactionStatus
+	status(allowPreconfirmation: Boolean): TransactionStatus
 	script: HexString
 	scriptData: HexString
 	bytecodeWitnessIndex: U16

crates/client/src/client.rs

@@ -938,8 +938,10 @@ impl FuelClient {
     pub async fn submit_and_await_status<'a>(
         &'a self,
         tx: &'a Transaction,
+        allow_preconfirmation: bool,
     ) -> io::Result<impl Stream<Item = io::Result<TransactionStatus>> + 'a> {
-        self.submit_and_await_status_opt(tx, None).await
+        self.submit_and_await_status_opt(tx, None, Some(allow_preconfirmation))
+            .await
     }
 
     /// Similar to [`Self::submit_and_await_commit_opt`], but includes all intermediate states.
@@ -948,13 +950,16 @@ impl FuelClient {
         &'a self,
         tx: &'a Transaction,
         estimate_predicates: Option<bool>,
+        allow_preconfirmation: Option<bool>,
     ) -> io::Result<impl Stream<Item = io::Result<TransactionStatus>> + 'a> {
         use cynic::SubscriptionBuilder;
+        use schema::tx::SubmitAndAwaitStatusArg;
         let tx = tx.clone().to_bytes();
         let s = schema::tx::SubmitAndAwaitStatusSubscription::build(
-            TxWithEstimatedPredicatesArg {
+            SubmitAndAwaitStatusArg {
                 tx: HexString(Bytes(tx)),
                 estimate_predicates,
+                allow_preconfirmation,
             },
         );
 

crates/client/src/client/schema/tx.rs

@@ -497,6 +497,15 @@ pub struct TxWithEstimatedPredicatesArg {
     pub estimate_predicates: Option<bool>,
 }
 
+#[derive(cynic::QueryVariables)]
+pub struct SubmitAndAwaitStatusArg {
+    pub tx: HexString,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub estimate_predicates: Option<bool>,
+    #[cynic(skip_serializing_if = "Option::is_none")]
+    pub allow_preconfirmation: Option<bool>,
+}
+
 #[derive(cynic::QueryFragment, Clone, Debug)]
 #[cynic(
     schema_path = "./assets/schema.sdl",
@@ -643,10 +652,10 @@ pub struct SubmitAndAwaitSubscriptionWithTransaction {
 #[cynic(
     schema_path = "./assets/schema.sdl",
     graphql_type = "Subscription",
-    variables = "TxWithEstimatedPredicatesArg"
+    variables = "SubmitAndAwaitStatusArg"
 )]
 pub struct SubmitAndAwaitStatusSubscription {
-    #[arguments(tx: $tx, estimatePredicates: $estimate_predicates)]
+    #[arguments(tx: $tx, estimatePredicates: $estimate_predicates, allowPreconfirmation: $allow_preconfirmation)]
     pub submit_and_await_status: TransactionStatus,
 }
 

crates/fuel-core/src/query/subscriptions.rs

@@ -28,6 +28,7 @@ pub(crate) async fn transaction_status_change<'a, State>(
     state: State,
     stream: BoxStream<'a, TxStatusMessage>,
     transaction_id: Bytes32,
+    allow_preconfirmation: bool,
 ) -> impl Stream<Item = anyhow::Result<ApiTxStatus>> + 'a
 where
     State: TxnStatusChangeState + Send + Sync + 'a,
@@ -50,7 +51,7 @@ where
         .chain(stream)
         // Keep taking the stream until the oneshot channel is closed.
         .take_until(closed)
-        .map(move |status| {
+        .filter_map(move |status | {
             if status.is_final() {
                 if let Some(close) = close.take() {
                     let _ = close.send(());
@@ -60,11 +61,15 @@ where
             match status {
                 TxStatusMessage::Status(status) => {
                     let status = ApiTxStatus::new(transaction_id, status);
-                    Ok(status)
+                    if !allow_preconfirmation && (matches!(status, ApiTxStatus::PreconfirmationFailure(_)) || matches!(status, ApiTxStatus::PreconfirmationSuccess(_))) {
+                        futures::future::ready(None)
+                    } else {
+                        futures::future::ready(Some(Ok(status)))
+                    }
                 },
                 // Map a failed status to an error for the api.
                 TxStatusMessage::FailedStatus => {
-                    Err(anyhow::anyhow!("Failed to get transaction status"))
+                    futures::future::ready(Some(Err(anyhow::anyhow!("Failed to get transaction status"))))
                 }
             }
         })

crates/fuel-core/src/query/subscriptions/test.rs

@@ -274,7 +274,7 @@ fn test_tsc_inner(
                 });
 
             let stream = futures::stream::iter(stream).boxed();
-            super::transaction_status_change(mock_state, stream, txn_id(0))
+            super::transaction_status_change(mock_state, stream, txn_id(0), true)
                 .await
                 .collect::<Vec<_>>()
                 .await

crates/fuel-core/src/schema/tx.rs

@@ -624,6 +624,8 @@ impl TxStatusSubscription {
         &self,
         ctx: &'a Context<'a>,
         #[graphql(desc = "The ID of the transaction")] id: TransactionId,
+        #[graphql(desc = "If true, accept to receive the preconfirmation status")]
+        allow_preconfirmation: Option<bool>,
     ) -> anyhow::Result<impl Stream<Item = async_graphql::Result<TransactionStatus>> + 'a>
     {
         let tx_status_manager = ctx.data_unchecked::<DynTxStatusManager>();
@@ -634,11 +636,14 @@ impl TxStatusSubscription {
             tx_status_manager,
             query,
         };
-        Ok(
-            transaction_status_change(status_change_state, rx, id.into())
-                .await
-                .map_err(async_graphql::Error::from),
+        Ok(transaction_status_change(
+            status_change_state,
+            rx,
+            id.into(),
+            allow_preconfirmation.unwrap_or(false),
         )
+        .await
+        .map_err(async_graphql::Error::from))
     }
 
     /// Submits transaction to the `TxPool` and await either success or failure.
@@ -653,7 +658,7 @@ impl TxStatusSubscription {
     > {
         use tokio_stream::StreamExt;
         let subscription =
-            submit_and_await_status(ctx, tx, estimate_predicates.unwrap_or(false))
+            submit_and_await_status(ctx, tx, estimate_predicates.unwrap_or(false), false)
                 .await?;
 
         Ok(subscription
@@ -663,24 +668,32 @@ impl TxStatusSubscription {
 
     /// Submits the transaction to the `TxPool` and returns a stream of events.
     /// Compared to the `submitAndAwait`, the stream also contains
-    /// `SubmittedStatus` as an intermediate state.
+    /// `SubmittedStatus` and potentially preconfirmation as an intermediate state.
     #[graphql(complexity = "query_costs().submit_and_await + child_complexity")]
     async fn submit_and_await_status<'a>(
         &self,
         ctx: &'a Context<'a>,
         tx: HexString,
         estimate_predicates: Option<bool>,
+        allow_preconfirmation: Option<bool>,
     ) -> async_graphql::Result<
         impl Stream<Item = async_graphql::Result<TransactionStatus>> + 'a,
     > {
-        submit_and_await_status(ctx, tx, estimate_predicates.unwrap_or(false)).await
+        submit_and_await_status(
+            ctx,
+            tx,
+            estimate_predicates.unwrap_or(false),
+            allow_preconfirmation.unwrap_or(false),
+        )
+        .await
     }
 }
 
 async fn submit_and_await_status<'a>(
     ctx: &'a Context<'a>,
     tx: HexString,
     estimate_predicates: bool,
+    allow_preconfirmation: bool,
 ) -> async_graphql::Result<
     impl Stream<Item = async_graphql::Result<TransactionStatus>> + 'a,
 > {
@@ -703,13 +716,29 @@ async fn submit_and_await_status<'a>(
     txpool.insert(tx).await?;
 
     Ok(subscription
-        .map(move |event| match event {
-            TxStatusMessage::Status(status) => {
-                let status = TransactionStatus::new(tx_id, status);
-                Ok(status)
-            }
-            TxStatusMessage::FailedStatus => {
-                Err(anyhow::anyhow!("Failed to get transaction status").into())
+        .filter_map(move |status| {
+            match status {
+                TxStatusMessage::Status(status) => {
+                    let status = TransactionStatus::new(tx_id, status);
+                    if !allow_preconfirmation
+                        && (matches!(
+                            status,
+                            TransactionStatus::PreconfirmationFailure(_)
+                        ) || matches!(
+                            status,
+                            TransactionStatus::PreconfirmationSuccess(_)
+                        ))
+                    {
+                        None
+                    } else {
+                        Some(Ok(status))
+                    }
+                }
+                // Map a failed status to an error for the api.
+                TxStatusMessage::FailedStatus => Some(Err(anyhow::anyhow!(
+                    "Failed to get transaction status"
+                )
+                .into())),
             }
         })
         .take(3))

crates/fuel-core/src/schema/tx/types.rs

@@ -769,15 +769,21 @@ impl Transaction {
     async fn status(
         &self,
         ctx: &Context<'_>,
+        allow_preconfirmation: Option<bool>,
     ) -> async_graphql::Result<Option<TransactionStatus>> {
         let id = self.1;
         let query = ctx.read_view()?;
 
         let tx_status_manager = ctx.data_unchecked::<DynTxStatusManager>();
 
-        get_tx_status(id, query.as_ref(), tx_status_manager)
-            .await
-            .map_err(Into::into)
+        get_tx_status(
+            id,
+            query.as_ref(),
+            tx_status_manager,
+            allow_preconfirmation.unwrap_or(false),
+        )
+        .await
+        .map_err(Into::into)
     }
 
     async fn script(&self) -> Option<HexString> {
@@ -1097,6 +1103,7 @@ pub(crate) async fn get_tx_status(
     id: fuel_core_types::fuel_types::Bytes32,
     query: &ReadView,
     tx_status_manager: &DynTxStatusManager,
+    allow_preconfirmation: bool,
 ) -> Result<Option<TransactionStatus>, StorageError> {
     let api_result = query
         .tx_status(&id)
@@ -1109,7 +1116,28 @@ pub(crate) async fn get_tx_status(
         None => {
             let status = tx_status_manager.status(id).await?;
             match status {
-                Some(status) => Ok(Some(TransactionStatus::new(id, status))),
+                Some(status) => {
+                    let status = TransactionStatus::new(id, status);
+
+                    // Filter out preconfirmation statuses if not allowed. Converting to submitted status
+                    // because it's the closest to the preconfirmation status.
+                    // Having `now()` as timestamp isn't ideal but shouldn't cause much inconsistency.
+                    if !allow_preconfirmation
+                        && (matches!(
+                            status,
+                            TransactionStatus::PreconfirmationSuccess(_)
+                        ) || matches!(
+                            status,
+                            TransactionStatus::PreconfirmationFailure(_)
+                        ))
+                    {
+                        Ok(Some(TransactionStatus::Submitted(SubmittedStatus(
+                            Tai64::now(),
+                        ))))
+                    } else {
+                        Ok(Some(status))
+                    }
+                }
                 None => Ok(None),
             }
         }

crates/fuel-core/src/service/query.rs

@@ -89,7 +89,7 @@ impl FuelService {
             db,
             tx_status_manager,
         };
-        Ok(transaction_status_change(state, rx, id).await)
+        Ok(transaction_status_change(state, rx, id, false).await)
     }
 }
 

tests/test-helpers/src/counter_contract.rs

@@ -78,7 +78,7 @@ pub async fn deploy(
     let contract_id = CreateMetadata::compute(&tx).unwrap().contract_id;
 
     let tx = tx.into();
-    let mut status_stream = client.submit_and_await_status(&tx).await.unwrap();
+    let mut status_stream = client.submit_and_await_status(&tx, true).await.unwrap();
     let intermediate_status = status_stream.next().await.unwrap().unwrap();
     assert!(matches!(
         intermediate_status,