fix unicode panic (ordinals#88)

src/brc20/ledger.rs

@@ -6,7 +6,7 @@ use std::fmt::{Debug, Display};
 pub trait LedgerRead {
   type Error: Debug + Display;
 
-  fn get_balances(&self, script_key: &ScriptKey) -> Result<Vec<(Tick, Balance)>, Self::Error>;
+  fn get_balances(&self, script_key: &ScriptKey) -> Result<Vec<Balance>, Self::Error>;
   fn get_balance(
     &self,
     script_key: &ScriptKey,
@@ -35,7 +35,6 @@ pub trait LedgerReadWrite: LedgerRead {
   fn update_token_balance(
     &self,
     script_key: &ScriptKey,
-    tick: &Tick,
     new_balance: Balance,
   ) -> Result<(), Self::Error>;
 

src/brc20/types/balance.rs

@@ -1,15 +1,20 @@
-use serde::{Deserialize, Serialize};
+use {
+  super::*,
+  serde::{Deserialize, Serialize},
+};
 #[derive(Debug, Deserialize, Serialize, Clone, PartialEq, PartialOrd, Ord, Eq)]
 pub struct Balance {
+  pub tick: Tick,
   pub overall_balance: u128,
   pub transferable_balance: u128,
 }
 
 impl Balance {
-  pub fn new() -> Self {
+  pub fn new(tick: &Tick) -> Self {
     Self {
-      overall_balance: 0 as u128,
-      transferable_balance: 0 as u128,
+      tick: tick.clone(),
+      overall_balance: 0u128,
+      transferable_balance: 0u128,
     }
   }
 }

src/brc20/types/tick.rs

@@ -1,9 +1,12 @@
 use super::super::error::BRC20Error;
 use crate::brc20::params::TICK_BYTE_COUNT;
 use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
-use std::str::FromStr;
+use std::{
+  fmt::{Display, Formatter},
+  str::FromStr,
+};
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Tick([u8; TICK_BYTE_COUNT]);
 
 impl FromStr for Tick {
@@ -15,17 +18,8 @@ impl FromStr for Tick {
     if bytes.len() != TICK_BYTE_COUNT {
       return Err(BRC20Error::InvalidTickLen(s.to_string()));
     }
-    Ok(Self(bytes.try_into().unwrap()))
-  }
-}
-
-impl PartialEq for Tick {
-  fn eq(&self, other: &Self) -> bool {
-    self.to_lowercase().0 == other.to_lowercase().0
-  }
 
-  fn ne(&self, other: &Self) -> bool {
-    !self.eq(other)
+    Ok(Self(bytes.try_into().unwrap()))
   }
 }
 
@@ -36,24 +30,8 @@ impl Tick {
     std::str::from_utf8(self.0.as_slice()).unwrap()
   }
 
-  pub fn to_lowercase(&self) -> Tick {
-    Self::from_str(self.as_str().to_lowercase().as_str()).unwrap()
-  }
-
-  pub fn as_bytes(&self) -> &[u8] {
-    self.0.as_slice()
-  }
-
-  pub fn hex(&self) -> String {
-    hex::encode(&self.0)
-  }
-
-  pub fn min_hex() -> String {
-    Self([0u8; TICK_BYTE_COUNT]).hex()
-  }
-
-  pub fn max_hex() -> String {
-    Self([0xffu8; TICK_BYTE_COUNT]).hex()
+  pub fn to_lowercase(&self) -> LowerTick {
+    LowerTick::new(&self.as_str().to_lowercase())
   }
 }
 
@@ -76,15 +54,109 @@ impl<'de> Deserialize<'de> for Tick {
   }
 }
 
+impl Display for Tick {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    write!(f, "{}", self.as_str())
+  }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct LowerTick(Box<[u8]>);
+
+impl LowerTick {
+  fn new(str: &str) -> Self {
+    LowerTick(str.as_bytes().to_vec().into_boxed_slice())
+  }
+
+  pub fn as_str(&self) -> &str {
+    std::str::from_utf8(&self.0).unwrap()
+  }
+
+  pub fn hex(&self) -> String {
+    let mut data = [0u8; TICK_BYTE_COUNT * 4];
+    data[..self.0.len()].copy_from_slice(&self.0);
+    hex::encode(data)
+  }
+
+  pub fn min_hex() -> String {
+    hex::encode([0u8; TICK_BYTE_COUNT * 4])
+  }
+
+  pub fn max_hex() -> String {
+    hex::encode([0xffu8; TICK_BYTE_COUNT * 4])
+  }
+}
+
+impl Display for LowerTick {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    write!(f, "{}", self.as_str())
+  }
+}
+
 #[cfg(test)]
 mod tests {
   use super::*;
 
+  #[test]
+  fn test_tick_length_case() {
+    assert!(Tick::from_str("XAİ").is_ok());
+    assert!(Tick::from_str("XAİİ").is_err());
+    assert!("XAİ".parse::<Tick>().is_ok());
+    assert!("XAİİ".parse::<Tick>().is_err());
+    assert!(Tick::from_str("X。").is_ok());
+    assert!("X。".parse::<Tick>().is_ok());
+    assert!(Tick::from_str("aBc1").is_ok());
+    assert!("aBc1".parse::<Tick>().is_ok());
+    assert!("ατ".parse::<Tick>().is_ok());
+    assert!("∑ii".parse::<Tick>().is_err());
+    assert!("∑i".parse::<Tick>().is_ok());
+    assert!("⊢i".parse::<Tick>().is_ok());
+    assert!("⊢ii".parse::<Tick>().is_err());
+    assert!("≯a".parse::<Tick>().is_ok());
+    assert!("a≯a".parse::<Tick>().is_err());
+  }
+  #[test]
+  fn test_tick_hex() {
+    assert_eq!(
+      Tick::from_str("XAİ").unwrap().to_lowercase().hex(),
+      "786169cc870000000000000000000000"
+    );
+    assert_eq!(
+      Tick::from_str("aBc1").unwrap().to_lowercase().hex(),
+      "61626331000000000000000000000000"
+    );
+  }
+
+  #[test]
+  fn test_tick_unicode_lowercase() {
+    assert_eq!(
+      Tick::from_str("XAİ").unwrap().to_lowercase().as_str(),
+      "xai\u{307}"
+    );
+    assert_eq!(
+      Tick::from_str("aBc1").unwrap().to_lowercase().as_str(),
+      "abc1",
+    );
+    assert_eq!("ατ".parse::<Tick>().unwrap().to_lowercase().as_str(), "ατ");
+    assert_eq!("∑H".parse::<Tick>().unwrap().to_lowercase().as_str(), "∑h");
+    assert_eq!("⊢I".parse::<Tick>().unwrap().to_lowercase().as_str(), "⊢i");
+    assert_eq!("≯A".parse::<Tick>().unwrap().to_lowercase().as_str(), "≯a");
+  }
+
   #[test]
   fn test_tick_compare_ignore_case() {
-    assert_eq!(Tick::from_str("aBc1"), Tick::from_str("AbC1"));
+    assert_ne!(Tick::from_str("aBc1"), Tick::from_str("AbC1"));
 
     assert_ne!(Tick::from_str("aBc1"), Tick::from_str("aBc2"));
+
+    assert_eq!(
+      Tick::from_str("aBc1").unwrap().to_lowercase(),
+      Tick::from_str("AbC1").unwrap().to_lowercase(),
+    );
+    assert_ne!(
+      Tick::from_str("aBc1").unwrap().to_lowercase(),
+      Tick::from_str("AbC2").unwrap().to_lowercase(),
+    );
   }
 
   #[test]

src/brc20/types/token_info.rs

@@ -1,7 +1,7 @@
 use super::*;
 use crate::InscriptionId;
 use serde::{Deserialize, Serialize};
-#[derive(Debug, PartialEq, Deserialize, Serialize)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
 pub struct TokenInfo {
   pub tick: Tick,
   pub inscription_id: InscriptionId,