fixing formatting issues through check-fmt

Author: mudigal

sdk/rust/examples/authorization_management.rs

@@ -58,9 +58,7 @@ async fn main() -> Result<()> {
 
 	// Authorize Bob's account
 	println!("⏳ Authorizing account...");
-	let receipt = client
-		.authorize_account(bob_account.clone(), transactions, bytes)
-		.await?;
+	let receipt = client.authorize_account(bob_account.clone(), transactions, bytes).await?;
 
 	println!("✅ Account authorized!");
 	println!("   Block hash: {}", receipt.block_hash);
@@ -79,9 +77,7 @@ async fn main() -> Result<()> {
 
 	// Authorize this specific preimage
 	println!("\n⏳ Authorizing preimage...");
-	let receipt = client
-		.authorize_preimage(content_hash, data.len() as u64)
-		.await?;
+	let receipt = client.authorize_preimage(content_hash, data.len() as u64).await?;
 
 	println!("✅ Preimage authorized!");
 	println!("   Block hash: {}", receipt.block_hash);
@@ -91,18 +87,14 @@ async fn main() -> Result<()> {
 	println!("═══ Refresh Authorization Example ═══\n");
 
 	println!("🔄 Refreshing Bob's account authorization...");
-	let receipt = client
-		.refresh_account_authorization(bob_account.clone())
-		.await?;
+	let receipt = client.refresh_account_authorization(bob_account.clone()).await?;
 
 	println!("✅ Authorization refreshed!");
 	println!("   Block hash: {}", receipt.block_hash);
 	println!("   Tx hash: {}\n", receipt.extrinsic_hash);
 
 	println!("🔄 Refreshing preimage authorization...");
-	let receipt = client
-		.refresh_preimage_authorization(content_hash)
-		.await?;
+	let receipt = client.refresh_preimage_authorization(content_hash).await?;
 
 	println!("✅ Preimage authorization refreshed!");
 	println!("   Block hash: {}", receipt.block_hash);

sdk/rust/examples/chunked_store.rs

@@ -40,9 +40,8 @@ async fn main() -> Result<()> {
 	println!("📁 Reading file: {}", file_path);
 
 	// 2. Read file data
-	let data = fs::read(file_path).map_err(|e| {
-		Error::StorageFailed(format!("Failed to read file: {:?}", e))
-	})?;
+	let data = fs::read(file_path)
+		.map_err(|e| Error::StorageFailed(format!("Failed to read file: {:?}", e)))?;
 
 	println!("📊 File size: {} bytes ({:.2} MB)\n", data.len(), data.len() as f64 / 1_048_576.0);
 
@@ -80,12 +79,11 @@ async fn main() -> Result<()> {
 			None, // use default config
 			StoreOptions::default(),
 			Some(|event| match event {
-				ProgressEvent::ChunkStarted { index, total } => {
+				ProgressEvent::ChunkStarted { index, total } =>
 					if total_chunks == 0 {
 						total_chunks = total;
 						println!("🔨 Starting upload of {} chunks...", total);
-					}
-				},
+					},
 				ProgressEvent::ChunkCompleted { index, total, cid } => {
 					chunks_completed += 1;
 					let progress = (chunks_completed as f32 / total as f32) * 100.0;

sdk/rust/examples/simple_store.rs

@@ -70,9 +70,11 @@ impl TransactionSubmitter for SubxtSubmitter {
 		transactions: u32,
 		bytes: u64,
 	) -> Result<TransactionReceipt> {
-		let tx = bulletin_runtime::tx()
-			.transaction_storage()
-			.authorize_account(who, transactions, bytes);
+		let tx = bulletin_runtime::tx().transaction_storage().authorize_account(
+			who,
+			transactions,
+			bytes,
+		);
 
 		let result = self
 			.api
@@ -141,9 +143,7 @@ impl TransactionSubmitter for SubxtSubmitter {
 		&self,
 		who: AccountId32,
 	) -> Result<TransactionReceipt> {
-		let tx = bulletin_runtime::tx()
-			.transaction_storage()
-			.refresh_account_authorization(who);
+		let tx = bulletin_runtime::tx().transaction_storage().refresh_account_authorization(who);
 
 		let result = self
 			.api

sdk/rust/src/async_client.rs

@@ -67,11 +67,7 @@ impl<S: TransactionSubmitter> AsyncBulletinClient<S> {
 
 	/// Create a client with custom configuration.
 	pub fn with_config(submitter: S, config: AsyncClientConfig) -> Self {
-		Self {
-			config,
-			auth_manager: AuthorizationManager::new(),
-			submitter,
-		}
+		Self { config, auth_manager: AuthorizationManager::new(), submitter }
 	}
 
 	/// Set the authorization manager.

sdk/rust/src/authorization.rs

@@ -39,10 +39,7 @@ pub struct AuthorizationManager {
 
 impl Default for AuthorizationManager {
 	fn default() -> Self {
-		Self {
-			default_scope: AuthorizationScope::Account,
-			auto_refresh: false,
-		}
+		Self { default_scope: AuthorizationScope::Account, auto_refresh: false }
 	}
 }
 
@@ -54,18 +51,12 @@ impl AuthorizationManager {
 
 	/// Create an authorization manager with account-based authorization.
 	pub fn with_account_auth() -> Self {
-		Self {
-			default_scope: AuthorizationScope::Account,
-			auto_refresh: false,
-		}
+		Self { default_scope: AuthorizationScope::Account, auto_refresh: false }
 	}
 
 	/// Create an authorization manager with preimage-based authorization.
 	pub fn with_preimage_auth() -> Self {
-		Self {
-			default_scope: AuthorizationScope::Preimage,
-			auto_refresh: false,
-		}
+		Self { default_scope: AuthorizationScope::Preimage, auto_refresh: false }
 	}
 
 	/// Enable auto-refresh of authorizations.
@@ -146,7 +137,11 @@ pub mod helpers {
 	/// Build authorization request parameters for account-based auth.
 	///
 	/// Returns: (transactions, max_size)
-	pub fn build_account_auth_params(data_size: u64, num_chunks: usize, include_manifest: bool) -> (u32, u64) {
+	pub fn build_account_auth_params(
+		data_size: u64,
+		num_chunks: usize,
+		include_manifest: bool,
+	) -> (u32, u64) {
 		let manager = AuthorizationManager::new();
 		manager.calculate_requirements(data_size, num_chunks, include_manifest)
 	}
@@ -229,7 +224,8 @@ mod tests {
 		assert_eq!(txs, 10);
 
 		// With manifest
-		let (txs_with_manifest, bytes_with_manifest) = manager.estimate_authorization(10_000_000, true);
+		let (txs_with_manifest, bytes_with_manifest) =
+			manager.estimate_authorization(10_000_000, true);
 		assert_eq!(txs_with_manifest, 11);
 		assert!(bytes_with_manifest > bytes);
 	}

sdk/rust/src/chunker.rs

@@ -5,8 +5,8 @@
 
 extern crate alloc;
 
-use alloc::vec::Vec;
 use crate::types::{Chunk, ChunkerConfig, Error, Result};
+use alloc::vec::Vec;
 
 /// Maximum chunk size allowed (8 MiB, matches pallet limit).
 pub const MAX_CHUNK_SIZE: usize = 8 * 1024 * 1024;
@@ -51,9 +51,7 @@ impl FixedSizeChunker {
 
 	/// Create a chunker with default configuration.
 	pub fn default_config() -> Self {
-		Self {
-			config: ChunkerConfig::default(),
-		}
+		Self { config: ChunkerConfig::default() }
 	}
 
 	/// Get the chunk size.
@@ -99,9 +97,11 @@ pub fn reassemble_chunks(chunks: &[Chunk]) -> Result<Vec<u8>> {
 	// Validate chunk indices are sequential
 	for (i, chunk) in chunks.iter().enumerate() {
 		if chunk.index != i as u32 {
-			return Err(Error::ChunkingFailed(
-				alloc::format!("Chunk index mismatch: expected {}, got {}", i, chunk.index),
-			));
+			return Err(Error::ChunkingFailed(alloc::format!(
+				"Chunk index mismatch: expected {}, got {}",
+				i,
+				chunk.index
+			)));
 		}
 	}
 
@@ -124,11 +124,7 @@ mod tests {
 	#[test]
 	fn test_fixed_size_chunker_single_chunk() {
 		let data = vec![1u8; 100];
-		let config = ChunkerConfig {
-			chunk_size: 1024,
-			max_parallel: 8,
-			create_manifest: true,
-		};
+		let config = ChunkerConfig { chunk_size: 1024, max_parallel: 8, create_manifest: true };
 
 		let chunker = FixedSizeChunker::new(config).unwrap();
 		let chunks = chunker.chunk(&data).unwrap();
@@ -142,11 +138,7 @@ mod tests {
 	#[test]
 	fn test_fixed_size_chunker_multiple_chunks() {
 		let data = vec![1u8; 2500];
-		let config = ChunkerConfig {
-			chunk_size: 1000,
-			max_parallel: 8,
-			create_manifest: true,
-		};
+		let config = ChunkerConfig { chunk_size: 1000, max_parallel: 8, create_manifest: true };
 
 		let chunker = FixedSizeChunker::new(config).unwrap();
 		let chunks = chunker.chunk(&data).unwrap();
@@ -165,11 +157,7 @@ mod tests {
 	#[test]
 	fn test_reassemble_chunks() {
 		let original_data = vec![1u8, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-		let config = ChunkerConfig {
-			chunk_size: 3,
-			max_parallel: 8,
-			create_manifest: true,
-		};
+		let config = ChunkerConfig { chunk_size: 3, max_parallel: 8, create_manifest: true };
 
 		let chunker = FixedSizeChunker::new(config).unwrap();
 		let chunks = chunker.chunk(&original_data).unwrap();

sdk/rust/src/cid.rs

@@ -36,10 +36,7 @@ pub fn hash_algorithm_to_pallet(algo: HashAlgorithm) -> HashingAlgorithm {
 
 /// Create a CidConfig from SDK types.
 pub fn create_config(codec: CidCodec, hash_algo: HashAlgorithm) -> CidConfig {
-	CidConfig {
-		codec: codec_to_u64(codec),
-		hashing: hash_algorithm_to_pallet(hash_algo),
-	}
+	CidConfig { codec: codec_to_u64(codec), hashing: hash_algorithm_to_pallet(hash_algo) }
 }
 
 /// Calculate CID for data using SDK configuration types.
@@ -49,7 +46,8 @@ pub fn calculate_cid_with_config(
 	hash_algo: HashAlgorithm,
 ) -> Result<CidData> {
 	let config = create_config(codec, hash_algo);
-	calculate_cid(data, Some(config)).map_err(|_| Error::InvalidCid("Failed to calculate CID".into()))
+	calculate_cid(data, Some(config))
+		.map_err(|_| Error::InvalidCid("Failed to calculate CID".into()))
 }
 
 /// Calculate CID with default configuration (raw codec, blake2b-256).

sdk/rust/src/client.rs

@@ -8,17 +8,14 @@
 
 extern crate alloc;
 
-use alloc::vec::Vec;
 use crate::{
 	authorization::AuthorizationManager,
 	chunker::{Chunker, FixedSizeChunker},
 	dag::{DagBuilder, UnixFsDagBuilder},
 	storage::{BatchStorageOperation, StorageOperation},
-	types::{
-		ChunkerConfig, Error, ProgressCallback, ProgressEvent, Result,
-		StoreOptions,
-	},
+	types::{ChunkerConfig, Error, ProgressCallback, ProgressEvent, Result, StoreOptions},
 };
+use alloc::vec::Vec;
 
 /// Configuration for the Bulletin client.
 #[derive(Debug, Clone)]
@@ -58,18 +55,12 @@ pub struct BulletinClient {
 impl BulletinClient {
 	/// Create a new Bulletin client with default configuration.
 	pub fn new() -> Self {
-		Self {
-			config: ClientConfig::default(),
-			auth_manager: AuthorizationManager::new(),
-		}
+		Self { config: ClientConfig::default(), auth_manager: AuthorizationManager::new() }
 	}
 
 	/// Create a client with custom configuration.
 	pub fn with_config(config: ClientConfig) -> Self {
-		Self {
-			config,
-			auth_manager: AuthorizationManager::new(),
-		}
+		Self { config, auth_manager: AuthorizationManager::new() }
 	}
 
 	/// Set the authorization manager.
@@ -175,9 +166,7 @@ pub mod async_client {
 	impl AsyncBulletinClient {
 		/// Create a new async client.
 		pub fn new(config: ClientConfig) -> Self {
-			Self {
-				client: BulletinClient::with_config(config),
-			}
+			Self { client: BulletinClient::with_config(config) }
 		}
 
 		/// Store data (placeholder - requires subxt integration).
@@ -196,7 +185,11 @@ pub mod async_client {
 		///     // Process result and return StoreResult
 		/// }
 		/// ```
-		pub async fn store_placeholder(&self, _data: Vec<u8>, _options: StoreOptions) -> Result<()> {
+		pub async fn store_placeholder(
+			&self,
+			_data: Vec<u8>,
+			_options: StoreOptions,
+		) -> Result<()> {
 			// Placeholder - users should implement with their subxt setup
 			Err(Error::StorageFailed(
 				"This is a placeholder. Implement with subxt integration.".into(),
@@ -241,11 +234,8 @@ mod tests {
 	fn test_prepare_store_chunked() {
 		let client = BulletinClient::new();
 		let data = vec![1u8; 5000];
-		let config = Some(ChunkerConfig {
-			chunk_size: 2000,
-			max_parallel: 8,
-			create_manifest: true,
-		});
+		let config =
+			Some(ChunkerConfig { chunk_size: 2000, max_parallel: 8, create_manifest: true });
 		let options = StoreOptions::default();
 
 		let result = client.prepare_store_chunked(&data, config, options, None);
@@ -260,11 +250,8 @@ mod tests {
 	fn test_prepare_store_chunked_no_manifest() {
 		let client = BulletinClient::new();
 		let data = vec![1u8; 5000];
-		let config = Some(ChunkerConfig {
-			chunk_size: 2000,
-			max_parallel: 8,
-			create_manifest: false,
-		});
+		let config =
+			Some(ChunkerConfig { chunk_size: 2000, max_parallel: 8, create_manifest: false });
 		let options = StoreOptions::default();
 
 		let result = client.prepare_store_chunked(&data, config, options, None);