Allow passing ordinals in degree notation

src/epoch.rs

@@ -99,6 +99,7 @@ mod tests {
       (Epoch(0).subsidy() + Epoch(1).subsidy()) * Epoch::BLOCKS
     );
     assert_eq!(Epoch(33).starting_ordinal(), Ordinal(Ordinal::SUPPLY));
+    assert_eq!(Epoch(34).starting_ordinal(), Ordinal(Ordinal::SUPPLY));
   }
 
   #[test]

src/height.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-#[derive(Copy, Clone, Debug, Display)]
+#[derive(Copy, Clone, Debug, Display, FromStr)]
 pub(crate) struct Height(pub(crate) u64);
 
 impl Height {
@@ -42,14 +42,6 @@ impl PartialEq<u64> for Height {
   }
 }
 
-impl FromStr for Height {
-  type Err = Error;
-
-  fn from_str(s: &str) -> Result<Self, Self::Err> {
-    Ok(Self(s.parse::<u64>()?))
-  }
-}
-
 #[cfg(test)]
 mod tests {
   use super::*;

src/main.rs

@@ -5,7 +5,7 @@ use {
     arguments::Arguments, bytes::Bytes, epoch::Epoch, height::Height, index::Index, nft::Nft,
     options::Options, ordinal::Ordinal, sat_point::SatPoint, subcommand::Subcommand,
   },
-  anyhow::{anyhow, Context, Error},
+  anyhow::{anyhow, bail, Context, Error},
   axum::{extract, http::StatusCode, response::IntoResponse, routing::get, Json, Router},
   axum_server::Handle,
   bdk::{

src/ordinal.rs

@@ -1,8 +1,6 @@
 use super::*;
 
-#[derive(
-  Copy, Clone, Eq, PartialEq, Debug, Display, Ord, PartialOrd, FromStr, Deserialize, Serialize,
-)]
+#[derive(Copy, Clone, Eq, PartialEq, Debug, Display, Ord, PartialOrd, Deserialize, Serialize)]
 #[serde(transparent)]
 pub(crate) struct Ordinal(pub(crate) u64);
 
@@ -27,7 +25,7 @@ impl Ordinal {
   }
 
   pub(crate) fn period(self) -> u64 {
-    self.0 / PERIOD_BLOCKS
+    self.height().n() / PERIOD_BLOCKS
   }
 
   pub(crate) fn subsidy_position(self) -> u64 {
@@ -52,6 +50,72 @@ impl Ordinal {
     }
     name.chars().rev().collect()
   }
+
+  fn from_degree(s: &str) -> Result<Self> {
+    let (cycle_number, rest) = s
+      .split_once('°')
+      .ok_or_else(|| anyhow!("Missing degree symbol"))?;
+    let cycle_number = cycle_number.parse::<u64>()?;
+
+    let (epoch_offset, rest) = rest
+      .split_once('′')
+      .ok_or_else(|| anyhow!("Missing prime symbol"))?;
+    let epoch_offset = epoch_offset.parse::<u64>()?;
+    if epoch_offset >= Epoch::BLOCKS {
+      bail!("Invalid epoch offset");
+    }
+
+    let (period_offset, rest) = rest
+      .split_once('″')
+      .ok_or_else(|| anyhow!("Missing double prime symbol"))?;
+    let period_offset = period_offset.parse::<u64>()?;
+    if period_offset >= PERIOD_BLOCKS {
+      bail!("Invalid period offset");
+    }
+
+    let cycle_start_epoch = cycle_number * CYCLE_EPOCHS;
+
+    let cycle_progression = period_offset
+      .checked_sub(epoch_offset % PERIOD_BLOCKS)
+      .ok_or_else(|| anyhow!("Invalid relationship between epoch offset and period offset"))?;
+
+    if cycle_progression % (Epoch::BLOCKS % PERIOD_BLOCKS) != 0 {
+      bail!("Invalid relationship between epoch offset and period offset");
+    }
+
+    let epochs_since_cycle_start = cycle_progression / (Epoch::BLOCKS % PERIOD_BLOCKS);
+
+    let epoch = cycle_start_epoch + epochs_since_cycle_start;
+
+    let height = Height(epoch * Epoch::BLOCKS + epoch_offset);
+
+    let (block_offset, rest) = match rest.split_once('‴') {
+      Some((block_offset, rest)) => (block_offset.parse::<u64>()?, rest),
+      None => (0, rest),
+    };
+
+    if !rest.is_empty() {
+      bail!("Trailing characters");
+    }
+
+    if block_offset >= height.subsidy() {
+      bail!("Invalid block offset");
+    }
+
+    Ok(height.starting_ordinal() + block_offset)
+  }
+
+  fn from_decimal(s: &str) -> Result<Self> {
+    let (height, offset) = s.split_once('.').ok_or_else(|| anyhow!("Missing period"))?;
+    let height = Height(height.parse()?);
+    let offset = offset.parse::<u64>()?;
+
+    if offset >= height.subsidy() {
+      bail!("Invalid block offset");
+    }
+
+    Ok(height.starting_ordinal() + offset)
+  }
 }
 
 impl PartialEq<u64> for Ordinal {
@@ -74,6 +138,25 @@ impl AddAssign<u64> for Ordinal {
   }
 }
 
