From 307fcc6333d9f05597ef61e90e4eaad5653e8f04 Mon Sep 17 00:00:00 2001
From: raphjaph <raphjaph@protonmail.com>
Date: Wed, 30 Nov 2022 20:18:44 +0100
Subject: [PATCH 1/6] rebasing

---
 src/index/updater.rs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/index/updater.rs b/src/index/updater.rs
index c348f649e0..9fb66d14fe 100644
--- a/src/index/updater.rs
+++ b/src/index/updater.rs
@@ -341,6 +341,8 @@ impl Updater {
     &mut self,
     tx: &Transaction,
     inscription_id_to_inscription: &mut Table<&InscriptionIdArray, str>,
+    // inscription_id_to_satpoint: &mut Table<&[u8; 32], &[u8; 44]>,
+    satpoint_to_inscription_id: &mut Table<&[u8; 44], &[u8; 32]>,
   ) -> Result {
     if let Some(inscription) = Inscription::from_transaction(tx) {
       let json = serde_json::to_string(&inscription)
@@ -348,6 +350,23 @@ impl Updater {
 
       inscription_id_to_inscription.insert(tx.txid().as_inner(), &json)?;
     }
+    
+    for tx_in in tx.input {
+      let mut offset = 0;
+      let outpoint = tx_in.previous_output;
+      let start = encode_satpoint(SatPoint { outpoint, offset: 0 });
+      let end = encode_satpoint(SatPoint { outpoint, offset: u64::MAX });
+      if let inscription_ids = satpoint_to_inscription_id.range(start..=end)? {
+        for id in inscription_ids {
+          let new_satpoint = encode_satpoint(SatPoint { outpoint: OutPoint { txid: tx.txid(), vout: 0 }, offset: 0 });
+          satpoint_to_inscription_id.insert(&new_satpoint, &id.1) ;
+        }
+      } else {
+
+      }
+    }
+    // check each input of tx for inscription outpoints -> index from satpoint to inscription_id
+    // record satpoint (txid:vout:offset) in same table 
 
     Ok(())
   }

From f48c69c82e075adff78903674e488bdacc78bcd6 Mon Sep 17 00:00:00 2001
From: raphjaph <raphjaph@protonmail.com>
Date: Wed, 30 Nov 2022 21:51:05 +0100
Subject: [PATCH 2/6] work with offset=0 and vout=0

---
 src/index.rs                                  | 62 +++++++++++++-----
 src/index/updater.rs                          | 65 ++++++++++++++-----
 src/subcommand/server.rs                      | 21 +++---
 .../server/templates/inscription.rs           | 11 ++++
 templates/inscription.html                    |  4 ++
 tests/server.rs                               | 12 +++-
 6 files changed, 129 insertions(+), 46 deletions(-)

diff --git a/src/index.rs b/src/index.rs
index 1ae7047b20..305e876f25 100644
--- a/src/index.rs
+++ b/src/index.rs
@@ -1,7 +1,6 @@
 use {
   self::updater::Updater,
   super::*,
-  bitcoin::consensus::encode::deserialize,
   bitcoin::BlockHeader,
   bitcoincore_rpc::{json::GetBlockHeaderResult, Auth, Client},
   indicatif::{ProgressBar, ProgressStyle},
@@ -33,6 +32,10 @@ const INSCRIPTION_ID_TO_INSCRIPTION: TableDefinition<&InscriptionIdArray, str> =
   TableDefinition::new("INSCRIPTION_ID_TO_INSCRIPTION");
 const WRITE_TRANSACTION_STARTING_BLOCK_COUNT_TO_TIMESTAMP: TableDefinition<u64, u128> =
   TableDefinition::new("WRITE_TRANSACTION_START_BLOCK_COUNT_TO_TIMESTAMP");
+const INSCRIPTION_ID_TO_SATPOINT: TableDefinition<&InscriptionIdArray, &SatPointArray> =
+  TableDefinition::new("INSCRIPTION_ID_TO_SATPOINT");
+const SATPOINT_TO_INSCRIPTION_ID: TableDefinition<&SatPointArray, &InscriptionIdArray> =
+  TableDefinition::new("SATPOINT_TO_INSCRIPTION_ID");
 
 fn encode_outpoint(outpoint: OutPoint) -> OutPointArray {
   let mut array = [0; 36];
@@ -50,6 +53,14 @@ fn encode_satpoint(satpoint: SatPoint) -> SatPointArray {
   array
 }
 
+fn decode_satpoint(array: SatPointArray) -> SatPoint {
+  Decodable::consensus_decode(&mut io::Cursor::new(array)).unwrap()
+}
+
+fn decode_outpoint(array: OutPointArray) -> OutPoint {
+  Decodable::consensus_decode(&mut io::Cursor::new(array)).unwrap()
+}
+
 pub(crate) struct Index {
   auth: Auth,
   chain: Chain,
@@ -190,10 +201,12 @@ impl Index {
         };
 
         tx.open_table(HEIGHT_TO_BLOCK_HASH)?;
+        tx.open_table(INSCRIPTION_ID_TO_INSCRIPTION)?;
+        tx.open_table(INSCRIPTION_ID_TO_SATPOINT)?;
         tx.open_table(ORDINAL_TO_INSCRIPTION_ID)?;
         tx.open_table(ORDINAL_TO_SATPOINT)?;
+        tx.open_table(SATPOINT_TO_INSCRIPTION_ID)?;
         tx.open_table(STATISTIC_TO_COUNT)?;
-        tx.open_table(INSCRIPTION_ID_TO_INSCRIPTION)?;
         tx.open_table(WRITE_TRANSACTION_STARTING_BLOCK_COUNT_TO_TIMESTAMP)?;
 
         if options.index_ordinals {
@@ -384,7 +397,7 @@ impl Index {
     let ordinal_to_satpoint = rtx.open_table(ORDINAL_TO_SATPOINT)?;
 
     for (ordinal, satpoint) in ordinal_to_satpoint.range(0..)? {
-      result.push((Ordinal(ordinal), deserialize(satpoint)?));
+      result.push((Ordinal(ordinal), decode_satpoint(*satpoint)));
     }
 
     Ok(result)
@@ -413,7 +426,7 @@ impl Index {
     self.client.get_block(&hash).into_option()
   }
 
-  pub(crate) fn inscription(&self, ordinal: Ordinal) -> Result<Option<Inscription>> {
+  pub(crate) fn get_inscription_by_ordinal(&self, ordinal: Ordinal) -> Result<Option<Inscription>> {
     let db = self.database.begin_read()?;
     let table = db.open_table(ORDINAL_TO_INSCRIPTION_ID)?;
 
@@ -434,18 +447,33 @@ impl Index {
     )
   }
 
-  pub(crate) fn inscription_from_txid(&self, txid: Txid) -> Result<Option<Inscription>> {
-    Ok(
-      self
-        .database
-        .begin_read()?
-        .open_table(INSCRIPTION_ID_TO_INSCRIPTION)?
-        .get(txid.as_inner())?
-        .map(|inscription| {
-          serde_json::from_str(inscription)
-            .expect("failed to deserialize inscription (JSON) from database")
-        }),
-    )
+  pub(crate) fn get_inscription_by_inscription_id(
+    &self,
+    txid: Txid,
+  ) -> Result<Option<(Inscription, SatPoint)>> {
+    let inscription = self
+      .database
+      .begin_read()?
+      .open_table(INSCRIPTION_ID_TO_INSCRIPTION)?
+      .get(txid.as_inner())?
+      .map(|inscription| {
+        serde_json::from_str(inscription)
+          .expect("failed to deserialize inscription (JSON) from database")
+      });
+
+    let inscription = match inscription {
+      Some(inscription) => inscription,
+      None => return Ok(None),
+    };
+
+    let satpoint = decode_satpoint(*self
+      .database
+      .begin_read()?
+      .open_table(INSCRIPTION_ID_TO_SATPOINT)?
+      .get(txid.as_inner())?
+      .ok_or_else(|| anyhow!("no satpoint for inscription"))?);
+
+    Ok(Some((inscription, satpoint)))
   }
 
   pub(crate) fn transaction(&self, txid: Txid) -> Result<Option<Transaction>> {
@@ -487,7 +515,7 @@ impl Index {
       for chunk in value.chunks_exact(11) {
         let (start, end) = Index::decode_ordinal_range(chunk.try_into().unwrap());
         if start <= ordinal && ordinal < end {
-          let outpoint: OutPoint = deserialize(key.as_slice())?;
+          let outpoint = decode_outpoint(*key);
           return Ok(Some(SatPoint {
             outpoint,
             offset: offset + ordinal - start,
diff --git a/src/index/updater.rs b/src/index/updater.rs
index 9fb66d14fe..f2099e5e54 100644
--- a/src/index/updater.rs
+++ b/src/index/updater.rs
@@ -318,9 +318,16 @@ impl Updater {
       }
     } else {
       let mut inscription_id_to_inscription = wtx.open_table(INSCRIPTION_ID_TO_INSCRIPTION)?;
+      let mut inscription_id_to_satpoint = wtx.open_table(INSCRIPTION_ID_TO_SATPOINT)?;
+      let mut satpoint_to_inscription_id = wtx.open_table(SATPOINT_TO_INSCRIPTION_ID)?;
 
       for tx in &block.txdata {
-        self.index_transaction_inscriptions(tx, &mut inscription_id_to_inscription)?
+        self.index_transaction_inscriptions(
+          tx,
+          &mut inscription_id_to_inscription,
+          &mut inscription_id_to_satpoint,
+          &mut satpoint_to_inscription_id,
+        )?
       }
     }
 
@@ -341,32 +348,56 @@ impl Updater {
     &mut self,
     tx: &Transaction,
     inscription_id_to_inscription: &mut Table<&InscriptionIdArray, str>,
-    // inscription_id_to_satpoint: &mut Table<&[u8; 32], &[u8; 44]>,
-    satpoint_to_inscription_id: &mut Table<&[u8; 44], &[u8; 32]>,
+    inscription_id_to_satpoint: &mut Table<&InscriptionIdArray, &SatPointArray>,
+    satpoint_to_inscription_id: &mut Table<&SatPointArray, &InscriptionIdArray>,
   ) -> Result {
     if let Some(inscription) = Inscription::from_transaction(tx) {
       let json = serde_json::to_string(&inscription)
         .expect("Inscription serialization should always succeed");
 
-      inscription_id_to_inscription.insert(tx.txid().as_inner(), &json)?;
+      let txid = tx.txid();
+      let satpoint = encode_satpoint(SatPoint {
+        outpoint: OutPoint { txid, vout: 0 },
+        offset: 0,
+      });
+
+      inscription_id_to_inscription.insert(txid.as_inner(), &json)?;
+      inscription_id_to_satpoint.insert(txid.as_inner(), &satpoint)?;
+      satpoint_to_inscription_id.insert(&satpoint, txid.as_inner())?;
     }
-    
-    for tx_in in tx.input {
-      let mut offset = 0;
-      let outpoint = tx_in.previous_output;
-      let start = encode_satpoint(SatPoint { outpoint, offset: 0 });
-      let end = encode_satpoint(SatPoint { outpoint, offset: u64::MAX });
-      if let inscription_ids = satpoint_to_inscription_id.range(start..=end)? {
-        for id in inscription_ids {
-          let new_satpoint = encode_satpoint(SatPoint { outpoint: OutPoint { txid: tx.txid(), vout: 0 }, offset: 0 });
-          satpoint_to_inscription_id.insert(&new_satpoint, &id.1) ;
-        }
-      } else {
 
+    for tx_in in &tx.input {
+      let outpoint = tx_in.previous_output;
+      let start = encode_satpoint(SatPoint {
+        outpoint,
+        offset: 0,
+      });
+
+      let end = encode_satpoint(SatPoint {
+        outpoint,
+        offset: u64::MAX,
+      });
+
+      let inscription_ids: Vec<(SatPointArray, InscriptionIdArray)> = satpoint_to_inscription_id
+        .range(start..=end)?
+        .map(|(satpoint, id)| (*satpoint, *id))
+        .collect();
+
+      for id in inscription_ids {
+        let new_satpoint = encode_satpoint(SatPoint {
+          outpoint: OutPoint {
+            txid: tx.txid(),
+            vout: 0,
+          },
+          offset: 0,
+        });
+
+        satpoint_to_inscription_id.insert(&new_satpoint, &id.1)?;
+        inscription_id_to_satpoint.insert(&id.1, &new_satpoint)?;
       }
     }
     // check each input of tx for inscription outpoints -> index from satpoint to inscription_id
-    // record satpoint (txid:vout:offset) in same table 
+    // record satpoint (txid:vout:offset) in same table
 
     Ok(())
   }
diff --git a/src/subcommand/server.rs b/src/subcommand/server.rs
index 69d11de4c6..48148d3d38 100644
--- a/src/subcommand/server.rs
+++ b/src/subcommand/server.rs
@@ -314,7 +314,7 @@ impl Server {
         blocktime: index.blocktime(ordinal.height()).map_err(|err| {
           ServerError::Internal(anyhow!("failed to retrieve blocktime from index: {err}"))
         })?,
-        inscription: index.inscription(ordinal).map_err(|err| {
+        inscription: index.get_inscription_by_ordinal(ordinal).map_err(|err| {
           ServerError::Internal(anyhow!(
             "failed to retrieve inscription for ordinal {ordinal} from index: {err}"
           ))
@@ -613,17 +613,20 @@ impl Server {
     Extension(index): Extension<Arc<Index>>,
     Path(txid): Path<Txid>,
   ) -> ServerResult<PageHtml> {
+    let (inscription, satpoint) = index
+      .get_inscription_by_inscription_id(txid)
+      .map_err(|err| {
+        ServerError::Internal(anyhow!(
+          "failed to retrieve inscription from txid {txid} from index: {err}"
+        ))
+      })?
+      .ok_or_else(|| ServerError::NotFound(format!("transaction {txid} has no inscription")))?;
+
     Ok(
       InscriptionHtml {
         txid,
-        inscription: index
-          .inscription_from_txid(txid)
-          .map_err(|err| {
-            ServerError::Internal(anyhow!(
-              "failed to retrieve inscription from txid {txid} from index: {err}"
-            ))
-          })?
-          .ok_or_else(|| ServerError::NotFound(format!("transaction {txid} has no inscription")))?,
+        inscription,
+        satpoint,
       }
       .page(
         chain,
diff --git a/src/subcommand/server/templates/inscription.rs b/src/subcommand/server/templates/inscription.rs
index 2a0575ae92..ce8df3eaaa 100644
--- a/src/subcommand/server/templates/inscription.rs
+++ b/src/subcommand/server/templates/inscription.rs
@@ -4,6 +4,7 @@ use super::*;
 pub(crate) struct InscriptionHtml {
   pub(crate) txid: Txid,
   pub(crate) inscription: Inscription,
+  pub(crate) satpoint: SatPoint,
 }
 
 impl Content for InscriptionHtml {
@@ -23,10 +24,15 @@ mod tests {
         txid: Txid::from_str("ec90757eb3b164aa43fc548faa2fa0c52025494f2c15d5ddf11260b4034ac6dc")
           .unwrap(),
         inscription: Inscription::Text("HELLOWORLD".into()),
+        satpoint: satpoint(1, 0), 
       }
       .to_string(),
       "
         <h1>Inscription</h1>
+        <dl>
+          <dt>satpoint</dt>
+          <dd>1111111111111111111111111111111111111111111111111111111111111111:1:0</dd>
+        </dl>
         HELLOWORLD
       "
       .unindent()
@@ -39,10 +45,15 @@ mod tests {
       InscriptionHtml {
         txid: Txid::from_str("ec90757eb3b164aa43fc548faa2fa0c52025494f2c15d5ddf11260b4034ac6dc").unwrap(),
         inscription: Inscription::Png(vec![1; 100]),
+        satpoint: satpoint(1, 0), 
       }
       .to_string(),
       "
         <h1>Inscription</h1>
+        <dl>
+          <dt>satpoint</dt>
+          <dd>1111111111111111111111111111111111111111111111111111111111111111:1:0</dd>
+        </dl>
         <img src=\"data:image/png;base64,AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQ==\">
       "
       .unindent()
diff --git a/templates/inscription.html b/templates/inscription.html
index fb06b7308c..0c2d67a50e 100644
--- a/templates/inscription.html
+++ b/templates/inscription.html
@@ -1,4 +1,8 @@
 <h1>Inscription</h1>
+<dl>
+  <dt>satpoint</dt>
+  <dd>{{ self.satpoint }}</dd>
+</dl>
 %% match &self.inscription {
 %%  Inscription::Text(content) => {
 {{ content }}
diff --git a/tests/server.rs b/tests/server.rs
index a82a4f8096..2cd8141f48 100644
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -47,15 +47,21 @@ fn inscription_page() {
   .stdout_regex("commit\t[[:xdigit:]]{64}\nreveal\t[[:xdigit:]]{64}\n")
   .run();
 
-  let reveal_tx = stdout.split("reveal\t").collect::<Vec<&str>>()[1];
+  let reveal_tx = stdout.split("reveal\t").collect::<Vec<&str>>()[1].trim();
 
   rpc_server.mine_blocks(1);
 
-  let ord_server = TestServer::spawn_with_args(&rpc_server, &["--index-ordinals"]);
+  let ord_server = TestServer::spawn_with_args(&rpc_server, &[]);
 
   ord_server.assert_response_regex(
     &format!("/inscription/{}", reveal_tx),
-    ".*<h1>Inscription</h1>
+    &format!(
+      ".*<h1>Inscription</h1>
+<dl>
+  <dt>satpoint</dt>
+  <dd>{reveal_tx}:0:0</dd>
+</dl>
 HELLOWORLD.*",
+    ),
   )
 }

From 6315de7d9a1a2353b213107388416dfeea4d64cf Mon Sep 17 00:00:00 2001
From: raphjaph <raphjaph@protonmail.com>
Date: Wed, 30 Nov 2022 22:22:11 +0100
Subject: [PATCH 3/6] works

---
 src/index/updater.rs | 40 ++++++++++++++++++++++------------------
 tests/server.rs      | 14 +++++++++++++-
 2 files changed, 35 insertions(+), 19 deletions(-)

diff --git a/src/index/updater.rs b/src/index/updater.rs
index f2099e5e54..f3e55ca235 100644
--- a/src/index/updater.rs
+++ b/src/index/updater.rs
@@ -248,11 +248,14 @@ impl Updater {
       }
     }
 
+    let mut inscription_id_to_inscription = wtx.open_table(INSCRIPTION_ID_TO_INSCRIPTION)?;
+    let mut inscription_id_to_satpoint = wtx.open_table(INSCRIPTION_ID_TO_SATPOINT)?;
+    let mut satpoint_to_inscription_id = wtx.open_table(SATPOINT_TO_INSCRIPTION_ID)?;
+
     if self.index_ordinals {
       let mut ordinal_to_inscription_id = wtx.open_table(ORDINAL_TO_INSCRIPTION_ID)?;
       let mut ordinal_to_satpoint = wtx.open_table(ORDINAL_TO_SATPOINT)?;
       let mut outpoint_to_ordinal_ranges = wtx.open_table(OUTPOINT_TO_ORDINAL_RANGES)?;
-      let mut inscription_id_to_inscription = wtx.open_table(INSCRIPTION_ID_TO_INSCRIPTION)?;
 
       let mut coinbase_inputs = VecDeque::new();
 
@@ -296,6 +299,8 @@ impl Updater {
           &mut ordinal_to_satpoint,
           &mut ordinal_to_inscription_id,
           &mut inscription_id_to_inscription,
+          &mut inscription_id_to_satpoint,
+          &mut satpoint_to_inscription_id,
           &mut input_ordinal_ranges,
           &mut ordinal_ranges_written,
           &mut outputs_in_block,
@@ -311,23 +316,21 @@ impl Updater {
           &mut ordinal_to_satpoint,
           &mut ordinal_to_inscription_id,
           &mut inscription_id_to_inscription,
+          &mut inscription_id_to_satpoint,
+          &mut satpoint_to_inscription_id,
           &mut coinbase_inputs,
           &mut ordinal_ranges_written,
           &mut outputs_in_block,
         )?;
       }
     } else {
-      let mut inscription_id_to_inscription = wtx.open_table(INSCRIPTION_ID_TO_INSCRIPTION)?;
-      let mut inscription_id_to_satpoint = wtx.open_table(INSCRIPTION_ID_TO_SATPOINT)?;
-      let mut satpoint_to_inscription_id = wtx.open_table(SATPOINT_TO_INSCRIPTION_ID)?;
-
       for tx in &block.txdata {
         self.index_transaction_inscriptions(
           tx,
           &mut inscription_id_to_inscription,
           &mut inscription_id_to_satpoint,
           &mut satpoint_to_inscription_id,
-        )?
+        )?;
       }
     }
 
@@ -350,8 +353,9 @@ impl Updater {
     inscription_id_to_inscription: &mut Table<&InscriptionIdArray, str>,
     inscription_id_to_satpoint: &mut Table<&InscriptionIdArray, &SatPointArray>,
     satpoint_to_inscription_id: &mut Table<&SatPointArray, &InscriptionIdArray>,
-  ) -> Result {
-    if let Some(inscription) = Inscription::from_transaction(tx) {
+  ) -> Result<bool> {
+    let inscription = Inscription::from_transaction(tx);
+    if let Some(inscription) = &inscription {
       let json = serde_json::to_string(&inscription)
         .expect("Inscription serialization should always succeed");
 
@@ -364,7 +368,7 @@ impl Updater {
       inscription_id_to_inscription.insert(txid.as_inner(), &json)?;
       inscription_id_to_satpoint.insert(txid.as_inner(), &satpoint)?;
       satpoint_to_inscription_id.insert(&satpoint, txid.as_inner())?;
-    }
+    };
 
     for tx_in in &tx.input {
       let outpoint = tx_in.previous_output;
@@ -396,10 +400,8 @@ impl Updater {
         inscription_id_to_satpoint.insert(&id.1, &new_satpoint)?;
       }
     }
-    // check each input of tx for inscription outpoints -> index from satpoint to inscription_id
-    // record satpoint (txid:vout:offset) in same table
 
-    Ok(())
+    Ok(inscription.is_some())
   }
 
   pub(crate) fn index_transaction_ordinals(
@@ -409,16 +411,18 @@ impl Updater {
     ordinal_to_satpoint: &mut Table<u64, &SatPointArray>,
     ordinal_to_inscription_id: &mut Table<u64, &InscriptionIdArray>,
     inscription_id_to_inscription: &mut Table<&InscriptionIdArray, str>,
+    inscription_id_to_satpoint: &mut Table<&InscriptionIdArray, &SatPointArray>,
+    satpoint_to_inscription_id: &mut Table<&SatPointArray, &InscriptionIdArray>,
     input_ordinal_ranges: &mut VecDeque<(u64, u64)>,
     ordinal_ranges_written: &mut u64,
     outputs_traversed: &mut u64,
   ) -> Result {
-    if let Some(inscription) = Inscription::from_transaction(tx) {
-      let json = serde_json::to_string(&inscription)
-        .expect("Inscription serialization should always succeed");
-
-      inscription_id_to_inscription.insert(tx.txid().as_inner(), &json)?;
-
+    if self.index_transaction_inscriptions(
+      tx,
+      inscription_id_to_inscription,
+      inscription_id_to_satpoint,
+      satpoint_to_inscription_id,
+    )? {
       if let Some((start, _end)) = input_ordinal_ranges.get(0) {
         ordinal_to_inscription_id.insert(&start, tx.txid().as_inner())?;
       }
diff --git a/tests/server.rs b/tests/server.rs
index 2cd8141f48..3bafaad2ee 100644
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -40,7 +40,7 @@ fn inscription_page() {
   let txid = rpc_server.mine_blocks(1)[0].txdata[0].txid();
 
   let stdout = CommandBuilder::new(format!(
-    "--chain regtest --index-ordinals wallet inscribe --satpoint {txid}:0:0 --file hello.txt"
+    "--chain regtest wallet inscribe --satpoint {txid}:0:0 --file hello.txt"
   ))
   .write("hello.txt", "HELLOWORLD")
   .rpc_server(&rpc_server)
@@ -52,7 +52,19 @@ fn inscription_page() {
   rpc_server.mine_blocks(1);
 
   let ord_server = TestServer::spawn_with_args(&rpc_server, &[]);
+  ord_server.assert_response_regex(
+    &format!("/inscription/{}", reveal_tx),
+    &format!(
+      ".*<h1>Inscription</h1>
+<dl>
+  <dt>satpoint</dt>
+  <dd>{reveal_tx}:0:0</dd>
+</dl>
+HELLOWORLD.*",
+    ),
+  );
 
+  let ord_server = TestServer::spawn_with_args(&rpc_server, &["--index-ordinals"]);
   ord_server.assert_response_regex(
     &format!("/inscription/{}", reveal_tx),
     &format!(

From 50561d04ef375187e90e5fe8c5eb8c037ee0adeb Mon Sep 17 00:00:00 2001
From: Casey Rodarmor <casey@rodarmor.com>
Date: Wed, 30 Nov 2022 13:33:03 -0800
Subject: [PATCH 4/6] Fix formatting

---
 src/index.rs                                   | 14 ++++++++------
 src/subcommand/server/templates/inscription.rs |  4 ++--
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/index.rs b/src/index.rs
index 305e876f25..1637a91ca5 100644
--- a/src/index.rs
+++ b/src/index.rs
@@ -466,12 +466,14 @@ impl Index {
       None => return Ok(None),
     };
 
-    let satpoint = decode_satpoint(*self
-      .database
-      .begin_read()?
-      .open_table(INSCRIPTION_ID_TO_SATPOINT)?
-      .get(txid.as_inner())?
-      .ok_or_else(|| anyhow!("no satpoint for inscription"))?);
+    let satpoint = decode_satpoint(
+      *self
+        .database
+        .begin_read()?
+        .open_table(INSCRIPTION_ID_TO_SATPOINT)?
+        .get(txid.as_inner())?
+        .ok_or_else(|| anyhow!("no satpoint for inscription"))?,
+    );
 
     Ok(Some((inscription, satpoint)))
   }
diff --git a/src/subcommand/server/templates/inscription.rs b/src/subcommand/server/templates/inscription.rs
index ce8df3eaaa..3a6147849b 100644
--- a/src/subcommand/server/templates/inscription.rs
+++ b/src/subcommand/server/templates/inscription.rs
@@ -24,7 +24,7 @@ mod tests {
         txid: Txid::from_str("ec90757eb3b164aa43fc548faa2fa0c52025494f2c15d5ddf11260b4034ac6dc")
           .unwrap(),
         inscription: Inscription::Text("HELLOWORLD".into()),
-        satpoint: satpoint(1, 0), 
+        satpoint: satpoint(1, 0),
       }
       .to_string(),
       "
@@ -45,7 +45,7 @@ mod tests {
       InscriptionHtml {
         txid: Txid::from_str("ec90757eb3b164aa43fc548faa2fa0c52025494f2c15d5ddf11260b4034ac6dc").unwrap(),
         inscription: Inscription::Png(vec![1; 100]),
-        satpoint: satpoint(1, 0), 
+        satpoint: satpoint(1, 0),
       }
       .to_string(),
       "

From c1b0dfe6555d74b4bc67fa6017f651faf1c65626 Mon Sep 17 00:00:00 2001
From: raphjaph <raphjaph@protonmail.com>
Date: Wed, 30 Nov 2022 23:15:39 +0100
Subject: [PATCH 5/6] test fails

---
 tests/server.rs | 54 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/tests/server.rs b/tests/server.rs
index 3bafaad2ee..46d3038ffc 100644
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -77,3 +77,57 @@ HELLOWORLD.*",
     ),
   )
 }
+
+#[test]
+fn inscription_page_after_send() {
+  let rpc_server = test_bitcoincore_rpc::spawn_with(Network::Regtest, "ord");
+  let txid = rpc_server.mine_blocks(1)[0].txdata[0].txid();
+
+  let stdout = CommandBuilder::new(format!(
+    "--chain regtest wallet inscribe --satpoint {txid}:0:0 --file hello.txt"
+  ))
+  .write("hello.txt", "HELLOWORLD")
+  .rpc_server(&rpc_server)
+  .stdout_regex("commit\t[[:xdigit:]]{64}\nreveal\t[[:xdigit:]]{64}\n")
+  .run();
+
+  let reveal_tx = stdout.split("reveal\t").collect::<Vec<&str>>()[1].trim();
+
+  rpc_server.mine_blocks(1);
+
+  let ord_server = TestServer::spawn_with_args(&rpc_server, &[]);
+  ord_server.assert_response_regex(
+    &format!("/inscription/{}", reveal_tx),
+    &format!(
+      ".*<h1>Inscription</h1>
+<dl>
+  <dt>satpoint</dt>
+  <dd>{reveal_tx}:0:0</dd>
+</dl>
+HELLOWORLD.*",
+    ),
+  );
+
+  let txid = CommandBuilder::new(format!(
+    "--chain regtest wallet send {txid}:0:0 bcrt1q6rhpng9evdsfnn833a4f4vej0asu6dk5srld6x"
+  ))
+  .write("hello.txt", "HELLOWORLD")
+  .rpc_server(&rpc_server)
+  .stdout_regex(".*")
+  .run();
+
+  rpc_server.mine_blocks(1);
+
+  let ord_server = TestServer::spawn_with_args(&rpc_server, &[]);
+  ord_server.assert_response_regex(
+    &format!("/inscription/{}", reveal_tx),
+    &format!(
+      ".*<h1>Inscription</h1>
+<dl>
+  <dt>satpoint</dt>
+  <dd>{txid}:0:0</dd>
+</dl>
+HELLOWORLD.*",
+    ),
+  )
+}

From d4d1266fefe6c6a237846a1bf00f87a432f05e67 Mon Sep 17 00:00:00 2001
From: Casey Rodarmor <casey@rodarmor.com>
Date: Wed, 30 Nov 2022 14:37:36 -0800
Subject: [PATCH 6/6] Fix send test

---
 src/index/updater.rs |  6 +++---
 tests/server.rs      | 13 +++++++------
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/index/updater.rs b/src/index/updater.rs
index f3e55ca235..827c0fa22e 100644
--- a/src/index/updater.rs
+++ b/src/index/updater.rs
@@ -387,7 +387,7 @@ impl Updater {
         .map(|(satpoint, id)| (*satpoint, *id))
         .collect();
 
-      for id in inscription_ids {
+      for (_old_satpoint, inscription_id) in inscription_ids {
         let new_satpoint = encode_satpoint(SatPoint {
           outpoint: OutPoint {
             txid: tx.txid(),
@@ -396,8 +396,8 @@ impl Updater {
           offset: 0,
         });
 
-        satpoint_to_inscription_id.insert(&new_satpoint, &id.1)?;
-        inscription_id_to_satpoint.insert(&id.1, &new_satpoint)?;
+        satpoint_to_inscription_id.insert(&new_satpoint, &inscription_id)?;
+        inscription_id_to_satpoint.insert(&inscription_id, &new_satpoint)?;
       }
     }
 
diff --git a/tests/server.rs b/tests/server.rs
index 46d3038ffc..c592c323bc 100644
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -91,25 +91,25 @@ fn inscription_page_after_send() {
   .stdout_regex("commit\t[[:xdigit:]]{64}\nreveal\t[[:xdigit:]]{64}\n")
   .run();
 
-  let reveal_tx = stdout.split("reveal\t").collect::<Vec<&str>>()[1].trim();
+  let reveal_txid = stdout.split("reveal\t").collect::<Vec<&str>>()[1].trim();
 
   rpc_server.mine_blocks(1);
 
   let ord_server = TestServer::spawn_with_args(&rpc_server, &[]);
   ord_server.assert_response_regex(
-    &format!("/inscription/{}", reveal_tx),
+    &format!("/inscription/{}", reveal_txid),
     &format!(
       ".*<h1>Inscription</h1>
 <dl>
   <dt>satpoint</dt>
-  <dd>{reveal_tx}:0:0</dd>
+  <dd>{reveal_txid}:0:0</dd>
 </dl>
 HELLOWORLD.*",
     ),
   );
 
   let txid = CommandBuilder::new(format!(
-    "--chain regtest wallet send {txid}:0:0 bcrt1q6rhpng9evdsfnn833a4f4vej0asu6dk5srld6x"
+    "--chain regtest wallet send {reveal_txid}:0:0 bcrt1q6rhpng9evdsfnn833a4f4vej0asu6dk5srld6x"
   ))
   .write("hello.txt", "HELLOWORLD")
   .rpc_server(&rpc_server)
@@ -120,14 +120,15 @@ HELLOWORLD.*",
 
   let ord_server = TestServer::spawn_with_args(&rpc_server, &[]);
   ord_server.assert_response_regex(
-    &format!("/inscription/{}", reveal_tx),
+    &format!("/inscription/{}", reveal_txid),
     &format!(
       ".*<h1>Inscription</h1>
 <dl>
   <dt>satpoint</dt>
-  <dd>{txid}:0:0</dd>
+  <dd>{}:0:0</dd>
 </dl>
 HELLOWORLD.*",
+      txid.trim(),
     ),
   )
 }