From 3d8554baec23e0a593835e0889358fa3218a2781 Mon Sep 17 00:00:00 2001
From: raphjaph <raphjaph@protonmail.com>
Date: Thu, 19 Dec 2024 19:58:29 -0500
Subject: [PATCH] Fix other spots

---
 src/api.rs               |  4 +-
 src/index.rs             | 87 ++++++++++++++++++++++++----------------
 src/subcommand/server.rs |  2 +
 src/templates/address.rs | 10 ++---
 templates/address.html   | 10 +++--
 5 files changed, 68 insertions(+), 45 deletions(-)

diff --git a/src/api.rs b/src/api.rs
index b780c07eb7..5b335c48e0 100644
--- a/src/api.rs
+++ b/src/api.rs
@@ -229,7 +229,7 @@ pub struct SatInscriptions {
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 pub struct AddressInfo {
   pub outputs: Vec<OutPoint>,
-  pub inscriptions: Vec<InscriptionId>,
+  pub inscriptions: Option<Vec<InscriptionId>>,
   pub sat_balance: u64,
-  pub runes_balances: Vec<(SpacedRune, Decimal, Option<char>)>,
+  pub runes_balances: Option<Vec<(SpacedRune, Decimal, Option<char>)>>,
 }
diff --git a/src/index.rs b/src/index.rs
index 830c8b412b..1b59f97bf2 100644
--- a/src/index.rs
+++ b/src/index.rs
@@ -1538,7 +1538,11 @@ impl Index {
   pub fn get_inscriptions_on_output_with_satpoints(
     &self,
     outpoint: OutPoint,
-  ) -> Result<Vec<(SatPoint, InscriptionId)>> {
+  ) -> Result<Option<Vec<(SatPoint, InscriptionId)>>> {
+    if !self.index_inscriptions {
+      return Ok(None);
+    }
+
     let rtx = self.database.begin_read()?;
     let outpoint_to_utxo_entry = rtx.open_table(OUTPOINT_TO_UTXO_ENTRY)?;
     let sequence_number_to_inscription_entry =
@@ -1562,6 +1566,7 @@ impl Index {
     Ok(Some(
       self
         .get_inscriptions_on_output_with_satpoints(outpoint)?
+        .unwrap_or_default()
         .iter()
         .map(|(_satpoint, inscription_id)| *inscription_id)
         .collect(),
@@ -1571,18 +1576,23 @@ impl Index {
   pub fn get_inscriptions_for_outputs(
     &self,
     outpoints: &Vec<OutPoint>,
-  ) -> Result<Vec<InscriptionId>> {
+  ) -> Result<Option<Vec<InscriptionId>>> {
+    if !self.index_inscriptions {
+      return Ok(None);
+    }
+
     let mut inscriptions = Vec::new();
     for outpoint in outpoints {
       inscriptions.extend(
         self
           .get_inscriptions_on_output_with_satpoints(*outpoint)?
+          .unwrap_or_default()
           .iter()
           .map(|(_satpoint, inscription_id)| *inscription_id),
       );
     }
 
-    Ok(inscriptions)
+    Ok(Some(inscriptions))
   }
 
   pub fn get_transaction(&self, txid: Txid) -> Result<Option<Transaction>> {
@@ -2258,29 +2268,31 @@ impl Index {
     outpoint_to_utxo_entry: &'a impl ReadableTable<&'static OutPointValue, &'static UtxoEntry>,
     sequence_number_to_inscription_entry: &'a impl ReadableTable<u32, InscriptionEntryValue>,
     outpoint: OutPoint,
-  ) -> Result<Vec<(SatPoint, InscriptionId)>> {
+  ) -> Result<Option<Vec<(SatPoint, InscriptionId)>>> {
     if !self.index_inscriptions {
-      return Ok(Vec::new());
+      return Ok(None);
     }
 
     let Some(utxo_entry) = outpoint_to_utxo_entry.get(&outpoint.store())? else {
-      return Ok(Vec::new());
+      return Ok(Some(Vec::new()));
     };
 
     let mut inscriptions = utxo_entry.value().parse(self).parse_inscriptions();
 
     inscriptions.sort_by_key(|(sequence_number, _)| *sequence_number);
 
-    inscriptions
-      .into_iter()
-      .map(|(sequence_number, offset)| {
-        let entry = sequence_number_to_inscription_entry
-          .get(sequence_number)?
-          .unwrap();
-        let satpoint = SatPoint { outpoint, offset };
-        Ok((satpoint, InscriptionEntry::load(entry.value()).id))
-      })
-      .collect::<Result<_>>()
+    let mut result = Vec::new();
+    for (sequence_number, offset) in inscriptions.into_iter() {
+      let entry = sequence_number_to_inscription_entry
+        .get(sequence_number)?
+        .unwrap();
+
+      let satpoint = SatPoint { outpoint, offset };
+
+      result.push((satpoint, InscriptionEntry::load(entry.value()).id))
+    }
+
+    Ok(Some(result))
   }
 
   pub fn get_address_info(&self, address: &Address) -> Result<Vec<OutPoint>> {
@@ -2300,35 +2312,37 @@ impl Index {
   pub(crate) fn get_aggregated_rune_balances_for_outputs(
     &self,
     outputs: &Vec<OutPoint>,
-  ) -> Result<Vec<(SpacedRune, Decimal, Option<char>)>> {
+  ) -> Result<Option<Vec<(SpacedRune, Decimal, Option<char>)>>> {
     let mut runes = BTreeMap::new();
 
     for output in outputs {
-      if let Some(rune_balances) = self.get_rune_balances_for_output(*output)? {
-        for (spaced_rune, pile) in rune_balances {
-          runes
-            .entry(spaced_rune)
-            .and_modify(|(decimal, _symbol): &mut (Decimal, Option<char>)| {
-              assert_eq!(decimal.scale, pile.divisibility);
-              decimal.value += pile.amount;
-            })
-            .or_insert((
-              Decimal {
-                value: pile.amount,
-                scale: pile.divisibility,
-              },
-              pile.symbol,
-            ));
-        }
+      let Some(rune_balances) = self.get_rune_balances_for_output(*output)? else {
+        return Ok(None);
+      };
+
+      for (spaced_rune, pile) in rune_balances {
+        runes
+          .entry(spaced_rune)
+          .and_modify(|(decimal, _symbol): &mut (Decimal, Option<char>)| {
+            assert_eq!(decimal.scale, pile.divisibility);
+            decimal.value += pile.amount;
+          })
+          .or_insert((
+            Decimal {
+              value: pile.amount,
+              scale: pile.divisibility,
+            },
+            pile.symbol,
+          ));
       }
     }
 
-    Ok(
+    Ok(Some(
       runes
         .into_iter()
         .map(|(spaced_rune, (decimal, symbol))| (spaced_rune, decimal, symbol))
         .collect(),
-    )
+    ))
   }
 
   pub(crate) fn get_sat_balances_for_outputs(&self, outputs: &Vec<OutPoint>) -> Result<u64> {
@@ -4436,6 +4450,7 @@ mod tests {
           .index
           .get_inscriptions_on_output_with_satpoints(OutPoint { txid, vout: 0 })
           .unwrap()
+          .unwrap_or_default()
           .iter()
           .map(|(_satpoint, inscription_id)| *inscription_id)
           .collect::<Vec<InscriptionId>>()
@@ -4500,6 +4515,7 @@ mod tests {
           .index
           .get_inscriptions_on_output_with_satpoints(OutPoint { txid, vout: 0 })
           .unwrap()
+          .unwrap_or_default()
       )
     }
   }
@@ -4549,6 +4565,7 @@ mod tests {
             vout: 0
           })
           .unwrap()
+          .unwrap_or_default()
       )
     }
   }
diff --git a/src/subcommand/server.rs b/src/subcommand/server.rs
index 28c0aa38bd..cdbaf763b2 100644
--- a/src/subcommand/server.rs
+++ b/src/subcommand/server.rs
@@ -758,6 +758,7 @@ impl Server {
           OutputType::Cardinal => {
             index
               .get_inscriptions_on_output_with_satpoints(output)?
+              .unwrap_or_default()
               .is_empty()
               && index
                 .get_rune_balances_for_output(output)?
@@ -766,6 +767,7 @@ impl Server {
           }
           OutputType::Inscribed => !index
             .get_inscriptions_on_output_with_satpoints(output)?
+            .unwrap_or_default()
             .is_empty(),
           OutputType::Runic => !index
             .get_rune_balances_for_output(output)?
diff --git a/src/templates/address.rs b/src/templates/address.rs
index 6eb8ebe5e0..9b9214ea30 100644
--- a/src/templates/address.rs
+++ b/src/templates/address.rs
@@ -4,9 +4,9 @@ use super::*;
 pub(crate) struct AddressHtml {
   pub(crate) address: Address,
   pub(crate) outputs: Vec<OutPoint>,
-  pub(crate) inscriptions: Vec<InscriptionId>,
+  pub(crate) inscriptions: Option<Vec<InscriptionId>>,
   pub(crate) sat_balance: u64,
-  pub(crate) runes_balances: Vec<(SpacedRune, Decimal, Option<char>)>,
+  pub(crate) runes_balances: Option<Vec<(SpacedRune, Decimal, Option<char>)>>,
 }
 
 impl PageContent for AddressHtml {
@@ -26,9 +26,9 @@ mod tests {
         .require_network(Network::Bitcoin)
         .unwrap(),
       outputs: vec![outpoint(1), outpoint(2)],
-      inscriptions: vec![inscription_id(1)],
+      inscriptions: Some(vec![inscription_id(1)]),
       sat_balance: 99,
-      runes_balances: vec![
+      runes_balances: Some(vec![
         (
           SpacedRune {
             rune: Rune::from_str("TEEEEEEEEESTRUNE").unwrap(),
@@ -51,7 +51,7 @@ mod tests {
           },
           Some('F'),
         ),
-      ],
+      ]),
     }
   }
 
diff --git a/templates/address.html b/templates/address.html
index 6b7146ae65..883da13ee8 100644
--- a/templates/address.html
+++ b/templates/address.html
@@ -2,21 +2,25 @@ <h1>Address {{ self.address }}</h1>
 <dl>
   <dt>sat balance</dt>
   <dd>{{ self.sat_balance }}</dd>
-%% if !self.inscriptions.is_empty() {
+%% let inscriptions = self.inscriptions.clone().unwrap_or_default();
+%% if !inscriptions.is_empty() {
   <dt>inscriptions</dt>
   <dd class=thumbnails>
-%% for inscription in &self.inscriptions {
+%% for inscription in &inscriptions {
     {{Iframe::thumbnail(*inscription)}}
 %% }
   </dd>
 %% }
+%% let runes_balances = self.runes_balances.clone().unwrap_or_default();
+%% if !runes_balances.is_empty() {
   <dt>runes balances</dt>
-%% for (rune, decimal, symbol) in self.runes_balances.iter() {
+%% for (rune, decimal, symbol) in runes_balances.iter() {
 %% if let Some(symbol) = symbol {
   <dd><a class=monospace href=/rune/{{ rune }}>{{ rune }}</a>: {{ decimal }}{{ symbol }}</dd>
 %% } else {
   <dd><a class=monospace href=/rune/{{ rune }}>{{ rune }}</a>: {{ decimal }}¤</dd>
 %% }
+%% }
 %% }
   <dt>outputs</dt>
   <dd>