+impl FromStr for Ordinal {
+  type Err = Error;
+
+  fn from_str(s: &str) -> Result<Self> {
+    if s.contains('°') {
+      Self::from_degree(s)
+    } else if s.contains('.') {
+      Self::from_decimal(s)
+    } else {
+      let ordinal = Self(s.parse()?);
+      if ordinal > Self::LAST {
+        Err(anyhow!("Invalid ordinal"))
+      } else {
+        Ok(ordinal)
+      }
+    }
+  }
+}
+
 #[cfg(test)]
 mod tests {
   use super::*;
@@ -102,6 +185,13 @@ mod tests {
     assert_eq!(Ordinal(2099999997689999).name(), "a");
   }
 
+  #[test]
+  fn period() {
+    assert_eq!(Ordinal(0).period(), 0);
+    assert_eq!(Ordinal(10080000000000).period(), 1);
+    assert_eq!(Ordinal(2099999997689999).period(), 3437);
+  }
+
   #[test]
   fn epoch() {
     assert_eq!(Ordinal(0).epoch(), 0);
@@ -177,10 +267,91 @@ mod tests {
     assert_eq!(ordinal, 101);
   }
 
+  fn parse(s: &str) -> Result<Ordinal, String> {
+    s.parse::<Ordinal>().map_err(|e| e.to_string())
+  }
+
+  #[test]
+  fn from_str_decimal() {
+    assert_eq!(parse("0.0").unwrap(), 0);
+    assert_eq!(parse("0.1").unwrap(), 1);
+    assert_eq!(parse("1.0").unwrap(), 50 * 100_000_000);
+    assert_eq!(parse("6929999.0").unwrap(), 2099999997689999);
+    assert!(parse("0.5000000000").is_err());
+    assert!(parse("6930000.0").is_err());
+  }
+
+  #[test]
+  fn from_str_degree() {
+    assert_eq!(parse("0°0′0″0‴").unwrap(), 0);
+    assert_eq!(parse("0°0′0″").unwrap(), 0);
+    assert_eq!(parse("0°0′0″1‴").unwrap(), 1);
+    assert_eq!(parse("0°2015′2015″0‴").unwrap(), 10075000000000);
+    assert_eq!(parse("0°2016′0″0‴").unwrap(), 10080000000000);
+    assert_eq!(parse("0°2017′1″0‴").unwrap(), 10085000000000);
+    assert_eq!(parse("0°2016′0″1‴").unwrap(), 10080000000001);
+    assert_eq!(parse("0°2017′1″1‴").unwrap(), 10085000000001);
+    assert_eq!(parse("0°209999′335″0‴").unwrap(), 1049995000000000);
+    assert_eq!(parse("0°0′336″0‴").unwrap(), 1050000000000000);
+    assert_eq!(parse("0°0′672″0‴").unwrap(), 1575000000000000);
+    assert_eq!(parse("0°209999′1007″0‴").unwrap(), 1837498750000000);
+    assert_eq!(parse("0°0′1008″0‴").unwrap(), 1837500000000000);
+    assert_eq!(parse("1°0′0″0‴").unwrap(), 2067187500000000);
+    assert_eq!(parse("2°0′0″0‴").unwrap(), 2099487304530000);
+    assert_eq!(parse("3°0′0″0‴").unwrap(), 2099991988080000);
+    assert_eq!(parse("4°0′0″0‴").unwrap(), 2099999873370000);
+    assert_eq!(parse("5°0′0″0‴").unwrap(), 2099999996220000);
+    assert_eq!(parse("5°0′336″0‴").unwrap(), 2099999997060000);
+    assert_eq!(parse("5°0′672″0‴").unwrap(), 2099999997480000);
+    assert_eq!(parse("5°1′673″0‴").unwrap(), 2099999997480001);
+    assert_eq!(parse("5°209999′1007″0‴").unwrap(), 2099999997689999);
+  }
+
+  #[test]
+  fn from_str_number() {
+    assert_eq!(parse("0").unwrap(), 0);
+    assert!(parse("foo").is_err());
+    assert_eq!(parse("2099999997689999").unwrap(), 2099999997689999);
+    assert!(parse("2099999997690000").is_err());
+  }
+
+  #[test]
+  fn from_str_degree_invalid_cycle_number() {
+    assert!(parse("5°0′0″0‴").is_ok());
+    assert!(parse("6°0′0″0‴").is_err());
+  }
+
+  #[test]
+  fn from_str_degree_invalid_epoch_offset() {
+    assert!(parse("0°209999′335″0‴").is_ok());
+    assert!(parse("0°210000′336″0‴").is_err());
+  }
+
+  #[test]
+  fn from_str_degree_invalid_period_offset() {
+    assert!(parse("0°2015′2015″0‴").is_ok());
+    assert!(parse("0°2016′2016″0‴").is_err());
+  }
+
+  #[test]
+  fn from_str_degree_invalid_block_offset() {
+    assert!(parse("0°0′0″4999999999‴").is_ok());
+    assert!(parse("0°0′0″5000000000‴").is_err());
+    assert!(parse("0°209999′335″4999999999‴").is_ok());
+    assert!(parse("0°0′336″4999999999‴").is_err());
+  }
+
+  #[test]
+  fn from_str_degree_invalid_period_block_relationship() {
+    assert!(parse("0°2015′2015″0‴").is_ok());
+    assert!(parse("0°2016′0″0‴").is_ok());
+    assert!(parse("0°2016′1″0‴").is_err());
+  }
+
   #[test]
-  fn from_str() {
-    assert_eq!("0".parse::<Ordinal>().unwrap(), 0);
-    assert!("foo".parse::<Ordinal>().is_err());
+  fn from_str_degree_post_distribution() {
+    assert!(parse("5°209999′1007″0‴").is_ok());
+    assert!(parse("5°0′1008″0‴").is_err());
   }
 
   #[test]

src/subcommand/traits.rs

@@ -11,17 +11,12 @@ impl Traits {
       return Err(anyhow!("Invalid ordinal"));
     }
 
-    println!("name: {}", self.ordinal.name());
-
-    println!("cycle: {}", self.ordinal.cycle());
-
-    println!("epoch: {}", self.ordinal.epoch());
-
-    println!("height: {}", self.ordinal.height());
-
-    println!("period: {}", self.ordinal.period());
-
-    println!("offset: {}", self.ordinal.subsidy_position());
+    println!("number: {}", self.ordinal.n());
+    println!(
+      "decimal: {}.{}",
+      self.ordinal.height(),
+      self.ordinal.subsidy_position()
+    );
 
     let height = self.ordinal.height().n();
     let c = height / (CYCLE_EPOCHS * Epoch::BLOCKS);
@@ -30,6 +25,13 @@ impl Traits {
     let o = self.ordinal.subsidy_position();
     println!("degree: {c}°{e}′{p}″{o}‴");
 
+    println!("name: {}", self.ordinal.name());
+    println!("height: {}", self.ordinal.height());
+    println!("cycle: {}", self.ordinal.cycle());
+    println!("epoch: {}", self.ordinal.epoch());
+    println!("period: {}", self.ordinal.period());
+    println!("offset: {}", self.ordinal.subsidy_position());
+
     println!(
       "rarity: {}",
       if c == 0 && o == 0 && p == 0 && e == 0 {

tests/lib.rs

@@ -89,7 +89,7 @@ struct Test {
   envs: Vec<(OsString, OsString)>,
   events: Vec<Event>,
   expected_status: i32,
-  expected_stderr: Option<String>,
+  expected_stderr: Expected,
   expected_stdout: Expected,
   tempdir: TempDir,
 }
@@ -105,7 +105,7 @@ impl Test {
       envs: Vec::new(),
       events: Vec::new(),
       expected_status: 0,
-      expected_stderr: None,
+      expected_stderr: Expected::Ignore,
       expected_stdout: Expected::String(String::new()),
       tempdir,
     }
@@ -139,7 +139,7 @@ impl Test {
   fn stdout_regex(self, expected_stdout: impl AsRef<str>) -> Self {
     Self {
       expected_stdout: Expected::Regex(
-        Regex::new(&format!("^{}$", expected_stdout.as_ref())).unwrap(),
+        Regex::new(&format!("(?s)^{}$", expected_stdout.as_ref())).unwrap(),
       ),
       ..self
     }
@@ -155,7 +155,16 @@ impl Test {
 
   fn expected_stderr(self, expected_stderr: &str) -> Self {
     Self {
-      expected_stderr: Some(expected_stderr.to_owned()),
+      expected_stderr: Expected::String(expected_stderr.to_owned()),
+      ..self
+    }
+  }
+
+  fn stderr_regex(self, expected_stderr: impl AsRef<str>) -> Self {
+    Self {
+      expected_stderr: Expected::Regex(
+        Regex::new(&format!("(?s)^{}$", expected_stderr.as_ref())).unwrap(),
+      ),
       ..self
     }
   }
@@ -219,7 +228,7 @@ impl Test {
       .envs(self.envs)
       .stdin(Stdio::null())
       .stdout(Stdio::piped())
-      .stderr(if self.expected_stderr.is_some() {
+      .stderr(if !matches!(self.expected_stderr, Expected::Ignore) {
         Stdio::piped()
       } else {
         Stdio::inherit()
@@ -291,21 +300,29 @@ impl Test {
       );
     }
 
-    let re = Regex::new(r"(?m)^\[.*\n")?;
+    let log_line_re = Regex::new(r"(?m)^\[.*\n")?;
 
-    for m in re.find_iter(stderr) {
-      print!("{}", m.as_str())
+    for log_line in log_line_re.find_iter(stderr) {
+      print!("{}", log_line.as_str())
     }
 
-    if let Some(expected_stderr) = self.expected_stderr {
-      assert_eq!(re.replace_all(stderr, ""), expected_stderr);
+    let stripped_stderr = log_line_re.replace_all(stderr, "");
+
+    match self.expected_stderr {
+      Expected::String(expected_stderr) => assert_eq!(stripped_stderr, expected_stderr),
+      Expected::Regex(expected_stderr) => assert!(
+        expected_stderr.is_match(&stripped_stderr),
+        "stderr did not match regex: {:?}",
+        stripped_stderr
+      ),
+      Expected::Ignore => {}
     }
 
     match self.expected_stdout {
       Expected::String(expected_stdout) => assert_eq!(stdout, expected_stdout),
       Expected::Regex(expected_stdout) => assert!(
         expected_stdout.is_match(stdout),
-        "stdout did not match regex: {}",
+        "stdout did not match regex: {:?}",
         stdout
       ),
       Expected::Ignore => {}