Migrate query-service availability endpoints

Cargo.toml

@@ -141,7 +141,7 @@ async-trait = "0.1"
 atomic = "0.6"
 atomic_store = { git = "https://github.com/EspressoSystems/atomicstore.git", tag = "0.1.5" }
 automod = "1.0.14"
-axum = "0.8.8"
+axum = { version = "0.8.8", features = ["ws"] }
 backoff = "0.4"
 base64 = "0.22"
 base64-bytes = "0.1"

crates/cliquenet/Cargo.toml

@@ -14,16 +14,16 @@ bytes           = { workspace = true }
 ed25519-compact = { workspace = true }
 parking_lot     = { workspace = true }
 rand            = "0.10.0"
+
+# optional:
+serde           = { workspace = true, features = ["derive"], optional = true }
+serde_bytes     = { workspace = true, optional = true }
 snow            = { workspace = true }
 thiserror       = { workspace = true }
 tokio           = { workspace = true, features = ["macros", "net", "rt", "time"] }
 tokio-util      = { workspace = true, features = ["join-map"] }
 tracing         = { workspace = true }
 
-# optional:
-serde           = { workspace = true, features = ["derive"], optional = true }
-serde_bytes     = { workspace = true, optional = true }
-
 [dev-dependencies]
 criterion  = { workspace = true }
 quickcheck = { workspace = true }

crates/espresso/api/Cargo.toml

@@ -9,6 +9,7 @@ anyhow = { workspace = true }
 async-trait = { workspace = true }
 axum = { workspace = true }
 base64 = { workspace = true }
+futures = { workspace = true }
 hex = { workspace = true }
 prost = { workspace = true }
 schemars = { workspace = true }

crates/espresso/api/examples/test_api.rs

@@ -170,6 +170,14 @@ impl v1::AvailabilityApi for TestApi {
         Ok(vec![0xde, 0xad, 0xbe, 0xef])
     }
 
+    async fn stream_namespace_proofs(
+        &self,
+        _from: usize,
+        _namespace: u32,
+    ) -> Result<futures::stream::BoxStream<'static, Self::NamespaceProofQueryData>> {
+        Ok(Box::pin(futures::stream::empty()))
+    }
+
     async fn get_state_cert(&self, epoch: u64) -> Result<Self::StateCertQueryDataV1> {
         tracing::info!("v1: get_state_cert(epoch={})", epoch);
         Ok(vec![0x01, 0x02, 0x03])
@@ -181,6 +189,132 @@ impl v1::AvailabilityApi for TestApi {
     }
 }
 
+// Stub HotShotAvailabilityApi for the example — returns empty/unit data.
+#[async_trait]
+impl v1::HotShotAvailabilityApi for TestApi {
+    type Leaf = serde_json::Value;
+    type Block = serde_json::Value;
+    type Header = serde_json::Value;
+    type Payload = serde_json::Value;
+    type VidCommon = serde_json::Value;
+    type Transaction = serde_json::Value;
+    type TransactionWithProof = serde_json::Value;
+    type BlockSummary = serde_json::Value;
+    type Limits = serde_json::Value;
+    type Cert2 = serde_json::Value;
+
+    async fn get_leaf(&self, _id: v1::LeafId) -> Result<Self::Leaf> {
+        Ok(serde_json::json!({}))
+    }
+    async fn get_leaf_range(&self, _from: usize, _until: usize) -> Result<Vec<Self::Leaf>> {
+        Ok(vec![])
+    }
+    async fn get_header(&self, _id: v1::BlockId) -> Result<Self::Header> {
+        Ok(serde_json::json!({}))
+    }
+    async fn get_header_range(&self, _from: usize, _until: usize) -> Result<Vec<Self::Header>> {
+        Ok(vec![])
+    }
+    async fn get_block(&self, _id: v1::BlockId) -> Result<Self::Block> {
+        Ok(serde_json::json!({}))
+    }
+    async fn get_block_range(&self, _from: usize, _until: usize) -> Result<Vec<Self::Block>> {
+        Ok(vec![])
+    }
+    async fn get_payload(&self, _id: v1::PayloadId) -> Result<Self::Payload> {
+        Ok(serde_json::json!({}))
+    }
+    async fn get_payload_range(&self, _from: usize, _until: usize) -> Result<Vec<Self::Payload>> {
+        Ok(vec![])
+    }
+    async fn get_vid_common(&self, _id: v1::BlockId) -> Result<Self::VidCommon> {
+        Ok(serde_json::json!({}))
+    }
+    async fn get_vid_common_range(
+        &self,
+        _from: usize,
+        _until: usize,
+    ) -> Result<Vec<Self::VidCommon>> {
+        Ok(vec![])
+    }
+    async fn get_transaction_by_position(
+        &self,
+        _height: u64,
+        _index: u64,
+    ) -> Result<Self::Transaction> {
+        Ok(serde_json::json!({}))
+    }
+    async fn get_transaction_by_hash(&self, _hash: String) -> Result<Self::Transaction> {
+        Ok(serde_json::json!({}))
+    }
+    async fn get_transaction_proof_by_position(
+        &self,
+        _height: u64,
+        _index: u64,
+    ) -> Result<Self::TransactionWithProof> {
+        Ok(serde_json::json!({}))
+    }
+    async fn get_transaction_proof_by_hash(
+        &self,
+        _hash: String,
+    ) -> Result<Self::TransactionWithProof> {
+        Ok(serde_json::json!({}))
+    }
+    async fn get_block_summary(&self, _height: usize) -> Result<Self::BlockSummary> {
+        Ok(serde_json::json!({}))
+    }
+    async fn get_block_summary_range(
+        &self,
+        _from: usize,
+        _until: usize,
+    ) -> Result<Vec<Self::BlockSummary>> {
+        Ok(vec![])
+    }
+    async fn get_limits(&self) -> Result<Self::Limits> {
+        Ok(serde_json::json!({"small_object_range_limit": 500, "large_object_range_limit": 100}))
+    }
+    async fn get_cert2(&self, _height: u64) -> Result<Option<Self::Cert2>> {
+        Ok(None)
+    }
+    async fn stream_leaves(
+        &self,
+        _from: usize,
+    ) -> Result<futures::stream::BoxStream<'static, Self::Leaf>> {
+        Ok(Box::pin(futures::stream::empty()))
+    }
+    async fn stream_headers(
+        &self,
+        _from: usize,
+    ) -> Result<futures::stream::BoxStream<'static, Self::Header>> {
+        Ok(Box::pin(futures::stream::empty()))
+    }
+    async fn stream_blocks(
+        &self,
+        _from: usize,
+    ) -> Result<futures::stream::BoxStream<'static, Self::Block>> {
+        Ok(Box::pin(futures::stream::empty()))
+    }
+    async fn stream_payloads(
+        &self,
+        _from: usize,
+    ) -> Result<futures::stream::BoxStream<'static, Self::Payload>> {
+        Ok(Box::pin(futures::stream::empty()))
+    }
+    async fn stream_vid_common(
+        &self,
+        _from: usize,
+    ) -> Result<futures::stream::BoxStream<'static, Self::VidCommon>> {
+        Ok(Box::pin(futures::stream::empty()))
+    }
+    async fn stream_transactions(
+        &self,
+        _from: usize,
+        _namespace: Option<u32>,
+    ) -> Result<futures::stream::BoxStream<'static, Self::Transaction>> {
+        Ok(Box::pin(futures::stream::empty()))
+    }
+}
+
 // Implement v2::RewardApi (simplified API - latest-only for claim/balance/proof)
 #[async_trait]
 impl v2::RewardApi for TestApi {