Misc review comments

src/index.rs

@@ -48,7 +48,7 @@ mod updater;
 #[cfg(test)]
 pub(crate) mod testing;
 
-const SCHEMA_VERSION: u64 = 21;
+const SCHEMA_VERSION: u64 = 22;
 
 macro_rules! define_table {
   ($name:ident, $key:ty, $value:ty) => {
@@ -834,7 +834,7 @@ impl Index {
         .begin_read()?
         .open_table(RUNE_ID_TO_RUNE_ENTRY)?
         .get(&id.store())?
-        .map(|entry| RuneEntry::load(entry.value()).rune),
+        .map(|entry| RuneEntry::load(entry.value()).spaced_rune.rune),
     )
   }
 
@@ -909,17 +909,13 @@ impl Index {
     let mut balances = Vec::new();
     let mut i = 0;
     while i < balances_buffer.len() {
-      let (id, length) = runes::varint::decode(&balances_buffer[i..]);
+      let ((id, amount), length) = RuneId::decode_balance(&balances_buffer[i..]).unwrap();
       i += length;
-      let (amount, length) = runes::varint::decode(&balances_buffer[i..]);
-      i += length;
-
-      let id = RuneId::try_from(id).unwrap();
 
       let entry = RuneEntry::load(id_to_rune_entries.get(id.store())?.unwrap().value());
 
       balances.push((
-        entry.spaced_rune(),
+        entry.spaced_rune,
         Pile {
           amount,
           divisibility: entry.divisibility,
@@ -954,8 +950,8 @@ impl Index {
 
     for (rune_id, balances) in rune_balances_by_id {
       let RuneEntry {
-        rune,
         divisibility,
+        spaced_rune,
         symbol,
         ..
       } = RuneEntry::load(
@@ -966,7 +962,7 @@ impl Index {
       );
 
       rune_balances.insert(
-        rune,
+        spaced_rune.rune,
         balances
           .into_iter()
           .map(|(outpoint, amount)| {
@@ -1002,11 +998,9 @@ impl Index {
       let mut balances = Vec::new();
       let mut i = 0;
       while i < balances_buffer.len() {
-        let (id, length) = runes::varint::decode(&balances_buffer[i..]);
-        i += length;
-        let (balance, length) = runes::varint::decode(&balances_buffer[i..]);
+        let ((id, balance), length) = RuneId::decode_balance(&balances_buffer[i..]).unwrap();
         i += length;
-        balances.push((RuneId::try_from(id)?, balance));
+        balances.push((id, balance));
       }
 
       result.push((outpoint, balances));
@@ -1220,7 +1214,7 @@ impl Index {
     let rune_id_to_rune_entry = rtx.open_table(RUNE_ID_TO_RUNE_ENTRY)?;
     let entry = rune_id_to_rune_entry.get(&id.value())?.unwrap();
 
-    Ok(Some(RuneEntry::load(entry.value()).spaced_rune()))
+    Ok(Some(RuneEntry::load(entry.value()).spaced_rune))
   }
 
   pub(crate) fn get_inscription_ids_by_sat(&self, sat: Sat) -> Result<Vec<InscriptionId>> {
@@ -1588,7 +1582,7 @@ impl Index {
       return Ok(false);
     }
 
-    if usize::try_from(outpoint.vout).unwrap() >= info.vout.len() {
+    if outpoint.vout.into_usize() >= info.vout.len() {
       return Ok(false);
     }
 
@@ -1869,7 +1863,7 @@ impl Index {
     {
       let rune_id_to_rune_entry = rtx.open_table(RUNE_ID_TO_RUNE_ENTRY)?;
       let entry = rune_id_to_rune_entry.get(&rune_id.value())?.unwrap();
-      Some(RuneEntry::load(entry.value()).spaced_rune())
+      Some(RuneEntry::load(entry.value()).spaced_rune)
     } else {
       None
     };

src/index/entry.rs

@@ -57,8 +57,7 @@ pub struct RuneEntry {
   pub mints: u64,
   pub number: u64,
   pub premine: u128,
-  pub rune: Rune,
-  pub spacers: u32,
+  pub spaced_rune: SpacedRune,
   pub supply: u128,
   pub symbol: Option<char>,
   pub timestamp: u32,
@@ -67,18 +66,18 @@ pub struct RuneEntry {
 impl RuneEntry {
   pub fn mintable(&self, block_height: Height, block_time: u32) -> Result<u128, MintError> {
     let Some(mint) = self.mint else {
-      return Err(MintError::Unmintable(self.rune));
+      return Err(MintError::Unmintable(self.spaced_rune.rune));
     };
 
     if let Some(end) = mint.end {
       if block_height.0 >= end {
-        return Err(MintError::End((self.rune, end)));
+        return Err(MintError::End((self.spaced_rune.rune, end)));
       }
     }
 
     if let Some(deadline) = mint.deadline {
       if block_time >= deadline {
-        return Err(MintError::Deadline((self.rune, deadline)));
+        return Err(MintError::Deadline((self.spaced_rune.rune, deadline)));
       }
     }
 
@@ -94,8 +93,7 @@ pub(super) type RuneEntryValue = (
   u64,                    // mints
   u64,                    // number
   u128,                   // premine
-  u128,                   // rune
-  u32,                    // spacers
+  (u128, u32),            // spaced rune
   u128,                   // supply
   Option<char>,           // symbol
   u32,                    // timestamp
@@ -114,15 +112,6 @@ type MintEntryValue = (
   Option<u128>, // limit
 );
 
-impl RuneEntry {
-  pub(crate) fn spaced_rune(&self) -> SpacedRune {
-    SpacedRune {
-      rune: self.rune,
-      spacers: self.spacers,
-    }
-  }
-}
-
 impl Default for RuneEntry {
   fn default() -> Self {
     Self {
@@ -133,8 +122,7 @@ impl Default for RuneEntry {
       mints: 0,
       number: 0,
       premine: 0,
-      rune: Rune(0),
-      spacers: 0,
+      spaced_rune: SpacedRune::default(),
       supply: 0,
       symbol: None,
       timestamp: 0,
@@ -154,8 +142,7 @@ impl Entry for RuneEntry {
       mints,
       number,
       premine,
-      rune,
-      spacers,
+      (rune, spacers),
       supply,
       symbol,
       timestamp,
@@ -182,8 +169,10 @@ impl Entry for RuneEntry {
       mints,
       number,
       premine,
-      rune: Rune(rune),
-      spacers,
+      spaced_rune: SpacedRune {
+        rune: Rune(rune),
+        spacers,
+      },
       supply,
       symbol,
       timestamp,
@@ -217,16 +206,15 @@ impl Entry for RuneEntry {
       self.mints,
       self.number,
       self.premine,
-      self.rune.0,
-      self.spacers,
+      (self.spaced_rune.rune.0, self.spaced_rune.spacers),
       self.supply,
       self.symbol,
       self.timestamp,
     )
   }
 }
 
-pub(super) type RuneIdValue = (u32, u16);
+pub(super) type RuneIdValue = (u32, u32);
 
 impl Entry for RuneId {
   type Value = RuneIdValue;
@@ -531,8 +519,10 @@ mod tests {
       mints: 11,
       number: 6,
       premine: 12,
-      rune: Rune(7),
-      spacers: 8,
+      spaced_rune: SpacedRune {
+        rune: Rune(7),
+        spacers: 8,
+      },
       supply: 9,
       symbol: Some('a'),
       timestamp: 10,
@@ -549,8 +539,7 @@ mod tests {
       11,
       6,
       12,
-      7,
-      8,
+      (7, 8),
       9,
       Some('a'),
       10,

src/index/updater.rs

@@ -608,7 +608,7 @@ impl<'index> Updater<'index> {
       };
 
       for (i, (tx, txid)) in block.txdata.iter().enumerate() {
-        rune_updater.index_runes(i, tx, *txid)?;
+        rune_updater.index_runes(u32::try_from(i).unwrap(), tx, *txid)?;
       }
 
       for (rune_id, update) in rune_updater.updates {