[DO NOT MERGE] Ord6

.gitignore

@@ -10,3 +10,4 @@
 /target
 /test-times.txt
 /tmp
+inscription_satpoint.txt

docs/src/guides/inscriptions.md

@@ -166,7 +166,7 @@ Creating Inscriptions
 To create an inscription with the contents of `FILE`, run:
 
 ```
-ord wallet inscribe FILE
+ord wallet inscribe --fee-rate FEE_RATE FILE
 ```
 
 Ord will output two transactions IDs, one for the commit transaction, and one

src/index.rs

@@ -568,7 +568,6 @@ impl Index {
           .open_table(SATPOINT_TO_INSCRIPTION_ID)?,
         outpoint,
       )?
-      .into_iter()
       .map(|(_satpoint, inscription_id)| inscription_id)
       .collect(),
     )

src/index/updater.rs

@@ -102,6 +102,7 @@ impl Updater {
 
     let mut uncommitted = 0;
     let mut value_cache = HashMap::new();
+
     loop {
       let block = match rx.recv() {
         Ok(block) => block,
@@ -113,10 +114,21 @@ impl Updater {
         &mut outpoint_sender,
         &mut value_receiver,
         &mut wtx,
-        block,
+        &block,
         &mut value_cache,
       )?;
 
+      if self.height.checked_sub(1).is_some() {
+        log::info!(
+          target: "new_inscription_satpoint",
+          "{{\"height\":{},\"block_hash\":\"{}\",\"prev_block_hash\":\"{}\",\"tx_count\":{}}}",
+          &self.height - 1,
+          &block.header.block_hash(),
+          &block.header.prev_blockhash,
+          &block.txdata.len(),
+        );
+      }
+
       if let Some(progress_bar) = &mut progress_bar {
         progress_bar.inc(1);
 
@@ -333,7 +345,7 @@ impl Updater {
     outpoint_sender: &mut Sender<OutPoint>,
     value_receiver: &mut Receiver<u64>,
     wtx: &mut WriteTransaction,
-    block: BlockData,
+    block: &BlockData,
     value_cache: &mut HashMap<OutPoint, u64>,
   ) -> Result<()> {
     // If value_receiver still has values something went wrong with the last block

src/index/updater/inscription_updater.rs

@@ -4,6 +4,7 @@ pub(super) struct Flotsam {
   inscription_id: InscriptionId,
   offset: u64,
   origin: Origin,
+  tx_in: Option<TxIn>,
 }
 
 enum Origin {
@@ -87,6 +88,7 @@ impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
             offset: input_value + old_satpoint.offset,
             inscription_id,
             origin: Origin::Old(old_satpoint),
+            tx_in: None,
           });
         }
 
@@ -115,6 +117,7 @@ impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
         inscription_id: txid.into(),
         offset: 0,
         origin: Origin::New(input_value - tx.output.iter().map(|txout| txout.value).sum::<u64>()),
+        tx_in: tx.input.get(0).cloned(),
       });
     };
 
@@ -239,6 +242,37 @@ impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
     self.satpoint_to_id.insert(&new_satpoint, &inscription_id)?;
     self.id_to_satpoint.insert(&inscription_id, &new_satpoint)?;
 
+    let inscription_id = InscriptionId::load(inscription_id);
+    let satpoint = SatPoint::load(new_satpoint);
+    let inscription_entry = self.id_to_entry.get(&inscription_id.store())?.unwrap();
+    let inscription_number = InscriptionEntry::load(inscription_entry.value()).number;
+
+    if let Some(tx_in) = flotsam.tx_in {
+      let inscription = Inscription::from_tx_input(&tx_in).unwrap();
+      let content_type = inscription.content_type().unwrap_or("");
+      let content_len = inscription.body().map_or(0, |body| body.len());
+
+      log::info!(
+        target: "new_inscription_satpoint",
+        "{},{},{},{},{},{}",
+        self.height,
+        satpoint,
+        inscription_id,
+        inscription_number,
+        content_type,
+        content_len,
+      );
+    } else {
+      log::info!(
+        target: "new_inscription_satpoint",
+        "{},{},{},{}",
+        self.height,
+        satpoint,
+        inscription_id,
+        inscription_number,
+      );
+    }
+
     Ok(())
   }
 }

src/inscription.rs

