More changes

utxo/src/amount.rs

@@ -1,5 +1,5 @@
 use crate::Asset;
-use serde::Serialize;
+use serde::{Serialize, Serializer};
 
 pub type AmountCents = i128;
 
@@ -17,14 +17,24 @@ pub type AmountCents = i128;
 /// operation.
 ///
 ///
-/// The `cents` and `Asset.id` must be used to store amounts in the storge
+/// The `cents` and `Asset.id` must be used to store amounts in the storage
 /// layer. Float or string representations should be used to display
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub struct Amount {
     asset: Asset,
     cents: AmountCents,
 }
 
+impl Serialize for Amount {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let serialized = self.to_string();
+        serializer.serialize_str(&serialized)
+    }
+}
+
 impl Amount {
     pub fn new(asset: Asset, cents: AmountCents) -> Self {
         Self { asset, cents }
@@ -51,3 +61,52 @@ impl Amount {
         })
     }
 }
+
+impl ToString for Amount {
+    fn to_string(&self) -> String {
+        let str = self.cents.to_string();
+        let precision: usize = self.asset.precision.into();
+        let str = if str.len() < precision + 1 {
+            format!("{}{}", "0".repeat(precision - str.len() + 1), str)
+        } else {
+            str
+        };
+
+        let (left, right) = str.split_at(str.len() - precision);
+        format!("{}.{}", left, right)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn dollar() {
+        let usd = Asset {
+            id: 1,
+            precision: 4,
+        };
+        let amount = usd.new_amount(1022100);
+        assert_eq!(amount.to_string(), "102.2100");
+    }
+
+    #[test]
+    fn bitcoin() {
+        let btc = Asset {
+            id: 1,
+            precision: 8,
+        };
+        assert_eq!(btc.new_amount(1022100).to_string(), "0.01022100");
+        assert_eq!(btc.new_amount(10).to_string(), "0.00000010");
+        assert_eq!(btc.new_amount(10000000).to_string(), "0.10000000");
+        assert_eq!(btc.new_amount(100000000).to_string(), "1.00000000");
+        assert_eq!(
+            btc.new_amount(100000000)
+                .checked_add(&btc.new_amount(100000000))
+                .unwrap()
+                .to_string(),
+            "2.00000000"
+        );
+    }
+}

utxo/src/id.rs

@@ -60,6 +60,23 @@ macro_rules! Id {
             }
         }
 
+        impl TryFrom<&[u8]> for $id {
+            type Error = Error;
+
+            fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+                if value.len() != 32 {
+                    return Err(Error::InvalidLength(
+                        stringify!($id).to_owned(),
+                        value.len(),
+                        32,
+                    ));
+                }
+                let mut bytes = [0u8; 32];
+                bytes.copy_from_slice(&value);
+                Ok(Self { bytes })
+            }
+        }
+
         impl TryFrom<Vec<u8>> for $id {
             type Error = Error;
 
@@ -99,3 +116,28 @@ macro_rules! Id {
 
 Id!(AccountId, "account");
 Id!(TransactionId, "tx");
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn from_random_data() {
+        let id = "something".parse::<AccountId>().expect("hashed value");
+        let id_str = id.to_string();
+        let id_bin: &[u8] = id.as_ref();
+        assert_eq!(71, id_str.len());
+        assert_eq!(
+            <&str as TryInto<AccountId>>::try_into(id_str.as_str()).expect("valid"),
+            id
+        );
+        assert_eq!(
+            <Vec<u8> as TryInto<AccountId>>::try_into(id_bin.to_owned()).expect("valid"),
+            id
+        );
+        assert_eq!(
+            <&[u8] as TryInto<AccountId>>::try_into(id_bin).expect("valid"),
+            id
+        );
+    }
+}