Merge pull request #44 from DenioD/sietch

add Sietch call for SDL

lib/src/commands.rs

@@ -721,6 +721,36 @@ impl Command for NewAddressCommand {
     }
 }
 
+struct NewSietchAddressCommand {}
+impl Command for NewSietchAddressCommand {
+    fn help(&self)  -> String {
+        let mut h = vec![];
+        h.push("New Sietch Address");
+        h.push("Usage:");
+        h.push("sietch [zs]");
+        h.push("");
+        h.push("Example:");
+        h.push("To create a new zdust:");
+        h.push("sietch zs");
+        h.join("\n")
+    }
+
+    fn short_help(&self) -> String {
+        "Create a sietch Address".to_string()
+    }
+
+    fn exec(&self, args: &[&str], lightclient: &LightClient) -> String {
+        if args.len() != 1 {
+            return format!("No address type specified\n{}", self.help());
+        }
+
+        match lightclient.do_new_sietchaddress(args[0]) {
+            Ok(j)  => j,
+            Err(e) => object!{ "error" => e }
+        }.pretty(2)
+    }
+}
+
 struct NotesCommand {}
 impl Command for NotesCommand {
     fn help(&self)  -> String {
@@ -831,6 +861,7 @@ pub fn get_commands() -> Box<HashMap<String, Box<dyn Command>>> {
     map.insert("list".to_string(),              Box::new(TransactionsCommand{}));
     map.insert("notes".to_string(),             Box::new(NotesCommand{}));
     map.insert("new".to_string(),               Box::new(NewAddressCommand{}));
+    map.insert("sietch".to_string(),            Box::new(NewSietchAddressCommand{}));
     map.insert("seed".to_string(),              Box::new(SeedCommand{}));
     map.insert("encrypt".to_string(),           Box::new(EncryptCommand{}));
     map.insert("decrypt".to_string(),           Box::new(DecryptCommand{}));

lib/src/lightclient.rs

@@ -37,7 +37,7 @@ use crate::ANCHOR_OFFSET;
 
 mod checkpoints;
 
-pub const DEFAULT_SERVER: &str = "https://hush-lightwallet.de:443";
+pub const DEFAULT_SERVER: &str = "https://lite.myhush.org";
 pub const WALLET_NAME: &str    = "silentdragonlite-wallet.dat";
 pub const LOGFILE_NAME: &str   = "silentdragonlite-wallet.debug.log";
 
@@ -867,6 +867,31 @@ impl LightClient {
         Ok(array![new_address])
     }
 
+    pub fn do_new_sietchaddress(&self, addr_type: &str) -> Result<JsonValue, String> {
+        if !self.wallet.read().unwrap().is_unlocked_for_spending() {
+            error!("Wallet is locked");
+            return Err("Wallet is locked".to_string());
+        }
+
+        let new_address = {
+            let wallet = self.wallet.write().unwrap();
+
+            match addr_type {
+                "zs" => wallet.add_zaddrdust(),
+                
+                _   => {
+                    let e = format!("Unrecognized address type: {}", addr_type);
+                    error!("{}", e);
+                    return Err(e);
+                }
+            }
+        };
+
+        self.do_save()?;
+
+        Ok(array!["sietch",new_address])
+    }
+
     pub fn clear_state(&self) {
         // First, clear the state from the wallet
         self.wallet.read().unwrap().clear_blocks();

lib/src/lightwallet.rs

@@ -4,9 +4,7 @@ use std::cmp;
 use std::collections::{HashMap, HashSet};
 use std::sync::{Arc, RwLock};
 use std::io::{Error, ErrorKind};
-
 use rand::{Rng, rngs::OsRng};
-
 use log::{info, warn, error};
 
 use protobuf::parse_from_bytes;
@@ -199,7 +197,7 @@ impl LightWallet {
             
             seed_bytes.copy_from_slice(&phrase.entropy());
         }
-
+      
         // The seed bytes is the raw entropy. To pass it to HD wallet generation, 
         // we need to get the 64 byte bip39 entropy
         let bip39_seed = bip39::Seed::new(&Mnemonic::from_entropy(&seed_bytes, Language::English).unwrap(), "");
@@ -458,6 +456,38 @@ impl LightWallet {
         self.extfvks.write().unwrap().push(extfvk);
         self.zaddress.write().unwrap().push(address);
 
+        zaddr
+    }
+    pub fn add_zaddrdust(&self) -> String {
+        if !self.unlocked {
+            return "".to_string();
+        }
+
+        let pos = self.extsks.read().unwrap().len() as u32;
+    
+        // Radnom Generator benutzen!!!!!!
+       
+            let mut rng = rand::thread_rng();
+            let letter: String = rng.gen_range(b'A', b'Z').to_string();
+            let number: String = rng.gen_range(0, 999999).to_string();
+           // let combi: String = letter.to_string() + number.to_string();
+            let s = format!("{}{:06}", letter, number);
+            //println!("{}", s);
+        
+        let my_string = String::from(s);
+       // let my_immutable_string = &my_string; //This is a &String type
+    let dust: &str = &my_string; //This is an &str type
+
+   
+
+        let bip39_seed = bip39::Seed::new(&Mnemonic::from_entropy(&self.seed, Language::English).unwrap(), dust);
+
+        let (_extsk, _extfvk, address) =
+            LightWallet::get_zaddr_from_bip39seed(&self.config, &bip39_seed.as_bytes(), pos);
+
+        let zaddr = encode_payment_address(self.config.hrp_sapling_address(), &address);
+       
+
         zaddr
     }