Show origin and inscription on /rune page

src/index.rs

@@ -848,6 +848,17 @@ impl Index {
     }))
   }
 
+  pub(crate) fn inscription_exists(&self, inscription_id: InscriptionId) -> Result<bool> {
+    Ok(
+      self
+        .database
+        .begin_read()?
+        .open_table(INSCRIPTION_ID_TO_SATPOINT)?
+        .get(&inscription_id.store())?
+        .is_some(),
+    )
+  }
+
   pub(crate) fn get_inscriptions_on_output_with_satpoints(
     &self,
     outpoint: OutPoint,

src/index/entry.rs

@@ -26,20 +26,31 @@ impl Entry for BlockHash {
 pub(crate) struct RuneEntry {
   pub(crate) burned: u128,
   pub(crate) divisibility: u8,
+  pub(crate) etching: Txid,
   pub(crate) rarity: Rarity,
   pub(crate) rune: Rune,
   pub(crate) supply: u128,
 }
 
-pub(super) type RuneEntryValue = (u128, u8, u8, u128, u128);
+pub(super) type RuneEntryValue = (u128, u8, (u128, u128), u8, u128, u128);
 
 impl Entry for RuneEntry {
   type Value = RuneEntryValue;
 
-  fn load((burned, divisibility, rarity, rune, supply): RuneEntryValue) -> Self {
+  fn load((burned, divisibility, etching, rarity, rune, supply): RuneEntryValue) -> Self {
     Self {
       burned,
       divisibility,
+      etching: {
+        let low = etching.0.to_le_bytes();
+        let high = etching.1.to_le_bytes();
+        Txid::from_byte_array([
+          low[0], low[1], low[2], low[3], low[4], low[5], low[6], low[7], low[8], low[9], low[10],
+          low[11], low[12], low[13], low[14], low[15], high[0], high[1], high[2], high[3], high[4],
+          high[5], high[6], high[7], high[8], high[9], high[10], high[11], high[12], high[13],
+          high[14], high[15],
+        ])
+      },
       rarity: Rarity::try_from(rarity).unwrap(),
       rune: Rune(rune),
       supply,
@@ -50,6 +61,19 @@ impl Entry for RuneEntry {
     (
       self.burned,
       self.divisibility,
+      {
+        let bytes = self.etching.to_byte_array();
+        (
+          u128::from_le_bytes([
+            bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
+            bytes[8], bytes[9], bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15],
+          ]),
+          u128::from_le_bytes([
+            bytes[16], bytes[17], bytes[18], bytes[19], bytes[20], bytes[21], bytes[22], bytes[23],
+            bytes[24], bytes[25], bytes[26], bytes[27], bytes[28], bytes[29], bytes[30], bytes[31],
+          ]),
+        )
+      },
       self.rarity.into(),
       self.rune.0,
       self.supply,
@@ -372,14 +396,45 @@ mod tests {
     let rune_entry = RuneEntry {
       burned: 1,
       divisibility: 2,
+      etching: Txid::from_byte_array([
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
+        0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
+        0x1E, 0x1F,
+      ]),
       rarity: Rarity::Epic,
       rune: Rune(4),
       supply: 5,
     };
 
-    assert_eq!(rune_entry.store(), (1, 2, 3, 4, 5));
+    assert_eq!(
+      rune_entry.store(),
+      (
+        1,
+        2,
+        (
+          0x0F0E0D0C0B0A09080706050403020100,
+          0x1F1E1D1C1B1A19181716151413121110
+        ),
+        3,
+        4,
+        5,
+      )
+    );
 
-    assert_eq!(RuneEntry::load((1, 2, 3, 4, 5)), rune_entry);
+    assert_eq!(
+      RuneEntry::load((
+        1,
+        2,
+        (
+          0x0F0E0D0C0B0A09080706050403020100,
+          0x1F1E1D1C1B1A19181716151413121110
+        ),
+        3,
+        4,
+        5,
+      )),
+      rune_entry
+    );
   }
 
   #[test]

src/index/updater/rune_updater.rs

@@ -80,10 +80,10 @@ impl<'a, 'db, 'tx> RuneUpdater<'a, 'db, 'tx> {
             // ignored.
             match u16::try_from(index) {
               Ok(index) => Some(Allocation {
-                id: u128::from(self.height) << 16 | u128::from(index),
                 balance: u128::max_value(),
-                rune: etching.rune,
                 divisibility: etching.divisibility,
+                id: u128::from(self.height) << 16 | u128::from(index),
+                rune: etching.rune,
               }),
               Err(_) => None,
             }
@@ -128,10 +128,10 @@ impl<'a, 'db, 'tx> RuneUpdater<'a, 'db, 'tx> {
       }
 
       if let Some(Allocation {
-        id,
         balance,
-        rune,
         divisibility,
+        id,
+        rune,
       }) = allocation
       {
         // Calculate the allocated supply
@@ -145,14 +145,15 @@ impl<'a, 'db, 'tx> RuneUpdater<'a, 'db, 'tx> {
             id.store(),
             RuneEntry {
               burned: 0,
+              divisibility,
+              etching: txid,
               rarity: if self.count == 0 {
                 self.rarity
               } else {
                 Rarity::Common
               },
               rune,
               supply,
-              divisibility,
             }
             .store(),
           )?;