Move runes types into ordinals crate (ordinals#3391)

Cargo.toml

@@ -79,10 +79,6 @@ reqwest = { version = "0.11.10", features = ["blocking", "brotli", "json"] }
 test-bitcoincore-rpc = { path = "crates/test-bitcoincore-rpc" }
 unindent = "0.2.1"
 
-[[bench]]
-name = "server"
-harness = false
-
 [[bin]]
 name = "ord"
 path = "src/bin/main.rs"

crates/ordinals/Cargo.toml

@@ -17,3 +17,4 @@ thiserror = "1.0.56"
 
 [dev-dependencies]
 serde_json = { version = "1.0.81", features = ["preserve_order"] }
+pretty_assertions = "1.2.1"

crates/ordinals/src/cenotaph.rs

@@ -0,0 +1,63 @@
+use super::*;
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum Cenotaph {
+ EdictOutput,
+ EdictRuneId,
+ Opcode,
+ SupplyOverflow,
+ TrailingIntegers,
+ TruncatedField,
+ UnrecognizedEvenTag,
+ UnrecognizedFlag,
+ Varint,
+}
+
+impl Cenotaph {
+ pub const ALL: [Self; 9] = [
+ Self::EdictOutput,
+ Self::EdictRuneId,
+ Self::Opcode,
+ Self::SupplyOverflow,
+ Self::TrailingIntegers,
+ Self::TruncatedField,
+ Self::UnrecognizedEvenTag,
+ Self::UnrecognizedFlag,
+ Self::Varint,
+ ];
+
+ pub fn flag(self) -> u32 {
+ 1 << (self as u32)
+ }
+}
+
+impl Display for Cenotaph {
+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::EdictOutput => write!(f, "edict output greater than transaction output count"),
+ Self::EdictRuneId => write!(f, "invalid rune ID in edict"),
+ Self::Opcode => write!(f, "non-pushdata opcode in OP_RETURN"),
+ Self::SupplyOverflow => write!(f, "supply overflows u128"),
+ Self::TrailingIntegers => write!(f, "trailing integers in body"),
+ Self::TruncatedField => write!(f, "field with missing value"),
+ Self::UnrecognizedEvenTag => write!(f, "unrecognized even tag"),
+ Self::UnrecognizedFlag => write!(f, "unrecognized field"),
+ Self::Varint => write!(f, "invalid varint"),
+ }
+ }
+}
+
+impl From<Cenotaph> for Runestone {
+ fn from(cenotaph: Cenotaph) -> Self {
+ Self {
+ cenotaph: cenotaph.flag(),
+ ..default()
+ }
+ }
+}
+
+impl From<Cenotaph> for u32 {
+ fn from(cenotaph: Cenotaph) -> Self {
+ cenotaph.flag()
+ }
+}

crates/ordinals/src/charm.rs

@@ -17,7 +17,7 @@ pub enum Charm {
 }
 
 impl Charm {
- pub const ALL: [Charm; 12] = [
+ pub const ALL: [Self; 12] = [
  Self::Coin,
  Self::Uncommon,
  Self::Rare,
@@ -67,9 +67,8 @@ impl Charm {
 
  pub fn charms(charms: u16) -> Vec<Charm> {
  Self::ALL
- .iter()
+ .into_iter()
  .filter(|charm| charm.is_set(charms))
- .copied()
  .collect()
  }
 }

src/runes/edict.rs → crates/ordinals/src/edict.rs

@@ -8,12 +8,7 @@ pub struct Edict {
 }
 
 impl Edict {
- pub(crate) fn from_integers(
- tx: &Transaction,
- id: RuneId,
- amount: u128,
- output: u128,
- ) -> Option<Self> {
+ pub fn from_integers(tx: &Transaction, id: RuneId, amount: u128, output: u128) -> Option<Self> {
  let Ok(output) = u32::try_from(output) else {
  return None;
  };

crates/ordinals/src/etching.rs

@@ -0,0 +1,39 @@
+use super::*;
+
+#[derive(Default, Serialize, Deserialize, Debug, PartialEq, Copy, Clone, Eq)]
+pub struct Etching {
+ pub divisibility: Option<u8>,
+ pub premine: Option<u128>,
+ pub rune: Option<Rune>,
+ pub spacers: Option<u32>,
+ pub symbol: Option<char>,
+ pub terms: Option<Terms>,
+}
+
+impl Etching {
+ pub const MAX_DIVISIBILITY: u8 = 38;
+ pub const MAX_SPACERS: u32 = 0b00000111_11111111_11111111_11111111;
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn max_spacers() {
+ let mut rune = String::new();
+
+ for (i, c) in Rune(u128::MAX).to_string().chars().enumerate() {
+ if i > 0 {
+ rune.push('•');
+ }
+
+ rune.push(c);
+ }
+
+ assert_eq!(
+ Etching::MAX_SPACERS,
+ rune.parse::<SpacedRune>().unwrap().spacers
+ );
+ }
+}

crates/ordinals/src/lib.rs

@@ -1,16 +1,21 @@
-//! Types for interoperating with ordinals and inscriptions.
+//! Types for interoperating with ordinals, inscriptions, and runes.
 
 use {
- bitcoin::constants::{COIN_VALUE, DIFFCHANGE_INTERVAL, SUBSIDY_HALVING_INTERVAL},
  bitcoin::{
  consensus::{Decodable, Encodable},
- OutPoint,
+ constants::{
+ COIN_VALUE, DIFFCHANGE_INTERVAL, MAX_SCRIPT_ELEMENT_SIZE, SUBSIDY_HALVING_INTERVAL,
+ },
+ opcodes,
+ script::{self, Instruction},
+ Network, OutPoint, ScriptBuf, Transaction,
  },
  derive_more::{Display, FromStr},
  serde::{Deserialize, Serialize},
  serde_with::{DeserializeFromStr, SerializeDisplay},
  std::{
  cmp,
+ collections::{HashMap, VecDeque},
  fmt::{self, Display, Formatter},
  io,
  num::ParseIntError,
@@ -20,18 +25,34 @@ use {
  thiserror::Error,
 };
 
-pub const CYCLE_EPOCHS: u32 = 6;
-
 pub use {
- charm::Charm, decimal_sat::DecimalSat, degree::Degree, epoch::Epoch, height::Height,
- rarity::Rarity, sat::Sat, sat_point::SatPoint,
+ cenotaph::Cenotaph, charm::Charm, decimal_sat::DecimalSat, degree::Degree, edict::Edict,
+ epoch::Epoch, etching::Etching, height::Height, pile::Pile, rarity::Rarity, rune::Rune,
+ rune_id::RuneId, runestone::Runestone, sat::Sat, sat_point::SatPoint, spaced_rune::SpacedRune,
+ terms::Terms,
 };
 
+pub const CYCLE_EPOCHS: u32 = 6;
+
+fn default<T: Default>() -> T {
+ Default::default()
+}
+
+mod cenotaph;
 mod charm;
 mod decimal_sat;
 mod degree;
+mod edict;
 mod epoch;
+mod etching;
 mod height;
+mod pile;
 mod rarity;
+mod rune;
+mod rune_id;
+mod runestone;
 mod sat;
 mod sat_point;
+mod spaced_rune;
+mod terms;
+pub mod varint;

src/runes/pile.rs → crates/ordinals/src/pile.rs

@@ -131,7 +131,7 @@ mod tests {
  assert_eq!(
  Pile {
  amount: u128::MAX,
- divisibility: MAX_DIVISIBILITY,
+ divisibility: 38,
  symbol: None,
  }
  .to_string(),