diff --git a/clients/native/src/commands/init.rs b/clients/native/src/commands/init.rs
index 55c8cc01ad..b66cc6b2cf 100644
--- a/clients/native/src/commands/init.rs
+++ b/clients/native/src/commands/init.rs
@@ -64,7 +64,6 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
         )
 }
 
-
 // this behaviour should definitely be changed, we shouldn't
 // need to get bandwidth credential for registration
 async fn prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) -> Credential {
diff --git a/clients/socks5/src/commands/init.rs b/clients/socks5/src/commands/init.rs
index 6af059a042..08291344f5 100644
--- a/clients/socks5/src/commands/init.rs
+++ b/clients/socks5/src/commands/init.rs
@@ -7,7 +7,6 @@ use clap::{App, Arg, ArgMatches};
 use client_core::client::key_manager::KeyManager;
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 
-
 use config::NymConfig;
 
 #[cfg(feature = "coconut")]
diff --git a/clients/tauri-client/src-tauri/src/main.rs b/clients/tauri-client/src-tauri/src/main.rs
index 01ffbd518c..051bc0bb3c 100644
--- a/clients/tauri-client/src-tauri/src/main.rs
+++ b/clients/tauri-client/src-tauri/src/main.rs
@@ -1,6 +1,6 @@
 #![cfg_attr(
-all(not(debug_assertions), target_os = "windows"),
-windows_subsystem = "windows"
+  all(not(debug_assertions), target_os = "windows"),
+  windows_subsystem = "windows"
 )]
 
 use std::sync::Arc;
