diff --git a/components/controller/src/identifier/mechanics/group.rs b/components/controller/src/identifier/mechanics/group.rs
index 190321e2..71bd041c 100644
--- a/components/controller/src/identifier/mechanics/group.rs
+++ b/components/controller/src/identifier/mechanics/group.rs
@@ -159,10 +159,7 @@ impl Identifier {
             let index = self.index_in_current_keys(&kc)?;
             let signature = vec![Signature::Transferable(
                 SignerData::LastEstablishment(self.id.clone()),
-                vec![IndexedSignature::new_both_same(
-                    exn_signature,
-                    index as u16,
-                )],
+                vec![IndexedSignature::new_both_same(exn_signature, index as u16)],
             )];
             let signer_exn = Message::Op(Op::Exchange(SignedExchange {
                 exchange_message: exn,
diff --git a/components/controller/src/identifier/mechanics/kel_managing.rs b/components/controller/src/identifier/mechanics/kel_managing.rs
index ab604837..c3bc2a9e 100644
--- a/components/controller/src/identifier/mechanics/kel_managing.rs
+++ b/components/controller/src/identifier/mechanics/kel_managing.rs
@@ -1,6 +1,10 @@
 use keri_core::{
     actor::{event_generator, prelude::SelfAddressingIdentifier},
-    event::{event_data::EventData, sections::{seal::Seal, KeyConfig}, KeyEvent},
+    event::{
+        event_data::EventData,
+        sections::{seal::Seal, KeyConfig},
+        KeyEvent,
+    },
     event_message::{
         cesr_adapter::{parse_event_type, EventType},
         msg::KeriEvent,
@@ -161,9 +165,7 @@ impl Identifier {
     /// group's current keys list.
     pub(crate) fn get_index(&self, key_event: &KeyEvent) -> Result<usize, MechanicsError> {
         match &key_event.event_data {
-            EventData::Icp(icp) => {
-                self.index_in_current_keys(&icp.key_config)
-            }
+            EventData::Icp(icp) => self.index_in_current_keys(&icp.key_config),
             EventData::Rot(rot) => {
                 let own_npk = &self.known_events.next_keys_hashes(&self.id)?[0];
                 rot.key_config
@@ -172,9 +174,7 @@ impl Identifier {
                     .position(|pk| own_npk.verify_binding(pk.to_str().as_bytes()))
                     .ok_or(MechanicsError::NotGroupParticipantError)
             }
-            EventData::Dip(dip) => {
-                self.index_in_current_keys(&dip.inception_data.key_config)
-            }
+            EventData::Dip(dip) => self.index_in_current_keys(&dip.inception_data.key_config),
             EventData::Drt(drt) => {
                 let own_npk = &self.known_events.next_keys_hashes(&self.id)?[0];
                 drt.key_config
diff --git a/components/controller/src/identifier/mechanics/mailbox.rs b/components/controller/src/identifier/mechanics/mailbox.rs
index f29dcd51..60890013 100644
--- a/components/controller/src/identifier/mechanics/mailbox.rs
+++ b/components/controller/src/identifier/mechanics/mailbox.rs
@@ -74,12 +74,10 @@ impl Identifier {
         mb: &MailboxResponse,
         group_id: &IdentifierPrefix,
     ) -> Result<Vec<ActionRequired>, MechanicsError> {
-
-
         for event in mb.multisig.iter() {
             self.process_group_multisig(event).await?;
         }
-        
+
         let action_required = futures::stream::iter(&mb.delegate)
             .then(|del_event| self.process_group_delegate(del_event, group_id))
             .try_filter_map(|del| async move { Ok(del) })
diff --git a/keriox_tests/src/lib.rs b/keriox_tests/src/lib.rs
index 1eafedf4..3e00f62e 100644
--- a/keriox_tests/src/lib.rs
+++ b/keriox_tests/src/lib.rs
@@ -1,9 +1,16 @@
 use std::{path::Path, sync::Arc};
 
 use keri_controller::{
-    config::ControllerConfig, controller::Controller, error::ControllerError, identifier::Identifier, mailbox_updating::ActionRequired, BasicPrefix, CryptoBox, IdentifierPrefix, KeyManager, LocationScheme, SelfSigningPrefix
+    config::ControllerConfig, controller::Controller, error::ControllerError,
+    identifier::Identifier, mailbox_updating::ActionRequired, BasicPrefix, CryptoBox,
+    IdentifierPrefix, KeyManager, LocationScheme, SelfSigningPrefix,
+};
+use keri_core::{
+    actor::error::ActorError,
+    mailbox::exchange::{Exchange, ForwardTopic, FwdArgs},
+    prefix::IndexedSignature,
+    transport::test::TestTransport,
 };
-use keri_core::{actor::error::ActorError, mailbox::exchange::{Exchange, ForwardTopic, FwdArgs}, prefix::IndexedSignature, transport::test::TestTransport};
 use said::{derivation::HashFunctionCode, sad::SerializationFormats};
 use transport::TelTestTransport;
 
@@ -85,65 +92,65 @@ pub async fn setup_identifier(
     (verifier, verifier_keypair, verifier_controller)
 }
 
-pub async fn handle_delegation_request(id: &mut Identifier, keypair: &CryptoBox, witness_id: &[BasicPrefix], delegator_group_id: IdentifierPrefix, delegatee_id: &IdentifierPrefix) -> Result<(), ControllerError>{
+pub async fn handle_delegation_request(
+    id: &mut Identifier,
+    keypair: &CryptoBox,
+    witness_id: &[BasicPrefix],
+    delegator_group_id: IdentifierPrefix,
+    delegatee_id: &IdentifierPrefix,
+) -> Result<(), ControllerError> {
     let query = id.query_mailbox(&delegator_group_id, witness_id)?;
     for qry in query {
         let signature = SelfSigningPrefix::Ed25519Sha512(keypair.sign(&qry.encode()?)?);
-        let ar = id
-            .finalize_query_mailbox(vec![(qry, signature)])
-            .await?;
+        let ar = id.finalize_query_mailbox(vec![(qry, signature)]).await?;
 
         assert_eq!(ar.len(), 1);
         match &ar[0] {
             ActionRequired::MultisigRequest(_, _) => unreachable!(),
             ActionRequired::DelegationRequest(delegating_event, exn) => {
-                let signature_ixn = SelfSigningPrefix::Ed25519Sha512(
-                    keypair.sign(&delegating_event.encode()?)?,
-                );
-                let signature_exn =
-                    SelfSigningPrefix::Ed25519Sha512(keypair.sign(&exn.encode()?)?);
+                let signature_ixn =
+                    SelfSigningPrefix::Ed25519Sha512(keypair.sign(&delegating_event.encode()?)?);
+                let signature_exn = SelfSigningPrefix::Ed25519Sha512(keypair.sign(&exn.encode()?)?);
                 id.finalize_group_incept(
-                        &delegating_event.encode()?,
-                        signature_ixn.clone(),
-                        vec![(exn.encode()?, signature_exn)],
-                    )
-                    .await
-                    .unwrap();
+                    &delegating_event.encode()?,
+                    signature_ixn.clone(),
+                    vec![(exn.encode()?, signature_exn)],
+                )
+                .await
+                .unwrap();
                 id.notify_witnesses().await?;
 
                 // Query for receipts
                 let query = id.query_mailbox(&delegator_group_id, witness_id)?;
 
                 for qry in query {
-                    let signature =
-                        SelfSigningPrefix::Ed25519Sha512(keypair.sign(&qry.encode()?)?);
+                    let signature = SelfSigningPrefix::Ed25519Sha512(keypair.sign(&qry.encode()?)?);
                     let action_required = id
                         .finalize_query_mailbox(vec![(qry, signature)])
                         .await
                         .unwrap();
                     assert!(action_required.is_empty());
                 }
-                
+
                 let kc = id.find_state(&delegator_group_id).unwrap().current;
                 let index = id.index_in_current_keys(&kc).unwrap();
                 // send accepted event to child
                 let exn_message = Exchange::Fwd {
-                        args: FwdArgs {
-                            recipient_id: delegatee_id.clone(),
-                            topic: ForwardTopic::Delegate,
-                        },
-                        to_forward: delegating_event.clone(),
-                    }
-                    .to_message(SerializationFormats::JSON, HashFunctionCode::Blake3_256);
+                    args: FwdArgs {
+                        recipient_id: delegatee_id.clone(),
+                        topic: ForwardTopic::Delegate,
+                    },
+                    to_forward: delegating_event.clone(),
+                }
+                .to_message(SerializationFormats::JSON, HashFunctionCode::Blake3_256);
                 let signature_exn =
                     SelfSigningPrefix::Ed25519Sha512(keypair.sign(&exn_message.encode()?)?);
 
                 let data_signature = IndexedSignature::new_both_same(signature_ixn, index as u16);
-                id
-                    .finalize_exchange(&exn_message.encode()?, signature_exn, data_signature)
+                id.finalize_exchange(&exn_message.encode()?, signature_exn, data_signature)
                     .await?;
             }
         };
-    };
+    }
     Ok(())
-}
\ No newline at end of file
+}
diff --git a/keriox_tests/src/settings.rs b/keriox_tests/src/settings.rs
index 47ba67a2..5f3dea81 100644
--- a/keriox_tests/src/settings.rs
+++ b/keriox_tests/src/settings.rs
@@ -36,7 +36,6 @@ impl AsyncTestContext for InfrastructureContext {
 
         async_std::task::spawn(first_witness.listen_http((Ipv4Addr::UNSPECIFIED, 3232)));
 
-
         let second_witness = {
             let wit_root = Builder::new().prefix("wit-db").tempdir().unwrap();
             Arc::new(
@@ -88,11 +87,10 @@ impl AsyncTestContext for InfrastructureContext {
         }
     }
 
-    async fn teardown(self) {
-    }
+    async fn teardown(self) {}
 }
 
-impl  InfrastructureContext {
+impl InfrastructureContext {
     pub fn first_witness_data(&self) -> (BasicPrefix, LocationScheme) {
         if let IdentifierPrefix::Basic(bp) = &self.first_witness_oobi.eid {
             (bp.clone(), self.first_witness_oobi.clone())
@@ -116,4 +114,4 @@ impl  InfrastructureContext {
             unreachable!()
         }
     }
-}
\ No newline at end of file
+}
diff --git a/keriox_tests/tests/indirect_mode_signing.rs b/keriox_tests/tests/indirect_mode_signing.rs
index d74a4391..ef2e7081 100644
--- a/keriox_tests/tests/indirect_mode_signing.rs
+++ b/keriox_tests/tests/indirect_mode_signing.rs
@@ -146,7 +146,9 @@ async fn indirect_mode_signing(ctx: &mut InfrastructureContext) -> Result<(), Co
     let (watcher_id, watcher_oobi) = ctx.watcher_data();
 
     // Resolve watcher oobi
-    verifying_identifier.resolve_oobi(&Oobi::Location(watcher_oobi)).await?;
+    verifying_identifier
+        .resolve_oobi(&Oobi::Location(watcher_oobi))
+        .await?;
 
     // Generate and sign event, that will be sent to watcher, so it knows to act
     // as verifier's watcher.
diff --git a/keriox_tests/tests/multi_delegator_single_delegatee.rs b/keriox_tests/tests/multi_delegator_single_delegatee.rs
index f56fa077..50d18ab5 100644
--- a/keriox_tests/tests/multi_delegator_single_delegatee.rs
+++ b/keriox_tests/tests/multi_delegator_single_delegatee.rs
@@ -1,4 +1,6 @@
-use keri_controller::{error::ControllerError, mailbox_updating::ActionRequired, KeyManager, SelfSigningPrefix};
+use keri_controller::{
+    error::ControllerError, mailbox_updating::ActionRequired, KeyManager, SelfSigningPrefix,
+};
 use keri_core::actor::prelude::Message;
 use keri_tests::{handle_delegation_request, settings::InfrastructureContext, setup_identifier};
 use tempfile::Builder;
@@ -6,41 +8,50 @@ use test_context::test_context;
 
 #[test_context(InfrastructureContext)]
 #[async_std::test]
-async fn multi_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> Result<(), ControllerError> {
-	let (witness_id, witness_oobi) = ctx.first_witness_data();
+async fn multi_delegator_single_delegatee(
+    ctx: &mut InfrastructureContext,
+) -> Result<(), ControllerError> {
+    let (witness_id, witness_oobi) = ctx.first_witness_data();
 
-	// Setup delegator identifier. It will be multisig group.
+    // Setup delegator identifier. It will be multisig group.
     // Setup identifier for first group participant.
     let root_0 = Builder::new().prefix("test-db1").tempdir().unwrap();
-    let (mut identifier1, km1, controller1) = setup_identifier(root_0.path(), vec![witness_oobi.clone()], None, None).await;
-   
+    let (mut identifier1, km1, controller1) =
+        setup_identifier(root_0.path(), vec![witness_oobi.clone()], None, None).await;
+
     assert!(identifier1.get_own_kel().is_some());
 
     // Setup identifier for second group participant.
     let root_1 = Builder::new().prefix("test-db2").tempdir().unwrap();
-    let (mut identifier2, km2, controller2) = setup_identifier(root_1.path(), vec![witness_oobi.clone()], None, None).await;
-   
+    let (mut identifier2, km2, controller2) =
+        setup_identifier(root_1.path(), vec![witness_oobi.clone()], None, None).await;
+
     assert!(identifier2.get_own_kel().is_some());
 
-	// Provide second identifier's KEL to first identifier. Can be done by watcher. Is necessary to create multisig event.
-	let id2_kel = identifier2.get_own_kel().unwrap();
-	for msg in id2_kel {
-		identifier1.known_events.process(&Message::Notice(msg)).unwrap();
-	}
+    // Provide second identifier's KEL to first identifier. Is necessary to create multisig event.
+    let id2_kel = identifier2.get_own_kel().unwrap();
+    for msg in id2_kel {
+        identifier1
+            .known_events
+            .process(&Message::Notice(msg))
+            .unwrap();
+    }
 
     let state = identifier1.find_state(identifier2.id()).unwrap();
     assert_eq!(state.sn, 0);
 
-    // Provide first identifier's KEL to second identifier. Can be done by watcher.
-	let id1_kel = identifier1.get_own_kel().unwrap();
-	for msg in id1_kel {
-		identifier2.known_events.process(&Message::Notice(msg)).unwrap();
-	}
+    // Provide first identifier's KEL to second identifier.
+    let id1_kel = identifier1.get_own_kel().unwrap();
+    for msg in id1_kel {
+        identifier2
+            .known_events
+            .process(&Message::Notice(msg))
+            .unwrap();
+    }
 
     let state = identifier2.find_state(identifier1.id()).unwrap();
     assert_eq!(state.sn, 0);
 
-
     // Identifier 1 initiate group inception
     let (group_inception, exn_messages) = identifier1.incept_group(
         vec![identifier2.id().clone()],
@@ -118,7 +129,7 @@ async fn multi_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> Re
 
     let group_state_1 = identifier1.find_state(&delegator_group_id)?;
     assert_eq!(group_state_1.sn, 0);
-    
+
     // Query to have receipt of group inception
     let query = identifier2.query_mailbox(&delegator_group_id, &[witness_id.clone()])?;
 
@@ -133,15 +144,21 @@ async fn multi_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> Re
     assert_eq!(group_state_2.sn, 0);
 
     println!("Delegator: {}", &delegator_group_id);
-    println!("\tparticipants: {:?}", &[&identifier1, &identifier2].iter().map(|part| part.id().to_string()).collect::<Vec<_>>());
+    println!(
+        "\tparticipants: {:?}",
+        &[&identifier1, &identifier2]
+            .iter()
+            .map(|part| part.id().to_string())
+            .collect::<Vec<_>>()
+    );
 
-	// Setup temporary directories for delegatee identifier
-    let delegatee_root = Builder::new().prefix("test-db2").tempdir().unwrap();	// Setup delegatee
-	// TODO why we need to setup identifier before incept group to create delegated identifier?
+    // Setup temporary directories for delegatee identifier
+    let delegatee_root = Builder::new().prefix("test-db2").tempdir().unwrap(); // Setup delegatee
 
-    let (mut temporary_delegatee_identifier, delegatee_keypair, _) = setup_identifier(delegatee_root.path(), vec![witness_oobi], None, None).await;
-    
-	// Generate delegated inception and exn, that is provide delegation request to delegator.
+    let (mut temporary_delegatee_identifier, delegatee_keypair, _) =
+        setup_identifier(delegatee_root.path(), vec![witness_oobi], None, None).await;
+
+    // Generate delegated inception and exn, that is provide delegation request to delegator.
     let (delegated_inception, exn_messages) = temporary_delegatee_identifier.incept_group(
         vec![],
         1,
@@ -167,26 +184,36 @@ async fn multi_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> Re
     // Event is not yet accepted. Missing delegating event.
     assert!(kel.is_none());
 
-
-	// Delegation accept process
+    // Delegation accept process
     // Each participant of delegator group asks about his mailbox to get delegated event.
-    handle_delegation_request(&mut identifier1, &km1, &[witness_id.clone()], delegator_group_id.clone(), &delegatee_id).await.unwrap();
-    handle_delegation_request(&mut identifier2, &km2, &[witness_id.clone()], delegator_group_id.clone(), &delegatee_id).await.unwrap();
+    handle_delegation_request(
+        &mut identifier1,
+        &km1,
+        &[witness_id.clone()],
+        delegator_group_id.clone(),
+        &delegatee_id,
+    )
+    .await
+    .unwrap();
+    handle_delegation_request(
+        &mut identifier2,
+        &km2,
+        &[witness_id.clone()],
+        delegator_group_id.clone(),
+        &delegatee_id,
+    )
+    .await
+    .unwrap();
 
     // ixn was accepted
     let delegator_state = controller2.find_state(&delegator_group_id)?;
-    let kel = controller2.get_kel_with_receipts(&delegator_group_id).unwrap();
     assert_eq!(delegator_state.sn, 1);
 
     // Query for receipts and second group participant ixn
-    println!("Delegator group identifier: {}", &delegator_group_id);
-    println!("First group identifier: {}", &identifier1.id());
-    println!("Second group identifier: {}", &identifier2.id());
     let query = identifier1.query_mailbox(&delegator_group_id, &[witness_id.clone()])?;
 
     for qry in query {
-        let signature =
-            SelfSigningPrefix::Ed25519Sha512(km1.sign(&qry.encode()?)?);
+        let signature = SelfSigningPrefix::Ed25519Sha512(km1.sign(&qry.encode()?)?);
         let action_required = identifier1
             .finalize_query_mailbox(vec![(qry, signature)])
             .await
@@ -197,22 +224,23 @@ async fn multi_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> Re
     let delegators_state = controller1.find_state(&delegator_group_id)?;
     assert_eq!(delegators_state.sn, 1);
 
-    
     // Process delegator's icp by identifier who'll request delegation.
     // TODO how child should get delegators kel?
     let delegators_kel = controller1
         .get_kel_with_receipts(&delegator_group_id)
         .unwrap();
     temporary_delegatee_identifier
-        .known_events.process(&Message::Notice(delegators_kel[0].clone()))?; // icp
-    
+        .known_events
+        .process(&Message::Notice(delegators_kel[0].clone()))?; // icp
+
     temporary_delegatee_identifier
         .known_events
         .process(&Message::Notice(delegators_kel[1].clone()))?; // receipt
     let state = temporary_delegatee_identifier.find_state(&delegator_group_id)?;
     assert_eq!(state.sn, 0);
     // Ask about delegated identifier mailbox
-    let query = temporary_delegatee_identifier.query_mailbox(&delegatee_id, &[witness_id.clone()])?;
+    let query =
+        temporary_delegatee_identifier.query_mailbox(&delegatee_id, &[witness_id.clone()])?;
 
     for qry in query {
         let signature = SelfSigningPrefix::Ed25519Sha512(delegatee_keypair.sign(&qry.encode()?)?);
@@ -227,11 +255,11 @@ async fn multi_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> Re
 
     // Child kel is not yet accepted
     let state = temporary_delegatee_identifier.find_state(&delegatee_id);
-    // assert_eq!(state, None);
     assert!(state.is_err());
 
     // Get mailbox for receipts.
-    let query = temporary_delegatee_identifier.query_mailbox(&delegatee_id, &[witness_id.clone()])?;
+    let query =
+        temporary_delegatee_identifier.query_mailbox(&delegatee_id, &[witness_id.clone()])?;
 
     for qry in query {
         let signature = SelfSigningPrefix::Ed25519Sha512(delegatee_keypair.sign(&qry.encode()?)?);
@@ -244,8 +272,6 @@ async fn multi_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> Re
     // Child kel is accepted
     let state = temporary_delegatee_identifier.find_state(&delegatee_id)?;
     assert_eq!(state.sn, 0);
-	
-
 
-	Ok(())
-}
\ No newline at end of file
+    Ok(())
+}
diff --git a/keriox_tests/tests/multisig_delegator_multisig_delegatee.rs b/keriox_tests/tests/multisig_delegator_multisig_delegatee.rs
index 35a46aa0..2eaf741e 100644
--- a/keriox_tests/tests/multisig_delegator_multisig_delegatee.rs
+++ b/keriox_tests/tests/multisig_delegator_multisig_delegatee.rs
@@ -1,4 +1,6 @@
-use keri_controller::{error::ControllerError, mailbox_updating::ActionRequired, KeyManager, SelfSigningPrefix};
+use keri_controller::{
+    error::ControllerError, mailbox_updating::ActionRequired, KeyManager, SelfSigningPrefix,
+};
 use keri_core::actor::prelude::Message;
 use keri_tests::{handle_delegation_request, settings::InfrastructureContext, setup_identifier};
 use tempfile::Builder;
@@ -6,41 +8,54 @@ use test_context::test_context;
 
 #[test_context(InfrastructureContext)]
 #[async_std::test]
-async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Result<(), ControllerError> {
-	let (witness_id, witness_oobi) = ctx.first_witness_data();
+async fn multi_delegator_multi_delegatee(
+    ctx: &mut InfrastructureContext,
+) -> Result<(), ControllerError> {
+    let (witness_id, witness_oobi) = ctx.first_witness_data();
 
-	// Setup delegator identifier. It will be multisig group.
+    // Setup delegator identifier. It will be multisig group.
     // Setup identifier for first group participant.
     let root_0 = Builder::new().prefix("test-db1").tempdir().unwrap();
-    let (mut delegator_identifier1, delegator_km1, controller1) = setup_identifier(root_0.path(), vec![witness_oobi.clone()], None, None).await;
-   
+    let (mut delegator_identifier1, delegator_km1, controller1) =
+        setup_identifier(root_0.path(), vec![witness_oobi.clone()], None, None).await;
+
     assert!(delegator_identifier1.get_own_kel().is_some());
 
     // Setup identifier for second group participant.
     let root_1 = Builder::new().prefix("test-db2").tempdir().unwrap();
-    let (mut delegator_identifier2, delegator_km2, controller2) = setup_identifier(root_1.path(), vec![witness_oobi.clone()], None, None).await;
-   
+    let (mut delegator_identifier2, delegator_km2, controller2) =
+        setup_identifier(root_1.path(), vec![witness_oobi.clone()], None, None).await;
+
     assert!(delegator_identifier2.get_own_kel().is_some());
 
-	// Provide second identifier's KEL to first identifier. Can be done by watcher. Is necessary to create multisig event.
-	let id2_kel = delegator_identifier2.get_own_kel().unwrap();
-	for msg in id2_kel {
-		delegator_identifier1.known_events.process(&Message::Notice(msg)).unwrap();
-	}
+    // Provide second identifier's KEL to first identifier. Can be done by watcher. Is necessary to create multisig event.
+    let id2_kel = delegator_identifier2.get_own_kel().unwrap();
+    for msg in id2_kel {
+        delegator_identifier1
+            .known_events
+            .process(&Message::Notice(msg))
+            .unwrap();
+    }
 
-    let state = delegator_identifier1.find_state(delegator_identifier2.id()).unwrap();
+    let state = delegator_identifier1
+        .find_state(delegator_identifier2.id())
+        .unwrap();
     assert_eq!(state.sn, 0);
 
     // Provide first identifier's KEL to second identifier. Can be done by watcher.
-	let id1_kel = delegator_identifier1.get_own_kel().unwrap();
-	for msg in id1_kel {
-		delegator_identifier2.known_events.process(&Message::Notice(msg)).unwrap();
-	}
+    let id1_kel = delegator_identifier1.get_own_kel().unwrap();
+    for msg in id1_kel {
+        delegator_identifier2
+            .known_events
+            .process(&Message::Notice(msg))
+            .unwrap();
+    }
 
-    let state = delegator_identifier2.find_state(delegator_identifier1.id()).unwrap();
+    let state = delegator_identifier2
+        .find_state(delegator_identifier1.id())
+        .unwrap();
     assert_eq!(state.sn, 0);
 
-
     // Identifier 1 initiate group inception
     let (group_inception, exn_messages) = delegator_identifier1.incept_group(
         vec![delegator_identifier2.id().clone()],
@@ -50,8 +65,10 @@ async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Res
         None,
     )?;
 
-    let signature_icp = SelfSigningPrefix::Ed25519Sha512(delegator_km1.sign(group_inception.as_bytes())?);
-    let signature_exn = SelfSigningPrefix::Ed25519Sha512(delegator_km1.sign(exn_messages[0].as_bytes())?);
+    let signature_icp =
+        SelfSigningPrefix::Ed25519Sha512(delegator_km1.sign(group_inception.as_bytes())?);
+    let signature_exn =
+        SelfSigningPrefix::Ed25519Sha512(delegator_km1.sign(exn_messages[0].as_bytes())?);
 
     // Group initiator needs to use `finalize_group_incept` instead of just
     // `finalize_event`, to send multisig request to other group participants.
@@ -69,7 +86,8 @@ async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Res
     assert!(kel.is_none());
 
     // Querying mailbox to get multisig request
-    let query = delegator_identifier2.query_mailbox(&delegator_identifier2.id(), &[witness_id.clone()])?;
+    let query =
+        delegator_identifier2.query_mailbox(&delegator_identifier2.id(), &[witness_id.clone()])?;
 
     for qry in query {
         let signature = SelfSigningPrefix::Ed25519Sha512(delegator_km2.sign(&qry.encode()?)?);
@@ -82,9 +100,11 @@ async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Res
                 unreachable!()
             }
             ActionRequired::MultisigRequest(multisig_event, exn) => {
-                let signature_ixn =
-                    SelfSigningPrefix::Ed25519Sha512(delegator_km2.sign(&multisig_event.encode()?)?);
-                let signature_exn = SelfSigningPrefix::Ed25519Sha512(delegator_km2.sign(&exn.encode()?)?);
+                let signature_ixn = SelfSigningPrefix::Ed25519Sha512(
+                    delegator_km2.sign(&multisig_event.encode()?)?,
+                );
+                let signature_exn =
+                    SelfSigningPrefix::Ed25519Sha512(delegator_km2.sign(&exn.encode()?)?);
                 delegator_identifier2
                     .finalize_group_incept(
                         &multisig_event.encode()?,
@@ -118,7 +138,7 @@ async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Res
 
     let group_state_1 = delegator_identifier1.find_state(&delegator_group_id)?;
     assert_eq!(group_state_1.sn, 0);
-    
+
     // Query to have receipt of group inception
     let query = delegator_identifier2.query_mailbox(&delegator_group_id, &[witness_id.clone()])?;
 
@@ -133,41 +153,67 @@ async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Res
     assert_eq!(group_state_2.sn, 0);
 
     println!("Delegator: {}", &delegator_group_id);
-    println!("\tparticipants: {:?}", &[&delegator_identifier1, &delegator_identifier2].iter().map(|part| part.id().to_string()).collect::<Vec<_>>());
-
+    println!(
+        "\tparticipants: {:?}",
+        &[&delegator_identifier1, &delegator_identifier2]
+            .iter()
+            .map(|part| part.id().to_string())
+            .collect::<Vec<_>>()
+    );
 
     // Setup delegatee identifier. It will be multisig group.
     // Setup identifier for first group participant.
     let delegatee_root_0 = Builder::new().prefix("test-db01").tempdir().unwrap();
-    let (mut delegatee_identifier1, delegatee_km1, delegatee_controller1) = setup_identifier(delegatee_root_0.path(), vec![witness_oobi.clone()], None, None).await;
-   
+    let (mut delegatee_identifier1, delegatee_km1, _delegatee_controller1) = setup_identifier(
+        delegatee_root_0.path(),
+        vec![witness_oobi.clone()],
+        None,
+        None,
+    )
+    .await;
+
     assert!(delegatee_identifier1.get_own_kel().is_some());
 
     // Setup identifier for second group participant.
     let delegatee_root_1 = Builder::new().prefix("test-db02").tempdir().unwrap();
-    let (mut delegatee_identifier2, delegatee_km2, delegatee_controller2) = setup_identifier(delegatee_root_1.path(), vec![witness_oobi.clone()], None, None).await;
-   
+    let (mut delegatee_identifier2, delegatee_km2, _delegatee_controller2) = setup_identifier(
+        delegatee_root_1.path(),
+        vec![witness_oobi.clone()],
+        None,
+        None,
+    )
+    .await;
+
     assert!(delegatee_identifier2.get_own_kel().is_some());
 
-	// Provide second identifier's KEL to first identifier.
-	let id2_kel = delegatee_identifier2.get_own_kel().unwrap();
-	for msg in id2_kel {
-		delegatee_identifier1.known_events.process(&Message::Notice(msg)).unwrap();
-	}
+    // Provide second identifier's KEL to first identifier.
+    let id2_kel = delegatee_identifier2.get_own_kel().unwrap();
+    for msg in id2_kel {
+        delegatee_identifier1
+            .known_events
+            .process(&Message::Notice(msg))
+            .unwrap();
+    }
 
-    let state = delegatee_identifier1.find_state(delegatee_identifier2.id()).unwrap();
+    let state = delegatee_identifier1
+        .find_state(delegatee_identifier2.id())
+        .unwrap();
     assert_eq!(state.sn, 0);
 
     // Provide first identifier's KEL to second identifier.
-	let id1_kel = delegatee_identifier1.get_own_kel().unwrap();
-	for msg in id1_kel {
-		delegatee_identifier2.known_events.process(&Message::Notice(msg)).unwrap();
-	}
+    let id1_kel = delegatee_identifier1.get_own_kel().unwrap();
+    for msg in id1_kel {
+        delegatee_identifier2
+            .known_events
+            .process(&Message::Notice(msg))
+            .unwrap();
+    }
 
-    let state = delegatee_identifier2.find_state(delegatee_identifier1.id()).unwrap();
+    let state = delegatee_identifier2
+        .find_state(delegatee_identifier1.id())
+        .unwrap();
     assert_eq!(state.sn, 0);
 
-
     // Identifier 1 initiate group inception
     let (delegatee_group_inception, exn_messages) = delegatee_identifier1.incept_group(
         vec![delegatee_identifier2.id().clone()],
@@ -177,21 +223,22 @@ async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Res
         Some(delegator_group_id.clone()),
     )?;
 
-    let signature_icp = SelfSigningPrefix::Ed25519Sha512(delegatee_km1.sign(delegatee_group_inception.as_bytes())?);
-    let exns = exn_messages.into_iter().map(|exn| {
-        let signature_exn = SelfSigningPrefix::Ed25519Sha512(delegatee_km1.sign(exn.as_bytes()).unwrap());
-        (exn.as_bytes().to_vec(), signature_exn)
-    }).collect();
+    let signature_icp =
+        SelfSigningPrefix::Ed25519Sha512(delegatee_km1.sign(delegatee_group_inception.as_bytes())?);
+    let exns = exn_messages
+        .into_iter()
+        .map(|exn| {
+            let signature_exn =
+                SelfSigningPrefix::Ed25519Sha512(delegatee_km1.sign(exn.as_bytes()).unwrap());
+            (exn.as_bytes().to_vec(), signature_exn)
+        })
+        .collect();
 
     // Group initiator needs to use `finalize_group_incept` instead of just
     // `finalize_event`, to send multisig request to other group participants.
     // Identifier who get this request from mailbox, can use just `finalize_event`
     let delegatee_group_id = delegatee_identifier1
-        .finalize_group_incept(
-            delegatee_group_inception.as_bytes(),
-            signature_icp,
-            exns,
-        )
+        .finalize_group_incept(delegatee_group_inception.as_bytes(), signature_icp, exns)
         .await?;
 
     let kel = delegatee_identifier1.get_kel(&delegatee_group_id);
@@ -199,7 +246,8 @@ async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Res
     assert!(kel.is_none());
 
     // Querying mailbox to get multisig request
-    let query = delegatee_identifier2.query_mailbox(&delegatee_identifier2.id(), &[witness_id.clone()])?;
+    let query =
+        delegatee_identifier2.query_mailbox(&delegatee_identifier2.id(), &[witness_id.clone()])?;
 
     for qry in query {
         let signature = SelfSigningPrefix::Ed25519Sha512(delegatee_km2.sign(&qry.encode()?)?);
@@ -212,9 +260,11 @@ async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Res
                 unreachable!()
             }
             ActionRequired::MultisigRequest(multisig_event, exn) => {
-                let signature_ixn =
-                    SelfSigningPrefix::Ed25519Sha512(delegatee_km2.sign(&multisig_event.encode()?)?);
-                let signature_exn = SelfSigningPrefix::Ed25519Sha512(delegatee_km2.sign(&exn.encode()?)?);
+                let signature_ixn = SelfSigningPrefix::Ed25519Sha512(
+                    delegatee_km2.sign(&multisig_event.encode()?)?,
+                );
+                let signature_exn =
+                    SelfSigningPrefix::Ed25519Sha512(delegatee_km2.sign(&exn.encode()?)?);
                 delegatee_identifier2
                     .finalize_group_incept(
                         &multisig_event.encode()?,
@@ -236,29 +286,36 @@ async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Res
             .await?;
     }
 
-	// Delegation accept process
+    // Delegation accept process
     // Each participant of delegator group asks about his mailbox to get delegated event.
-    handle_delegation_request(&mut delegator_identifier1, &delegator_km1, &[witness_id.clone()], delegator_group_id.clone(), &delegatee_group_id).await.unwrap();
-    handle_delegation_request(&mut delegator_identifier2, &delegator_km2, &[witness_id.clone()], delegator_group_id.clone(), &delegatee_group_id).await.unwrap();
-
-    // ixn was accepted. 
+    handle_delegation_request(
+        &mut delegator_identifier1,
+        &delegator_km1,
+        &[witness_id.clone()],
+        delegator_group_id.clone(),
+        &delegatee_group_id,
+    )
+    .await
+    .unwrap();
+    handle_delegation_request(
+        &mut delegator_identifier2,
+        &delegator_km2,
+        &[witness_id.clone()],
+        delegator_group_id.clone(),
+        &delegatee_group_id,
+    )
+    .await
+    .unwrap();
+
+    // ixn was accepted.
     let delegator_state = controller2.find_state(&delegator_group_id).unwrap();
-    let kel = controller2.get_kel_with_receipts(&delegator_group_id).unwrap();
     assert_eq!(delegator_state.sn, 1);
 
-    println!("\nDelegator group identifier: {}", &delegator_group_id);
-    println!("First group identifier: {}", &delegator_identifier1.id());
-    println!("Second group identifier: {}", &delegator_identifier2.id());
-    println!("Delegatee group identifier: {}", &delegatee_group_id);
-    println!("First group identifier: {}", &delegatee_identifier1.id());
-    println!("Second group identifier: {}", &delegatee_identifier2.id());
-     
-     // Query for receipts and second group participant ixn
+    // Query for receipts and second group participant ixn
     let query = delegator_identifier1.query_mailbox(&delegator_group_id, &[witness_id.clone()])?;
 
     for qry in query {
-        let signature =
-            SelfSigningPrefix::Ed25519Sha512(delegator_km1.sign(&qry.encode()?)?);
+        let signature = SelfSigningPrefix::Ed25519Sha512(delegator_km1.sign(&qry.encode()?)?);
         let action_required = delegator_identifier1
             .finalize_query_mailbox(vec![(qry, signature)])
             .await
@@ -269,24 +326,25 @@ async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Res
     let delegators_state = controller1.find_state(&delegator_group_id).unwrap();
     assert_eq!(delegators_state.sn, 1);
 
-    
     // Process delegator's icp by identifier who has requested delegation.
     // TODO how child should get delegator kel?
     let delegators_kel = controller1
         .get_kel_with_receipts(&delegator_group_id)
         .unwrap();
     delegatee_identifier1
-        .known_events.process(&Message::Notice(delegators_kel[0].clone()))?; // icp
-    
+        .known_events
+        .process(&Message::Notice(delegators_kel[0].clone()))?; // icp
+
     delegatee_identifier1
         .known_events
         .process(&Message::Notice(delegators_kel[1].clone()))?; // receipt
     let state = delegatee_identifier1.find_state(&delegator_group_id)?;
     assert_eq!(state.sn, 0);
 
-     delegatee_identifier2
-        .known_events.process(&Message::Notice(delegators_kel[0].clone()))?; // icp
-    
+    delegatee_identifier2
+        .known_events
+        .process(&Message::Notice(delegators_kel[0].clone()))?; // icp
+
     delegatee_identifier2
         .known_events
         .process(&Message::Notice(delegators_kel[1].clone()))?; // receipt
@@ -315,10 +373,14 @@ async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Res
         assert!(ar.is_empty())
     }
 
-    let state = delegatee_identifier1.find_state(&delegatee_group_id).unwrap();
+    let state = delegatee_identifier1
+        .find_state(&delegatee_group_id)
+        .unwrap();
     assert_eq!(state.sn, 0);
 
-    let state = delegatee_identifier1.find_state(&delegator_group_id).unwrap();
+    let state = delegatee_identifier1
+        .find_state(&delegator_group_id)
+        .unwrap();
     assert_eq!(state.sn, 1);
 
     // Ask about delegated identifier mailbox
@@ -328,15 +390,20 @@ async fn multi_delegator_multi_delegatee(ctx: &mut InfrastructureContext) -> Res
         let signature = SelfSigningPrefix::Ed25519Sha512(delegatee_km2.sign(&qry.encode()?)?);
         let ar = delegatee_identifier2
             .finalize_query_mailbox(vec![(qry, signature)])
-            .await.unwrap();
+            .await
+            .unwrap();
         assert!(ar.is_empty())
     }
 
-    let state = delegatee_identifier2.find_state(&delegatee_group_id).unwrap();
+    let state = delegatee_identifier2
+        .find_state(&delegatee_group_id)
+        .unwrap();
     assert_eq!(state.sn, 0);
 
-    let state = delegatee_identifier2.find_state(&delegator_group_id).unwrap();
+    let state = delegatee_identifier2
+        .find_state(&delegator_group_id)
+        .unwrap();
     assert_eq!(state.sn, 1);
 
-	Ok(())
-}
\ No newline at end of file
+    Ok(())
+}
diff --git a/keriox_tests/tests/single_delegator_single_delegatee.rs b/keriox_tests/tests/single_delegator_single_delegatee.rs
index e736b23b..a025bfcb 100644
--- a/keriox_tests/tests/single_delegator_single_delegatee.rs
+++ b/keriox_tests/tests/single_delegator_single_delegatee.rs
@@ -1,6 +1,10 @@
 use std::sync::Arc;
 
-use keri_controller::{config::ControllerConfig, controller::Controller, error::ControllerError, identifier::Identifier, mailbox_updating::ActionRequired, BasicPrefix, CryptoBox, KeyManager, SelfSigningPrefix};
+use keri_controller::{
+    config::ControllerConfig, controller::Controller, error::ControllerError,
+    mailbox_updating::ActionRequired, BasicPrefix, CryptoBox, KeyManager,
+    SelfSigningPrefix,
+};
 use keri_core::{actor::prelude::Message, prefix::IndexedSignature};
 use keri_tests::settings::InfrastructureContext;
 use tempfile::Builder;
@@ -8,26 +12,33 @@ use test_context::test_context;
 
 #[test_context(InfrastructureContext)]
 #[async_std::test]
-async fn single_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> Result<(), ControllerError> {
-	let (first_witness_id, first_witness_oobi) = ctx.first_witness_data();
+async fn single_delegator_single_delegatee(
+    ctx: &mut InfrastructureContext,
+) -> Result<(), ControllerError> {
+    let (first_witness_id, first_witness_oobi) = ctx.first_witness_data();
 
-	// Setup delegator identifier
+    // Setup delegator identifier
     let delegator_root = Builder::new().prefix("test-db").tempdir().unwrap();
-	let delegator_keypair = CryptoBox::new()?;
+    let delegator_keypair = CryptoBox::new()?;
 
     let delegator_pk = BasicPrefix::Ed25519(delegator_keypair.public_key());
     let delegator_npk = BasicPrefix::Ed25519(delegator_keypair.next_public_key());
 
     let delegatee_root = Builder::new().prefix("test-db2").tempdir().unwrap();
-	
-	// Setup delegator identifier
+
+    // Setup delegator identifier
     let delegator_controller = Arc::new(Controller::new(ControllerConfig {
         db_path: delegator_root.path().to_owned(),
         ..Default::default()
     })?);
 
-	 let icp_event = delegator_controller
-        .incept(vec![delegator_pk], vec![delegator_npk], vec![first_witness_oobi.clone()], 1)
+    let icp_event = delegator_controller
+        .incept(
+            vec![delegator_pk],
+            vec![delegator_npk],
+            vec![first_witness_oobi.clone()],
+            1,
+        )
         .await?;
     let signature = SelfSigningPrefix::Ed25519Sha512(delegator_keypair.sign(icp_event.as_bytes())?);
 
@@ -47,8 +58,8 @@ async fn single_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> R
     }
     println!("Delegator: {}", &delegator_identifier.id());
 
-	// Setup delegatee
-	// TODO why we need to setup identifier before incept group to create delegated identifier?
+    // Setup delegatee
+    // TODO why we need to setup identifier before incept group to create delegated identifier?
     let delegatee_controller = Arc::new(Controller::new(ControllerConfig {
         db_path: delegatee_root.path().to_owned(),
         ..Default::default()
@@ -69,8 +80,10 @@ async fn single_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> R
     temporary_delegatee_identifier.notify_witnesses().await?;
 
     // Quering mailbox to get receipts
-    let query = temporary_delegatee_identifier
-        .query_mailbox(temporary_delegatee_identifier.id(), &[first_witness_id.clone()])?;
+    let query = temporary_delegatee_identifier.query_mailbox(
+        temporary_delegatee_identifier.id(),
+        &[first_witness_id.clone()],
+    )?;
 
     for qry in query {
         let signature = SelfSigningPrefix::Ed25519Sha512(delegatee_keypair.sign(&qry.encode()?)?);
@@ -79,7 +92,7 @@ async fn single_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> R
             .await?;
     }
 
-	// Generate delegated inception and exn, that is provide delegation request to delegator.
+    // Generate delegated inception and exn, that is provide delegation request to delegator.
     let (delegated_inception, exn_messages) = temporary_delegatee_identifier.incept_group(
         vec![],
         1,
@@ -105,10 +118,10 @@ async fn single_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> R
     // Event is not yet accepted. Missing delegating event.
     assert!(kel.is_none());
 
-
-	// Delegation accept process
+    // Delegation accept process
     // Delegator asks about his mailbox to get delegated event.
-    let query = delegator_identifier.query_mailbox(delegator_identifier.id(), &[first_witness_id.clone()])?;
+    let query = delegator_identifier
+        .query_mailbox(delegator_identifier.id(), &[first_witness_id.clone()])?;
 
     for qry in query {
         let signature = SelfSigningPrefix::Ed25519Sha512(delegator_keypair.sign(&qry.encode()?)?);
@@ -135,7 +148,8 @@ async fn single_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> R
                 delegator_identifier.notify_witnesses().await?;
 
                 // Query for receipts
-                let query = delegator_identifier.query_mailbox(delegator_identifier.id(), &[first_witness_id.clone()])?;
+                let query = delegator_identifier
+                    .query_mailbox(delegator_identifier.id(), &[first_witness_id.clone()])?;
 
                 for qry in query {
                     let signature =
@@ -152,7 +166,8 @@ async fn single_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> R
                     .await?;
 
                 // ixn was accepted
-                let delegators_state = delegator_controller.find_state(delegator_identifier.id())?;
+                let delegators_state =
+                    delegator_controller.find_state(delegator_identifier.id())?;
                 assert_eq!(delegators_state.sn, 1);
             }
         };
@@ -171,7 +186,8 @@ async fn single_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> R
         .save(&Message::Notice(delegators_kel[1].clone()))?; // receipt
 
     // Ask about delegated identifier mailbox
-    let query = temporary_delegatee_identifier.query_mailbox(&delegatee_id, &[first_witness_id.clone()])?;
+    let query =
+        temporary_delegatee_identifier.query_mailbox(&delegatee_id, &[first_witness_id.clone()])?;
 
     for qry in query {
         let signature = SelfSigningPrefix::Ed25519Sha512(delegatee_keypair.sign(&qry.encode()?)?);
@@ -190,7 +206,8 @@ async fn single_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> R
     assert!(state.is_err());
 
     // Get mailbox for receipts.
-    let query = temporary_delegatee_identifier.query_mailbox(&delegatee_id, &[first_witness_id.clone()])?;
+    let query =
+        temporary_delegatee_identifier.query_mailbox(&delegatee_id, &[first_witness_id.clone()])?;
 
     for qry in query {
         let signature = SelfSigningPrefix::Ed25519Sha512(delegatee_keypair.sign(&qry.encode()?)?);
@@ -204,5 +221,5 @@ async fn single_delegator_single_delegatee(ctx: &mut InfrastructureContext) -> R
     let state = temporary_delegatee_identifier.find_state(&delegatee_id)?;
     assert_eq!(state.sn, 0);
 
-	Ok(())
-}
\ No newline at end of file
+    Ok(())
+}
diff --git a/keriox_tests/tests/test_witness_rotation.rs b/keriox_tests/tests/test_witness_rotation.rs
index 0d748c8b..08681928 100644
--- a/keriox_tests/tests/test_witness_rotation.rs
+++ b/keriox_tests/tests/test_witness_rotation.rs
@@ -1,6 +1,4 @@
-use keri_controller::{
-    error::ControllerError, BasicPrefix, KeyManager, SelfSigningPrefix,
-};
+use keri_controller::{error::ControllerError, BasicPrefix, KeyManager, SelfSigningPrefix};
 use keri_tests::{settings::InfrastructureContext, setup_identifier};
 use tempfile::Builder;
 use test_context::test_context;
@@ -14,12 +12,8 @@ async fn test_witness_rotation(ctx: &mut InfrastructureContext) -> Result<(), Co
     let (_second_witness_id, second_witness_oobi) = ctx.second_witness_data();
 
     // Setup identifier with `witness1` as witness
-    let (mut identifier, mut controller_keypair, _) = setup_identifier(
-        root0.path(),
-        vec![first_witness_oobi.clone()],
-        None, None,
-    )
-    .await;
+    let (mut identifier, mut controller_keypair, _) =
+        setup_identifier(root0.path(), vec![first_witness_oobi.clone()], None, None).await;
 
     let state = identifier.find_state(identifier.id())?;
     assert_eq!(state.sn, 0);