Content endpoint

src/inscription.rs

@@ -100,16 +100,20 @@ impl Inscription {
  }
  }
 
- pub(crate) fn content_type(&self) -> Option<&str> {
- str::from_utf8(self.content_type.as_ref()?).ok()
+ pub(crate) fn content_bytes(&self) -> Option<&[u8]> {
+ Some(self.content.as_ref()?)
+ }
+
+ pub(crate) fn content_html(&self) -> Trusted<ContentHtml> {
+ Trusted(ContentHtml(self.content()))
  }
 
  pub(crate) fn content_size(&self) -> Option<usize> {
- Some(self.content.as_ref()?.len())
+ Some(self.content_bytes()?.len())
  }
 
- pub(crate) fn content_html(&self) -> Trusted<ContentHtml> {
- Trusted(ContentHtml(self.content()))
+ pub(crate) fn content_type(&self) -> Option<&str> {
+ str::from_utf8(self.content_type.as_ref()?).ok()
  }
 }
 

src/subcommand/server.rs

@@ -154,10 +154,11 @@ impl Server {
  .route("/block/:query", get(Self::block))
  .route("/bounties", get(Self::bounties))
  .route("/clock", get(Self::clock))
+ .route("/content/:inscription_id", get(Self::content))
  .route("/faq", get(Self::faq))
  .route("/favicon.ico", get(Self::favicon))
  .route("/input/:block/:transaction/:input", get(Self::input))
- .route("/inscription/:txid", get(Self::inscription))
+ .route("/inscription/:inscription_id", get(Self::inscription))
  .route("/install.sh", get(Self::install_script))
  .route("/ordinal/:sat", get(Self::ordinal))
  .route("/output/:output", get(Self::output))
@@ -635,6 +636,37 @@ impl Server {
  Redirect::to("https://docs.ordinals.com/bounty/")
  }
 
+ async fn content(
+ Extension(index): Extension<Arc<Index>>,
+ Path(inscription_id): Path<InscriptionId>,
+ ) -> ServerResult<Response> {
+ let (inscription, _) = index
+ .get_inscription_by_inscription_id(inscription_id)
+ .map_err(|err| {
+ ServerError::Internal(anyhow!(
+ "failed to retrieve inscription with inscription id {inscription_id} from index: {err}"
+ ))
+ })?
+ .ok_or_else(|| {
+ ServerError::NotFound(format!("transaction {inscription_id} has no inscription"))
+ })?;
+
+ let (content_type, content) = Self::content_response(inscription).ok_or_else(|| {
+ ServerError::NotFound(format!("inscription {inscription_id} has no content"))
+ })?;
+
+ Ok(([(header::CONTENT_TYPE, content_type)], content).into_response())
+ }
+
+ fn content_response(inscription: Inscription) -> Option<(String, Vec<u8>)> {
+ let content = inscription.content_bytes()?;
+
+ match inscription.content_type() {
+ Some(content_type) => Some((content_type.into(), content.to_vec())),
+ None => Some(("application/octet-stream".into(), content.to_vec())),
+ }
+ }
+
  async fn inscription(
  Extension(chain): Extension<Chain>,
  Extension(index): Extension<Arc<Index>>,
@@ -1631,4 +1663,34 @@ next.*",
  5,
  );
  }
+
+ #[test]
+ fn content_response_no_content() {
+ assert_eq!(
+ Server::content_response(Inscription::new(
+ Some("text/plain".as_bytes().to_vec()),
+ None
+ )),
+ None
+ );
+ }
+
+ #[test]
+ fn content_response_with_content() {
+ assert_eq!(
+ Server::content_response(Inscription::new(
+ Some("text/plain".as_bytes().to_vec()),
+ Some(vec![1, 2, 3]),
+ )),
+ Some(("text/plain".into(), vec![1, 2, 3]))
+ );
+ }
+
+ #[test]
+ fn content_response_no_content_type() {
+ assert_eq!(
+ Server::content_response(Inscription::new(None, Some(vec![]))),
+ Some(("application/octet-stream".into(), vec![]))
+ );
+ }
 }

tests/server.rs

@@ -159,3 +159,31 @@ HELLOWORLD.*",
  ),
  )
 }
+
+#[test]
+fn inscription_content() {
+ 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 = reveal_txid_from_inscribe_stdout(&stdout);
+
+ rpc_server.mine_blocks(1);
+
+ let response =
+ TestServer::spawn_with_args(&rpc_server, &[]).request(&format!("/content/{reveal_tx}"));
+
+ assert_eq!(response.status(), StatusCode::OK);
+ assert_eq!(
+ response.headers().get("content-type").unwrap(),
+ "text/plain;charset=utf-8"
+ );
+ assert_eq!(response.bytes().unwrap(), "HELLOWORLD");
+}

tests/test_server.rs

@@ -1,6 +1,9 @@
-use super::*;
-use crate::command_builder::ToArgs;
-use bitcoincore_rpc::{Auth, Client, RpcApi};
+use {
+ super::*,
+ crate::command_builder::ToArgs,
+ bitcoincore_rpc::{Auth, Client, RpcApi},
+ reqwest::blocking::Response,
+};
 
 pub(crate) struct TestServer {
  child: Child,
@@ -76,6 +79,24 @@ impl TestServer {
  assert_eq!(response.status(), StatusCode::OK);
  assert_regex_match!(response.text().unwrap(), regex);
  }
+
+ pub(crate) fn request(&self, path: &str) -> Response {
+ let client = Client::new(&self.rpc_url, Auth::None).unwrap();
+ let chain_block_count = client.get_block_count().unwrap() + 1;
+
+ for i in 0.. {
+ let response = reqwest::blocking::get(self.url().join("/block-count").unwrap()).unwrap();
+ assert_eq!(response.status(), StatusCode::OK);
+ if response.text().unwrap().parse::<u64>().unwrap() == chain_block_count {
+ break;
+ } else if i == 20 {
+ panic!("index failed to synchronize with chain");
+ }
+ thread::sleep(Duration::from_millis(25));
+ }
+
+ reqwest::blocking::get(self.url().join(path).unwrap()).unwrap()
+ }
 }
 
 impl Drop for TestServer {