rebased ocean-archive

Author: nagarajm22

lib/Cargo.lock

@@ -19,7 +19,7 @@ tarpc = { version = "0.33", features = ["tokio1", "serde1", "serde-transport","t
 tokio = { version = "1", features = ["full"] }
 serde_json = "1.0"
 json = "0.12.4"
-tokio-serde = {version="0.8.0", features = ["full"]}
+tokio-serde = {version="0.8.0"}
 futures = "0.3.29"
 jsonrpsee =  { version = "0.20.3", features = ["server", "macros", "http-client", "jsonrpsee-server"] }
 rocksdb = "0.21.0"
@@ -28,3 +28,4 @@ tempdir = "0.3.7"
 bitcoin_hashes = "0.12.0"
 structopt = { version = "0.3", default-features = false }
 tempfile = "3.8.1"
+anyhow.workspace = true

lib/ain-ocean/Cargo.toml

@@ -1,9 +1,12 @@
-use axum::{debug_handler, extract::{Path, Query}, Json, routing::get, Router};
+use axum::{
+    debug_handler,
+    extract::{Path, Query},
+    routing::get,
+    Json, Router,
+};
 use serde::{Deserialize, Serialize};
 
 use crate::api_paged_response::ApiPagedResponse;
-use axum::{extract::Path, routing::get, Router};
-use serde::Deserialize;
 
 #[derive(Deserialize)]
 struct BlockId {
@@ -18,7 +21,7 @@ struct BlockHash {
 #[derive(Deserialize)]
 pub struct ListBlocksQuery {
     pub size: usize,
-    pub next: Option<String>
+    pub next: Option<String>,
 }
 
 #[debug_handler]
@@ -31,15 +34,9 @@ async fn list_blocks(Query(query): Query<ListBlocksQuery>) -> Json<ApiPagedRespo
         Block { id: "2".into() },
     ];
 
-    Json(ApiPagedResponse
-        ::of(
-            blocks,
-            query.size,
-            |block| block.clone().id
-        )
-    )
-async fn list_blocks() -> String {
-    "List of blocks".to_string()
+    Json(ApiPagedResponse::of(blocks, query.size, |block| {
+        block.clone().id
+    }))
 }
 
 async fn get_block(Path(BlockId { id }): Path<BlockId>) -> String {

lib/ain-ocean/src/api/block.rs

@@ -5,17 +5,17 @@ use serde::Serialize;
 /// Each ApiPagedResponse holds the data array and the "token" for next part of the slice.
 /// The next token should be passed via query 'next' and only used when getting the next slice.
 /// Hence the first request, the next token is always empty and not provided.
-/// 
+///
 /// With ascending sorted list and a limit of 3 items per slice will have the behaviour as such.
-/// 
+///
 /// SORTED  : | [1] [2] [3] | [4] [5] [6] | [7] [8] [9] | [10]
 /// Query 1 : Data: [1] [2] [3], Next: 3, Operator: GT (>)
 /// Query 2 : Data: [4] [5] [6], Next: 6, Operator: GT (>)
 /// Query 3 : Data: [7] [8] [9], Next: 3, Operator: GT (>)
 /// Query 4 : Data: [10], Next: undefined
-/// 
+///
 /// This design is resilient also mutating sorted list, where pagination is not.
-/// 
+///
 /// SORTED  : [2] [4] [6] [8] [10] [12] [14]
 /// Query 1 : Data: [2] [4] [6], Next: 6, Operator: GT (>)
 ///
@@ -27,7 +27,7 @@ use serde::Serialize;
 /// Limitations of this requires your dat astructure to always be sorted in one direction and your sort
 /// indexes always fixed. Hence the moving down of the slice window, your operator will be greater than (GT).
 /// While moving up your operator will be less than (GT).
-/// 
+///
 /// ASC  : | [1] [2] [3] | [4] [5] [6] | [7] [8] [9] |
 ///                      >3            >6             >9
 /// DESC : | [9] [8] [7] | [6] [5] [4] | [3] [2] [1] |
@@ -37,15 +37,15 @@ use serde::Serialize;
 /// when the usage narrative is clear and so will the use of ease. LIST query must be dead simple.
 /// Image travelling down the path, and getting a "next token" to get the next set of itmes to
 /// continue walking.
-/// 
+///
 /// Because the limit is not part of the slice window your query mechanism should support varying size windows.
-/// 
+///
 /// DATA: | [1] [2] [3] | [4] [5] [6] [7] | [8] [9] | ...
 ///       | limit 3, >3 | limit 4, >7     | limit 2, >9
 /// For simplicity your API should not attempt to allow access to different sort indexes, be cognizant of
 /// how our APIs are consumed. If we create a GET /blocks operation to list blocks what would the correct indexes
 /// be 99% of the time?
-/// 
+///
 /// Answer: Blocks sorted by height in descending order, that's your sorted list and your slice window.
 ///       : <- Latest | [100] [99] [98] [97] [...] | Oldest ->
 ///
@@ -62,7 +62,12 @@ struct ApiPage {
 
 impl<T> ApiPagedResponse<T> {
     pub fn new(data: Vec<T>, next: Option<&str>) -> Self {
-        Self { data, page: ApiPage{ next: next.map(Into::into) } } // Option<&str> -> Option<String>
+        Self {
+            data,
+            page: ApiPage {
+                next: next.map(Into::into),
+            },
+        } // Option<&str> -> Option<String>
     }
 
     pub fn next(data: Vec<T>, next: Option<&str>) -> Self {
@@ -77,22 +82,22 @@ impl<T> ApiPagedResponse<T> {
             Self::next(data, None)
         }
     }
-    
+
     pub fn empty() -> Self {
         Self::new(Vec::new(), None)
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::{ApiPagedResponse, ApiPage};
-    
+    use super::{ApiPage, ApiPagedResponse};
+
     #[derive(Clone, Debug)]
     struct Item {
         id: String,
         sort: String,
     }
-    
+
     impl Item {
         fn new(id: &str, sort: &str) -> Self {
             Self {
@@ -101,25 +106,19 @@ mod tests {
             }
         }
     }
-    
+
     #[test]
     fn should_next_with_none() {
-        let items: Vec<Item> = vec![
-            Item::new("0", "a"),
-            Item::new("1", "b"),
-        ];
-    
+        let items: Vec<Item> = vec![Item::new("0", "a"), Item::new("1", "b")];
+
         let next = ApiPagedResponse::next(items, None).page.next;
         assert_eq!(next, None);
     }
 
     #[test]
     fn should_next_with_value() {
-        let items: Vec<Item> = vec![
-            Item::new("0", "a"),
-            Item::new("1", "b"),
-        ];
-    
+        let items: Vec<Item> = vec![Item::new("0", "a"), Item::new("1", "b")];
+
         let next = ApiPagedResponse::next(items, Some("b")).page.next;
         assert_eq!(next, Some("b".into()));
     }
@@ -131,20 +130,18 @@ mod tests {
             Item::new("1", "b"),
             Item::new("2", "c"),
         ];
-        
-        let next = ApiPagedResponse::of(items, 3, |item| item.clone().sort).page.next;
+
+        let next = ApiPagedResponse::of(items, 3, |item| item.clone().sort)
+            .page
+            .next;
         assert_eq!(next, Some("c".into()))
     }
-    
+
     #[test]
     fn should_not_create_with_limit_3_while_size_2() {
-        let items: Vec<Item> = vec![
-            Item::new("0", "a"),
-            Item::new("1", "b"),
-        ];
-        
+        let items: Vec<Item> = vec![Item::new("0", "a"), Item::new("1", "b")];
+
         let page = ApiPagedResponse::of(items, 3, |item| item.clone().sort).page;
-        assert_eq!(page, ApiPage{next: None})
+        assert_eq!(page, ApiPage { next: None })
     }
-
 }

lib/ain-ocean/src/api_paged_response.rs

@@ -3,6 +3,7 @@ use crate::database::db_manger::RocksDB;
 use crate::model::masternode::Masternode;
 use anyhow::{anyhow, Result};
 use serde::{Deserialize, Serialize};
+use serde_json;
 
 pub struct MasterNodeDB {
     pub db: RocksDB,