Refactor inscriptions paginations

src/index.rs

@@ -1301,55 +1301,31 @@ impl Index {
     Ok(result)
   }
 
-  pub(crate) fn get_latest_inscriptions_with_prev_and_next(
+  pub(crate) fn get_inscriptions_paginated(
     &self,
-    n: usize,
-    from: Option<u32>,
-  ) -> Result<(Vec<InscriptionId>, Option<u32>, Option<u32>, u32, u32)> {
+    page_size: usize,
+    page_index: usize,
+  ) -> Result<(Vec<InscriptionId>, bool)> {
     let rtx = self.database.begin_read()?;
 
     let sequence_number_to_inscription_entry =
       rtx.open_table(SEQUENCE_NUMBER_TO_INSCRIPTION_ENTRY)?;
 
-    let highest = match sequence_number_to_inscription_entry.iter()?.next_back() {
-      Some(Ok((number, _entry))) => number.value(),
-      Some(Err(_)) | None => return Ok(Default::default()),
-    };
-
-    let lowest = match sequence_number_to_inscription_entry.iter()?.next() {
-      Some(Ok((number, _entry))) => number.value(),
-      Some(Err(_)) | None => return Ok(Default::default()),
-    };
-
-    let from = from.unwrap_or(highest);
-
-    let prev = if let Some(prev) = from.checked_sub(n.try_into()?) {
-      sequence_number_to_inscription_entry
-        .get(&prev)?
-        .map(|_| prev)
-    } else {
-      None
-    };
-
-    let next = if from < highest {
-      Some(
-        from
-          .checked_add(n.try_into()?)
-          .unwrap_or(highest)
-          .min(highest),
-      )
-    } else {
-      None
-    };
-
-    let inscriptions = sequence_number_to_inscription_entry
-      .range(..=from)?
+    let mut inscriptions = sequence_number_to_inscription_entry
+      .iter()?
       .rev()
-      .take(n)
+      .skip(page_size.saturating_mul(page_index))
+      .take(page_size.saturating_add(1))
       .flat_map(|result| result.map(|(_number, entry)| InscriptionEntry::load(entry.value()).id))
-      .collect();
+      .collect::<Vec<InscriptionId>>();
+
+    let more = inscriptions.len() > page_size;
+
+    if more {
+      inscriptions.pop();
+    }
 
-    Ok((inscriptions, prev, next, lowest, highest))
+    Ok((inscriptions, more))
   }
 
   pub(crate) fn get_inscriptions_in_block(&self, block_height: u32) -> Result<Vec<InscriptionId>> {
@@ -2820,59 +2796,9 @@ mod tests {
 
       context.mine_blocks(1);
 
-      let (inscriptions, prev, next, _, _) = context
-        .index
-        .get_latest_inscriptions_with_prev_and_next(100, None)
-        .unwrap();
+      let (inscriptions, more) = context.index.get_inscriptions_paginated(100, 0).unwrap();
       assert_eq!(inscriptions, &[inscription_id]);
-      assert_eq!(prev, None);
-      assert_eq!(next, None);
-    }
-  }
-
-  #[test]
-  fn get_latest_inscriptions_with_prev_and_next() {
-    for context in Context::configurations() {
-      context.mine_blocks(1);
-
-      let mut ids = Vec::new();
-
-      for i in 0..103 {
-        let txid = context.rpc_server.broadcast_tx(TransactionTemplate {
-          inputs: &[(i + 1, 0, 0, inscription("text/plain", "hello").to_witness())],
-          ..Default::default()
-        });
-        ids.push(InscriptionId { txid, index: 0 });
-        context.mine_blocks(1);
-      }
-
-      ids.reverse();
-
-      let (inscriptions, prev, next, lowest, highest) = context
-        .index
-        .get_latest_inscriptions_with_prev_and_next(100, None)
-        .unwrap();
-      assert_eq!(inscriptions, &ids[..100]);
-      assert_eq!(prev, Some(2));
-      assert_eq!(next, None);
-      assert_eq!(highest, 102);
-      assert_eq!(lowest, 0);
-
-      let (inscriptions, prev, next, _lowest, _highest) = context
-        .index
-        .get_latest_inscriptions_with_prev_and_next(100, Some(101))
-        .unwrap();
-      assert_eq!(inscriptions, &ids[1..101]);
-      assert_eq!(prev, Some(1));
-      assert_eq!(next, Some(102));
-
-      let (inscriptions, prev, next, _lowest, _highest) = context
-        .index
-        .get_latest_inscriptions_with_prev_and_next(100, Some(0))
-        .unwrap();
-      assert_eq!(inscriptions, &ids[102..103]);
-      assert_eq!(prev, None);
-      assert_eq!(next, Some(100));
+      assert!(!more);
     }
   }
 

src/subcommand/server.rs

@@ -211,15 +211,14 @@ impl Server {
         .route("/input/:block/:transaction/:input", get(Self::input))
         .route("/inscription/:inscription_query", get(Self::inscription))
         .route("/inscriptions", get(Self::inscriptions))
-        .route("/inscriptions/:from", get(Self::inscriptions_from))
-        .route("/inscriptions/:from/:n", get(Self::inscriptions_from_n))
+        .route("/inscriptions/:page", get(Self::inscriptions_paginated))
         .route(
           "/inscriptions/block/:height",
           get(Self::inscriptions_in_block),
         )
         .route(
           "/inscriptions/block/:height/:page",
-          get(Self::inscriptions_in_block_from_page),
+          get(Self::inscriptions_in_block_paginated),
         )
         .route("/install.sh", get(Self::install_script))
         .route("/ordinal/:sat", get(Self::ordinal))
@@ -1329,88 +1328,95 @@ impl Server {
     Extension(index): Extension<Arc<Index>>,
     accept_json: AcceptJson,
   ) -> ServerResult<Response> {
-    Self::inscriptions_inner(page_config, index, None, 100, accept_json).await
-  }
-
-  async fn inscriptions_in_block(
-    Extension(page_config): Extension<Arc<PageConfig>>,
-    Extension(index): Extension<Arc<Index>>,
-    Path(block_height): Path<u32>,
-    accept_json: AcceptJson,
-  ) -> ServerResult<Response> {
-    Self::inscriptions_in_block_from_page(
+    Self::inscriptions_paginated(
       Extension(page_config),
       Extension(index),
-      Path((block_height, 0)),
+      Path(0),
       accept_json,
     )
     .await
   }
 
-  async fn inscriptions_in_block_from_page(
+  async fn inscriptions_paginated(
     Extension(page_config): Extension<Arc<PageConfig>>,
     Extension(index): Extension<Arc<Index>>,
-    Path((block_height, page)): Path<(u32, usize)>,
+    Path(page_index): Path<usize>,
     accept_json: AcceptJson,
   ) -> ServerResult<Response> {
-    let inscriptions = index.get_inscriptions_in_block(block_height)?;
+    let (inscriptions, more_inscriptions) = index.get_inscriptions_paginated(100, page_index)?;
+
+    let prev = page_index.checked_sub(1);
+
+    let next = more_inscriptions.then_some(page_index + 1);
 
     Ok(if accept_json.0 {
-      Json(InscriptionsJson::new(inscriptions, None, None, None, None)).into_response()
+      Json(InscriptionsJson {
+        inscriptions,
+        page_index,
+        more: more_inscriptions,
+      })
+      .into_response()
     } else {
-      InscriptionsBlockHtml::new(
-        block_height,
-        index.block_height()?.unwrap_or(Height(0)).n(),
+      InscriptionsHtml {
         inscriptions,
-        page,
-      )?
+        next,
+        prev,
+      }
       .page(page_config)
       .into_response()
     })
   }
 
-  async fn inscriptions_from(
+  async fn inscriptions_in_block(
     Extension(page_config): Extension<Arc<PageConfig>>,
     Extension(index): Extension<Arc<Index>>,
-    Path(from): Path<u32>,
+    Path(block_height): Path<u32>,
     accept_json: AcceptJson,
   ) -> ServerResult<Response> {
-    Self::inscriptions_inner(page_config, index, Some(from), 100, accept_json).await
+    Self::inscriptions_in_block_paginated(
+      Extension(page_config),
+      Extension(index),
+      Path((block_height, 0)),
+      accept_json,
+    )
+    .await
   }
 
-  async fn inscriptions_from_n(
+  async fn inscriptions_in_block_paginated(
     Extension(page_config): Extension<Arc<PageConfig>>,
     Extension(index): Extension<Arc<Index>>,
-    Path((from, n)): Path<(u32, usize)>,
+    Path((block_height, page_index)): Path<(u32, usize)>,
     accept_json: AcceptJson,
   ) -> ServerResult<Response> {
-    Self::inscriptions_inner(page_config, index, Some(from), n, accept_json).await
-  }
+    let page_size = 100;
+
+    let mut inscriptions = index
+      .get_inscriptions_in_block(block_height)?
+      .into_iter()
+      .skip(page_index.saturating_mul(page_size))
+      .take(page_size.saturating_add(1))
+      .collect::<Vec<InscriptionId>>();
+
+    let more = inscriptions.len() > page_size;
+
+    if more {
+      inscriptions.pop();
+    }
 
-  async fn inscriptions_inner(
-    page_config: Arc<PageConfig>,
-    index: Arc<Index>,
-    from: Option<u32>,
-    n: usize,
-    accept_json: AcceptJson,
-  ) -> ServerResult<Response> {
-    let (inscriptions, prev, next, lowest, highest) =
-      index.get_latest_inscriptions_with_prev_and_next(n, from)?;
     Ok(if accept_json.0 {
-      Json(InscriptionsJson::new(
+      Json(InscriptionsJson {
         inscriptions,
-        prev,
-        next,
-        Some(lowest),
-        Some(highest),
-      ))
+        page_index,
+        more,
+      })
       .into_response()
     } else {
-      InscriptionsHtml {
+      InscriptionsBlockHtml::new(
+        block_height,
+        index.block_height()?.unwrap_or(Height(0)).n(),
         inscriptions,
-        next,
-        prev,
-      }
+        page_index,
+      )?
       .page(page_config)
       .into_response()
     })
@@ -3592,7 +3598,7 @@ mod tests {
     server.mine_blocks(1);
 
     server.assert_response_regex(
-      "/inscriptions",
+      "/inscriptions/1",
       StatusCode::OK,
       ".*<a class=prev href=/inscriptions/0>prev</a>\nnext.*",
     );
@@ -3615,7 +3621,7 @@ mod tests {
     server.assert_response_regex(
       "/inscriptions/0",
       StatusCode::OK,
-      ".*prev\n<a class=next href=/inscriptions/100>next</a>.*",
+      ".*prev\n<a class=next href=/inscriptions/1>next</a>.*",
     );
   }
 

src/templates/inscriptions.rs

@@ -3,35 +3,15 @@ use super::*;
 #[derive(Boilerplate)]
 pub(crate) struct InscriptionsHtml {
   pub(crate) inscriptions: Vec<InscriptionId>,
-  pub(crate) prev: Option<u32>,
-  pub(crate) next: Option<u32>,
+  pub(crate) prev: Option<usize>,
+  pub(crate) next: Option<usize>,
 }
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 pub struct InscriptionsJson {
   pub inscriptions: Vec<InscriptionId>,
-  pub prev: Option<u32>,
-  pub next: Option<u32>,
-  pub lowest: Option<u32>,
-  pub highest: Option<u32>,
-}
-
-impl InscriptionsJson {
-  pub fn new(
-    inscriptions: Vec<InscriptionId>,
-    prev: Option<u32>,
-    next: Option<u32>,
-    lowest: Option<u32>,
-    highest: Option<u32>,
-  ) -> Self {
-    Self {
-      inscriptions,
-      prev,
-      next,
-      lowest,
-      highest,
-    }
-  }
+  pub more: bool,
+  pub page_index: usize,
 }
 
 impl PageContent for InscriptionsHtml {