@@ -9,203 +9,206 @@ use tokio::sync::RwLock;
 use url::Url;
 
 use coconut_interface::{
-    self, Attribute, Credential, hash_to_scalar, Parameters, Signature, Theta, VerificationKey,
+  self, hash_to_scalar, Attribute, Credential, Parameters, Signature, Theta, VerificationKey,
 };
 use credentials::{obtain_aggregate_signature, obtain_aggregate_verification_key};
 
 struct State {
-    signatures: Vec<Signature>,
-    n_attributes: u32,
-    params: Parameters,
-    serial_number: Attribute,
-    binding_number: Attribute,
-    voucher_value: Attribute,
-    voucher_info: Attribute,
-    aggregated_verification_key: Option<VerificationKey>,
+  signatures: Vec<Signature>,
+  n_attributes: u32,
+  params: Parameters,
+  serial_number: Attribute,
+  binding_number: Attribute,
+  voucher_value: Attribute,
+  voucher_info: Attribute,
+  aggregated_verification_key: Option<VerificationKey>,
 }
 
 impl State {
-    fn init(public_attributes_bytes: Vec<Vec<u8>>, private_attributes_bytes: Vec<Vec<u8>>) -> State {
-        let n_attributes = (public_attributes_bytes.len() + private_attributes_bytes.len()) as u32;
-        let params = Parameters::new(n_attributes).unwrap();
-        let public_attributes = public_attributes_bytes
-            .iter()
-            .map(hash_to_scalar)
-            .collect::<Vec<Attribute>>();
-        let private_attributes = private_attributes_bytes
-            .iter()
-            .map(hash_to_scalar)
-            .collect::<Vec<Attribute>>();
-        State {
-            signatures: Vec::new(),
-            n_attributes,
-            params,
-            serial_number: private_attributes[0],
-            binding_number: private_attributes[1],
-            voucher_value: public_attributes[0],
-            voucher_info: public_attributes[1],
-            aggregated_verification_key: None,
-        }
+  fn init(public_attributes_bytes: Vec<Vec<u8>>, private_attributes_bytes: Vec<Vec<u8>>) -> State {
+    let n_attributes = (public_attributes_bytes.len() + private_attributes_bytes.len()) as u32;
+    let params = Parameters::new(n_attributes).unwrap();
+    let public_attributes = public_attributes_bytes
+      .iter()
+      .map(hash_to_scalar)
+      .collect::<Vec<Attribute>>();
+    let private_attributes = private_attributes_bytes
+      .iter()
+      .map(hash_to_scalar)
+      .collect::<Vec<Attribute>>();
+    State {
+      signatures: Vec::new(),
+      n_attributes,
+      params,
+      serial_number: private_attributes[0],
+      binding_number: private_attributes[1],
+      voucher_value: public_attributes[0],
+      voucher_info: public_attributes[1],
+      aggregated_verification_key: None,
     }
+  }
 }
 
 fn parse_url_validators(raw: &[String]) -> Result<Vec<Url>, String> {
-    let mut parsed_urls = Vec::with_capacity(raw.len());
-    for url in raw {
-        let parsed_url: Url = url
-            .parse()
-            .map_err(|err| format!("one of validator urls is malformed - {}", err))?;
-        parsed_urls.push(parsed_url)
-    }
-    Ok(parsed_urls)
+  let mut parsed_urls = Vec::with_capacity(raw.len());
+  for url in raw {
+    let parsed_url: Url = url
+      .parse()
+      .map_err(|err| format!("one of validator urls is malformed - {}", err))?;
+    parsed_urls.push(parsed_url)
+  }
+  Ok(parsed_urls)
 }
 
 #[tauri::command]
 async fn randomise_credential(
-    idx: usize,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+  idx: usize,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Vec<Signature>, String> {
-    let mut state = state.write().await;
-    let signature = state.signatures.remove(idx);
-    let (new_signature, _) = signature.randomise(&state.params);
-    state.signatures.insert(idx, new_signature);
-    Ok(state.signatures.clone())
+  let mut state = state.write().await;
+  let signature = state.signatures.remove(idx);
+  let (new_signature, _) = signature.randomise(&state.params);
+  state.signatures.insert(idx, new_signature);
+  Ok(state.signatures.clone())
 }
 
 #[tauri::command]
 async fn delete_credential(
-    idx: usize,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+  idx: usize,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Vec<Signature>, String> {
-    let mut state = state.write().await;
-    state.signatures.remove(idx);
-    Ok(state.signatures.clone())
+  let mut state = state.write().await;
+  state.signatures.remove(idx);
+  Ok(state.signatures.clone())
 }
 
 #[tauri::command]
 async fn list_credentials(
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Vec<Signature>, String> {
-    let state = state.read().await;
-    Ok(state.signatures.clone())
+  let state = state.read().await;
+  Ok(state.signatures.clone())
 }
 
 async fn get_aggregated_verification_key(
-    validator_urls: Vec<String>,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+  validator_urls: Vec<String>,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<VerificationKey, String> {
-    if let Some(verification_key) = &state.read().await.aggregated_verification_key {
-        return Ok(verification_key.clone());
-    }
+  if let Some(verification_key) = &state.read().await.aggregated_verification_key {
+    return Ok(verification_key.clone());
+  }
 
-    let parsed_urls = parse_url_validators(&validator_urls)?;
-    let key = obtain_aggregate_verification_key(&parsed_urls)
-        .await
-        .map_err(|err| format!("failed to obtain aggregate verification key - {:?}", err))?;
+  let parsed_urls = parse_url_validators(&validator_urls)?;
+  let key = obtain_aggregate_verification_key(&parsed_urls)
+    .await
+    .map_err(|err| format!("failed to obtain aggregate verification key - {:?}", err))?;
 
-    state
-        .write()
-        .await
-        .aggregated_verification_key
-        .replace(key.clone());
+  state
+    .write()
+    .await
+    .aggregated_verification_key
+    .replace(key.clone());
 
-    Ok(key)
+  Ok(key)
 }
 
 async fn prove_credential(
-    idx: usize,
-    validator_urls: Vec<String>,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+  idx: usize,
+  validator_urls: Vec<String>,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Theta, String> {
-    let verification_key = get_aggregated_verification_key(validator_urls, state.clone()).await?;
-    let state = state.read().await;
+  let verification_key = get_aggregated_verification_key(validator_urls, state.clone()).await?;
+  let state = state.read().await;
 
-    if let Some(signature) = state.signatures.get(idx) {
-        match coconut_interface::prove_bandwidth_credential(
-            &state.params,
-            &verification_key,
-            signature,
-            state.serial_number,
-            state.binding_number,
-        ) {
-            Ok(theta) => Ok(theta),
-            Err(e) => Err(format!("{:?}", e)),
-        }
-    } else {
-        Err("Got invalid Signature idx".to_string())
+  if let Some(signature) = state.signatures.get(idx) {
+    match coconut_interface::prove_bandwidth_credential(
+      &state.params,
+      &verification_key,
+      signature,
+      state.serial_number,
+      state.binding_number,
+    ) {
+      Ok(theta) => Ok(theta),
+      Err(e) => Err(format!("{:?}", e)),
     }
+  } else {
+    Err("Got invalid Signature idx".to_string())
+  }
 }
 
 #[tauri::command]
 async fn verify_credential(
-    idx: usize,
-    validator_urls: Vec<String>,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+  idx: usize,
+  validator_urls: Vec<String>,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<bool, String> {
-    // the API needs to be improved but at least it should compile (in theory)
-    let verification_key =
-        get_aggregated_verification_key(validator_urls.clone(), state.clone()).await?;
-    let theta = prove_credential(idx, validator_urls, state.clone()).await?;
+  // the API needs to be improved but at least it should compile (in theory)
+  let verification_key =
+    get_aggregated_verification_key(validator_urls.clone(), state.clone()).await?;
+  let theta = prove_credential(idx, validator_urls, state.clone()).await?;
 
-    let state = state.read().await;
+  let state = state.read().await;
 
-    let public_attributes_bytes = vec![state.voucher_value.to_bytes().to_vec(), state.voucher_info.to_bytes().to_vec()];
+  let public_attributes_bytes = vec![
+    state.voucher_value.to_bytes().to_vec(),
+    state.voucher_info.to_bytes().to_vec(),
+  ];
 
-    let credential = Credential::new(
-        state.n_attributes,
-        theta,
-        public_attributes_bytes,
-        state
-            .signatures
-            .get(idx)
-            .ok_or("Got invalid signature idx")?,
-    );
+  let credential = Credential::new(
+    state.n_attributes,
+    theta,
+    public_attributes_bytes,
+    state
+      .signatures
+      .get(idx)
+      .ok_or("Got invalid signature idx")?,
+  );
 
-    Ok(credential.verify(&verification_key))
+  Ok(credential.verify(&verification_key))
 }
 
 #[tauri::command]
 async fn get_credential(
-    validator_urls: Vec<String>,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+  validator_urls: Vec<String>,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Vec<Signature>, String> {
-    let guard = state.read().await;
-    let parsed_urls = parse_url_validators(&validator_urls)?;
-    let verification_key =
-        get_aggregated_verification_key(validator_urls.clone(), state.clone()).await?;
-    let public_attributes = vec![guard.voucher_value, guard.voucher_info];
-    let private_attributes = vec![guard.serial_number, guard.binding_number];
+  let guard = state.read().await;
+  let parsed_urls = parse_url_validators(&validator_urls)?;
+  let verification_key =
+    get_aggregated_verification_key(validator_urls.clone(), state.clone()).await?;
+  let public_attributes = vec![guard.voucher_value, guard.voucher_info];
+  let private_attributes = vec![guard.serial_number, guard.binding_number];
 
-    let signature = obtain_aggregate_signature(
-        &guard.params,
-        &public_attributes,
-        &private_attributes,
-        &parsed_urls,
-        &verification_key,
-    )
-        .await
-        .map_err(|err| format!("failed to obtain aggregate signature - {:?}", err))?;
+  let signature = obtain_aggregate_signature(
+    &guard.params,
+    &public_attributes,
+    &private_attributes,
+    &parsed_urls,
+    &verification_key,
+  )
+  .await
+  .map_err(|err| format!("failed to obtain aggregate signature - {:?}", err))?;
 
-    let mut state = state.write().await;
-    state.signatures.push(signature);
-    Ok(state.signatures.clone())
+  let mut state = state.write().await;
+  state.signatures.push(signature);
+  Ok(state.signatures.clone())
 }
 
 fn main() {
-    let public_attributes = vec![b"public_key".to_vec()];
-    let private_attributes = vec![b"private_key".to_vec()];
-    tauri::Builder::default()
-        .manage(Arc::new(RwLock::new(State::init(
-            public_attributes,
-            private_attributes,
-        ))))
-        .invoke_handler(tauri::generate_handler![
+  let public_attributes = vec![b"public_key".to_vec()];
+  let private_attributes = vec![b"private_key".to_vec()];
+  tauri::Builder::default()
+    .manage(Arc::new(RwLock::new(State::init(
+      public_attributes,
+      private_attributes,
+    ))))
+    .invoke_handler(tauri::generate_handler![
       get_credential,
       randomise_credential,
       delete_credential,
       list_credentials,
       verify_credential
     ])
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
+    .run(tauri::generate_context!())
+    .expect("error while running tauri application");
 }
diff --git a/common/credentials/src/bandwidth.rs b/common/credentials/src/bandwidth.rs
index dbd7eb408c..ec2ca6df82 100644
--- a/common/credentials/src/bandwidth.rs
+++ b/common/credentials/src/bandwidth.rs
@@ -9,8 +9,7 @@
 use url::Url;
 
 use coconut_interface::{
-    Credential, Parameters, PrivateAttribute, PublicAttribute,
-    Signature, VerificationKey,
+    Credential, Parameters, PrivateAttribute, PublicAttribute, Signature, VerificationKey,
 };
 
 use crate::error::Error;
@@ -66,7 +65,7 @@ pub async fn obtain_signature(
         validators,
         verification_key,
     )
-        .await
+    .await
 }
 
 pub fn prepare_for_spending(
@@ -75,7 +74,10 @@ pub fn prepare_for_spending(
     attributes: &BandwidthVoucherAttributes,
     verification_key: &VerificationKey,
 ) -> Result<Credential, Error> {
-    let public_attributes = vec![raw_identity.to_vec(), BANDWIDTH_VALUE.to_be_bytes().to_vec()];
+    let public_attributes = vec![
+        raw_identity.to_vec(),
+        BANDWIDTH_VALUE.to_be_bytes().to_vec(),
+    ];
 
     let params = Parameters::new(TOTAL_ATTRIBUTES)?;
 
diff --git a/common/credentials/src/utils.rs b/common/credentials/src/utils.rs
index d951d46c3b..411885879c 100644
--- a/common/credentials/src/utils.rs
+++ b/common/credentials/src/utils.rs
@@ -4,8 +4,8 @@
 use url::Url;
 
 use coconut_interface::{
-    aggregate_signature_shares, aggregate_verification_keys, Attribute,
-    BlindSignRequestBody, Credential, Parameters, prepare_blind_sign, prove_bandwidth_credential, Signature,
+    aggregate_signature_shares, aggregate_verification_keys, prepare_blind_sign,
+    prove_bandwidth_credential, Attribute, BlindSignRequestBody, Credential, Parameters, Signature,
     SignatureShare, VerificationKey,
 };
 
@@ -121,7 +121,7 @@ pub async fn obtain_aggregate_signature(
         &client,
         &validator_partial_vk.key,
     )
-        .await?;
+    .await?;
     shares.push(SignatureShare::new(first, 0));
 
     for (id, validator_url) in validators.iter().enumerate().skip(1) {
@@ -134,7 +134,7 @@ pub async fn obtain_aggregate_signature(
             &client,
             &validator_partial_vk.key,
         )
-            .await?;
+        .await?;
         let share = SignatureShare::new(signature, id as u64);
         shares.push(share)
     }
diff --git a/common/nymcoconut/src/error.rs b/common/nymcoconut/src/error.rs
index b53c8360a6..32b9e90dbb 100644
--- a/common/nymcoconut/src/error.rs
+++ b/common/nymcoconut/src/error.rs
@@ -38,9 +38,9 @@ pub enum CoconutError {
     #[error("Deserialization error: {0}")]
     Deserialization(String),
     #[error(
-    "Deserailization error, expected at least {} bytes, got {}",
-    min,
-    actual
+        "Deserailization error, expected at least {} bytes, got {}",
+        min,
+        actual
     )]
     DeserializationMinLength { min: usize, actual: usize },
     #[error("Tried to deserialize {object} with bytes of invalid length. Expected {actual} < {} or {modulus_target} % {modulus} == 0")]
diff --git a/common/nymcoconut/src/lib.rs b/common/nymcoconut/src/lib.rs
index 2aafc5bc14..f3305bcc17 100644
--- a/common/nymcoconut/src/lib.rs
+++ b/common/nymcoconut/src/lib.rs
@@ -22,20 +22,20 @@ pub use elgamal::PublicKey;
 pub use error::CoconutError;
 pub use scheme::aggregation::aggregate_signature_shares;
 pub use scheme::aggregation::aggregate_verification_keys;
-pub use scheme::BlindedSignature;
 pub use scheme::issuance::blind_sign;
-pub use scheme::issuance::BlindSignRequest;
 pub use scheme::issuance::prepare_blind_sign;
-pub use scheme::keygen::KeyPair;
+pub use scheme::issuance::BlindSignRequest;
 pub use scheme::keygen::ttp_keygen;
+pub use scheme::keygen::KeyPair;
 pub use scheme::keygen::VerificationKey;
-pub use scheme::setup::Parameters;
 pub use scheme::setup::setup;
+pub use scheme::setup::Parameters;
+pub use scheme::verification::prove_bandwidth_credential;
+pub use scheme::verification::verify_credential;
+pub use scheme::verification::Theta;
+pub use scheme::BlindedSignature;
 pub use scheme::Signature;
 pub use scheme::SignatureShare;
-pub use scheme::verification::prove_bandwidth_credential;
-pub use scheme::verification::Theta;
-pub use scheme::verification::verify_credential;
 pub use traits::Base58;
 pub use utils::hash_to_scalar;
 
diff --git a/common/nymcoconut/src/scheme/mod.rs b/common/nymcoconut/src/scheme/mod.rs
index 0e9312c940..33f7a77aa8 100644
--- a/common/nymcoconut/src/scheme/mod.rs
+++ b/common/nymcoconut/src/scheme/mod.rs
@@ -22,13 +22,13 @@ use group::Curve;
 
 pub use keygen::{SecretKey, VerificationKey};
 
-use crate::{Attribute, elgamal};
 use crate::elgamal::Ciphertext;
 use crate::error::{CoconutError, Result};
 use crate::scheme::setup::Parameters;
 use crate::scheme::verification::check_bilinear_pairing;
 use crate::traits::{Base58, Bytable};
 use crate::utils::try_deserialize_g1_projective;
+use crate::{elgamal, Attribute};
 
 pub mod aggregation;
 pub mod issuance;
@@ -265,16 +265,16 @@ mod tests {
             &lambda,
             &[],
         )
-            .unwrap()
-            .unblind(
-                &params,
-                elgamal_keypair.private_key(),
-                &keypair1.verification_key(),
-                &private_attributes,
-                &[],
-                &lambda.commitment_hash,
-            )
-            .unwrap();
+        .unwrap()
+        .unblind(
+            &params,
+            elgamal_keypair.private_key(),
+            &keypair1.verification_key(),
+            &private_attributes,
+            &[],
+            &lambda.commitment_hash,
+        )
+        .unwrap();
 
         let sig2 = blind_sign(
             &mut params,
@@ -283,16 +283,16 @@ mod tests {
             &lambda,
             &[],
         )
-            .unwrap()
-            .unblind(
-                &params,
-                elgamal_keypair.private_key(),
-                &keypair2.verification_key(),
-                &private_attributes,
-                &[],
-                &lambda.commitment_hash,
-            )
-            .unwrap();
+        .unwrap()
+        .unblind(
+            &params,
+            elgamal_keypair.private_key(),
+            &keypair2.verification_key(),
+            &private_attributes,
+            &[],
+            &lambda.commitment_hash,
+        )
+        .unwrap();
 
         let theta1 = prove_bandwidth_credential(
             &mut params,
@@ -301,7 +301,7 @@ mod tests {
             serial_number,
             binding_number,
         )
-            .unwrap();
+        .unwrap();
 
         let theta2 = prove_bandwidth_credential(
             &mut params,
@@ -310,7 +310,7 @@ mod tests {
             serial_number,
             binding_number,
         )
-            .unwrap();
+        .unwrap();
 
         assert!(verify_credential(
             &params,
@@ -384,7 +384,7 @@ mod tests {
             &private_attributes,
             &public_attributes,
         )
-            .unwrap();
+        .unwrap();
 
         let sig1 = blind_sign(
             &mut params,
@@ -393,16 +393,16 @@ mod tests {
             &lambda,
             &public_attributes,
         )
-            .unwrap()
-            .unblind(
-                &params,
-                elgamal_keypair.private_key(),
-                &keypair1.verification_key(),
-                &private_attributes,
-                &public_attributes,
-                &lambda.commitment_hash,
-            )
-            .unwrap();
+        .unwrap()
+        .unblind(
+            &params,
+            elgamal_keypair.private_key(),
+            &keypair1.verification_key(),
+            &private_attributes,
+            &public_attributes,
+            &lambda.commitment_hash,
+        )
+        .unwrap();
 
         let sig2 = blind_sign(
             &mut params,
@@ -411,16 +411,16 @@ mod tests {
             &lambda,
             &public_attributes,
         )
-            .unwrap()
-            .unblind(
-                &params,
-                elgamal_keypair.private_key(),
-                &keypair2.verification_key(),
-                &private_attributes,
-                &public_attributes,
-                &lambda.commitment_hash,
-            )
-            .unwrap();
+        .unwrap()
+        .unblind(
+            &params,
+            elgamal_keypair.private_key(),
+            &keypair2.verification_key(),
+            &private_attributes,
+            &public_attributes,
+            &lambda.commitment_hash,
+        )
+        .unwrap();
 
         let theta1 = prove_bandwidth_credential(
             &mut params,
@@ -429,7 +429,7 @@ mod tests {
             serial_number,
             binding_number,
         )
-            .unwrap();
+        .unwrap();
 
         let theta2 = prove_bandwidth_credential(
             &mut params,
@@ -438,7 +438,7 @@ mod tests {
             serial_number,
             binding_number,
         )
-            .unwrap();
+        .unwrap();
 
         assert!(verify_credential(
             &params,
@@ -479,7 +479,7 @@ mod tests {
             &private_attributes,
             &public_attributes,
         )
-            .unwrap();
+        .unwrap();
 
         let sigs = keypairs
             .iter()
@@ -491,16 +491,16 @@ mod tests {
                     &lambda,
                     &public_attributes,
                 )
-                    .unwrap()
-                    .unblind(
-                        &params,
-                        elgamal_keypair.private_key(),
-                        &keypair.verification_key(),
-                        &private_attributes,
-                        &public_attributes,
-                        &lambda.commitment_hash,
-                    )
-                    .unwrap()
+                .unwrap()
+                .unblind(
+                    &params,
+                    elgamal_keypair.private_key(),
+                    &keypair.verification_key(),
+                    &private_attributes,
+                    &public_attributes,
+                    &lambda.commitment_hash,
+                )
+                .unwrap()
             })
             .collect::<Vec<_>>();
 
@@ -525,7 +525,7 @@ mod tests {
             serial_number,
             binding_number,
         )
-            .unwrap();
+        .unwrap();
 
         assert!(verify_credential(
             &params,
@@ -547,7 +547,7 @@ mod tests {
             serial_number,
             binding_number,
         )
-            .unwrap();
+        .unwrap();
 
         assert!(verify_credential(
             &params,
@@ -570,7 +570,7 @@ mod tests {
             signature.0.to_affine().to_compressed(),
             signature.1.to_affine().to_compressed(),
         ]
-            .concat();
+        .concat();
         assert_eq!(expected_bytes, bytes);
         assert_eq!(signature, Signature::try_from(&bytes[..]).unwrap())
     }
@@ -590,10 +590,10 @@ mod tests {
         // also make sure it is equivalent to the internal g1 compressed bytes concatenated
         let expected_bytes = [
             blinded_sig.0.to_affine().to_compressed(),
-            blinded_sig.1.0.to_affine().to_compressed(),
-            blinded_sig.1.1.to_affine().to_compressed(),
+            blinded_sig.1 .0.to_affine().to_compressed(),
+            blinded_sig.1 .1.to_affine().to_compressed(),
         ]
-            .concat();
+        .concat();
         assert_eq!(expected_bytes, bytes);
         assert_eq!(blinded_sig, BlindedSignature::try_from(&bytes[..]).unwrap())
     }
diff --git a/common/nymcoconut/src/tests/e2e.rs b/common/nymcoconut/src/tests/e2e.rs
index 1eb4f16982..d271008aa7 100644
--- a/common/nymcoconut/src/tests/e2e.rs
+++ b/common/nymcoconut/src/tests/e2e.rs
@@ -1,7 +1,7 @@
 use crate::{
-    aggregate_signature_shares, aggregate_verification_keys, blind_sign, CoconutError,
-    elgamal_keygen, prepare_blind_sign, prove_bandwidth_credential, setup, Signature, SignatureShare,
-    ttp_keygen, VerificationKey, verify_credential,
+    aggregate_signature_shares, aggregate_verification_keys, blind_sign, elgamal_keygen,
+    prepare_blind_sign, prove_bandwidth_credential, setup, ttp_keygen, verify_credential,
+    CoconutError, Signature, SignatureShare, VerificationKey,
 };
 
 #[test]