Fixed clippy issues

utxo/src/amount.rs

@@ -96,46 +96,6 @@ impl Amount {
         Self { asset, cents }
     }
 
-    /// Creates a new amount from a human amount (a floating number serialized
-    /// as string to avoid loss precision)
-    pub fn from_human(asset: Asset, human_amount: &str) -> Result<Self, Error> {
-        let mut dot_at = None;
-        for (pos, i) in human_amount.chars().enumerate() {
-            match i {
-                '-' => {
-                    if pos != 0 {
-                        return Err(Error::NoANumber(human_amount.to_owned()));
-                    }
-                }
-                '.' => {
-                    if dot_at.is_some() {
-                        return Err(Error::NoANumber(human_amount.to_owned()));
-                    }
-                    dot_at = Some(pos);
-                }
-                '0'..='9' => {}
-                _ => {
-                    return Err(Error::NoANumber(human_amount.to_owned()));
-                }
-            }
-        }
-
-        let (whole, fractional_part) = if let Some(dot_at) = dot_at {
-            let (whole, fractional_part) = human_amount.split_at(dot_at);
-            (whole, fractional_part[1..].to_owned())
-        } else {
-            (human_amount, "".to_owned())
-        };
-
-        let fractional_part = fractional_part + &"0".repeat(asset.precision.into());
-
-        let cents = (whole.to_owned() + &fractional_part[..asset.precision.into()])
-            .parse::<AmountCents>()
-            .map_err(|_| Error::NoANumber(format!("{}.{}", whole, fractional_part)))?;
-
-        Ok(Self { asset, cents })
-    }
-
     #[inline]
     /// Returns the asset for this amount
     pub fn asset(&self) -> &Asset {
@@ -239,20 +199,19 @@ mod test {
     #[test]
     fn from_human() {
         let btc: Asset = "BTC/8".parse().expect("asset");
-        let parsed_amount = Amount::from_human(btc.clone(), "0.1").expect("valid amount");
+        let parsed_amount = btc.from_human("0.1").expect("valid amount");
         assert_eq!(parsed_amount.to_string(), "0.1");
-        let parsed_amount = Amount::from_human(btc.clone(), "-0.1").expect("valid amount");
+        let parsed_amount = btc.from_human("-0.1").expect("valid amount");
         assert_eq!(parsed_amount.to_string(), "-0.1");
-        let parsed_amount = Amount::from_human(btc.clone(), "-0.000001").expect("valid amount");
+        let parsed_amount = btc.from_human("-0.000001").expect("valid amount");
         assert_eq!(parsed_amount.to_string(), "-0.000001");
-        let parsed_amount = Amount::from_human(btc.clone(), "-0.000000001").expect("valid amount");
+        let parsed_amount = btc.from_human("-0.000000001").expect("valid amount");
         assert_eq!(parsed_amount.to_string(), "0");
-        let parsed_amount = Amount::from_human(btc.clone(), "0.000001").expect("valid amount");
+        let parsed_amount = btc.from_human("0.000001").expect("valid amount");
         assert_eq!(parsed_amount.to_string(), "0.000001");
-        let parsed_amount =
-            Amount::from_human(btc.clone(), "-0.000000100001").expect("valid amount");
+        let parsed_amount = btc.from_human("-0.000000100001").expect("valid amount");
         assert_eq!(parsed_amount.to_string(), "-0.0000001");
-        let parsed_amount = Amount::from_human(btc, "100000").expect("valid amount");
+        let parsed_amount = btc.from_human("100000").expect("valid amount");
         assert_eq!(parsed_amount.to_string(), "100000");
     }
 }

utxo/src/asset.rs

@@ -82,7 +82,7 @@ impl Asset {
             (human_amount, "".to_owned())
         };
 
-        let fractional_part = fractional_part + &"0".repeat(self.precision.into());
+        let fractional_part = format!("{}{}", fractional_part, "0".repeat(self.precision.into()));
 
         let cents = (whole.to_owned() + &fractional_part[..self.precision.into()])
             .parse::<AmountCents>()

utxo/src/error.rs

@@ -12,6 +12,10 @@ pub enum Error {
     #[error("Conversion overflow: {0}")]
     Overflow(String),
 
+    /// An internal conversion error
+    #[error("Conversion overflow: {0}")]
+    Underflow(String),
+
     /// A storage error
     #[error("Storage: {0}")]
     Storage(#[from] storage::Error),

utxo/src/ledger.rs

@@ -1,6 +1,6 @@
 use crate::{
-    config::Config, storage::Storage, transaction::Type, AccountId, Amount, Error, PaymentFrom,
-    PaymentId, Status, Transaction, TransactionId,
+    amount::AmountCents, config::Config, storage::Storage, transaction::Type, AccountId, Amount,
+    Error, PaymentFrom, PaymentId, Status, Transaction, TransactionId,
 };
 use std::{cmp::Ordering, collections::HashMap, sync::Arc};
 
@@ -44,12 +44,14 @@ where
         &self,
         payments: Vec<(AccountId, Amount)>,
     ) -> Result<(Option<Transaction>, Vec<PaymentFrom>), Error> {
-        let mut to_spend = HashMap::new();
+        let mut to_spend = HashMap::<_, AmountCents>::new();
 
         for (account_id, amount) in payments.into_iter() {
             let id = (account_id, amount.asset().clone());
             if let Some(value) = to_spend.get_mut(&id) {
-                *value += amount.cents();
+                *value = value
+                    .checked_add(amount.cents())
+                    .ok_or(Error::Overflow("cents".to_owned()))?;
             } else {
                 to_spend.insert(id, amount.cents());
             }
@@ -67,7 +69,9 @@ where
                 .await?;
             for payment in iterator.into_iter() {
                 let cents = payment.amount.cents();
-                to_spend_cents -= cents;
+                to_spend_cents = to_spend_cents
+                    .checked_sub(cents)
+                    .ok_or(Error::Underflow("cents".to_owned()))?;
                 payments.push(payment);
                 match to_spend_cents.cmp(&0) {
                     Ordering::Equal => {
@@ -89,8 +93,14 @@ where
                             .ok_or(Error::InsufficientBalance(account.clone(), asset.clone()))?;
 
                         change_input.push(input);
-                        change_output
-                            .push((account.clone(), asset.new_amount(cents - to_spend_cents)));
+                        change_output.push((
+                            account.clone(),
+                            asset.new_amount(
+                                cents
+                                    .checked_sub(to_spend_cents)
+                                    .ok_or(Error::Underflow("change cents".to_owned()))?,
+                            ),
+                        ));
                         change_output.push((account.clone(), asset.new_amount(to_spend_cents)));
 
                         // Go to the next payment
@@ -131,13 +141,17 @@ where
             let creates = split_input.creates();
             for i in 0..total {
                 // Spend the new payment
+                let index = i
+                    .checked_mul(2)
+                    .ok_or(Error::Overflow("index overflow".to_owned()))?;
+                let uindex: usize = index.into();
                 payments.push(PaymentFrom {
                     id: PaymentId {
                         transaction: split_input.id.clone(),
-                        position: i * 2,
+                        position: index,
                     },
-                    from: creates[(i * 2) as usize].to.clone(),
-                    amount: creates[(i * 2) as usize].amount.clone(),
+                    from: creates[uindex].to.clone(),
+                    amount: creates[uindex].amount.clone(),
                 });
             }
             Some(split_input)

utxo/src/lib.rs

@@ -17,8 +17,8 @@
 //! Verax aims to be simple, auditable, cryptographically provable and human
 //! auditable friendly.
 
-#![deny(missing_docs)]
 #![deny(warnings)]
+#![deny(missing_docs)]
 #![deny(unused_crate_dependencies)]
 #![deny(clippy::arithmetic_side_effects)]
 #![deny(clippy::cast_possible_truncation)]

utxo/src/storage/mod.rs

@@ -69,6 +69,14 @@ pub enum Error {
     /// No update was performed when expecting one
     NoUpdate,
 
+    #[error("Math error, overflow")]
+    /// Overflow error
+    Overflow,
+
+    #[error("Math error, underflow")]
+    /// Underflow error
+    Underflow,
+
     #[error("Record not found")]
     /// The requested record was not found
     NotFound,
@@ -503,7 +511,7 @@ pub mod test {
         assert!(at_least_one_negative_amount);
     }
 
-    pub async fn relate_account_to_transaction<'a, T>(storage: &'a T)
+    pub async fn relate_account_to_transaction<T>(storage: &T)
     where
         T: Storage,
     {
@@ -570,7 +578,7 @@ pub mod test {
         }
     }
 
-    pub async fn not_spendable_new_payments_not_spendable<'a, T>(storage: &'a T)
+    pub async fn not_spendable_new_payments_not_spendable<T>(storage: &T)
     where
         T: Storage,
     {

utxo/src/storage/sqlite/batch.rs

@@ -119,11 +119,14 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
             query = query.bind(id);
         }
 
-        let updated_records = query
-            .execute(&mut *self.inner)
-            .await
-            .map_err(|e| Error::Storage(e.to_string()))?
-            .rows_affected() as usize;
+        let updated_records = usize::try_from(
+            query
+                .execute(&mut *self.inner)
+                .await
+                .map_err(|e| Error::Storage(e.to_string()))?
+                .rows_affected(),
+        )
+        .map_err(|_| Error::Overflow)?;
 
         if updated_records == spends.len() {
             Ok(())
@@ -208,8 +211,8 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
         .map_err(|e| Error::Storage(e.to_string()))?;
 
         Ok((
-            creates.rows_affected() as usize,
-            spends.rows_affected() as usize,
+            usize::try_from(creates.rows_affected()).map_err(|_| Error::Overflow)?,
+            usize::try_from(spends.rows_affected()).map_err(|_| Error::Overflow)?,
         ))
     }
 

utxo/src/storage/sqlite/mod.rs

@@ -86,10 +86,9 @@ impl SQLite {
             .map_err(|_| Error::Storage("Invalid asset".to_string()))?;
 
         let cents = row
-            .try_get::<i64, usize>(pos + 1)
+            .try_get::<i64, usize>(pos.checked_add(1).ok_or(Error::Overflow)?)
             .map_err(|_| Error::Storage("Invalid cents".to_string()))?
-            .try_into()
-            .map_err(|_| Error::Storage("Invalid cents".to_string()))?;
+            .into();
 
         Ok(asset.new_amount(cents))
     }
@@ -207,7 +206,9 @@ impl Storage for SQLite {
         let mut to_return = vec![];
         for row in results.into_iter() {
             let amount = Self::sql_row_to_amount(&row, 1)?;
-            target_amount -= amount.cents();
+            target_amount = target_amount
+                .checked_sub(amount.cents())
+                .ok_or(Error::Underflow)?;
             to_return.push(PaymentFrom {
                 id: Self::sql_row_to_payment_id(&row, 0)?,
                 from: row
@@ -278,7 +279,10 @@ impl Storage for SQLite {
         let sql = if types.is_empty() {
             r#"SELECT "transaction_id" FROM "transaction_accounts" WHERE "account_id" = ? ORDER BY "created_at" DESC"#.to_owned()
         } else {
-            let params = format!("?{}", ", ?".repeat(types.len() - 1));
+            let params = format!(
+                "?{}",
+                ", ?".repeat(types.len().checked_add(1).ok_or(Error::Underflow)?)
+            );
             format!(
                 r#"SELECT "transaction_id" FROM "transaction_accounts" WHERE "account_id" = ? AND "type" IN ({}) ORDER BY "created_at" DESC"#,
                 params