refactor: share wait_for_tx helper across Rust tutorials

rust-client/src/bin/hash_preimage_note.rs

@@ -17,7 +17,7 @@ use miden_client::{
     keystore::{FilesystemKeyStore, Keystore},
     note::{Note, NoteAssets, NoteRecipient, NoteStorage, NoteTag, NoteType, PartialNoteMetadata},
     rpc::{GrpcClient, VerifyingRpcClient},
-    transaction::{TransactionId, TransactionRequestBuilder},
+    transaction::TransactionRequestBuilder,
     Client, ClientError, Felt,
 };
 use miden_client_sqlite_store::ClientBuilderSqliteExt;
@@ -85,14 +85,6 @@ async fn create_basic_faucet(
     Ok(account)
 }
 
-/// Waits for a specific transaction to be committed.
-async fn wait_for_tx(
-    client: &mut Client<FilesystemKeyStore>,
-    tx_id: TransactionId,
-) -> Result<(), ClientError> {
-    rust_client::wait_for_transaction(client, tx_id).await
-}
-
 #[tokio::main]
 async fn main() -> Result<(), ClientError> {
     // Initialize client
@@ -169,7 +161,6 @@ async fn main() -> Result<(), ClientError> {
 
     // Wait for the note to be available
     client.sync_state().await?;
-    wait_for_tx(&mut client, tx_id).await?;
 
     // Consume the minted note
     let consumable_notes = client
@@ -256,8 +247,6 @@ async fn main() -> Result<(), ClientError> {
         tx_id
     );
 
-    wait_for_tx(&mut client, tx_id).await?;
-
     let bob = client
         .get_account(bob_account.id())
         .await?

rust-client/src/bin/network_notes_counter_contract.rs

@@ -19,22 +19,14 @@ use miden_client::{
         NoteRecipient, NoteStorage, NoteTag, NoteType, P2idNote, PartialNoteMetadata,
     },
     rpc::{GrpcClient, VerifyingRpcClient},
-    transaction::{ExpirationTransactionScript, TransactionId, TransactionRequestBuilder},
+    transaction::{ExpirationTransactionScript, TransactionRequestBuilder},
     Client, ClientError, Felt, Word,
 };
 use miden_client_sqlite_store::ClientBuilderSqliteExt;
 use rand::Rng;
 use rust_client::{fund_account_for_fees, FeeConfig, TutorialNetwork};
 use tokio::time::{sleep, Duration};
 
-/// Waits for a specific transaction to be committed.
-async fn wait_for_tx(
-    client: &mut Client<FilesystemKeyStore>,
-    tx_id: TransactionId,
-) -> Result<(), ClientError> {
-    rust_client::wait_for_transaction(client, tx_id).await
-}
-
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Initialize client
@@ -235,7 +227,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("network increment note creation tx submitted, waiting for onchain commitment");
 
     // Wait for the note transaction to be committed
-    wait_for_tx(&mut client, note_tx_id).await.unwrap();
 
     // Waiting for network note to be picked up by the network transaction builder
     sleep(Duration::from_secs(6)).await;

rust-client/src/bin/note_creation_in_masm.rs

@@ -22,7 +22,7 @@ use miden_client::{
         PartialNoteMetadata,
     },
     rpc::{GrpcClient, VerifyingRpcClient},
-    transaction::{TransactionId, TransactionRequestBuilder},
+    transaction::TransactionRequestBuilder,
     Client, ClientError, Felt,
 };
 use miden_client_sqlite_store::ClientBuilderSqliteExt;
@@ -119,14 +119,6 @@ async fn wait_for_notes(
     ))))
 }
 
-/// Waits for a specific transaction to be committed.
-async fn wait_for_tx(
-    client: &mut Client<FilesystemKeyStore>,
-    tx_id: TransactionId,
-) -> Result<(), ClientError> {
-    rust_client::wait_for_transaction(client, tx_id).await
-}
-
 #[tokio::main]
 async fn main() -> Result<(), ClientError> {
     // Initialize client
@@ -307,8 +299,6 @@ async fn main() -> Result<(), ClientError> {
         tx_id
     );
 
-    wait_for_tx(&mut client, tx_id).await?;
-
     // The SDK verifies expected recipients; also check the actual successor's assets and metadata.
     let successor = client
         .get_output_note(output_note.id())

rust-client/src/bin/unauthenticated_note_transfer.rs

@@ -17,22 +17,14 @@ use miden_client::{
     keystore::{FilesystemKeyStore, Keystore},
     note::{Note, NoteType, P2idNote},
     rpc::{GrpcClient, VerifyingRpcClient},
-    transaction::{TransactionId, TransactionRequestBuilder},
+    transaction::TransactionRequestBuilder,
     utils::{Deserializable, Serializable},
     Client, ClientError,
 };
 use miden_client_sqlite_store::ClientBuilderSqliteExt;
 use miden_protocol::transaction::InputNote;
 use rust_client::{fund_account_for_fees, FeeConfig, TutorialNetwork};
 
-/// Waits for a specific transaction to be committed.
-async fn wait_for_tx(
-    client: &mut Client<FilesystemKeyStore>,
-    tx_id: TransactionId,
-) -> Result<(), ClientError> {
-    rust_client::wait_for_transaction(client, tx_id).await
-}
-
 #[tokio::main]
 async fn main() -> Result<(), ClientError> {
     // Initialize client
@@ -176,7 +168,6 @@ async fn main() -> Result<(), ClientError> {
     println!("Minted tokens. TX: {:?}", tx_id);
 
     // Wait for mint transaction to be committed
-    wait_for_tx(&mut client, tx_id).await?;
 
     // Get the minted note and consume it
     let consumable_notes = client
@@ -194,7 +185,6 @@ async fn main() -> Result<(), ClientError> {
         println!("Consumed minted note. TX: {:?}", consume_tx_id);
 
         // Wait for consumption to complete
-        wait_for_tx(&mut client, consume_tx_id).await?;
     }
 
     //------------------------------------------------------------