Allow invalid ordinals

src/command/name.rs

@@ -7,10 +7,8 @@ pub(crate) struct Name {
 
 impl Name {
   pub(crate) fn run(self) -> Result {
-    for c in self.name.chars() {
-      if !('a'..='z').contains(&c) {
-        return Err("Invalid name".into());
-      }
+    if self.name.is_empty() || self.name.chars().any(|c| !('a'..='z').contains(&c)) {
+      return Err("Invalid name".into());
     }
 
     let mut min = 0;
@@ -20,7 +18,7 @@ impl Name {
     loop {
       log::info!("min max guess: {} {} {}", min, max, guess);
 
-      let name = Ordinal::new(guess).name();
+      let name = Ordinal(guess).name();
 
       match name
         .len()

src/command/range.rs

@@ -24,13 +24,7 @@ impl Range {
     let end = start + self.height.subsidy();
 
     if self.name {
-      let (start, end) = match (Ordinal::new_checked(start), Ordinal::new_checked(end)) {
-        (Some(start), Some(end)) => (start.name(), end.name()),
-        (Some(start), None) => (start.name(), start.name()),
-        (None, None) => (Ordinal::LAST.name(), Ordinal::LAST.name()),
-        (None, Some(_)) => unreachable!(),
-      };
-      println!("[{},{})", start, end);
+      println!("[{},{})", Ordinal(start).name(), Ordinal(end).name());
     } else {
       println!("[{},{})", start, end);
     }

src/command/traits.rs

@@ -7,6 +7,10 @@ pub(crate) struct Traits {
 
 impl Traits {
   pub(crate) fn run(self) -> Result {
+    if self.ordinal > Ordinal::LAST {
+      return Err("Invalid ordinal".into());
+    }
+
     let n = self.ordinal.n();
 
     if n % 2 == 0 {

src/epoch.rs

@@ -5,39 +5,40 @@ pub(crate) struct Epoch(pub(crate) u64);
 
 impl Epoch {
   pub(crate) const STARTING_ORDINALS: &'static [Ordinal] = &[
-    Ordinal::new(0),
-    Ordinal::new(1050000000000000),
-    Ordinal::new(1575000000000000),
-    Ordinal::new(1837500000000000),
-    Ordinal::new(1968750000000000),
-    Ordinal::new(2034375000000000),
-    Ordinal::new(2067187500000000),
-    Ordinal::new(2083593750000000),
-    Ordinal::new(2091796875000000),
-    Ordinal::new(2095898437500000),
-    Ordinal::new(2097949218750000),
-    Ordinal::new(2098974609270000),
-    Ordinal::new(2099487304530000),
-    Ordinal::new(2099743652160000),
-    Ordinal::new(2099871825870000),
-    Ordinal::new(2099935912620000),
-    Ordinal::new(2099967955890000),
-    Ordinal::new(2099983977420000),
-    Ordinal::new(2099991988080000),
-    Ordinal::new(2099995993410000),
-    Ordinal::new(2099997995970000),
-    Ordinal::new(2099998997250000),
-    Ordinal::new(2099999497890000),
-    Ordinal::new(2099999748210000),
-    Ordinal::new(2099999873370000),
-    Ordinal::new(2099999935950000),
-    Ordinal::new(2099999967240000),
-    Ordinal::new(2099999982780000),
-    Ordinal::new(2099999990550000),
-    Ordinal::new(2099999994330000),
-    Ordinal::new(2099999996220000),
-    Ordinal::new(2099999997060000),
-    Ordinal::new(2099999997480000),
+    Ordinal(0),
+    Ordinal(1050000000000000),
+    Ordinal(1575000000000000),
+    Ordinal(1837500000000000),
+    Ordinal(1968750000000000),
+    Ordinal(2034375000000000),
+    Ordinal(2067187500000000),
+    Ordinal(2083593750000000),
+    Ordinal(2091796875000000),
+    Ordinal(2095898437500000),
+    Ordinal(2097949218750000),
+    Ordinal(2098974609270000),
+    Ordinal(2099487304530000),
+    Ordinal(2099743652160000),
+    Ordinal(2099871825870000),
+    Ordinal(2099935912620000),
+    Ordinal(2099967955890000),
+    Ordinal(2099983977420000),
+    Ordinal(2099991988080000),
+    Ordinal(2099995993410000),
+    Ordinal(2099997995970000),
+    Ordinal(2099998997250000),
+    Ordinal(2099999497890000),
+    Ordinal(2099999748210000),
+    Ordinal(2099999873370000),
+    Ordinal(2099999935950000),
+    Ordinal(2099999967240000),
+    Ordinal(2099999982780000),
+    Ordinal(2099999990550000),
+    Ordinal(2099999994330000),
+    Ordinal(2099999996220000),
+    Ordinal(2099999997060000),
+    Ordinal(2099999997480000),
+    Ordinal(Ordinal::SUPPLY),
   ];
 
   pub(crate) const BLOCKS: u64 = 210000;
@@ -50,8 +51,10 @@ impl Epoch {
     }
   }
 
-  pub(crate) fn starting_ordinal(self) -> Option<Ordinal> {
-    Self::STARTING_ORDINALS.get(self.0 as usize).cloned()
+  pub(crate) fn starting_ordinal(self) -> Ordinal {
+    *Self::STARTING_ORDINALS
+      .get(self.0 as usize)
+      .unwrap_or_else(|| Self::STARTING_ORDINALS.last().unwrap())
   }
 
   pub(crate) fn starting_height(self) -> Height {
@@ -86,16 +89,16 @@ mod tests {
 
   #[test]
   fn starting_ordinal() {
-    assert_eq!(Epoch(0).starting_ordinal().unwrap(), 0);
+    assert_eq!(Epoch(0).starting_ordinal(), 0);
     assert_eq!(
-      Epoch(1).starting_ordinal().unwrap(),
+      Epoch(1).starting_ordinal(),
       Epoch(0).subsidy() * Epoch::BLOCKS
     );
     assert_eq!(
-      Epoch(2).starting_ordinal().unwrap(),
+      Epoch(2).starting_ordinal(),
       (Epoch(0).subsidy() + Epoch(1).subsidy()) * Epoch::BLOCKS
     );
-    assert_eq!(Epoch(33).starting_ordinal(), None);
+    assert_eq!(Epoch(33).starting_ordinal(), Ordinal(Ordinal::SUPPLY));
   }
 
   #[test]
@@ -104,13 +107,13 @@ mod tests {
 
     let mut epoch_ordinals = Vec::new();
 
-    for epoch in 0..33 {
+    for epoch in 0..34 {
       epoch_ordinals.push(ordinal);
       ordinal += Epoch::BLOCKS * Epoch(epoch).subsidy();
     }
 
     assert_eq!(Epoch::STARTING_ORDINALS, epoch_ordinals);
-    assert_eq!(Epoch::STARTING_ORDINALS.len(), 33);
+    assert_eq!(Epoch::STARTING_ORDINALS.len(), 34);
   }
 
   #[test]
@@ -143,10 +146,10 @@ mod tests {
 
   #[test]
   fn from_ordinal() {
-    assert_eq!(Epoch::from(Ordinal::new(0)), 0);
-    assert_eq!(Epoch::from(Ordinal::new(1)), 0);
-    assert_eq!(Epoch::from(Epoch(1).starting_ordinal().unwrap()), 1);
-    assert_eq!(Epoch::from(Epoch(1).starting_ordinal().unwrap() + 1), 1);
+    assert_eq!(Epoch::from(Ordinal(0)), 0);
+    assert_eq!(Epoch::from(Ordinal(1)), 0);
+    assert_eq!(Epoch::from(Epoch(1).starting_ordinal()), 1);
+    assert_eq!(Epoch::from(Epoch(1).starting_ordinal() + 1), 1);
   }
 
   #[test]

src/height.rs

@@ -12,11 +12,11 @@ impl Height {
     Epoch::from(self).subsidy()
   }
 
-  pub(crate) fn starting_ordinal(self) -> Option<Ordinal> {
+  pub(crate) fn starting_ordinal(self) -> Ordinal {
     let epoch = Epoch::from(self);
-    let epoch_starting_ordinal = epoch.starting_ordinal()?;
+    let epoch_starting_ordinal = epoch.starting_ordinal();
     let epoch_starting_height = epoch.starting_height();
-    Some(epoch_starting_ordinal + (self - epoch_starting_height.n()).n() * epoch.subsidy())
+    epoch_starting_ordinal + (self - epoch_starting_height.n()).n() * epoch.subsidy()
   }
 }
 
@@ -95,20 +95,20 @@ mod tests {
 
   #[test]
   fn starting_ordinal() {
-    assert_eq!(Height(0).starting_ordinal().unwrap(), 0);
-    assert_eq!(Height(1).starting_ordinal().unwrap(), 5000000000);
+    assert_eq!(Height(0).starting_ordinal(), 0);
+    assert_eq!(Height(1).starting_ordinal(), 5000000000);
     assert_eq!(
-      Height(210000 - 1).starting_ordinal().unwrap(),
+      Height(210000 - 1).starting_ordinal(),
       (210000 - 1) * 5000000000
     );
+    assert_eq!(Height(210000).starting_ordinal(), 210000 * 5000000000);
     assert_eq!(
-      Height(210000).starting_ordinal().unwrap(),
-      210000 * 5000000000
+      Height(210000 + 1).starting_ordinal(),
+      210000 * 5000000000 + 2500000000
     );
     assert_eq!(
-      Height(210000 + 1).starting_ordinal().unwrap(),
-      210000 * 5000000000 + 2500000000
+      Height(u64::max_value()).starting_ordinal(),
+      *Epoch::STARTING_ORDINALS.last().unwrap()
     );
-    assert_eq!(Height(u64::max_value()).starting_ordinal(), None);
   }
 }

src/index.rs

@@ -51,7 +51,8 @@ impl Index {
       let mut coinbase_inputs = VecDeque::new();
 
       let h = Height(height);
-      if let Some(start) = h.starting_ordinal() {
+      if h.subsidy() > 0 {
+        let start = h.starting_ordinal();
         coinbase_inputs.push_front((start.n(), (start + h.subsidy()).n()));
       }
 

src/main.rs

@@ -5,7 +5,7 @@ use {
     consensus::{Decodable, Encodable},
     Block, Network, OutPoint, Transaction,
   },
-  derive_more::Display,
+  derive_more::{Display, FromStr},
   integer_cbrt::IntegerCubeRoot,
   integer_sqrt::IntegerSquareRoot,
   redb::{