cargo fmt

crates/sp_client/src/aesgcm.rs

@@ -1,10 +1,10 @@
 /* This module is temporary. We'll use the module described in key_encription
 module defined in sdk_common repository! Some of the methods there were copied here.
-*/  
+*/
-use wasm_bindgen::JsValue;
-use web_sys::console;
 use core::result::Result as CoreResult;
 use rand::RngCore;
+use wasm_bindgen::JsValue;
+use web_sys::console;
 
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
@@ -15,16 +15,14 @@ use aes_gcm::{
     aead::{AeadInPlace, KeyInit},
     Aes256Gcm,
 };
-use rand::rngs::OsRng;
 use hex;
 use hex::FromHexError;
-
+use rand::rngs::OsRng;
 
 pub struct Aes256GcmIv96Bit {
     pub key: GenericArray<u8, U32>,
 }
 
-
 impl Aes256GcmIv96Bit {
     pub fn new() -> Self {
         let mut key_bytes = [0u8; 32];
@@ -96,7 +94,6 @@ impl Aes256GcmIv96Bit {
             Err(_) => Err("Échec du décodage de la clé".to_string()),
         }
     }
-    
 }
 
 #[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -118,9 +115,8 @@ impl KeyEncryption {
             algorithm,
         }
     }
-    
+
     pub fn encode(&self, data: String) -> CoreResult<String, String> {
-       
         if let Some(ref key) = self.key {
             let decoded_key = Aes256GcmIv96Bit::import_key(key)?;
             let encrypted_data = decoded_key.encrypt_string(&data)?;
@@ -140,7 +136,7 @@ impl KeyEncryption {
         }
     }
 
-       pub fn enc(&self, data: Value) -> String {
+    pub fn enc(&self, data: Value) -> String {
         let data_string = serde_json::to_string(&data).unwrap_or_else(|_| "".to_string());
         self.encode(data_string).unwrap_or_else(|_| "".to_string())
     }
@@ -172,6 +168,6 @@ impl KeyEncryption {
 
 fn hex_to_generic_array(hex_string: &str) -> Result<GenericArray<u8, U32>, FromHexError> {
     let byte_vec = hex::decode(hex_string)?;
-    let array = GenericArray::clone_from_slice(&byte_vec[..32]); 
+    let array = GenericArray::clone_from_slice(&byte_vec[..32]);
     Ok(array)
-}
+}

crates/sp_client/src/api.rs

@@ -11,6 +11,8 @@ use wasm_bindgen::convert::FromWasmAbi;
 use wasm_bindgen::prelude::*;
 
 use sp_backend::spclient::SpendKey;
+use sp_backend::spclient::{derive_keys_from_seed, OutputList, SpClient};
+
 type ApiResult<T: FromWasmAbi> = Result<T, ApiError>;
 
 const IS_TESTNET: bool = true;

crates/sp_client/src/injecteurhtml.rs

@@ -2,7 +2,8 @@ use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
 pub fn inject_html_create_id() -> String {
-    String::from("
+    String::from(
+        "
         <div class='card'>
             <div class='side-by-side'>
                 <h3>Create an Id</h3>
@@ -22,7 +23,8 @@ pub fn inject_html_create_id() -> String {
             </form><br/>
             <div id='passwordalert' class='passwordalert'></div>
         </div>
-    ")
+    ",
+    )
 }
 
 #[wasm_bindgen]
@@ -75,7 +77,8 @@ pub fn inject_html_revokeimage() -> String {
 
 #[wasm_bindgen]
 pub fn inject_html_revoke() -> String {
-    String::from("
+    String::from(
+        "
         <div class='card'>
             <div class='side-by-side'>
                 <h3>Revoke an Id</h3>
@@ -95,5 +98,6 @@ pub fn inject_html_revoke() -> String {
                 <button type='submit' id='submitButton' class='recover bg-primary'>Revoke</button>
             </form>
         </div>
-    ")
+    ",
+    )
 }

crates/sp_client/src/lib.rs

@@ -1,8 +1,7 @@
 #![allow(warnings)]
+mod aesgcm;
 pub mod api;
 mod injecteurhtml;
 mod process;
-mod user;
-mod aesgcm;
 mod secretdata;
-
+mod user;

crates/sp_client/src/process.rs

@@ -7,4 +7,4 @@ pub fn get_process() -> Vec<String> {
     data_process.push(String::from("process2"));
     data_process.push(String::from("process3"));
     data_process
-}
+}

crates/sp_client/src/secretdata.rs

@@ -263,4 +263,4 @@ static GF256_LOG: [u8; 256] = [
     0x53, 0x39, 0x84, 0x3c, 0x41, 0xa2, 0x6d, 0x47, 0x14, 0x2a, 0x9e, 0x5d, 0x56, 0xf2, 0xd3, 0xab,
     0x44, 0x11, 0x92, 0xd9, 0x23, 0x20, 0x2e, 0x89, 0xb4, 0x7c, 0xb8, 0x26, 0x77, 0x99, 0xe3, 0xa5,
     0x67, 0x4a, 0xed, 0xde, 0xc5, 0x31, 0xfe, 0x18, 0x0d, 0x63, 0x8c, 0x80, 0xc0, 0xf7, 0x70, 0x07,
-];
+];

crates/sp_client/src/user.rs

@@ -1,33 +1,31 @@
+use anyhow::Error;
 use bitcoin::secp256k1::SecretKey;
+use rand::{self, thread_rng, Rng, RngCore};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
-use rand::{self, Rng,thread_rng, RngCore};
+use tsify::Tsify;
-use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsValue;
 use web_sys::console;
-use anyhow::Error;
 
-use crate::aesgcm::{Aes256GcmIv96Bit,KeyEncryption};
+use crate::aesgcm::{Aes256GcmIv96Bit, KeyEncryption};
 use crate::secretdata::SecretData;
-use hex;
-use sha2::{Sha256, Digest};
 use bytes::Bytes;
+use hex;
+use sha2::{Digest, Sha256};
 use std::fs::File;
 
-use crate::api::{generate_sp_wallet_return,generate_sp_wallet};
+use crate::api::{generate_sp_wallet, generate_sp_wallet_return};
-use sp_backend::spclient::SpendKey;
-use sp_backend::spclient::{SpClient, OutputList};
 use sp_backend::silentpayments::sending::SilentPaymentAddress;
+use sp_backend::spclient::SpendKey;
+use sp_backend::spclient::{OutputList, SpClient};
 
 use img_parts::jpeg::Jpeg;
 use img_parts::{ImageEXIF, ImageICC};
 
 use scrypt::{
-    password_hash::{
+    password_hash::{rand_core::OsRng, PasswordHash, PasswordHasher, PasswordVerifier, SaltString},
-        rand_core::OsRng,
+    Scrypt,
-        PasswordHash, PasswordHasher, PasswordVerifier, SaltString
-    },
-    Scrypt
 };
 
 //extern crate shamir;
@@ -85,22 +83,38 @@ impl User {
         
          //part1 enc
         let pwd_hash_part1 = from_hex_to_b64(&sha_256(&format!("{}{}",password, &random_seed1)));
+
+        //split recover spend key
+        let (part1_key, part2_key) =
+            priv_recover_spend_key.split_at(priv_recover_spend_key.len() / 2);
+
+        //part1 enc
+        let pwd_hash_part1 = from_hex_to_b64(&sha_256(&format!("{}{}", password, &random_seed1)));
         let key_enc_part1 = KeyEncryption::new(None, Some(pwd_hash_part1.clone()), None);
         let part1_key_enc = key_enc_part1.enc_string(part1_key.to_string());
-         //part2 enc
+        //part2 enc
         let pwd_hash_part2 = from_hex_to_b64(&sha_256(&format!("{}{}", password, random_seed2)));
         let key_enc_part2 = KeyEncryption::new(None, Some(pwd_hash_part2.clone()), None);
         let part2_key_enc = key_enc_part2.enc_string(part2_key.to_string());
-         //image recover       
+        //image recover
-        let image_recover = ImageRecover::new(image_to_recover,  &random_seed1, &random_seed2,&part1_key_enc);
+        let image_recover = ImageRecover::new(
+            image_to_recover,
+            &random_seed1,
+            &random_seed2,
+            &part1_key_enc,
+        );
         //image revoke
         //let priv_revoke_spend_key = wallet.priv_revoke_spend_key.to_owned();
         //let priv_revoke_scan_key = wallet.priv_revoke_scan_key.to_owned();
-        let image_revoke = ImageRevoke::new(image_to_revoke,&priv_revoke_spend_key,&priv_revoke_scan_key);        
+        let image_revoke = ImageRevoke::new(
+            image_to_revoke,
+            &priv_revoke_spend_key,
+            &priv_revoke_scan_key,
+        );
         //create shardings
-         let sharding = Sharding::new(&part2_key_enc, 10u8);  //nMembers = 10 for testing, need to recover nmember elsewhere
+        let sharding = Sharding::new(&part2_key_enc, 10u8); //nMembers = 10 for testing, need to recover nmember elsewhere
-        //Pre ID
+                                                            //Pre ID
-        let pre_id = sha_256(&format!("{}{}",password, part2_key_enc));
+        let pre_id = sha_256(&format!("{}{}", password, part2_key_enc));
 
         //Create PRDList
         //@todo
@@ -109,144 +123,142 @@ impl User {
         //Receive List Items (PCD)
 
         console::log_1(&"authentication: ok".into());
-        User {image_recover,
+        User {
+            image_recover,
             image_revoke,
             sharding,
             pre_id,
-            recovered_spend_key:None
+            recovered_spend_key: None,
         }
     }
 
-    pub fn login(&self,password: &str, image_recover: &[u8]) -> Option<String>{
+    pub fn login(&self, password: &str, image_recover: &[u8]) -> Option<String> {
         let exif_image_bytes = read_exif(image_recover).unwrap_or_else(|error| {
             panic!("Unable to read the image exif: {}", error);
         });
-        
+
         let exif_image_string = String::from_utf8(exif_image_bytes.to_vec()).unwrap();
         let exif_image_json: Value = serde_json::from_str(&exif_image_string).unwrap();
         let random_seed1 = exif_image_json["random_seed1"].as_str().unwrap_or("N/A");
         let random_seed2 = exif_image_json["random_seed2"].as_str().unwrap_or("N/A");
         let part1_key_enc = exif_image_json["part1_key_enc"].as_str().unwrap_or("N/A");
-        let part1_recovered = Self::recover_part1(password,random_seed1,part1_key_enc);
+        let part1_recovered = Self::recover_part1(password, random_seed1, part1_key_enc);
-        let part1_trimmed =  part1_recovered.trim_matches('"');
+        let part1_trimmed = part1_recovered.trim_matches('"');
-       
+
         //@todo: get shardings from member managers!!
         let shardings = self.sharding.shares_vec.clone(); // temporary
 
-        let part2_recovered = Self::recover_part2(&password,&random_seed2, shardings);
+        let part2_recovered = Self::recover_part2(&password, &random_seed2, shardings);
-        let part2_trimmed =  part2_recovered.trim_matches('"');
+        let part2_trimmed = part2_recovered.trim_matches('"');
         let recover_key_hex: String = format!("{}{}", part1_trimmed, part2_trimmed);
-        
+
         Some(recover_key_hex)
     }
 
-    fn recover_part1(password: &str, random_seed1: &str, part1_key_enc: & str) -> String{
+    fn recover_part1(password: &str, random_seed1: &str, part1_key_enc: &str) -> String {
-        let pwd_hash_part1 = from_hex_to_b64(&sha_256(&format!("{}{}",password, random_seed1)));
+        let pwd_hash_part1 = from_hex_to_b64(&sha_256(&format!("{}{}", password, random_seed1)));
         let key_dec_part1 = KeyEncryption::new(None, Some(pwd_hash_part1), None);
-        let part1_key_recovered = key_dec_part1.decode(part1_key_enc.to_string()).unwrap_or_else(|_| "".to_string());
+        let part1_key_recovered = key_dec_part1
+            .decode(part1_key_enc.to_string())
+            .unwrap_or_else(|_| "".to_string());
         part1_key_recovered
     }
 
-    fn recover_part2(password: &str, random_seed2: &str, shares_vec: Vec<Vec<u8>>) -> String{
+    fn recover_part2(password: &str, random_seed2: &str, shares_vec: Vec<Vec<u8>>) -> String {
-        let quorum_sharding = (Sharding::QUORUM_SHARD * f32::from(shares_vec.len() as u8)).round() as u8;
+        let quorum_sharding =
+            (Sharding::QUORUM_SHARD * f32::from(shares_vec.len() as u8)).round() as u8;
         let part2_key_enc = SecretData::recover_secret(quorum_sharding, shares_vec).unwrap();
-        let pwd_hash_part2 = from_hex_to_b64(&sha_256(&format!("{}{}",password, random_seed2)));
+        let pwd_hash_part2 = from_hex_to_b64(&sha_256(&format!("{}{}", password, random_seed2)));
-        let key_dec_part2 = KeyEncryption::new(None, Some(pwd_hash_part2), None); 
+        let key_dec_part2 = KeyEncryption::new(None, Some(pwd_hash_part2), None);
-        let part2_key_recovered = key_dec_part2.decode(part2_key_enc).unwrap_or_else(|_| "".to_string()); 
+        let part2_key_recovered = key_dec_part2
+            .decode(part2_key_enc)
+            .unwrap_or_else(|_| "".to_string());
         part2_key_recovered
-    } 
+    }
-
 
     //not used
-    pub fn pbkdf2(password: &str, data: & str)->String {
+    pub fn pbkdf2(password: &str, data: &str) -> String {
         let data_salt = data.trim_end_matches('=');
         let salt = SaltString::from_b64(data_salt)
-            .map(|s| { s })
+            .map(|s| s)
-            .unwrap_or_else(|_| {
+            .unwrap_or_else(|_| panic!("Failed to parse salt value from base64 string"));
-               panic!("Failed to parse salt value from base64 string")
+
-             });
+        let mut password_hash = String::new();
-        
-        let mut password_hash = String::new(); 
         if let Ok(pwd) = Scrypt.hash_password(password.as_bytes(), &salt) {
-                password_hash.push_str(&pwd.to_string());
+            password_hash.push_str(&pwd.to_string());
         }
         sha_256(&password_hash)
-       
-
     }
-   
+
-    pub fn get_image_recover(&self)-> Vec<u8>{
+    pub fn get_image_recover(&self) -> Vec<u8> {
         return self.image_recover.image_recover_bytes.clone();
     }
-  
+
-    pub fn get_exif_image(&self,image:&[u8])-> Vec<u8>{
+    pub fn get_exif_image(&self, image: &[u8]) -> Vec<u8> {
-       return read_exif(image).expect("Error reading the exif");
+        return read_exif(image).expect("Error reading the exif");
     }
 
-    pub fn get_image_revoke(&self)-> Vec<u8>{
+    pub fn get_image_revoke(&self) -> Vec<u8> {
         return self.image_revoke.image_revoke_bytes.clone();
     }
 
     // Test sharing JS side
-    pub fn get_shares(&self)->Vec<String>{
+    pub fn get_shares(&self) -> Vec<String> {
         self.sharding.shares_format_str.clone()
-            
     }
-    
+
     //Test sharing Js side
-    pub fn get_secret(&self,shardings: Vec<String>)->String{
+    pub fn get_secret(&self, shardings: Vec<String>) -> String {
-        let mut shares_vec =  Vec::new();
+        let mut shares_vec = Vec::new();
-        
+
-        for s in shardings.iter(){
+        for s in shardings.iter() {
-             let bytes_vec: Vec<u8> = s
+            let bytes_vec: Vec<u8> = s
                 .trim_matches(|c| c == '[' || c == ']')
                 .split(',')
                 .filter_map(|s| s.trim().parse().ok())
                 .collect();
             shares_vec.push(bytes_vec);
-
         }
         self.sharding.recover_secrete(shares_vec.clone())
     }
-   
+}
- }
 
 #[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct ImageRecover {
-   image_recover_bytes: Vec<u8>,
+    image_recover_bytes: Vec<u8>,
 }
 
-impl ImageRecover{
+impl ImageRecover {
-    pub fn new(image_to_recover: &[u8],
+    pub fn new(
+        image_to_recover: &[u8],
         random_seed1: &str,
         random_seed2: &str,
-        part1_key_enc: &str, 
+        part1_key_enc: &str,
-    ) -> Self{
+    ) -> Self {
-            let data_exif_json = json!({
+        let data_exif_json = json!({
-                "random_seed1": random_seed1,
+            "random_seed1": random_seed1,
-                "random_seed2": random_seed2,
+            "random_seed2": random_seed2,
-                "part1_key_enc": part1_key_enc
+            "part1_key_enc": part1_key_enc
-            }); 
+        });
-            
-            let data = serde_json::to_string(&data_exif_json).unwrap();
-            let image_recover = write_exif(image_to_recover, &data);
-            ImageRecover{
-                image_recover_bytes: image_recover.expect("Image recover not generated!")
-            }
-     }
 
+        let data = serde_json::to_string(&data_exif_json).unwrap();
+        let image_recover = write_exif(image_to_recover, &data);
+        ImageRecover {
+            image_recover_bytes: image_recover.expect("Image recover not generated!"),
+        }
+    }
 }
 
 #[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct ImageRevoke {
-   image_revoke_bytes: Vec<u8>,
+    image_revoke_bytes: Vec<u8>,
 }
-impl ImageRevoke{
+impl ImageRevoke {
-    pub fn new(image_to_revoke: &[u8],
+    pub fn new(
+        image_to_revoke: &[u8],
         priv_revoke_spend_key: &str,
         priv_revoke_scan_key: &str,
-
+    ) -> Self {
-    )->Self{
         let data_exif_json = json!({
             "priv_revoke_spend_key":priv_revoke_spend_key,
             "priv_revoke_scan_key":priv_revoke_scan_key
@@ -254,73 +266,69 @@ impl ImageRevoke{
 
         let data = serde_json::to_string(&data_exif_json).unwrap();
         let image_revoke = write_exif(image_to_revoke, &data);
-        ImageRevoke{
+        ImageRevoke {
-            image_revoke_bytes: image_revoke.expect("Image revoke not generated!")
+            image_revoke_bytes: image_revoke.expect("Image revoke not generated!"),
         }
     }
-
 }
 
-
 #[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Sharding {
-   shares_vec: Vec<Vec<u8>>,
+    shares_vec: Vec<Vec<u8>>,
-   shares_format_str: Vec<String>,
+    shares_format_str: Vec<String>,
-   
 }
 
-impl Sharding{
+impl Sharding {
-    const QUORUM_SHARD: f32= 0.80_f32;
+    const QUORUM_SHARD: f32 = 0.80_f32;
-    pub fn new(
+    pub fn new(part2_key_enc: &str, number_members: u8) -> Self {
-        part2_key_enc: &str,
+        let secret_data = SecretData::with_secret(part2_key_enc, number_members);
-        number_members: u8, 
+        let mut shares_format_str: Vec<String> = Vec::new();
-        )->Self{
+        let shares_vec = (1..=number_members)
-            let secret_data = SecretData::with_secret(part2_key_enc, number_members); 
+            .map(|i| match secret_data.get_share(i) {
-            let mut shares_format_str: Vec<String> = Vec::new();
-            let shares_vec =  (1..=number_members).map(|i| match secret_data.get_share(i)
-            {
                 Ok(share) => {
-                    let string = format!("[{}]", share.clone().iter()
+                    let string = format!(
-                    .map(|b|  format!("{}", b))
+                        "[{}]",
-                    .collect::<Vec<_>>()
+                        share
-                    .join(","));
+                            .clone()
+                            .iter()
+                            .map(|b| format!("{}", b))
+                            .collect::<Vec<_>>()
+                            .join(",")
+                    );
                     shares_format_str.push(string.clone());
                     share
-                },
+                }
                 Err(_) => panic!("Not able to recover the shares!"),
-            }
+            })
-            ).collect::<Vec<_>>();
+            .collect::<Vec<_>>();
-                   
+
-            Sharding{
+        Sharding {
             shares_vec,
-            shares_format_str
+            shares_format_str,
-           
         }
     }
-    
+
-    pub fn recover_secrete(&self, shares:  Vec<Vec<u8>>) -> String {
+    pub fn recover_secrete(&self, shares: Vec<Vec<u8>>) -> String {
         let quorum_sharding = (Self::QUORUM_SHARD * f32::from(shares.len() as u8)).round() as u8;
-        SecretData::recover_secret(quorum_sharding, shares).unwrap() 
+        SecretData::recover_secret(quorum_sharding, shares).unwrap()
     }
 }
 
 //associated functions
-pub fn generate_random_key(length:usize) ->String {
+pub fn generate_random_key(length: usize) -> String {
     let mut rng = rand::thread_rng();
-    let random_bytes: Vec<u8> = (0..length)
+    let random_bytes: Vec<u8> = (0..length).map(|_| rng.gen_range(0x00..=0xFF)).collect();
-        .map(|_| rng.gen_range(0x00..=0xFF))
-        .collect();
     base64::encode(random_bytes)
 }
 
-pub fn sha_256(data: &str)-> String{
+pub fn sha_256(data: &str) -> String {
     let mut hasher = Sha256::new();
     hasher.update(data);
     let result = hasher.finalize();
     hex::encode(result)
 }
 
- pub fn write_exif(image_to_recover: &[u8], data: &str) -> Result<Vec<u8>, String>{
+pub fn write_exif(image_to_recover: &[u8], data: &str) -> Result<Vec<u8>, String> {
     let image_to_recover_bytes = Bytes::from(image_to_recover.to_vec());
     let mut jpeg = Jpeg::from_bytes(image_to_recover_bytes).unwrap();
     let data_bytes = Bytes::from(data.as_bytes().to_vec());
@@ -330,45 +338,47 @@ pub fn sha_256(data: &str)-> String{
     Ok(output_image.to_vec())
 }
 
-
+pub fn read_exif(image: &[u8]) -> Result<Vec<u8>, String> {
- pub fn read_exif(image: &[u8])->Result<Vec<u8>, String>{
     let image_bytes = Bytes::from(image.to_vec());
     let jpeg = Jpeg::from_bytes(image_bytes).unwrap();
 
-     //exif out
+    //exif out
-     let mut exif_image = Bytes::new();
+    let mut exif_image = Bytes::new();
-     if let Some(ref meta) = jpeg.exif(){
+    if let Some(ref meta) = jpeg.exif() {
-         exif_image = meta.clone();
+        exif_image = meta.clone();
-    }else {
+    } else {
-         return Err("No exif data".to_string());
+        return Err("No exif data".to_string());
-     }
+    }
-     let exif_bytes =exif_image.as_ref();
+    let exif_bytes = exif_image.as_ref();
-     Ok(exif_bytes.to_vec())
+    Ok(exif_bytes.to_vec())
 }
 
 //change for return Result?
-pub fn from_hex_to_b58(hex_string: &str)-> String{
+pub fn from_hex_to_b58(hex_string: &str) -> String {
     let decoded_data = hex::decode(hex_string).expect("Failed to decode hex string");
     let base58_string = bs58::encode(decoded_data).into_string();
-     base58_string
+    base58_string
 }
 //change for return Result?
-pub fn from_b58_to_hex(base58_string: &str)-> String{
+pub fn from_b58_to_hex(base58_string: &str) -> String {
     let decoded_data = bs58::decode(base58_string.to_owned()).into_vec().unwrap();
-    let hex_string = decoded_data.iter().map(|b| format!("{:02x}", b)).collect::<String>();
+    let hex_string = decoded_data
+        .iter()
+        .map(|b| format!("{:02x}", b))
+        .collect::<String>();
     hex_string
 }
 
-fn from_b64_to_hex(base64_string:&str)->String{
+fn from_b64_to_hex(base64_string: &str) -> String {
     let decoded_data = base64::decode(base64_string).unwrap();
-    let hex_string = decoded_data.iter().map(|b| format!("{:02x}", b)).collect::<String>();
+    let hex_string = decoded_data
+        .iter()
+        .map(|b| format!("{:02x}", b))
+        .collect::<String>();
     hex_string
 }
-fn from_hex_to_b64(hex_string:&str)->String{
+fn from_hex_to_b64(hex_string: &str) -> String {
     let decoded_data = hex::decode(hex_string).expect("Failed to decode hex string");
     let base64_string = base64::encode(decoded_data);
     base64_string
 }
-
-
-