WIP

Author: dkijania

catalyst-toolbox/src/bin/cli/advisor_reviews/mod.rs

@@ -83,7 +83,7 @@ impl Export {
         let reviews = read_vca_reviews_aggregated_file(&from)?;
         match format {
             OutputFormat::Csv => {
-                utils::csv::dump_data_to_csv(&reviews, &to)?;
+                utils::csv::dump_data_to_csv(reviews.iter(), &to)?;
             }
             OutputFormat::Json => {
                 serde_json::to_writer(open_file_write(&Some(to))?, &reviews)?;

catalyst-toolbox/src/bin/cli/kedqr/decode/img.rs

@@ -3,19 +3,19 @@ use catalyst_toolbox::kedqr::KeyQrCode;
 use catalyst_toolbox::kedqr::QrPin;
 use chain_crypto::AsymmetricKey;
 use chain_crypto::Ed25519Extended;
+use chain_crypto::SecretKey;
 use std::error::Error;
 use std::fs::File;
 use std::io::Write;
+use std::path::Path;
 use std::path::PathBuf;
 
-pub fn secret_from_qr(
+pub fn save_secret_from_qr(
     qr: PathBuf,
     output: Option<PathBuf>,
     pin: QrPin,
 ) -> Result<(), Box<dyn Error>> {
-    let img = image::open(qr)?;
-    let secret = KeyQrCode::decode(img, &pin.password)?;
-    let sk = secret.first().unwrap().clone();
+    let sk = secret_from_qr(&qr, pin)?;
     let hrp = Ed25519Extended::SECRET_BECH32_HRP;
     let secret_key = bech32::encode(hrp, sk.leak_secret().to_base32(), Variant::Bech32)?;
 
@@ -32,3 +32,12 @@ pub fn secret_from_qr(
     };
     Ok(())
 }
+
+pub fn secret_from_qr(
+    qr: impl AsRef<Path>,
+    pin: QrPin,
+) -> Result<SecretKey<Ed25519Extended>, catalyst_toolbox::kedqr::KeyQrCodeError> {
+    let img = image::open(qr)?;
+    let secret = KeyQrCode::decode(img, &pin.password)?;
+    Ok(secret.first().unwrap().clone())
+}

catalyst-toolbox/src/bin/cli/kedqr/decode/mod.rs

@@ -1,10 +1,10 @@
-mod hash;
 mod img;
+mod payload;
 
-use crate::cli::kedqr::encode::QrCodeOpts;
+use crate::cli::kedqr::QrCodeOpts;
 use catalyst_toolbox::kedqr::QrPin;
-pub use hash::decode_hash;
-pub use img::secret_from_qr;
+pub use img::{save_secret_from_qr, secret_from_qr};
+pub use payload::{decode_payload, secret_from_payload};
 use std::error::Error;
 use std::path::PathBuf;
 use structopt::StructOpt;
@@ -13,7 +13,7 @@ use structopt::StructOpt;
 #[derive(Debug, PartialEq, StructOpt)]
 #[structopt(rename_all = "kebab-case")]
 pub struct DecodeQrCodeCmd {
-    /// Path to file containing img or hash.
+    /// Path to file containing img or payload.
     #[structopt(short, long, parse(from_os_str))]
     input: PathBuf,
     /// Path to file to save secret output, if not provided console output will be attempted.
@@ -30,8 +30,8 @@ pub struct DecodeQrCodeCmd {
 impl DecodeQrCodeCmd {
     pub fn exec(self) -> Result<(), Box<dyn Error>> {
         match self.opts {
-            QrCodeOpts::Hash => decode_hash(self.input, self.output, self.pin),
-            QrCodeOpts::Img => secret_from_qr(self.input, self.output, self.pin),
+            QrCodeOpts::Payload => decode_payload(self.input, self.output, self.pin),
+            QrCodeOpts::Img => save_secret_from_qr(self.input, self.output, self.pin),
         }
     }
 }

catalyst-toolbox/src/bin/cli/kedqr/decode/payload.rs

@@ -0,0 +1,58 @@
+use bech32::{ToBase32, Variant};
+use catalyst_toolbox::kedqr::{decode, QrPin};
+use chain_crypto::{AsymmetricKey, Ed25519Extended, SecretKey};
+use std::{
+    error::Error,
+    fs::{File, OpenOptions},
+    io::{BufRead, BufReader, Write},
+    path::{Path, PathBuf},
+};
+
+pub fn decode_payload(
+    input: PathBuf,
+    output: Option<PathBuf>,
+    pin: QrPin,
+) -> Result<(), Box<dyn Error>> {
+    // generate qrcode with key and parsed pin
+    let secret = secret_from_payload(input, pin)?;
+    let hrp = Ed25519Extended::SECRET_BECH32_HRP;
+    let secret_key = bech32::encode(hrp, secret.leak_secret().to_base32(), Variant::Bech32)?;
+    // process output
+    match output {
+        Some(path) => {
+            // save qr code to file, or print to stdout if it fails
+            let mut file = File::create(path)?;
+            file.write_all(secret_key.as_bytes())?;
+        }
+        None => {
+            // prints qr code to stdout when no path is specified
+            println!("{}", secret_key);
+        }
+    }
+    Ok(())
+}
+
+pub fn secret_from_payload(
+    input: impl AsRef<Path>,
+    pin: QrPin,
+) -> Result<SecretKey<Ed25519Extended>, catalyst_toolbox::kedqr::KeyQrCodePayloadError> {
+    let input = OpenOptions::new()
+        .create(false)
+        .read(true)
+        .write(false)
+        .append(false)
+        .open(&input)
+        .expect("Could not open input file.");
+
+    let mut reader = BufReader::new(input);
+    let mut payload_str = String::new();
+    let _len = reader
+        .read_line(&mut payload_str)
+        .expect("Could not read input file.");
+    payload_str = payload_str.trim_end().to_string();
+
+    // use parsed pin from args
+    let pwd = pin.password;
+    // generate qrcode with key and parsed pin
+    decode(payload_str, &pwd)
+}

catalyst-toolbox/src/bin/cli/kedqr/encode/mod.rs

@@ -1,9 +1,10 @@
-mod hash;
 mod img;
+mod payload;
 
+use crate::cli::kedqr::QrCodeOpts;
 use catalyst_toolbox::kedqr::QrPin;
-pub use hash::generate_hash;
 pub use img::generate_qr;
+pub use payload::generate_payload;
 use std::error::Error;
 use std::path::PathBuf;
 use structopt::StructOpt;
@@ -29,15 +30,8 @@ pub struct EncodeQrCodeCmd {
 impl EncodeQrCodeCmd {
     pub fn exec(self) -> Result<(), Box<dyn Error>> {
         match self.opts {
-            QrCodeOpts::Hash => generate_hash(self.input, self.output, self.pin),
+            QrCodeOpts::Payload => generate_payload(self.input, self.output, self.pin),
             QrCodeOpts::Img => generate_qr(self.input, self.output, self.pin),
         }
     }
 }
-
-#[derive(Debug, PartialEq, StructOpt)]
-#[structopt(rename_all = "kebab-case")]
-pub enum QrCodeOpts {
-    Img,
-    Hash,
-}

catalyst-toolbox/src/bin/cli/kedqr/encode/payload.rs

@@ -0,0 +1,54 @@
+use catalyst_toolbox::kedqr::generate;
+use catalyst_toolbox::kedqr::QrPin;
+use chain_crypto::bech32::Bech32;
+use chain_crypto::{Ed25519Extended, SecretKey};
+use std::fs::File;
+use std::io::Write;
+use std::{
+    error::Error,
+    fs::OpenOptions,
+    io::{BufRead, BufReader},
+    path::PathBuf,
+};
+
+pub fn generate_payload(
+    input: PathBuf,
+    output: Option<PathBuf>,
+    pin: QrPin,
+) -> Result<(), Box<dyn Error>> {
+    // open input key and parse it
+    let key_file = OpenOptions::new()
+        .create(false)
+        .read(true)
+        .write(false)
+        .append(false)
+        .open(&input)
+        .expect("Could not open input file.");
+
+    let mut reader = BufReader::new(key_file);
+    let mut key_str = String::new();
+    let _key_len = reader
+        .read_line(&mut key_str)
+        .expect("Could not read input file.");
+    let sk = key_str.trim_end().to_string();
+
+    let secret_key: SecretKey<Ed25519Extended> =
+        SecretKey::try_from_bech32_str(&sk).expect("Malformed secret key.");
+    // use parsed pin from args
+    let pwd = pin.password;
+    // generate qrcode with key and parsed pin
+    let qr = generate(secret_key, &pwd);
+    // process output
+    match output {
+        Some(path) => {
+            // save qr code to file, or print to stdout if it fails
+            let mut file = File::create(path)?;
+            file.write_all(qr.as_bytes())?;
+        }
+        None => {
+            // prints qr code to stdout when no path is specified
+            println!("{}", qr);
+        }
+    }
+    Ok(())
+}

catalyst-toolbox/src/bin/cli/kedqr/info.rs

@@ -0,0 +1,106 @@
+use super::QrCodeOpts;
+use crate::cli::kedqr::decode::{secret_from_payload, secret_from_qr};
+use catalyst_toolbox::kedqr::QrPin;
+use chain_addr::{AddressReadable, Discrimination, Kind};
+use chain_core::{
+    mempack::{ReadBuf, Readable},
+    property::Deserialize,
+};
+use chain_crypto::{Ed25519Extended, SecretKey};
+use chain_impl_mockchain::block::Block;
+use jormungandr_lib::interfaces::{Block0Configuration, Initial};
+use std::io::BufReader;
+use std::path::{Path, PathBuf};
+use structopt::StructOpt;
+use url::Url;
+#[derive(StructOpt, Debug)]
+pub struct InfoForQrCodeCmd {
+    /// Path to file containing img or payload.
+    #[structopt(short, long, parse(from_os_str))]
+    input: PathBuf,
+
+    /// Pin code. 4-digit number is used on Catalyst.
+    #[structopt(short, long, parse(try_from_str))]
+    pin: QrPin,
+
+    /// Blockchain block0. Can be either url of local file path
+    #[structopt(long = "block0")]
+    pub block0: Option<String>,
+
+    /// Set the discrimination type to testing (default is production).
+    #[structopt(short, long)]
+    pub testing: bool,
+
+    #[structopt(flatten)]
+    opts: QrCodeOpts,
+}
+
+impl InfoForQrCodeCmd {
+    pub fn exec(self) -> Result<(), Box<dyn std::error::Error>> {
+        let secret_key: SecretKey<Ed25519Extended> = {
+            match self.opts {
+                QrCodeOpts::Payload => secret_from_payload(&self.input, self.pin)?,
+                QrCodeOpts::Img => secret_from_qr(&self.input, self.pin)?,
+            }
+        };
+        let kind = Kind::Account(secret_key.to_public());
+        let address = chain_addr::Address(test_discrimination(self.testing), kind);
+
+        if let Some(block0_path) = &self.block0 {
+            let block = {
+                if Path::new(block0_path).exists() {
+                    let reader = std::fs::OpenOptions::new()
+                        .create(false)
+                        .write(false)
+                        .read(true)
+                        .append(false)
+                        .open(block0_path)?;
+                    let reader = BufReader::new(reader);
+                    Block::deserialize(reader)?
+                } else if Url::parse(block0_path).is_ok() {
+                    let response = reqwest::blocking::get(block0_path)?;
+                    let block0_bytes = response.bytes()?.to_vec();
+                    Block::read(&mut ReadBuf::from(&block0_bytes))?
+                } else {
+                    panic!("invalid block0: should be either path to filesystem or url ");
+                }
+            };
+            let genesis = Block0Configuration::from_block(&block)?;
+
+            for initial in genesis.initial.iter() {
+                if let Initial::Fund(initial_utxos) = initial {
+                    if let Some(entry) = initial_utxos
+                        .iter()
+                        .find(|x| x.address == address.clone().into())
+                    {
+                        println!(
+                            "Address corresponding to input qr found in block0: '{}' with value: '{}'", 
+                            AddressReadable::from_address(&test_prefix(self.testing),&address), entry.value);
+                        return Ok(());
+                    }
+                }
+            }
+            eprintln!("Address corresponding to input qr not found in block0");
+        } else {
+            println!(
+                "Address: {}",
+                AddressReadable::from_address(&test_prefix(self.testing), &address)
+            );
+        }
+        Ok(())
+    }
+}
+
+pub fn test_discrimination(testing: bool) -> Discrimination {
+    match testing {
+        false => Discrimination::Production,
+        true => Discrimination::Test,
+    }
+}
+
+pub fn test_prefix(testing: bool) -> String {
+    match test_discrimination(testing) {
+        Discrimination::Production => "ca".to_string(),
+        Discrimination::Test => "ta".to_string(),
+    }
+}

catalyst-toolbox/src/bin/cli/kedqr/mod.rs

@@ -1,23 +1,39 @@
 mod decode;
 mod encode;
+mod info;
+mod verify;
 
 use std::error::Error;
 use structopt::StructOpt;
+
 #[derive(StructOpt)]
 #[structopt(rename_all = "kebab-case")]
 pub enum QrCodeCmd {
     /// Encode qr code
     Encode(encode::EncodeQrCodeCmd),
     /// Decode qr code
     Decode(decode::DecodeQrCodeCmd),
+    /// Prints information for qr code
+    Info(info::InfoForQrCodeCmd),
+    /// Validates qr code
+    Verify(verify::VerifyQrCodeCmd),
 }
 
 impl QrCodeCmd {
     pub fn exec(self) -> Result<(), Box<dyn Error>> {
         match self {
             Self::Encode(encode) => encode.exec()?,
             Self::Decode(decode) => decode.exec()?,
+            Self::Info(info) => info.exec()?,
+            Self::Verify(verify) => verify.exec()?,
         };
         Ok(())
     }
 }
+
+#[derive(Debug, PartialEq, StructOpt)]
+#[structopt(rename_all = "kebab-case")]
+pub enum QrCodeOpts {
+    Img,
+    Payload,
+}