test

src/index.rs

@@ -2027,18 +2027,23 @@ impl Index {
     &self,
     address: Address,
   ) -> Result<Vec<InscriptionId>> {
-    Ok(
-      self
-        .database
-        .begin_read()?
-        .open_table(ADDRESS_TO_INSCRIPTION_IDS)?
-        .get(address.to_string().as_bytes())?
-        .unwrap()
-        .value()
-        .iter()
-        .map(|entry| InscriptionId::load(*entry))
-        .collect(),
-    )
+    let entry = self
+      .database
+      .begin_read()?
+      .open_table(ADDRESS_TO_INSCRIPTION_IDS)?
+      .get(address.to_string().as_bytes())?;
+
+    if let Some(entry) = entry {
+      return Ok(
+        entry
+          .value()
+          .iter()
+          .map(|entry| InscriptionId::load(*entry))
+          .collect(),
+      );
+    }
+
+    Ok(vec![])
   }
 
   fn inscriptions_on_output<'a: 'tx, 'tx>(
@@ -6214,4 +6219,104 @@ mod tests {
       }
     );
   }
+
+  #[test]
+  fn inscription_get_attached_to_address() {
+    let context = Context::builder()
+      .arg("--index-sats")
+      .arg("--index-transactions")
+      .arg("--index-addresses")
+      .build();
+
+    context.mine_blocks(1);
+
+    let txid = context.rpc_server.broadcast_tx(TransactionTemplate {
+      inputs: &[(1, 0, 0, inscription("text/plain", "hello").to_witness())],
+      ..Default::default()
+    });
+
+    let inscription_id = InscriptionId { txid, index: 0 };
+
+    assert_eq!(
+      context
+        .index
+        .get_inscriptions_on_output(OutPoint { txid, vout: 0 })
+        .unwrap(),
+      []
+    );
+
+    context.mine_blocks(1);
+
+    {
+      let transaction = context.index.get_transaction(txid).unwrap().unwrap();
+
+      let address = context
+        .index
+        .settings
+        .chain()
+        .address_from_script(&transaction.output[0].script_pubkey)
+        .unwrap();
+
+      assert_eq!(
+        context
+          .index
+          .get_inscription_ids_by_address(address)
+          .unwrap(),
+        [inscription_id]
+      );
+    }
+
+    assert_eq!(
+      context
+        .index
+        .get_inscriptions_on_output(OutPoint { txid, vout: 0 })
+        .unwrap(),
+      [inscription_id]
+    );
+
+    let send_id = context.rpc_server.broadcast_tx(TransactionTemplate {
+      inputs: &[(2, 1, 0, Default::default())],
+      ..Default::default()
+    });
+
+    context.mine_blocks(1);
+
+    {
+      let transaction = context.index.get_transaction(send_id).unwrap().unwrap();
+
+      let address = context
+        .index
+        .settings
+        .chain()
+        .address_from_script(&transaction.output[0].script_pubkey)
+        .unwrap();
+
+      assert_eq!(
+        context
+          .index
+          .get_inscription_ids_by_address(address)
+          .unwrap(),
+        [inscription_id]
+      );
+    }
+
+    assert_eq!(
+      context
+        .index
+        .get_inscriptions_on_output(OutPoint { txid, vout: 0 })
+        .unwrap(),
+      []
+    );
+
+    assert_eq!(
+      context
+        .index
+        .get_inscriptions_on_output(OutPoint {
+          txid: send_id,
+          vout: 0,
+        })
+        .unwrap(),
+      [inscription_id]
+    );
+  }
 }

src/index/updater/inscription_updater.rs

@@ -571,7 +571,7 @@ impl<'a, 'tx> InscriptionUpdater<'a, 'tx> {
     Ok(())
   }
 
-  fn index_address_to_inscription(
+  fn index_address_to_inscription<'address>(
     &mut self,
     flotsam: &Flotsam,
     transaction: &Transaction,
@@ -588,15 +588,15 @@ impl<'a, 'tx> InscriptionUpdater<'a, 'tx> {
       {
         let transaction: Transaction = consensus::encode::deserialize(transaction.value())?;
 
-        let address_entry =
+        let address =
           self.transaction_to_address(&transaction, old_satpoint.outpoint.vout.into_usize())?;
 
-        let mut inscription_ids = self.get_inscription_ids_by_address(&address_entry)?;
+        let mut inscription_ids = self.get_inscription_ids_by_address(&address)?;
         inscription_ids.retain(|&id| id != flotsam.inscription_id.store());
 
         self
           .address_to_inscription_ids
-          .insert(&address_entry.as_bytes(), inscription_ids)?;
+          .insert(address.to_string().as_bytes(), inscription_ids)?;
       }
     }
 
@@ -609,23 +609,24 @@ impl<'a, 'tx> InscriptionUpdater<'a, 'tx> {
 
     self
       .address_to_inscription_ids
-      .insert(&address.as_bytes(), inscription_ids)?;
+      .insert(address.to_string().as_bytes(), inscription_ids)?;
 
     Ok(())
   }
 
   #[inline]
-  fn transaction_to_address(&self, transaction: &Transaction, vout: usize) -> Result<ScriptBuf> {
+  fn transaction_to_address(&self, transaction: &Transaction, vout: usize) -> Result<Address> {
     let tx_out = transaction.output.get(vout).unwrap();
 
-    let address = self.chain.address_from_script(&tx_out.script_pubkey)?;
-
-    Ok(address.script_pubkey())
+    Ok(self.chain.address_from_script(&tx_out.script_pubkey)?)
   }
 
   #[inline]
-  fn get_inscription_ids_by_address(&self, address: &ScriptBuf) -> Result<Vec<InscriptionIdValue>> {
-    if let Some(entry) = self.address_to_inscription_ids.get(&address.as_bytes())? {
+  fn get_inscription_ids_by_address(&self, address: &Address) -> Result<Vec<InscriptionIdValue>> {
+    if let Some(entry) = self
+      .address_to_inscription_ids
+      .get(address.to_string().as_bytes())?
+    {
       return Ok(entry.value().clone());
     }