Limit blocks

src/index.rs

@@ -5,6 +5,8 @@ use {
   redb::WriteStrategy,
 };
 
+mod rtx;
+
 const HEIGHT_TO_HASH: TableDefinition<u64, [u8]> = TableDefinition::new("HEIGHT_TO_HASH");
 const OUTPOINT_TO_ORDINAL_RANGES: TableDefinition<[u8], [u8]> =
   TableDefinition::new("OUTPOINT_TO_ORDINAL_RANGES");
@@ -231,29 +233,26 @@ impl Index {
     Ok(false)
   }
 
-  pub(crate) fn height(&self) -> Result<u64> {
-    let tx = self.database.begin_read()?;
-
-    let height_to_hash = tx.open_table(HEIGHT_TO_HASH)?;
+  fn begin_read(&self) -> Result<rtx::Rtx> {
+    Ok(rtx::Rtx(self.database.begin_read()?))
+  }
 
-    Ok(
-      height_to_hash
-        .range(0..)?
-        .rev()
-        .next()
-        .map(|(height, _hash)| height)
-        .unwrap_or(0),
-    )
+  pub(crate) fn height(&self) -> Result<u64> {
+    self.begin_read()?.height()
   }
 
-  pub(crate) fn all(&self) -> Result<Vec<(u64, BlockHash)>> {
+  pub(crate) fn blocks(&self, take: u64) -> Result<Vec<(u64, BlockHash)>> {
     let mut blocks = Vec::new();
 
-    let tx = self.database.begin_read()?;
+    let rtx = self.begin_read()?;
+
+    let height = rtx.height()?;
 
-    let height_to_hash = tx.open_table(HEIGHT_TO_HASH)?;
+    let height_to_hash = rtx.0.open_table(HEIGHT_TO_HASH)?;
 
-    let mut cursor = height_to_hash.range(0..)?.rev();
+    let mut cursor = height_to_hash
+      .range(height.saturating_sub(take)..=height)?
+      .rev();
 
     while let Some(next) = cursor.next() {
       blocks.push((next.0, BlockHash::from_slice(next.1)?));

src/index/rtx.rs

@@ -0,0 +1,18 @@
+use super::*;
+
+pub(crate) struct Rtx<'a>(pub(crate) redb::ReadTransaction<'a>);
+
+impl Rtx<'_> {
+  pub(crate) fn height(&self) -> Result<u64> {
+    let height_to_hash = self.0.open_table(HEIGHT_TO_HASH)?;
+
+    Ok(
+      height_to_hash
+        .range(0..)?
+        .rev()
+        .next()
+        .map(|(height, _hash)| height)
+        .unwrap_or(0),
+    )
+  }
+}

src/subcommand/server.rs

@@ -229,7 +229,7 @@ impl Server {
   }
 
   async fn root(index: extract::Extension<Arc<Index>>) -> impl IntoResponse {
-    match index.all() {
+    match index.blocks(100) {
       Ok(blocks) => RootHtml { blocks }.page().into_response(),
       Err(err) => {
         eprintln!("Error getting blocks: {err}");

tests/server.rs

@@ -149,6 +149,19 @@ fn root() {
   );
 }
 
+#[test]
+fn root_block_limit() {
+  let mut state = State::new();
+
+  state.blocks(200);
+
+  state.request_regex(
+    "/",
+    200,
+    ".*<ul>\n(  <li>[[:digit:]]{3} - <a href=/block/[[:xdigit:]]{64}>[[:xdigit:]]{64}</a></li>\n){101}</ul>.*"
+  );
+}
+
 #[test]
 fn block() {
   let mut state = State::new();