style(contracts): apply cargo fmt to all Rust files (#253)

Author: Kami-no-san

contracts/src/attestation_protocol.rs

@@ -13,7 +13,9 @@
 //! - It can withdraw with [`revoke_attestation`].
 //! - The contract admin can [`deactivate_attester`] (and [`reactivate_attester`]).
 
-use soroban_sdk::{contracterror, contracttype, panic_with_error, Address, BytesN, Env, String, Vec};
+use soroban_sdk::{
+    contracterror, contracttype, panic_with_error, Address, BytesN, Env, String, Vec,
+};
 
 use crate::credential_registry;
 use crate::utils::validation::{

contracts/src/attestation_protocol_test.rs

@@ -29,7 +29,11 @@ fn setup() -> (Env, Address, Address) {
     (env, contract_id, admin)
 }
 
-fn create_credential(client: &AetherMintContractClient, admin: &Address, recipient: &Address) -> u64 {
+fn create_credential(
+    client: &AetherMintContractClient,
+    admin: &Address,
+    recipient: &Address,
+) -> u64 {
     let env = client.env.clone();
     client.issue_credential_with_expiration(
         admin,
@@ -101,7 +105,10 @@ fn test_attest_and_verify_credential() {
     let record = attestations.get(0).unwrap();
     assert_eq!(record.attester, attester.clone());
     assert_eq!(record.credential_id, credential_id);
-    assert_eq!(record.metadata, String::from_str(&env, "verified transcript"));
+    assert_eq!(
+        record.metadata,
+        String::from_str(&env, "verified transcript")
+    );
 
     assert_eq!(client.get_attestation_count(&credential_id), 1);
     assert_eq!(client.get_attester(&attester).attestation_count, 1);
@@ -119,8 +126,18 @@ fn test_multiple_attesters() {
     client.register_attester(&attester_a, &String::from_str(&env, "MIT"), &key(&env));
     client.register_attester(&attester_b, &String::from_str(&env, "Stanford"), &key(&env));
 
-    client.attest_credential(&attester_a, &credential_id, &sig(&env), &String::from_str(&env, "a"));
-    client.attest_credential(&attester_b, &credential_id, &sig(&env), &String::from_str(&env, "b"));
+    client.attest_credential(
+        &attester_a,
+        &credential_id,
+        &sig(&env),
+        &String::from_str(&env, "a"),
+    );
+    client.attest_credential(
+        &attester_b,
+        &credential_id,
+        &sig(&env),
+        &String::from_str(&env, "b"),
+    );
 
     assert_eq!(client.get_attestations(&credential_id).len(), 2);
     assert_eq!(client.get_attestation_count(&credential_id), 2);
@@ -138,8 +155,18 @@ fn test_duplicate_attestation_fails() {
 
     let credential_id = create_credential(&client, &admin, &recipient);
     client.register_attester(&attester, &String::from_str(&env, "MIT"), &key(&env));
-    client.attest_credential(&attester, &credential_id, &sig(&env), &String::from_str(&env, "x"));
-    client.attest_credential(&attester, &credential_id, &sig(&env), &String::from_str(&env, "y"));
+    client.attest_credential(
+        &attester,
+        &credential_id,
+        &sig(&env),
+        &String::from_str(&env, "x"),
+    );
+    client.attest_credential(
+        &attester,
+        &credential_id,
+        &sig(&env),
+        &String::from_str(&env, "y"),
+    );
 }
 
 #[test]
@@ -151,7 +178,12 @@ fn test_revoke_attestation() {
 
     let credential_id = create_credential(&client, &admin, &recipient);
     client.register_attester(&attester, &String::from_str(&env, "MIT"), &key(&env));
-    client.attest_credential(&attester, &credential_id, &sig(&env), &String::from_str(&env, "x"));
+    client.attest_credential(
+        &attester,
+        &credential_id,
+        &sig(&env),
+        &String::from_str(&env, "x"),
+    );
     assert_eq!(client.get_attestation_count(&credential_id), 1);
 
     client.revoke_attestation(&attester, &credential_id);
@@ -182,7 +214,12 @@ fn test_attest_by_unregistered_attester_fails() {
     let recipient = Address::generate(&env);
     let attester = Address::generate(&env);
     let credential_id = create_credential(&client, &admin, &recipient);
-    client.attest_credential(&attester, &credential_id, &sig(&env), &String::from_str(&env, "x"));
+    client.attest_credential(
+        &attester,
+        &credential_id,
+        &sig(&env),
+        &String::from_str(&env, "x"),
+    );
 }
 
 #[test]
@@ -211,7 +248,12 @@ fn test_deactivate_and_reactivate_attester() {
     client.reactivate_attester(&admin, &attester);
     assert!(client.get_attester(&attester).is_active);
 
-    client.attest_credential(&attester, &credential_id, &sig(&env), &String::from_str(&env, "x"));
+    client.attest_credential(
+        &attester,
+        &credential_id,
+        &sig(&env),
+        &String::from_str(&env, "x"),
+    );
     assert!(client.is_attested_by(&credential_id, &attester));
 }
 
@@ -226,7 +268,12 @@ fn test_deactivated_attester_cannot_attest() {
     let credential_id = create_credential(&client, &admin, &recipient);
     client.register_attester(&attester, &String::from_str(&env, "MIT"), &key(&env));
     client.deactivate_attester(&admin, &attester);
-    client.attest_credential(&attester, &credential_id, &sig(&env), &String::from_str(&env, "x"));
+    client.attest_credential(
+        &attester,
+        &credential_id,
+        &sig(&env),
+        &String::from_str(&env, "x"),
+    );
 }
 
 #[test]

contracts/src/credential_events.rs

@@ -164,10 +164,7 @@ pub fn get_credential_event(env: &Env, event_id: u64) -> Option<CredentialEventR
 
 /// Fetch all event records associated with a given credential id,
 /// in insertion order.
-pub fn get_credential_events(
-    env: &Env,
-    credential_id: u64,
-) -> Vec<CredentialEventRecord> {
+pub fn get_credential_events(env: &Env, credential_id: u64) -> Vec<CredentialEventRecord> {
     let ids: Vec<u64> = env
         .storage()
         .instance()

contracts/src/credential_registry.rs

@@ -1,6 +1,4 @@
-use crate::credential_events::{
-    publish_credential_event, CredentialLifecycleEvent,
-};
+use crate::credential_events::{publish_credential_event, CredentialLifecycleEvent};
 use crate::utils::storage::{EntityType, StorageUtils};
 use crate::utils::validation::{
     validate_duration, validate_non_zero_address, validate_string_length, MAX_DESCRIPTION_LENGTH,
@@ -64,8 +62,8 @@ pub enum CredentialRegistryKey {
     UserCredentials(Address),
     CredentialCount,
     ExpiredCredentials,
-    RenewalHistory(u64),    // credential_id -> Vec<RenewalRecord>
-    AttestationCount(u64),  // credential_id -> number of active attestations
+    RenewalHistory(u64),   // credential_id -> Vec<RenewalRecord>
+    AttestationCount(u64), // credential_id -> number of active attestations
 }
 
 /// Renewal record for tracking credential renewals
@@ -163,12 +161,7 @@ pub fn issue_credential_with_expiration(
 
     // Emit credential lifecycle event with consistent
     // (credential_id, actor, timestamp) payload and queryable record.
-    publish_credential_event(
-        env,
-        CredentialLifecycleEvent::Issued,
-        credential_id,
-        issuer,
-    );
+    publish_credential_event(env, CredentialLifecycleEvent::Issued, credential_id, issuer);
 
     credential_id
 }

contracts/src/credential_registry_test.rs

@@ -16,11 +16,7 @@ fn setup_env() -> (Env, Address) {
     (env, admin)
 }
 
-fn make_params(
-    env: &Env,
-    recipient: Address,
-    _idx: u32,
-) -> BatchCredentialParams {
+fn make_params(env: &Env, recipient: Address, _idx: u32) -> BatchCredentialParams {
     BatchCredentialParams {
         recipient,
         title: String::from_str(env, "Soroban Bootcamp"),
@@ -187,7 +183,12 @@ fn test_batch_emits_lifecycle_events_for_each_credential() {
     for i in 0..3u32 {
         let cred_id = ids.get(i).unwrap();
         let events = crate::credential_events::get_credential_events(&env, cred_id);
-        assert_eq!(events.len(), 1, "credential {} should have exactly 1 event", cred_id);
+        assert_eq!(
+            events.len(),
+            1,
+            "credential {} should have exactly 1 event",
+            cred_id
+        );
         assert_eq!(
             events.get(0).unwrap().event_type,
             crate::credential_events::CredentialLifecycleEvent::Issued,

contracts/src/credentials.rs

@@ -1,6 +1,4 @@
-use crate::credential_events::{
-    publish_credential_event, CredentialLifecycleEvent,
-};
+use crate::credential_events::{publish_credential_event, CredentialLifecycleEvent};
 use crate::utils::storage::{EntityType, StorageUtils};
 use soroban_sdk::{contracttype, Address, Env, String, Symbol, Vec};
 
@@ -56,7 +54,9 @@ pub fn issue_credential(
 ) -> u64 {
     issuer.require_auth();
 
-    let admin: Address = env.storage().instance()
+    let admin: Address = env
+        .storage()
+        .instance()
         .get(&Symbol::new(env, "admin"))
         .unwrap_or_else(|| panic!("Admin not set"));
     if issuer != admin {
@@ -104,12 +104,7 @@ pub fn issue_credential(
         .set(&CredentialKey::CredentialCount, &credential_id);
 
     // Emit lifecycle event (publishes on-chain event + records for queryability)
-    publish_credential_event(
-        env,
-        CredentialLifecycleEvent::Issued,
-        credential_id,
-        issuer,
-    );
+    publish_credential_event(env, CredentialLifecycleEvent::Issued, credential_id, issuer);
 
     credential_id
 }
@@ -150,7 +145,9 @@ pub fn verify_credential(env: &Env, credential_id: u64, verifier: Address) -> bo
 pub fn revoke_credential(env: &Env, credential_id: u64, revoker: Address) {
     revoker.require_auth();
 
-    let admin: Address = env.storage().instance()
+    let admin: Address = env
+        .storage()
+        .instance()
         .get(&Symbol::new(env, "admin"))
         .unwrap_or_else(|| panic!("Admin not set"));
     if revoker != admin {
@@ -215,7 +212,7 @@ pub fn get_credential_revocation_time(env: &Env, credential_id: u64) -> Option<u
         .get(&CredentialKey::CredentialRevocations(credential_id))
 }
 
-    // Get credential count with optimized storage
+// Get credential count with optimized storage
 pub fn get_credential_count(env: &Env) -> u64 {
     env.storage()
         .instance()

contracts/src/credentials_test.rs

@@ -54,8 +54,7 @@ fn test_issue_and_verify_credential() {
 
     // Integration: lifecycle events must be recorded by the unified
     // credential_events module so off-chain indexers can subscribe to them.
-    let issued_records =
-        crate::credential_events::get_credential_events(&env, cred_id);
+    let issued_records = crate::credential_events::get_credential_events(&env, cred_id);
     assert_eq!(issued_records.len(), 3); // Issued, Verified, Revoked
     assert_eq!(
         issued_records.get(0).unwrap().event_type,

contracts/src/dna_storage.rs

@@ -529,10 +529,19 @@ fn verify_blockchain_reference(env: &Env, reference: &String) -> bool {
     // Simplified verification - check if credential exists on blockchain
     let mut reference_buf = [0u8; 64];
     let ref_len = reference.copy_into_slice(&mut reference_buf);
-    if ref_len >= 5 && reference_buf[0] == b'c' && reference_buf[1] == b'r' 
-        && reference_buf[2] == b'e' && reference_buf[3] == b'd' && reference_buf[4] == b'_' {
+    if ref_len >= 5
+        && reference_buf[0] == b'c'
+        && reference_buf[1] == b'r'
+        && reference_buf[2] == b'e'
+        && reference_buf[3] == b'd'
+        && reference_buf[4] == b'_'
+    {
         // Simplified: just check if any credential exists
-        if let Some(_) = env.storage().persistent().get::<_, u64>(&DNAStorageKey::DNACredentialCount) {
+        if let Some(_) = env
+            .storage()
+            .persistent()
+            .get::<_, u64>(&DNAStorageKey::DNACredentialCount)
+        {
             return true;
         }
     }
@@ -605,8 +614,8 @@ pub struct CheckpointMeta {
     pub checkpoint_id: u64,
     pub label: String,
     pub timestamp: u64,
-    pub data_size: u32,  // number of credential IDs captured
-    pub hash: u64,       // rolling hash of the snapshot
+    pub data_size: u32, // number of credential IDs captured
+    pub hash: u64,      // rolling hash of the snapshot
 }
 
 /// Storage keys for checkpoints.
@@ -687,9 +696,7 @@ pub fn create_checkpoint(env: &Env, label: String) -> u64 {
         .set(&CheckpointKey::Snapshot(checkpoint_id), &snapshot);
 
     index.push_back(checkpoint_id);
-    env.storage()
-        .instance()
-        .set(&CheckpointKey::Index, &index);
+    env.storage().instance().set(&CheckpointKey::Index, &index);
 
     // Verify integrity immediately after capture
     let recalc = snapshot_hash(&snapshot);

contracts/src/dna_storage_checkpoint_test.rs

@@ -2,9 +2,9 @@
 mod tests {
     use crate::dna_services::verify_integrity;
     use crate::dna_storage::{
-        create_checkpoint, delete_checkpoint, list_checkpoints, restore_checkpoint,
-        DNACredential, DNASequence, DNAStorageKey, DNAStorageProtocol,
-        DnaMetadata, ErrorCorrectionLevel, MAX_CHECKPOINTS,
+        create_checkpoint, delete_checkpoint, list_checkpoints, restore_checkpoint, DNACredential,
+        DNASequence, DNAStorageKey, DNAStorageProtocol, DnaMetadata, ErrorCorrectionLevel,
+        MAX_CHECKPOINTS,
     };
     use crate::lib::DataKey;
     use soroban_sdk::{testutils::Address as _, Address, Env, String, Vec};