Avoid skip

src/index.rs

@@ -1656,23 +1656,32 @@ impl Index {
 
   pub(crate) fn get_inscriptions_paginated(
     &self,
-    page_size: usize,
-    page_index: usize,
+    page_size: u32,
+    page_index: u32,
   ) -> 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 mut inscriptions = sequence_number_to_inscription_entry
+    let last = sequence_number_to_inscription_entry
       .iter()?
+      .next_back()
+      .map(|result| result.map(|(number, _entry)| number.value()))
+      .transpose()?
+      .unwrap_or_default();
+
+    let start = last.saturating_sub(page_size.saturating_mul(page_index));
+
+    let end = start.saturating_sub(page_size);
+
+    let mut inscriptions = sequence_number_to_inscription_entry
+      .range(end..=start)?
       .rev()
-      .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::<Vec<InscriptionId>>();
+      .map(|result| result.map(|(_number, entry)| InscriptionEntry::load(entry.value()).id))
+      .collect::<Result<Vec<InscriptionId>, StorageError>>()?;
 
-    let more = inscriptions.len() > page_size;
+    let more = u32::try_from(inscriptions.len()).unwrap_or(u32::MAX) > page_size;
 
     if more {
       inscriptions.pop();
@@ -3348,7 +3357,7 @@ mod tests {
   }
 
   #[test]
-  fn get_latest_inscriptions_with_no_prev_and_next() {
+  fn get_latest_inscriptions_with_no_more() {
     for context in Context::configurations() {
       context.mine_blocks(1);
 
@@ -3366,6 +3375,33 @@ mod tests {
     }
   }
 
+  #[test]
+  fn get_latest_inscriptions_with_more() {
+    for context in Context::configurations() {
+      context.mine_blocks(1);
+
+      let mut ids = Vec::new();
+
+      for i in 0..101 {
+        let txid = context.rpc_server.broadcast_tx(TransactionTemplate {
+          inputs: &[(i + 1, 0, 0, inscription("text/plain", "hello").to_witness())],
+          ..Default::default()
+        });
+        context.mine_blocks(1);
+        ids.push(InscriptionId { txid, index: 0 });
+      }
+
+      ids.reverse();
+      ids.pop();
+
+      assert_eq!(ids.len(), 100);
+
+      let (inscriptions, more) = context.index.get_inscriptions_paginated(100, 0).unwrap();
+      assert_eq!(inscriptions, ids);
+      assert!(more);
+    }
+  }
+
   #[test]
   fn unsynced_index_fails() {
     for context in Context::configurations() {

src/subcommand/server.rs

@@ -1460,21 +1460,21 @@ impl Server {
   async fn inscriptions_paginated(
     Extension(server_config): Extension<Arc<ServerConfig>>,
     Extension(index): Extension<Arc<Index>>,
-    Path(page_index): Path<usize>,
+    Path(page_index): Path<u32>,
     AcceptJson(accept_json): AcceptJson,
   ) -> ServerResult<Response> {
     task::block_in_place(|| {
-      let (inscriptions, more_inscriptions) = index.get_inscriptions_paginated(100, page_index)?;
+      let (inscriptions, more) = index.get_inscriptions_paginated(100, page_index)?;
 
       let prev = page_index.checked_sub(1);
 
-      let next = more_inscriptions.then_some(page_index + 1);
+      let next = more.then_some(page_index + 1);
 
       Ok(if accept_json {
         Json(InscriptionsJson {
           inscriptions,
           page_index,
-          more: more_inscriptions,
+          more,
         })
         .into_response()
       } else {
@@ -1507,20 +1507,23 @@ impl Server {
   async fn inscriptions_in_block_paginated(
     Extension(server_config): Extension<Arc<ServerConfig>>,
     Extension(index): Extension<Arc<Index>>,
-    Path((block_height, page_index)): Path<(u32, usize)>,
+    Path((block_height, page_index)): Path<(u32, u32)>,
     AcceptJson(accept_json): AcceptJson,
   ) -> ServerResult<Response> {
     task::block_in_place(|| {
       let page_size = 100;
 
+      let page_index_usize = usize::try_from(page_index).unwrap_or(usize::MAX);
+      let page_size_usize = usize::try_from(page_size).unwrap_or(usize::MAX);
+
       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))
+        .skip(page_index_usize.saturating_mul(page_size_usize))
+        .take(page_size_usize.saturating_add(1))
         .collect::<Vec<InscriptionId>>();
 
-      let more = inscriptions.len() > page_size;
+      let more = inscriptions.len() > page_size_usize;
 
       if more {
         inscriptions.pop();

src/templates/inscriptions.rs

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

src/templates/inscriptions_block.rs

@@ -6,8 +6,8 @@ pub(crate) struct InscriptionsBlockHtml {
   pub(crate) inscriptions: Vec<InscriptionId>,
   pub(crate) prev_block: Option<u32>,
   pub(crate) next_block: Option<u32>,
-  pub(crate) prev_page: Option<usize>,
-  pub(crate) next_page: Option<usize>,
+  pub(crate) prev_page: Option<u32>,
+  pub(crate) next_page: Option<u32>,
 }
 
 impl InscriptionsBlockHtml {
@@ -16,7 +16,7 @@ impl InscriptionsBlockHtml {
     current_blockheight: u32,
     inscriptions: Vec<InscriptionId>,
     more_inscriptions: bool,
-    page_index: usize,
+    page_index: u32,
   ) -> Result<Self> {
     if inscriptions.is_empty() {
       return Err(anyhow!("page index {page_index} exceeds inscription count"));