leave error enums outside cli untouched

Author: cameron1024

catalyst-toolbox/src/archive.rs

@@ -3,7 +3,6 @@ use chain_core::{packer::Codec, property::DeserializeFromSlice};
 use chain_impl_mockchain::{
     block::Block, chaintypes::HeaderId, fragment::Fragment, transaction::InputEnum,
 };
-use color_eyre::{eyre::bail, Report};
 use jormungandr_lib::interfaces::{AccountIdentifier, Address};
 
 use serde::Serialize;
@@ -12,6 +11,21 @@ use std::{collections::HashMap, path::Path};
 
 const MAIN_TAG: &str = "HEAD";
 
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error(transparent)]
+    Storage(#[from] chain_storage::Error),
+
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+
+    #[error(transparent)]
+    Csv(#[from] csv::Error),
+
+    #[error("Only accounts inputs are supported not Utxos")]
+    UnhandledInput,
+}
+
 #[derive(Serialize)]
 struct Vote {
     fragment_id: String,
@@ -22,10 +36,7 @@ struct Vote {
     raw_fragment: String,
 }
 
-pub fn generate_archive_files(
-    jormungandr_database: &Path,
-    output_dir: &Path,
-) -> Result<(), Report> {
+pub fn generate_archive_files(jormungandr_database: &Path, output_dir: &Path) -> Result<(), Error> {
     let db = chain_storage::BlockStore::file(
         jormungandr_database,
         HeaderId::zero_hash()
@@ -56,7 +67,7 @@ pub fn generate_archive_files(
                     AccountIdentifier::from(account_id)
                         .into_address(Discrimination::Production, "ca")
                 } else {
-                    bail!("unhandled input")
+                    return Err(Error::UnhandledInput);
                 };
                 let certificate = tx.as_slice().payload().into_payload();
 

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

@@ -16,6 +16,7 @@ pub struct Archive {
 
 impl Archive {
     pub fn exec(self) -> Result<(), Report> {
-        generate_archive_files(&self.jormungandr_database, &self.output_dir)
+        generate_archive_files(&self.jormungandr_database, &self.output_dir)?;
+        Ok(())
     }
 }

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

@@ -54,5 +54,5 @@ pub fn secret_from_payload(
     // use parsed pin from args
     let pwd = pin.password;
     // generate qrcode with key and parsed pin
-    decode(payload_str, &pwd)
+    Ok(decode(payload_str, &pwd)?)
 }

catalyst-toolbox/src/bin/cli/stats/archive.rs

@@ -87,6 +87,6 @@ pub struct BatchSizeByCaster {
 
 impl BatchSizeByCaster {
     pub fn exec(&self, archiver: ArchiveStats) -> Result<BTreeMap<String, usize>, Report> {
-        archiver.max_batch_size_per_caster(self.slots_in_epoch)
+        Ok(archiver.max_batch_size_per_caster(self.slots_in_epoch)?)
     }
 }

catalyst-toolbox/src/ideascale/fetch.rs

@@ -1,13 +1,21 @@
 use crate::ideascale::models::de::{Fund, Funnel, Proposal, Stage};
 
-use color_eyre::Report;
 use once_cell::sync::Lazy;
 use serde::de::DeserializeOwned;
 use url::Url;
 
 use std::collections::HashMap;
 use std::convert::TryInto;
 
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    RequestError(#[from] reqwest::Error),
+
+    #[error("Could not get value from json, missing attribute {attribute_name}")]
+    MissingAttribute { attribute_name: &'static str },
+}
+
 pub type Scores = HashMap<u32, f32>;
 pub type Sponsors = HashMap<String, String>;
 
@@ -19,30 +27,31 @@ static BASE_IDEASCALE_URL: Lazy<url::Url> = Lazy::new(|| {
 
 static CLIENT: Lazy<reqwest::Client> = Lazy::new(reqwest::Client::new);
 
-async fn request_data<T: DeserializeOwned>(api_token: String, url: Url) -> Result<T, Report> {
-    Ok(CLIENT
+async fn request_data<T: DeserializeOwned>(api_token: String, url: Url) -> Result<T, Error> {
+    CLIENT
         .get(url)
         .header("api_token", api_token)
         .send()
         .await?
         .json()
-        .await?)
+        .await
+        .map_err(Error::RequestError)
 }
 
-pub async fn get_funds_data(api_token: String) -> Result<Vec<Fund>, Report> {
+pub async fn get_funds_data(api_token: String) -> Result<Vec<Fund>, Error> {
     request_data(
         api_token,
         BASE_IDEASCALE_URL.join("campaigns/groups").unwrap(),
     )
     .await
 }
 
-pub async fn get_stages(api_token: String) -> Result<Vec<Stage>, Report> {
+pub async fn get_stages(api_token: String) -> Result<Vec<Stage>, Error> {
     request_data(api_token, BASE_IDEASCALE_URL.join("stages").unwrap()).await
 }
 
 /// we test token by running lightweight query and observe response code
-pub async fn is_token_valid(api_token: String) -> Result<bool, Report> {
+pub async fn is_token_valid(api_token: String) -> Result<bool, Error> {
     let url = BASE_IDEASCALE_URL.join("profile/avatars").unwrap();
 
     let response = CLIENT
@@ -57,7 +66,7 @@ pub async fn is_token_valid(api_token: String) -> Result<bool, Report> {
 pub async fn get_proposals_data(
     challenge_id: u32,
     api_token: String,
-) -> Result<Vec<Proposal>, Report> {
+) -> Result<Vec<Proposal>, Error> {
     request_data(
         api_token,
         BASE_IDEASCALE_URL
@@ -70,7 +79,7 @@ pub async fn get_proposals_data(
     .await
 }
 
-pub async fn get_funnels_data_for_fund(api_token: String) -> Result<Vec<Funnel>, Report> {
+pub async fn get_funnels_data_for_fund(api_token: String) -> Result<Vec<Funnel>, Error> {
     let challenges: Vec<Funnel> =
         request_data(api_token, BASE_IDEASCALE_URL.join("funnels").unwrap()).await?;
     Ok(challenges)

catalyst-toolbox/src/ideascale/mod.rs

@@ -5,8 +5,6 @@ use crate::ideascale::models::de::{clean_str, Challenge, Fund, Funnel, Proposal,
 
 use std::collections::{HashMap, HashSet};
 
-use color_eyre::eyre::bail;
-use color_eyre::Report;
 use regex::Regex;
 
 pub use crate::ideascale::fetch::{Scores, Sponsors};
@@ -16,6 +14,24 @@ pub use crate::ideascale::models::custom_fields::CustomFieldTags;
 // should not change
 const PROCESS_IMPROVEMENTS_ID: u32 = 7666;
 
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    Fetch(#[from] fetch::Error),
+
+    #[error(transparent)]
+    Join(#[from] tokio::task::JoinError),
+
+    #[error(transparent)]
+    Serde(#[from] serde_json::Error),
+
+    #[error(transparent)]
+    Regex(#[from] regex::Error),
+
+    #[error("invalid token")]
+    InvalidToken,
+}
+
 #[derive(Debug)]
 pub struct IdeaScaleData {
     pub funnels: HashMap<u32, Funnel>,
@@ -30,10 +46,11 @@ pub async fn fetch_all(
     stages_filters: &[&str],
     excluded_proposals: &HashSet<u32>,
     api_token: String,
-) -> Result<IdeaScaleData, Report> {
+) -> Result<IdeaScaleData, Error> {
     if !fetch::is_token_valid(api_token.clone()).await? {
-        bail!("invalid token");
+        return Err(Error::InvalidToken);
     }
+
     let funnels_task = tokio::spawn(fetch::get_funnels_data_for_fund(api_token.clone()));
     let funds_task = tokio::spawn(fetch::get_funds_data(api_token.clone()));
     let funnels = funnels_task

catalyst-toolbox/src/kedqr/img.rs

@@ -1,20 +1,49 @@
 use super::payload;
-use chain_crypto::{Ed25519Extended, SecretKey};
-use color_eyre::Report;
-use image::{DynamicImage, ImageBuffer, Luma};
+use chain_crypto::{Ed25519Extended, SecretKey, SecretKeyError};
+use image::{DynamicImage, ImageBuffer, ImageError, Luma};
 use qrcode::{
     render::{svg, unicode},
     EcLevel, QrCode,
 };
 use std::fmt;
 use std::fs::File;
-use std::io::prelude::*;
+use std::io::{self, prelude::*};
 use std::path::Path;
+use symmetric_cipher::Error as SymmetricCipherError;
+use thiserror::Error;
 
 pub struct KeyQrCode {
     inner: QrCode,
 }
 
+#[derive(Error, Debug)]
+pub enum KeyQrCodeError {
+    #[error("encryption-decryption protocol error")]
+    SymmetricCipher(#[from] SymmetricCipherError),
+    #[error("io error")]
+    Io(#[from] io::Error),
+    #[error("invalid secret key")]
+    SecretKey(#[from] SecretKeyError),
+    #[error("couldn't decode QR code")]
+    QrDecodeError(#[from] QrDecodeError),
+    #[error("failed to decode hex")]
+    HexDecodeError(#[from] hex::FromHexError),
+    #[error("failed to decode hex")]
+    QrCodeHashError(#[from] super::payload::Error),
+    #[error(transparent)]
+    Image(#[from] ImageError),
+}
+
+#[derive(Error, Debug)]
+pub enum QrDecodeError {
+    #[error("couldn't decode QR code")]
+    DecodeError(#[from] quircs::DecodeError),
+    #[error("couldn't extract QR code")]
+    ExtractError(#[from] quircs::ExtractError),
+    #[error("QR code payload is not valid uf8")]
+    NonUtf8Payload,
+}
+
 impl KeyQrCode {
     pub fn generate(key: SecretKey<Ed25519Extended>, password: &[u8]) -> Self {
         let enc_hex = payload::generate(key, password);
@@ -23,7 +52,7 @@ impl KeyQrCode {
         KeyQrCode { inner }
     }
 
-    pub fn write_svg(&self, path: impl AsRef<Path>) -> Result<(), Report> {
+    pub fn write_svg(&self, path: impl AsRef<Path>) -> Result<(), KeyQrCodeError> {
         let mut out = File::create(path)?;
         let svg_file = self
             .inner
@@ -46,20 +75,23 @@ impl KeyQrCode {
     pub fn decode(
         img: DynamicImage,
         password: &[u8],
-    ) -> Result<Vec<SecretKey<Ed25519Extended>>, Report> {
+    ) -> Result<Vec<SecretKey<Ed25519Extended>>, KeyQrCodeError> {
         let mut decoder = quircs::Quirc::default();
 
         let img = img.into_luma8();
 
         let codes = decoder.identify(img.width() as usize, img.height() as usize, &img);
 
         codes
-            .map(|code| -> Result<_, Report> {
-                let decoded = code?.decode()?;
+            .map(|code| -> Result<_, KeyQrCodeError> {
+                let decoded = code
+                    .map_err(QrDecodeError::ExtractError)
+                    .and_then(|c| c.decode().map_err(QrDecodeError::DecodeError))?;
 
                 // TODO: I actually don't know if this can fail
-                let h = std::str::from_utf8(&decoded.payload)?;
-                payload::decode(h, password)
+                let h = std::str::from_utf8(&decoded.payload)
+                    .map_err(|_| QrDecodeError::NonUtf8Payload)?;
+                payload::decode(h, password).map_err(Into::into)
             })
             .collect()
     }

catalyst-toolbox/src/kedqr/mod.rs

@@ -1,12 +1,11 @@
 mod img;
 mod payload;
 
-use color_eyre::eyre::{bail, eyre};
-use color_eyre::Report;
-pub use img::KeyQrCode;
-pub use payload::{decode, generate};
+pub use img::{KeyQrCode, KeyQrCodeError};
+pub use payload::{decode, generate, Error as KeyQrCodePayloadError};
 use std::path::PathBuf;
 use std::str::FromStr;
+use thiserror::Error;
 
 pub const PIN_LENGTH: usize = 4;
 
@@ -15,18 +14,37 @@ pub struct QrPin {
     pub password: [u8; 4],
 }
 
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    BadPin(#[from] BadPinError),
+    #[error(transparent)]
+    KeyQrCodeHash(#[from] KeyQrCodePayloadError),
+    #[error(transparent)]
+    KeyQrCode(#[from] KeyQrCodeError),
+}
+
+#[derive(Error, Debug)]
+pub enum BadPinError {
+    #[error("The PIN must consist of {PIN_LENGTH} digits, found {0}")]
+    InvalidLength(usize),
+    #[error("Invalid digit {0}")]
+    InvalidDigit(char),
+    #[error("cannot detect file name from path {0:?} in order to read qr pin from it")]
+    UnableToDetectFileName(PathBuf),
+}
+
 impl FromStr for QrPin {
-    type Err = Report;
+    type Err = BadPinError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         if s.chars().count() != PIN_LENGTH {
-            let len = s.len();
-            bail!("invalid length: {len}");
+            return Err(BadPinError::InvalidLength(s.len()));
         }
 
         let mut pwd = [0u8; 4];
         for (i, digit) in s.chars().enumerate() {
-            pwd[i] = digit.to_digit(10).ok_or(eyre!("invalid digit"))? as u8;
+            pwd[i] = digit.to_digit(10).ok_or(BadPinError::InvalidDigit(digit))? as u8;
         }
         Ok(QrPin { password: pwd })
     }
@@ -40,13 +58,13 @@ pub enum PinReadMode {
 
 /// supported format is *1234.png
 impl PinReadMode {
-    pub fn into_qr_pin(&self) -> Result<QrPin, Report> {
+    pub fn into_qr_pin(&self) -> Result<QrPin, BadPinError> {
         match self {
             PinReadMode::Global(ref global) => QrPin::from_str(global),
             PinReadMode::FromFileName(qr) => {
                 let file_name = qr
                     .file_stem()
-                    .ok_or_else(|| eyre!("unable to detext filename: {}", qr.to_string_lossy()))?;
+                    .ok_or_else(|| BadPinError::UnableToDetectFileName(qr.to_path_buf()))?;
                 QrPin::from_str(
                     &file_name
                         .to_str()

catalyst-toolbox/src/kedqr/payload.rs

@@ -1,6 +1,19 @@
-use chain_crypto::{Ed25519Extended, SecretKey};
-use color_eyre::Report;
-use symmetric_cipher::{decrypt, encrypt};
+use chain_crypto::{Ed25519Extended, SecretKey, SecretKeyError};
+use std::io;
+use symmetric_cipher::{decrypt, encrypt, Error as SymmetricCipherError};
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("encryption-decryption protocol error")]
+    SymmetricCipher(#[from] SymmetricCipherError),
+    #[error("io error")]
+    Io(#[from] io::Error),
+    #[error("invalid secret key")]
+    SecretKey(#[from] SecretKeyError),
+    #[error("failed to decode hex")]
+    HexDecode(#[from] hex::FromHexError),
+}
 
 pub fn generate(key: SecretKey<Ed25519Extended>, password: &[u8]) -> String {
     let secret = key.leak_secret();
@@ -16,7 +29,7 @@ pub fn generate(key: SecretKey<Ed25519Extended>, password: &[u8]) -> String {
 pub fn decode<S: Into<String>>(
     payload: S,
     password: &[u8],
-) -> Result<SecretKey<Ed25519Extended>, Report> {
+) -> Result<SecretKey<Ed25519Extended>, Error> {
     let encrypted_bytes = hex::decode(payload.into())?;
     let key = decrypt(password, &encrypted_bytes)?;
     Ok(SecretKey::from_binary(&key)?)