Merge branch 'main' into ma/binary-upgrade-test-scenarios

Author: sveitser

Cargo.lock

@@ -143,7 +143,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"

Cargo.toml

@@ -35,8 +35,9 @@ pub async fn fetch_stake_table_from_sequencer(
     epoch: Option<EpochNumber>,
 ) -> Result<HSStakeTable<SeqTypes>> {
     tracing::info!("Initializing stake table from node for epoch {epoch:?}");
+    const NUM_RETRIES: usize = 5;
 
-    loop {
+    for i in 0..NUM_RETRIES {
         match epoch {
             Some(epoch) => match surf_disco::Client::<
                 tide_disco::error::ServerError,
@@ -46,13 +47,15 @@ pub async fn fetch_stake_table_from_sequencer(
             .send()
             .await
             {
-                Ok(resp) => break Ok(resp.into()),
+                Ok(resp) => return Ok(resp.into()),
                 Err(e) => {
                     let url = sequencer_url
                         .join(&format!("node/stake-table/{}", epoch.u64()))
                         .unwrap();
-                    tracing::error!(%url, "Failed to fetch the stake table: {e}");
-                    sleep(Duration::from_secs(5)).await;
+                    tracing::warn!(%url, "Failed to fetch the stake table: {e}, num_retries left: {}", NUM_RETRIES - i - 1);
+                    if NUM_RETRIES - i > 1 {
+                        sleep(Duration::from_secs(5)).await;
+                    }
                 },
             },
             None => {
@@ -67,16 +70,21 @@ pub async fn fetch_stake_table_from_sequencer(
                                 &value["config"]["known_nodes_with_stake"].to_string(),
                             )
                             .with_context(|| "Failed to parse the stake table")?;
-                        break Ok(known_nodes_with_stake.into());
+                        return Ok(known_nodes_with_stake.into());
                     },
                     Err(e) => {
-                        tracing::error!(%url, "Failed to fetch the network config: {e}");
-                        sleep(Duration::from_secs(5)).await;
+                        tracing::warn!(%url, "Failed to fetch the network config: {e}, num_retries left: {}", NUM_RETRIES - i - 1);
+                        if NUM_RETRIES - i > 1 {
+                            sleep(Duration::from_secs(5)).await;
+                        }
                     },
                 }
             },
         }
     }
+    Err(anyhow::anyhow!(
+        "Failed to fetch the stake table after {NUM_RETRIES} attempts"
+    ))
 }
 
 #[inline]

contracts/rust/deployer/src/network_config.rs

@@ -9,12 +9,14 @@ 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 }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serialization-api = { path = "../../serialization/api" }
+thiserror = { workspace = true }
 tokio = { workspace = true }
 tonic = { workspace = true }
 tonic-prost = { workspace = true }

crates/espresso/api/Cargo.toml

@@ -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 {