JSON for everyone

src/lib.rs

@@ -23,12 +23,9 @@ use {
     inscription::Inscription,
     inscription_id::InscriptionId,
     media::Media,
-    object::Object,
     options::Options,
     outgoing::Outgoing,
-    rarity::Rarity,
     representation::Representation,
-    sat::Sat,
     subcommand::Subcommand,
     tally::Tally,
   },
@@ -74,7 +71,7 @@ use {
 };
 
 pub use crate::{
-  fee_rate::FeeRate, sat_point::SatPoint,
+  fee_rate::FeeRate, object::Object, rarity::Rarity, sat::Sat, sat_point::SatPoint,
   subcommand::wallet::transaction_builder::TransactionBuilder,
 };
 

src/object.rs

@@ -1,7 +1,7 @@
 use super::*;
 
 #[derive(Debug, PartialEq)]
-pub(crate) enum Object {
+pub enum Object {
   Address(Address),
   Hash([u8; 32]),
   InscriptionId(InscriptionId),
@@ -50,6 +50,24 @@ impl Display for Object {
   }
 }
 
+impl Serialize for Object {
+  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+  where
+    S: Serializer,
+  {
+    serializer.collect_str(self)
+  }
+}
+
+impl<'de> Deserialize<'de> for Object {
+  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+  where
+    D: Deserializer<'de>,
+  {
+    Ok(DeserializeFromStr::deserialize(deserializer)?.0)
+  }
+}
+
 #[cfg(test)]
 mod tests {
   use super::*;

src/sat.rs

@@ -2,7 +2,7 @@ use super::*;
 
 #[derive(Copy, Clone, Eq, PartialEq, Debug, Display, Ord, PartialOrd, Deserialize, Serialize)]
 #[serde(transparent)]
-pub struct Sat(pub(crate) u64);
+pub struct Sat(pub u64);
 
 impl Sat {
   pub(crate) const LAST: Self = Self(Self::SUPPLY - 1);

src/subcommand.rs

@@ -1,16 +1,16 @@
 use super::*;
 
-mod epochs;
-mod find;
+pub mod epochs;
+pub mod find;
 mod index;
-mod info;
-mod list;
-mod parse;
+pub mod info;
+pub mod list;
+pub mod parse;
 mod preview;
 mod server;
-mod subsidy;
-mod supply;
-mod traits;
+pub mod subsidy;
+pub mod supply;
+pub mod traits;
 pub mod wallet;
 
 fn print_json(output: impl Serialize) -> Result {

src/subcommand/epochs.rs

@@ -1,8 +1,17 @@
 use super::*;
 
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct Output {
+  pub starting_sats: Vec<Sat>,
+}
+
 pub(crate) fn run() -> Result {
+  let mut starting_sats = Vec::new();
   for sat in Epoch::STARTING_SATS {
-    println!("{}", sat);
+    starting_sats.push(sat);
   }
+
+  print_json(Output { starting_sats })?;
+
   Ok(())
 }

src/subcommand/find.rs

@@ -6,6 +6,11 @@ pub(crate) struct Find {
   sat: Sat,
 }
 
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct Output {
+  pub satpoint: SatPoint,
+}
+
 impl Find {
   pub(crate) fn run(self, options: Options) -> Result {
     let index = Index::open(&options)?;
@@ -14,7 +19,7 @@ impl Find {
 
     match index.find(self.sat.0)? {
       Some(satpoint) => {
-        println!("{satpoint}");
+        print_json(Output { satpoint })?;
         Ok(())
       }
       None => Err(anyhow!("sat has not been mined as of index height")),

src/subcommand/info.rs

@@ -6,26 +6,33 @@ pub(crate) struct Info {
   transactions: bool,
 }
 
+#[derive(Serialize, Deserialize)]
+pub struct TransactionsOutput {
+  pub start: u64,
+  pub end: u64,
+  pub count: u64,
+  pub elapsed: f64,
+}
+
 impl Info {
   pub(crate) fn run(self, options: Options) -> Result {
     let index = Index::open(&options)?;
     index.update()?;
     let info = index.info()?;
 
     if self.transactions {
-      println!("start\tend\tcount\telapsed");
-
+      let mut output = Vec::new();
       for window in info.transactions.windows(2) {
         let start = &window[0];
         let end = &window[1];
-        println!(
-          "{}\t{}\t{}\t{:.2}",
-          start.starting_block_count,
-          end.starting_block_count,
-          end.starting_block_count - start.starting_block_count,
-          (end.starting_timestamp - start.starting_timestamp) as f64 / 1000.0 / 60.0
-        );
+        output.push(TransactionsOutput {
+          start: start.starting_block_count,
+          end: end.starting_block_count,
+          count: end.starting_block_count - start.starting_block_count,
+          elapsed: (end.starting_timestamp - start.starting_timestamp) as f64 / 1000.0 / 60.0,
+        });
       }
+      print_json(output)?;
     } else {
       print_json(info)?;
     }

src/subcommand/list.rs

@@ -6,6 +6,15 @@ pub(crate) struct List {
   outpoint: OutPoint,
 }
 
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct Output {
+  pub output: OutPoint,
+  pub start: u64,
+  pub size: u64,
+  pub rarity: Rarity,
+  pub name: String,
+}
+
 impl List {
   pub(crate) fn run(self, options: Options) -> Result {
     let index = Index::open(&options)?;
@@ -14,10 +23,19 @@ impl List {
 
     match index.list(self.outpoint)? {
       Some(crate::index::List::Unspent(ranges)) => {
+        let mut outputs = Vec::new();
         for (output, start, size, rarity, name) in list(self.outpoint, ranges) {
-          println!("{output}\t{start}\t{size}\t{rarity}\t{name}");
+          outputs.push(Output {
+            output,
+            start,
+            size,
+            rarity,
+            name,
+          });
         }
 
+        print_json(outputs)?;
+
         Ok(())
       }
       Some(crate::index::List::Spent) => Err(anyhow!("output spent.")),

src/subcommand/parse.rs

@@ -6,9 +6,16 @@ pub(crate) struct Parse {
   object: Object,
 }
 
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct Output {
+  pub object: Object,
+}
+
 impl Parse {
   pub(crate) fn run(self) -> Result {
-    println!("{}", self.object);
+    print_json(Output {
+      object: self.object,
+    })?;
     Ok(())
   }
 }

src/subcommand/subsidy.rs

@@ -6,6 +6,13 @@ pub(crate) struct Subsidy {
   height: Height,
 }
 
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct Output {
+  pub first: u64,
+  pub subsidy: u64,
+  pub name: String,
+}
+
 impl Subsidy {
   pub(crate) fn run(self) -> Result {
     let first = self.height.starting_sat();
@@ -16,7 +23,11 @@ impl Subsidy {
       bail!("block {} has no subsidy", self.height);
     }
 
-    println!("{}\t{}\t{}", first, self.height.subsidy(), first.name());
+    print_json(Output {
+      first: first.0,
+      subsidy,
+      name: first.name(),
+    })?;
 
     Ok(())
   }

src/subcommand/supply.rs

@@ -1,5 +1,13 @@
 use super::*;
 
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct Output {
+  pub supply: u64,
+  pub first: u64,
+  pub last: u64,
+  pub last_mined_in_block: u64,
+}
+
 pub(crate) fn run() -> Result {
   let mut last = 0;
 
@@ -10,10 +18,12 @@ pub(crate) fn run() -> Result {
     last += 1;
   }
 
-  println!("supply: {}", Sat::SUPPLY);
-  println!("first: {}", 0);
-  println!("last: {}", Sat::SUPPLY - 1);
-  println!("last mined in block: {}", last);
+  print_json(Output {
+    supply: Sat::SUPPLY,
+    first: 0,
+    last: Sat::SUPPLY - 1,
+    last_mined_in_block: last,
+  })?;
 
   Ok(())
 }

src/subcommand/traits.rs

@@ -6,71 +6,35 @@ pub(crate) struct Traits {
   sat: Sat,
 }
 
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct Output {
+  pub number: u64,
+  pub decimal: String,
+  pub degree: String,
+  pub name: String,
+  pub height: u64,
+  pub cycle: u64,
+  pub epoch: u64,
+  pub period: u64,
+  pub offset: u64,
+  pub rarity: Rarity,
+}
+
 impl Traits {
   pub(crate) fn run(self) -> Result {
-    print!("{}", self);
-    Ok(())
-  }
-}
+    print_json(Output {
+      number: self.sat.n(),
+      decimal: self.sat.decimal().to_string(),
+      degree: self.sat.degree().to_string(),
+      name: self.sat.name(),
+      height: self.sat.height().0,
+      cycle: self.sat.cycle(),
+      epoch: self.sat.epoch().0,
+      period: self.sat.period(),
+      offset: self.sat.third(),
+      rarity: self.sat.rarity(),
+    })?;
 
-impl Display for Traits {
-  fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-    writeln!(f, "number: {}", self.sat.n())?;
-    writeln!(f, "decimal: {}", self.sat.decimal())?;
-    writeln!(f, "degree: {}", self.sat.degree())?;
-    writeln!(f, "name: {}", self.sat.name())?;
-    writeln!(f, "height: {}", self.sat.height())?;
-    writeln!(f, "cycle: {}", self.sat.cycle())?;
-    writeln!(f, "epoch: {}", self.sat.epoch())?;
-    writeln!(f, "period: {}", self.sat.period())?;
-    writeln!(f, "offset: {}", self.sat.third())?;
-    writeln!(f, "rarity: {}", self.sat.rarity())?;
     Ok(())
   }
 }
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-
-  #[test]
-  fn first() {
-    assert_eq!(
-      Traits { sat: Sat(0) }.to_string(),
-      "\
-number: 0
-decimal: 0.0
-degree: 0°0′0″0‴
-name: nvtdijuwxlp
-height: 0
-cycle: 0
-epoch: 0
-period: 0
-offset: 0
-rarity: mythic
-",
-    );
-  }
-
-  #[test]
-  fn last() {
-    assert_eq!(
-      Traits {
-        sat: Sat(2099999997689999)
-      }
-      .to_string(),
-      "\
-number: 2099999997689999
-decimal: 6929999.0
-degree: 5°209999′1007″0‴
-name: a
-height: 6929999
-cycle: 5
-epoch: 32
-period: 3437
-offset: 0
-rarity: uncommon
-",
-    );
-  }
-}

tests/command_builder.rs

@@ -61,13 +61,6 @@ impl CommandBuilder {
     }
   }
 
-  pub(crate) fn expected_stdout(self, expected_stdout: impl AsRef<str>) -> Self {
-    Self {
-      expected_stdout: Expected::String(expected_stdout.as_ref().to_owned()),
-      ..self
-    }
-  }
-
   pub(crate) fn stdout_regex(self, expected_stdout: impl AsRef<str>) -> Self {
     Self {
       expected_stdout: Expected::regex(expected_stdout.as_ref()),