Remove base64 and use the built-in id

Cargo.lock

@@ -526,12 +526,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ba43ea6f343b788c8764558649e08df62f86c6ef251fdaeb1ffd010a9ae50a2"
 
 [[package]]
-name = "base64"
-version = "0.22.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
-
-[[package]]
 name = "base64ct"
 version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -3267,7 +3261,6 @@ name = "verax"
 version = "0.1.0"
 dependencies = [
  "async-trait",
- "base64 0.22.1",
  "bech32",
  "borsh",
  "chrono",

utxo/Cargo.toml

@@ -5,7 +5,6 @@ edition = "2021"
 
 [dependencies]
 async-trait = "0.1.73"
-base64 = "0.22.1"
 bech32 = "0.11.0"
 borsh = { version = "1.3.1", features = ["derive", "bytes", "de_strict_order"] }
 chrono = { version = "0.4.31", features = ["serde"] }

utxo/src/id/binary.rs

@@ -9,6 +9,7 @@ macro_rules! BinaryId {
             PartialOrd,
             Ord,
             Hash,
+            Default,
             PartialEq,
             borsh::BorshSerialize,
             borsh::BorshDeserialize,
@@ -18,6 +19,12 @@ macro_rules! BinaryId {
             bytes: [u8; 32],
         }
 
+        impl From<[u8; 32]> for $id {
+            fn from(bytes: [u8; 32]) -> Self {
+                Self { bytes }
+            }
+        }
+
         impl $id {
             /// Creates a new instance of $id from the raw bytes
             pub fn new(bytes: [u8; 32]) -> Self {
@@ -30,11 +37,12 @@ macro_rules! BinaryId {
             }
         }
 
-        impl FromStr for $id {
-            type Err = Error;
+        impl std::str::FromStr for $id {
+            type Err = crate::id::Error;
             fn from_str(value: &str) -> Result<Self, Self::Err> {
                 Ok(Self::try_from(value).unwrap_or_else(|_| {
-                    let mut hasher = Sha256::new();
+                    use sha2::Digest;
+                    let mut hasher = sha2::Sha256::new();
                     hasher.update(&value);
                     Self {
                         bytes: hasher.finalize().into(),
@@ -55,21 +63,22 @@ macro_rules! BinaryId {
         impl<'de> Deserialize<'de> for $id {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
             where
-                D: Deserializer<'de>,
+                D: serde::Deserializer<'de>,
             {
-                let s = String::deserialize(deserializer)?;
+                use std::str::FromStr;
+                let s = <String as serde::Deserialize>::deserialize(deserializer)?;
                 // Use FromStr to parse the string and construct the struct
                 $id::from_str(&s).map_err(serde::de::Error::custom)
             }
         }
 
         impl TryFrom<&str> for $id {
-            type Error = Error;
+            type Error = crate::id::Error;
             fn try_from(value: &str) -> Result<Self, Self::Error> {
                 let (hrp, bytes) = bech32::decode(&value)?;
                 let hrp = hrp.to_string();
                 if hrp != $suffix {
-                    return Err(Error::InvalidPrefix(
+                    return Err(crate::id::Error::InvalidPrefix(
                         stringify!($id).to_owned(),
                         $suffix.to_owned(),
                         hrp,
@@ -81,11 +90,11 @@ macro_rules! BinaryId {
         }
 
         impl TryFrom<&[u8]> for $id {
-            type Error = Error;
+            type Error = crate::id::Error;
 
             fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
                 if value.len() != 32 {
-                    return Err(Error::InvalidLength(
+                    return Err(crate::id::Error::InvalidLength(
                         stringify!($id).to_owned(),
                         value.len(),
                         32,
@@ -98,11 +107,11 @@ macro_rules! BinaryId {
         }
 
         impl TryFrom<Vec<u8>> for $id {
-            type Error = Error;
+            type Error = crate::id::Error;
 
             fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
                 if value.len() != 32 {
-                    return Err(Error::InvalidLength(
+                    return Err(crate::id::Error::InvalidLength(
                         stringify!($id).to_owned(),
                         value.len(),
                         32,
@@ -114,7 +123,7 @@ macro_rules! BinaryId {
             }
         }
 
-        impl Display for $id {
+        impl std::fmt::Display for $id {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 let hrp = bech32::Hrp::parse($suffix).map_err(|_| std::fmt::Error)?;
                 write!(

utxo/src/id/mod.rs

@@ -1,5 +1,4 @@
 use serde::{de, Deserialize, Deserializer, Serialize};
-use sha2::{Digest, Sha256};
 use std::{fmt::Display, ops::Deref, str::FromStr};
 
 #[derive(

utxo/src/token.rs

@@ -5,11 +5,12 @@ use hmac::{Hmac, Mac};
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 use sha2::Sha256;
+use std::ops::Deref;
 
 type HmacSha256 = Hmac<Sha256>;
 
-/// Upload payload
-pub type TokenPayload = [u8; 10];
+crate::BinaryId!(TokenPayload, "token");
+crate::BinaryId!(TokenSignature, "sig");
 
 #[derive(thiserror::Error, Debug, Serialize)]
 /// Error type
@@ -55,10 +56,10 @@ impl TokenManager {
         };
 
         let mut mac = HmacSha256::new_from_slice(&self.0).expect("HMAC can take key of any size");
-        mac.update(update_token);
+        mac.update(update_token.deref());
 
         let result = mac.finalize().into_bytes();
-        if &result[..] != token.signature {
+        if &result[..] != *token.signature {
             Err(Error::InvalidSignature)
         } else {
             Ok(())
@@ -68,13 +69,13 @@ impl TokenManager {
     /// Creates a new instance of the token
     pub fn new_token(&self, owner: String, duration: Duration) -> (Token, TokenPayload) {
         let mut rng = rand::thread_rng();
-        let mut payload = TokenPayload::default();
+        let mut payload = [0u8; 32];
         rng.fill(&mut payload);
 
         let mut mac = HmacSha256::new_from_slice(&self.0).expect("HMAC can take key of any size");
         mac.update(&payload);
 
-        let signature = mac.finalize().into_bytes().to_vec();
+        let signature: [u8; 32] = mac.finalize().into_bytes().into();
 
         (
             // The token cannot be altered once it is commited, as the revision ID is the hash of
@@ -82,9 +83,9 @@ impl TokenManager {
             Token {
                 expires_at: Utc::now() + duration,
                 owner,
-                signature,
+                signature: signature.into(),
             },
-            payload,
+            payload.into(),
         )
     }
 }
@@ -100,11 +101,7 @@ pub struct Token {
         deserialize_with = "crate::from_ts_microseconds"
     )]
     expires_at: DateTime<Utc>,
-    #[serde(
-        serialize_with = "crate::serialize_base64",
-        deserialize_with = "crate::deserialize_base64"
-    )]
-    signature: Vec<u8>,
+    signature: TokenSignature,
     owner: String,
 }
 

utxo/src/transaction/mod.rs

@@ -5,9 +5,8 @@ use crate::{
     token::{TokenManager, TokenPayload},
     AccountId, Amount, FilterableValue, MaxLengthString, PaymentFrom, RevId, Status, TxId,
 };
-use base64::{engine::general_purpose, Engine as _};
 use chrono::{DateTime, Duration, TimeZone, Utc};
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::{Deserialize, Serialize};
 use std::ops::Deref;
 
 mod base_tx;
@@ -20,24 +19,6 @@ pub use self::{base_tx::BaseTx, error::Error, revision::Revision, typ::Type};
 /// Tag definition
 pub type Tag = MaxLengthString<64>;
 
-pub(crate) fn serialize_base64<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    let encoded = general_purpose::STANDARD_NO_PAD.encode(bytes);
-    serializer.serialize_str(&encoded)
-}
-
-pub(crate) fn deserialize_base64<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let s = String::deserialize(deserializer)?;
-    general_purpose::STANDARD_NO_PAD
-        .decode(&s)
-        .map_err(serde::de::Error::custom)
-}
-
 pub(crate) fn to_ts_microseconds<W: std::io::Write>(
     dt: &DateTime<Utc>,
     writer: &mut W,