fix: format

Signed-off-by: gsstoykov <[email protected]>

Author: gsstoykov

examples/batch_transaction.rs

@@ -3,14 +3,7 @@
 use std::str::FromStr;
 
 use hedera::{
-    AccountBalanceQuery,
-    AccountCreateTransaction,
-    AccountId,
-    BatchTransaction,
-    Client,
-    Hbar,
-    PrivateKey,
-    TransferTransaction,
+    AccountBalanceQuery, AccountCreateTransaction, AccountId, BatchTransaction, Client, Hbar, PrivateKey, TransferTransaction
 };
 
 #[tokio::main]
@@ -48,7 +41,7 @@ async fn main() -> hedera::Result<()> {
     // Create a transfer from Alice to the operator
     let mut alice_transfer = TransferTransaction::new();
     alice_transfer
-        .hbar_transfer(alice, Hbar::new(-1))  // Alice sends 1 HBAR
+        .hbar_transfer(alice, Hbar::new(-1)) // Alice sends 1 HBAR
         .hbar_transfer(operator_account, Hbar::new(1)); // Operator receives 1 HBAR
 
     // Freeze the transaction and set batch key
@@ -59,7 +52,7 @@ async fn main() -> hedera::Result<()> {
     // Create a transfer from Bob to the operator
     let mut bob_transfer = TransferTransaction::new();
     bob_transfer
-        .hbar_transfer(bob, Hbar::new(-2))     // Bob sends 2 HBAR
+        .hbar_transfer(bob, Hbar::new(-2)) // Bob sends 2 HBAR
         .hbar_transfer(operator_account, Hbar::new(2)); // Operator receives 2 HBAR
 
     // Freeze the transaction and set batch key
@@ -75,7 +68,7 @@ async fn main() -> hedera::Result<()> {
 
     // Step 5: Create and execute the batch transaction
     println!("\nExecuting batch transaction...");
-    
+
     let mut batch = BatchTransaction::new();
     batch.add_inner_transaction(alice_transfer.into())?;
     batch.add_inner_transaction(bob_transfer.into())?;
@@ -85,7 +78,7 @@ async fn main() -> hedera::Result<()> {
     // Execute the batch transaction
     let response = batch.execute(&client).await?;
     let receipt = response.get_receipt(&client).await?;
-    
+
     println!("Batch transaction executed successfully!");
     println!("Transaction ID: {}", response.transaction_id);
     println!("Status: {:?}", receipt.status);
@@ -121,9 +114,11 @@ async fn create_account(
         .await?;
 
     let receipt = response.get_receipt(client).await?;
-    receipt.account_id.ok_or_else(|| hedera::Error::TimedOut(
-        Box::new(hedera::Error::GrpcStatus(tonic::Status::not_found("account_id not found in receipt")))
-    ))
+    receipt.account_id.ok_or_else(|| {
+        hedera::Error::TimedOut(Box::new(hedera::Error::GrpcStatus(
+            tonic::Status::not_found("account_id not found in receipt"),
+        )))
+    })
 }
 
 async fn print_balance(client: &Client, name: &str, account_id: AccountId) -> hedera::Result<()> {
@@ -133,4 +128,4 @@ async fn print_balance(client: &Client, name: &str, account_id: AccountId) -> he
         .await?;
     println!("{}: {} HBAR", name, balance.hbars);
     Ok(())
-} 
+}

src/batch_transaction.rs

@@ -2,6 +2,7 @@
 
 use hedera_proto::services;
 use hedera_proto::services::util_service_client::UtilServiceClient;
+use prost::Message;
 use tonic::transport::Channel;
 
 use crate::ledger_id::RefLedgerId;
@@ -13,8 +14,6 @@ use crate::transaction::{
     TransactionData,
     TransactionExecute,
 };
-use prost::Message;
-
 use crate::{
     AnyTransaction,
     BoxGrpcFuture,
@@ -27,38 +26,38 @@ use crate::{
 
 /// Execute multiple transactions in a single consensus event. This allows for atomic execution of multiple
 /// transactions, where they either all succeed or all fail together.
-/// 
+///
 /// # Requirements
-/// 
+///
 /// - All inner transactions must be frozen before being added to the batch
 /// - All inner transactions must have a batch key set (using `set_batch_key()` or `batchify()`)
 /// - All inner transactions must be signed as required for each individual transaction
 /// - The BatchTransaction must be signed by all batch keys of the inner transactions
 /// - Certain transaction types (FreezeTransaction, BatchTransaction) are not allowed in a batch
-/// 
+///
 /// # Important notes
-/// 
+///
 /// - Fees are assessed for each inner transaction separately
 /// - The maximum number of inner transactions in a batch is limited to 25
 /// - Inner transactions cannot be scheduled transactions
-/// 
+///
 /// # Example usage
-/// 
+///
 /// ```rust,no_run
 /// use hedera::{BatchTransaction, TransferTransaction, PrivateKey, Client, Hbar};
-/// 
+///
 /// # async fn example() -> hedera::Result<()> {
 /// let client = Client::for_testnet();
 /// let batch_key = PrivateKey::generate_ed25519();
-/// 
+///
 /// // Create and prepare inner transaction
 /// let inner_transaction = TransferTransaction::new()
 ///     .hbar_transfer(sender, -amount)
 ///     .hbar_transfer(receiver, amount)
 ///     .freeze_with(&client)?
 ///     .set_batch_key(batch_key.public_key().into())
 ///     .sign(&operator_key)?;
-/// 
+///
 /// // Create and execute batch transaction
 /// let response = BatchTransaction::new()
 ///     .add_inner_transaction(inner_transaction)?
@@ -78,50 +77,56 @@ pub struct BatchTransactionData {
 
 impl BatchTransaction {
     /// Append a transaction to the list of transactions this BatchTransaction will execute.
-    /// 
+    ///
     /// # Requirements for the inner transaction
-    /// 
+    ///
     /// - Must be frozen (use `freeze()` or `freeze_with(client)`)
     /// - Must have a batch key set (use `set_batch_key()` or `batchify()`)
     /// - Must not be a blacklisted transaction type
-    /// 
+    ///
     /// # Errors
-    /// 
+    ///
     /// Returns an error if:
     /// - The transaction is null
     /// - This transaction is frozen
     /// - The inner transaction is not frozen or missing a batch key
     /// - The transaction is of a blacklisted type (FreezeTransaction, BatchTransaction)
-    pub fn add_inner_transaction(&mut self, transaction: AnyTransaction) -> crate::Result<&mut Self> {
+    pub fn add_inner_transaction(
+        &mut self,
+        transaction: AnyTransaction,
+    ) -> crate::Result<&mut Self> {
         self.require_not_frozen();
         self.validate_inner_transaction(&transaction)?;
         self.data_mut().inner_transactions.push(transaction);
         Ok(self)
     }
 
     /// Set the list of transactions to be executed as part of this BatchTransaction.
-    /// 
+    ///
     /// # Requirements for each inner transaction
-    /// 
+    ///
     /// - Must be frozen (use `freeze()` or `freeze_with(client)`)
     /// - Must have a batch key set (use `set_batch_key()` or `batchify()`)
     /// - Must not be a blacklisted transaction type
-    /// 
+    ///
     /// Note: This method creates a defensive copy of the provided list.
-    /// 
+    ///
     /// # Errors
-    /// 
+    ///
     /// Returns an error if:
     /// - Any inner transaction is not frozen or missing a batch key
     /// - Any transaction is of a blacklisted type
-    pub fn set_inner_transactions(&mut self, transactions: Vec<AnyTransaction>) -> crate::Result<&mut Self> {
+    pub fn set_inner_transactions(
+        &mut self,
+        transactions: Vec<AnyTransaction>,
+    ) -> crate::Result<&mut Self> {
         self.require_not_frozen();
-        
+
         // Validate all transactions before setting
         for transaction in &transactions {
             self.validate_inner_transaction(transaction)?;
         }
-        
+
         self.data_mut().inner_transactions = transactions;
         Ok(self)
     }
@@ -132,24 +137,20 @@ impl BatchTransaction {
     }
 
     /// Get the list of transaction IDs of each inner transaction of this BatchTransaction.
-    /// 
+    ///
     /// This method is particularly useful after execution to:
     /// - Track individual transaction results
     /// - Query receipts for specific inner transactions
     /// - Monitor the status of each transaction in the batch
-    /// 
+    ///
     /// **NOTE:** Transaction IDs will only be meaningful after the batch transaction has been
     /// executed or the IDs have been explicitly set on the inner transactions.
     pub fn get_inner_transaction_ids(&self) -> Vec<Option<TransactionId>> {
-        self.data()
-            .inner_transactions
-            .iter()
-            .map(|tx| tx.get_transaction_id())
-            .collect()
+        self.data().inner_transactions.iter().map(|tx| tx.get_transaction_id()).collect()
     }
 
     /// Validates if a transaction is allowed in a batch transaction.
-    /// 
+    ///
     /// A transaction is valid if:
     /// - It is not a blacklisted type (FreezeTransaction or BatchTransaction)
     /// - It is frozen
@@ -159,12 +160,12 @@ impl BatchTransaction {
         match transaction.data() {
             AnyTransactionData::Freeze(_) => {
                 return Err(Error::basic_parse(
-                    "Transaction type FreezeTransaction is not allowed in a batch transaction"
+                    "Transaction type FreezeTransaction is not allowed in a batch transaction",
                 ));
             }
             AnyTransactionData::Batch(_) => {
                 return Err(Error::basic_parse(
-                    "Transaction type BatchTransaction is not allowed in a batch transaction"
+                    "Transaction type BatchTransaction is not allowed in a batch transaction",
                 ));
             }
             _ => {}
@@ -196,11 +197,12 @@ impl ToTransactionDataProtobuf for BatchTransactionData {
         _chunk_info: &ChunkInfo,
     ) -> services::transaction_body::Data {
         let mut builder = services::AtomicBatchTransactionBody::default();
-        
+
         for transaction in &self.inner_transactions {
             // Get the signed transaction bytes from each inner transaction
             // Note: This unwrap is OK because inner transactions should be frozen
-            let signed_transaction_bytes = transaction.to_signed_transaction_bytes()
+            let signed_transaction_bytes = transaction
+                .to_signed_transaction_bytes()
                 .expect("Inner transaction should be frozen and serializable");
             builder.transactions.push(signed_transaction_bytes);
         }
@@ -231,14 +233,12 @@ impl ValidateChecksums for BatchTransactionData {
 impl FromProtobuf<services::AtomicBatchTransactionBody> for BatchTransactionData {
     fn from_protobuf(pb: services::AtomicBatchTransactionBody) -> crate::Result<Self> {
         let mut inner_transactions = Vec::new();
-        
+
         for signed_transaction_bytes in pb.transactions {
             // Create a transaction from the signed transaction bytes
-            let proto_transaction = services::Transaction {
-                signed_transaction_bytes,
-                ..Default::default()
-            };
-            
+            let proto_transaction =
+                services::Transaction { signed_transaction_bytes, ..Default::default() };
+
             let transaction = AnyTransaction::from_bytes(&proto_transaction.encode_to_vec())?;
             inner_transactions.push(transaction);
         }
@@ -268,7 +268,7 @@ mod tests {
     fn test_validate_non_frozen_transaction() {
         let mut batch = BatchTransaction::new();
         let inner_tx = TransferTransaction::new();
-        
+
         let result = batch.add_inner_transaction(inner_tx.into());
         assert!(result.is_err());
         assert!(result.unwrap_err().to_string().contains("Inner transaction should be frozen"));
@@ -280,11 +280,11 @@ mod tests {
         let inner_tx = TransferTransaction::new();
         // Note: In a real scenario, you would freeze the transaction first,
         // then set a batch key, but this test just checks the validation logic
-        
+
         let result = batch.add_inner_transaction(inner_tx.into());
         assert!(result.is_err());
         // The error will be about the transaction not being frozen first,
         // which comes before the batch key check
         assert!(result.unwrap_err().to_string().contains("Inner transaction should be frozen"));
     }
-} 
+}

src/transaction/any.rs

@@ -909,7 +909,9 @@ impl AnyTransaction {
                     .into_iter()
                     .map(CustomFeeLimit::from_protobuf)
                     .collect::<Result<Vec<_>, _>>()?,
-                batch_key: first_body.batch_key.map(|key| crate::protobuf::FromProtobuf::from_protobuf(key).unwrap()),
+                batch_key: first_body
+                    .batch_key
+                    .map(|key| crate::protobuf::FromProtobuf::from_protobuf(key).unwrap()),
             },
             signers: Vec::new(),
             sources: None,
@@ -1119,9 +1121,9 @@ impl FromProtobuf<Vec<services::transaction_body::Data>> for ServicesTransaction
                 (Self::Ethereum(v), Data::EthereumTransaction(element)) => v.push(element),
                 (Self::UtilPrng(v), Data::UtilPrng(element)) => v.push(element),
                 (Self::TokenAirdrop(v), Data::TokenAirdrop(element)) => v.push(element),
-                                 (Self::TokenClaimAirdrop(v), Data::TokenClaimAirdrop(element)) => v.push(element),
-                 (Self::TokenCancelAirdrop(v), Data::TokenCancelAirdrop(element)) => v.push(element),
-                 (Self::AtomicBatch(v), Data::AtomicBatch(element)) => v.push(element),
+                (Self::TokenClaimAirdrop(v), Data::TokenClaimAirdrop(element)) => v.push(element),
+                (Self::TokenCancelAirdrop(v), Data::TokenCancelAirdrop(element)) => v.push(element),
+                (Self::AtomicBatch(v), Data::AtomicBatch(element)) => v.push(element),
                 _ => return Err(Error::from_protobuf("mismatched transaction types")),
             }
         }

src/transaction/mod.rs

@@ -517,22 +517,22 @@ impl<D: ValidateChecksums> Transaction<D> {
 
 impl<D: TransactionExecute> Transaction<D> {
     /// Convert this transaction to signed transaction bytes.
-    /// 
+    ///
     /// This is used internally for batch transactions to get the bytes
     /// of each inner transaction.
-    /// 
+    ///
     /// # Errors
-    /// 
+    ///
     /// Returns an error if the transaction is not frozen or cannot be serialized.
     pub fn to_signed_transaction_bytes(&self) -> crate::Result<Vec<u8>> {
         if !self.is_frozen() {
             return Err(crate::Error::basic_parse(
-                "Transaction must be frozen to get signed transaction bytes"
+                "Transaction must be frozen to get signed transaction bytes",
             ));
         }
 
         let transaction_list = self.make_transaction_list()?;
-        
+
         // For batch transactions, we need the signed transaction bytes from the first transaction
         if let Some(first_transaction) = transaction_list.first() {
             Ok(first_transaction.signed_transaction_bytes.clone())
@@ -543,11 +543,15 @@ impl<D: TransactionExecute> Transaction<D> {
 
     /// Convenience method to mark a transaction as part of a batch transaction.
     /// The Transaction will be frozen and signed by the operator of the client.
-    /// 
+    ///
     /// # Errors
-    /// 
+    ///
     /// Returns an error if the client has no operator configured.
-    pub fn batchify(&mut self, client: &crate::Client, batch_key: crate::Key) -> crate::Result<&mut Self> {
+    pub fn batchify(
+        &mut self,
+        client: &crate::Client,
+        batch_key: crate::Key,
+    ) -> crate::Result<&mut Self> {
         self.require_not_frozen();
         self.set_batch_key(batch_key);
         self.freeze_with(client)?;