Clean up some error mapping.

src/lib.rs

@@ -90,8 +90,7 @@ impl ZkContract {
         }
 
         // execute
-        //let params = std::mem::take(&mut self.params);
-        let params = std::mem::replace(&mut self.params, HashMap::default());
+        let params = std::mem::take(&mut self.params);
         self.vm.initialize(&params.into_iter().collect())?;
 
         // prove

src/service/bridge.rs

@@ -90,7 +90,7 @@ impl Bridge {
             .collect::<FuturesUnordered<async_channel::Recv<TokenNotification>>>()
             .next()
             .await
-            .map(|o| o.map_err(|e| Error::from(e)))
+            .map(|o| o.map_err(Error::from))
     }
 
     pub async fn subscribe(self: Arc<Self>) -> BridgeSubscribtion {

src/service/sol.rs

@@ -105,14 +105,9 @@ impl SolClient {
 
         // Fetch the current balance.
         let (prev_balance, decimals) = if mint.is_none() {
-            (
-                rpc.get_balance(&pubkey)
-                    .map_err(|err| SolFailed::from(err))?,
-                9,
-            )
+            (rpc.get_balance(&pubkey).map_err(SolFailed::from)?, 9)
         } else {
-            get_account_token_balance(&rpc, &pubkey, &mint.unwrap())
-                .map_err(|err| SolFailed::from(err))?
+            get_account_token_balance(&rpc, &pubkey, &mint.unwrap()).map_err(SolFailed::from)?
         };
 
         // WebSocket connection
@@ -359,7 +354,7 @@ impl NetworkClient for SolClient {
 
         let _signature = rpc
             .send_and_confirm_transaction(&tx)
-            .map_err(|err| SolFailed::from(err))?;
+            .map_err(SolFailed::from)?;
 
         Ok(())
     }

src/util.rs

@@ -94,28 +94,30 @@ pub fn generate_id(tkn_str: &str) -> Result<jubjub::Fr> {
         debug!(target: "PARSE ID", "COULD NOT DECODE STR");
     }
     let mut data = bs58::decode(tkn_str).into_vec().unwrap();
-    let token_id = deserialize::<jubjub::Fr>(&data);
-    if token_id.is_err() {
-        let mut counter = 0;
-        loop {
-            data.truncate(28);
-            let serialized_counter = serialize(&counter);
-            data.extend(serialized_counter.iter());
-            let mut hasher = Sha256::new();
-            hasher.update(&data);
-            let hash = hasher.finalize();
-            let token_id = deserialize::<jubjub::Fr>(&hash);
-            if token_id.is_err() {
-                counter += 1;
-                continue;
+
+    let token_id = match deserialize::<jubjub::Fr>(&data) {
+        Ok(v) => v,
+        Err(_) => {
+            let mut counter = 0;
+            loop {
+                data.truncate(28);
+                let serialized_counter = serialize(&counter);
+                data.extend(serialized_counter.iter());
+                let mut hasher = Sha256::new();
+                hasher.update(&data);
+                let hash = hasher.finalize();
+                let token_id = deserialize::<jubjub::Fr>(&hash);
+                if token_id.is_err() {
+                    counter += 1;
+                    continue;
+                }
+                debug!(target: "CASHIER", "DESERIALIZATION SUCCESSFUL");
+                token_id.unwrap();
             }
-            debug!(target: "CASHIER", "DESERIALIZATION SUCCESSFUL");
-            let tkn = token_id.unwrap();
-            return Ok(tkn);
         }
-    } else {
-        Ok(token_id.unwrap())
-    }
+    };
+
+    Ok(token_id)
 }
 
 pub fn parse_wrapped_token(token: &str) -> Result<jubjub::Fr> {