move parse_id function to src/util.rs

src/util.rs

@@ -1,4 +1,9 @@
 use crate::Result;
+use crate::serial::{deserialize, serialize};
+
+use sha2::{Digest, Sha256};
+use serde_json::Value;
+use log::*;
 
 use std::path::{Path, PathBuf};
 
@@ -17,3 +22,94 @@ pub fn join_config_path(file: &PathBuf) -> Result<PathBuf> {
 
     Ok(path)
 }
+
+// here we hash the alphanumeric token ID. if it fails, we change the last 4 bytes and hash it
+// again, and keep repeating until it works.
+pub fn parse_id(token: &Value) -> Result<jubjub::Fr> {
+    let tkn_str = token.as_str().unwrap();
+    if bs58::decode(tkn_str).into_vec().is_err() {
+        // TODO: make this an error
+        debug!(target: "CASHIER", "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;
+            }
+            debug!(target: "CASHIER", "DESERIALIZATION SUCCESSFUL");
+            let tkn = token_id.unwrap();
+            return Ok(tkn);
+        }
+    }
+    unreachable!();
+}
+
+
+
+#[cfg(test)]
+mod tests {
+    use crate::serial::{deserialize, serialize};
+    use sha2::{Digest, Sha256};
+
+    #[test]
+    fn test_jubjub_parsing() {
+        // 1. counter = 0
+        // 2. serialized_counter = serialize(counter)
+        // 3. asset_id_data = hash(data + serialized_counter)
+        // 4. asset_id = deserialize(asset_id_data)
+        // 5. test parse
+        // 6. loop
+        let tkn_str = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+        println!("{}", tkn_str);
+        if bs58::decode(tkn_str).into_vec().is_err() {
+            println!("Could not decode str into vec");
+        }
+        let mut data = bs58::decode(tkn_str).into_vec().unwrap();
+        println!("{:?}", data);
+        let mut hasher = Sha256::new();
+        hasher.update(&data);
+        let hash = hasher.finalize();
+        let token_id = deserialize::<jubjub::Fr>(&hash);
+        println!("{:?}", token_id);
+        let mut counter = 0;
+        if token_id.is_err() {
+            println!("could not deserialize tkn 58");
+            loop {
+                println!("TOKEN IS NONE. COMMENCING LOOP");
+                counter += 1;
+                println!("LOOP NUMBER {}", counter);
+                println!("{:?}", data.len());
+                data.truncate(28);
+                let serialized_counter = serialize(&counter);
+                println!("{:?}", serialized_counter);
+                data.extend(serialized_counter.iter());
+                println!("{:?}", data.len());
+                let mut hasher = Sha256::new();
+                hasher.update(&data);
+                let hash = hasher.finalize();
+                let token_id = deserialize::<jubjub::Fr>(&hash);
+                println!("{:?}", token_id);
+                if token_id.is_err() {
+                    continue;
+                }
+                if counter > 10 {
+                    break;
+                }
+                println!("deserialization successful");
+                token_id.unwrap();
+                break;
+            }
+        };
+    }
+}