@@ -30,6 +30,17 @@ impl Inscription {
 
   pub(crate) fn from_transaction(tx: &Transaction) -> Option<Inscription> {
     InscriptionParser::parse(&tx.input.get(0)?.witness).ok()
+    // for input in &tx.input {
+    //   if let Some(inscription) = Inscription::from_tx_input(input) {
+    //     return Some(inscription);
+    //   }
+    // }
+
+    // None
+  }
+
+  pub(crate) fn from_tx_input(tx_in: &TxIn) -> Option<Inscription> {
+    InscriptionParser::parse(&tx_in.witness).ok()
   }
 
   pub(crate) fn from_file(chain: Chain, path: impl AsRef<Path>) -> Result<Self, Error> {
@@ -389,6 +400,17 @@ mod tests {
     );
   }
 
+  #[test]
+  fn no_content_type_and_no_body() {
+    assert_eq!(
+      InscriptionParser::parse(&envelope(&[b"ord"])),
+      Ok(Inscription {
+        content_type: None,
+        body: None,
+      }),
+    );
+  }
+
   #[test]
   fn valid_body_in_multiple_pushes() {
     assert_eq!(

src/lib.rs

@@ -54,8 +54,8 @@ use {
     env,
     ffi::OsString,
     fmt::{self, Display, Formatter},
-    fs::{self, File},
-    io,
+    fs::{self, File, OpenOptions},
+    io::{self, Write},
     net::{TcpListener, ToSocketAddrs},
     ops::{Add, AddAssign, Sub},
     path::{Path, PathBuf},
@@ -144,7 +144,20 @@ fn timestamp(seconds: u32) -> DateTime<Utc> {
 const INTERRUPT_LIMIT: u64 = 5;
 
 pub fn main() {
-  env_logger::init();
+  let inscription_satpoint_logs_file = OpenOptions::new()
+    .write(true)
+    .append(true)
+    .create(true)
+    .open("inscription_satpoint.txt")
+    .unwrap();
+
+  env_logger::builder()
+    .filter(Some("new_inscription_satpoint"), log::LevelFilter::Info)
+    .target(env_logger::Target::Pipe(Box::new(
+      inscription_satpoint_logs_file,
+    )))
+    .format(|buf, record| writeln!(buf, "{}", record.args()))
+    .init();
 
   ctrlc::set_handler(move || {
     LISTENERS

src/subcommand.rs

@@ -12,6 +12,7 @@ pub mod subsidy;
 pub mod supply;
 pub mod traits;
 pub mod wallet;
+pub mod witness;
 
 fn print_json(output: impl Serialize) -> Result {
   serde_json::to_writer_pretty(io::stdout(), &output)?;
@@ -45,6 +46,8 @@ pub(crate) enum Subcommand {
   Traits(traits::Traits),
   #[clap(subcommand, about = "Wallet commands")]
   Wallet(wallet::Wallet),
+  #[clap(subcommand, about = "Extract witness content from inscription")]
+  Witness(witness::Witness),
 }
 
 impl Subcommand {
@@ -67,6 +70,7 @@ impl Subcommand {
       Self::Supply => supply::run(),
       Self::Traits(traits) => traits.run(),
       Self::Wallet(wallet) => wallet.run(options),
+      Self::Witness(witness) => witness.run(options),
     }
   }
 }

src/subcommand/server.rs

@@ -12,12 +12,12 @@ use {
   },
   axum::{
     body,
-    extract::{Extension, Path, Query},
+    extract::{Extension, Path, Query, RawBody},
     headers::UserAgent,
     http::{header, HeaderMap, HeaderValue, StatusCode, Uri},
     response::{IntoResponse, Redirect, Response},
-    routing::get,
-    Router, TypedHeader,
+    routing::{get, post},
+    Json, Router, TypedHeader,
   },
   axum_server::Handle,
   rust_embed::RustEmbed,
@@ -27,7 +27,7 @@ use {
     caches::DirCache,
     AcmeConfig,
   },
-  std::{cmp::Ordering, str},
+  std::{cmp::Ordering, str, collections::HashMap},
   tokio_stream::StreamExt,
   tower_http::{
     compression::CompressionLayer,
@@ -87,11 +87,34 @@ impl Display for StaticHtml {
   }
 }
 
+#[derive(Serialize, Deserialize, Clone)]
+struct InscriptionData {
+  number: u64,
+  id: InscriptionId,
+  owner_address: Address,
+  location: SatPoint,
+  genesis_height: u64,
+  genesis_transaction: Txid,
+  creator_address: Address,
+  content_length: usize,
+  content_type: String,
+}
+
+#[derive(Serialize)]
+struct InscriptionsDataResult {
+  inscriptions: HashMap<InscriptionId, InscriptionData>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+struct InscriptionsDataRequest {
+  ids: Vec<InscriptionId>,
+}
+
 #[derive(Debug, Parser)]
 pub(crate) struct Server {
   #[clap(
     long,
-    default_value = "0.0.0.0",
+    default_value = "127.0.0.1",
     help = "Listen on <ADDRESS> for incoming requests."
   )]
   address: String,
@@ -154,6 +177,7 @@ impl Server {
         .route("/feed.xml", get(Self::feed))
         .route("/input/:block/:transaction/:input", get(Self::input))
         .route("/inscription/:inscription_id", get(Self::inscription))
+        .route("/inscriptions-data/", post(Self::inscriptions_data))
         .route("/inscriptions", get(Self::inscriptions))
         .route("/inscriptions/:from", get(Self::inscriptions_from))
         .route("/install.sh", get(Self::install_script))
@@ -768,7 +792,7 @@ impl Server {
       .get_inscription_by_id(inscription_id)?
       .ok_or_not_found(|| format!("inscription {inscription_id}"))?;
 
-    return match inscription.media() {
+    match inscription.media() {
       Media::Audio => Ok(PreviewAudioHtml { inscription_id }.into_response()),
       Media::Iframe => Ok(
         Self::content_response(inscription)
@@ -809,7 +833,101 @@ impl Server {
       }
       Media::Unknown => Ok(PreviewUnknownHtml.into_response()),
       Media::Video => Ok(PreviewVideoHtml { inscription_id }.into_response()),
+    }
+  }
+
+  async fn inscriptions_data(
+    Extension(page_config): Extension<Arc<PageConfig>>,
+    Extension(index): Extension<Arc<Index>>,
+    RawBody(body): RawBody,
+  ) -> ServerResult<Json<InscriptionsDataResult>> {
+    let body_bytes = hyper::body::to_bytes(body).await.unwrap().to_vec();
+    let body_string = String::from_utf8(body_bytes).unwrap();
+    let request_body = serde_json::from_str::<InscriptionsDataRequest>(&body_string).unwrap();
+
+    let inscriptions = request_body.ids;
+    let mut data_map: HashMap<InscriptionId, InscriptionData> = HashMap::new();
+
+    for inscription_id in inscriptions.into_iter() {
+      match Server::get_inscription_data(&index, page_config.chain, inscription_id).await {
+        Ok(inscription_data) => {
+          data_map.insert(inscription_id, inscription_data);
+        }
+        Err(_) => {
+          // skip broken inscriptions
+          continue;
+        }
+      }
+    }
+
+    let inscription_data_result = InscriptionsDataResult {
+      inscriptions: data_map,
     };
+
+    Ok(Json(inscription_data_result))
+  }
+
+  async fn get_inscription_data(
+    index: &Arc<Index>,
+    chain: Chain,
+    inscription_id: InscriptionId,
+  ) -> Result<InscriptionData> {
+    let entry = index.get_inscription_entry(inscription_id)?.unwrap();
+
+    let inscription = index.get_inscription_by_id(inscription_id)?.unwrap();
+
+    let satpoint = index
+      .get_inscription_satpoint_by_id(inscription_id)?
+      .unwrap();
+
+    let output = index
+      .get_transaction(satpoint.outpoint.txid)?
+      .unwrap()
+      .output
+      .into_iter()
+      .nth(satpoint.outpoint.vout.try_into().unwrap())
+      .unwrap();
+
+    let previous_outpoint = index
+      .get_transaction(inscription_id.txid)?
+      .unwrap()
+      .input
+      .into_iter()
+      .nth(inscription_id.index.try_into().unwrap())
+      .unwrap()
+      .previous_output;
+
+    let previous_output = index
+      .get_transaction(previous_outpoint.txid)?
+      .unwrap()
+      .output
+      .into_iter()
+      .nth(previous_outpoint.vout.try_into().unwrap())
+      .unwrap();
+
+    let owner_address = chain
+      .address_from_script(&output.script_pubkey)
+      .ok()
+      .unwrap();
+
+    let creator_address = chain
+      .address_from_script(&previous_output.script_pubkey)
+      .ok()
+      .unwrap();
+
+    let inscription_data = InscriptionData {
+      number: entry.number,
+      id: inscription_id,
+      owner_address,
+      genesis_height: entry.height,
+      genesis_transaction: inscription_id.txid,
+      creator_address,
+      location: satpoint,
+      content_length: inscription.content_length().unwrap_or(0),
+      content_type: inscription.content_type().unwrap_or("").to_string(),
+    };
+
+    Ok(inscription_data)
   }
 
   async fn inscription(