refactor!: use submit_and_await_commit API

packages/fuels-accounts/src/provider.rs

@@ -197,24 +197,29 @@ impl Provider {
     }
 
     /// Sends a transaction to the underlying Provider's client.
-    pub async fn send_transaction_and_await_commit<T: Transaction>(&self, tx: T) -> Result<TxId> {
-        let tx_id = self.send_transaction(tx.clone()).await?;
-        let _status = self.client.await_transaction_commit(&tx_id).await?;
-
+    pub async fn send_transaction_and_await_commit<T: Transaction>(
+        &self,
+        mut tx: T,
+    ) -> Result<TxId> {
+        self.prepare_transaction_for_sending(&mut tx).await?;
+        let tx_id = tx.id(self.chain_id());
+        let _tx_status = self
+            .client
+            .submit_and_await_commit(&tx.clone().into())
+            .await?;
         #[cfg(feature = "coin-cache")]
         {
             if matches!(
-                _status,
+                _tx_status,
                 TransactionStatus::SqueezedOut { .. } | TransactionStatus::Failure { .. }
             ) {
                 self.cache.lock().await.remove_items(tx.used_coins())
             }
         }
-
         Ok(tx_id)
     }
 
-    pub async fn send_transaction<T: Transaction>(&self, mut tx: T) -> Result<TxId> {
+    async fn prepare_transaction_for_sending<T: Transaction>(&self, tx: &mut T) -> Result<()> {
         tx.precompute(&self.chain_id())?;
 
         let chain_info = self.chain_info().await?;
@@ -228,10 +233,18 @@ impl Provider {
         }
 
         self.validate_transaction(tx.clone()).await?;
+        Ok(())
+    }
 
+    pub async fn send_transaction<T: Transaction>(&self, mut tx: T) -> Result<TxId> {
+        self.prepare_transaction_for_sending(&mut tx).await?;
         self.submit(tx).await
     }
 
+    pub async fn await_transaction_commit<T: Transaction>(&self, id: TxId) -> Result<TxStatus> {
+        Ok(self.client.await_transaction_commit(&id).await?.into())
+    }
+
     async fn validate_transaction<T: Transaction>(&self, tx: T) -> Result<()> {
         let tolerance = 0.0;
         let TransactionCost {

packages/fuels-accounts/src/provider/retryable_client.rs

@@ -63,6 +63,11 @@ impl RetryableClient {
             .await
     }
 
+    pub async fn submit_and_await_commit(&self, tx: &Transaction) -> io::Result<TransactionStatus> {
+        self.our_retry(|| self.client.submit_and_await_commit(tx))
+            .await
+    }
+
     pub async fn submit(&self, tx: &Transaction) -> io::Result<types::primitives::TransactionId> {
         self.our_retry(|| self.client.submit(tx)).await
     }