feat(sozo): provider health check

bin/sozo/src/commands/migrate.rs

@@ -1,6 +1,8 @@
-use anyhow::{Context, Result};
+use crate::commands::LOG_TARGET;
+use anyhow::{anyhow, Context, Result};
 use clap::Args;
 use colored::*;
+use dojo_utils::utils::health_check_provider;
 use dojo_utils::{self, TxnConfig};
 use dojo_world::contracts::WorldContract;
 use dojo_world::services::IpfsService;
@@ -10,9 +12,10 @@ use sozo_ops::migration_ui::MigrationUi;
 use sozo_scarbext::WorkspaceExt;
 use starknet::core::utils::parse_cairo_short_string;
 use starknet::providers::Provider;
+use std::sync::Arc;
 use tabled::settings::Style;
 use tabled::{Table, Tabled};
-use tracing::trace;
+use tracing::{error, trace};
 
 use super::options::account::AccountOptions;
 use super::options::ipfs::IpfsOptions;
@@ -141,6 +144,12 @@ async fn print_banner(ws: &Workspace<'_>, starknet: &StarknetOptions) -> Result<
     let profile_config = ws.load_profile_config()?;
     let (provider, rpc_url) = starknet.provider(profile_config.env.as_ref())?;
 
+    let provider = Arc::new(provider);
+    if let Err(e) = health_check_provider(provider.clone()).await {
+        error!(target: LOG_TARGET,"Provider health check failed during sozo migrate.");
+        return Err(e);
+    }
+    let provider = Arc::try_unwrap(provider).map_err(|_| anyhow!("Failed to unwrap Arc"))?;
     let chain_id = provider.chain_id().await?;
     let chain_id =
         parse_cairo_short_string(&chain_id).with_context(|| "Cannot parse chain_id as string")?;

bin/sozo/src/commands/mod.rs

@@ -34,6 +34,8 @@ use migrate::MigrateArgs;
 use model::ModelArgs;
 use test::TestArgs;
 
+pub(crate) const LOG_TARGET: &str = "sozo::cli";
+
 #[derive(Debug, Subcommand)]
 pub enum Commands {
     #[command(about = "Grant or revoke a contract permission to write to a resource")]
@@ -42,8 +44,10 @@ pub enum Commands {
     Build(Box<BuildArgs>),
     #[command(about = "Build and migrate the world every time a file changes")]
     Dev(Box<DevArgs>),
-    #[command(about = "Run a migration, declaring and deploying contracts as necessary to update \
-                       the world")]
+    #[command(
+        about = "Run a migration, declaring and deploying contracts as necessary to update \
+                       the world"
+    )]
     Migrate(Box<MigrateArgs>),
     #[command(about = "Execute a system with the given calldata.")]
     Execute(Box<ExecuteArgs>),

bin/sozo/src/utils.rs

@@ -1,10 +1,13 @@
 use std::collections::HashMap;
 use std::io::{self, Write};
 use std::str::FromStr;
+use std::sync::Arc;
 
+use crate::commands::LOG_TARGET;
 use anyhow::{anyhow, Context, Result};
 use camino::Utf8PathBuf;
 use colored::*;
+use dojo_utils::utils::health_check_provider;
 use dojo_world::config::ProfileConfig;
 use dojo_world::contracts::ContractInfo;
 use dojo_world::diff::WorldDiff;
@@ -19,7 +22,7 @@ use starknet::core::types::Felt;
 use starknet::core::utils as snutils;
 use starknet::providers::jsonrpc::HttpTransport;
 use starknet::providers::{JsonRpcClient, Provider};
-use tracing::trace;
+use tracing::{error, trace};
 
 use crate::commands::options::account::{AccountOptions, SozoAccount};
 use crate::commands::options::starknet::StarknetOptions;
@@ -113,6 +116,12 @@ pub async fn get_world_diff_and_provider(
     let world_address = get_world_address(&profile_config, &world, &world_local)?;
 
     let (provider, rpc_url) = starknet.provider(env)?;
+    let provider = Arc::new(provider);
+    if let Err(e) = health_check_provider(provider.clone()).await {
+        error!(target: LOG_TARGET,"Provider health check failed during sozo inspect.");
+        return Err(e);
+    }
+    let provider = Arc::try_unwrap(provider).map_err(|_| anyhow!("Failed to unwrap Arc"))?;
     trace!(?provider, "Provider initialized.");
 
     let spec_version = provider.spec_version().await?;

crates/dojo/utils/src/lib.rs

@@ -14,3 +14,4 @@ pub mod env;
 pub mod keystore;
 
 pub mod signal;
+pub mod utils;

crates/dojo/utils/src/utils.rs

@@ -0,0 +1,22 @@
+use starknet::core::types::{BlockId, BlockTag};
+use starknet::providers::Provider;
+use tracing::trace;
+
+pub async fn health_check_provider<P: Provider + Sync + std::fmt::Debug + 'static>(
+    provider: P,
+) -> anyhow::Result<(), anyhow::Error> {
+    match provider.get_block_with_tx_hashes(BlockId::Tag(BlockTag::Latest)).await {
+        Ok(block) => {
+            trace!(
+                latest_block = ?block,
+                "Provider health check."
+            );
+            Ok(())
+        }
+        Err(_) => {
+            let error_info =
+                format!("Unhealthy provider {:?}, please check your configuration.", provider);
+            Err(anyhow::anyhow!(error_info))
+        }
+    }
+}

crates/torii/core/Cargo.toml

@@ -18,6 +18,7 @@ chrono.workspace = true
 crypto-bigint.workspace = true
 data-url.workspace = true
 dojo-types.workspace = true
+dojo-utils.workspace = true
 dojo-world.workspace = true
 futures-channel = "0.3.0"
 futures-util.workspace = true

crates/torii/core/src/engine.rs

@@ -6,6 +6,7 @@ use std::time::Duration;
 
 use anyhow::Result;
 use bitflags::bitflags;
+use dojo_utils::utils::health_check_provider;
 use dojo_world::contracts::world::WorldContractReader;
 use futures_util::future::{join_all, try_join_all};
 use hashlink::LinkedHashMap;
@@ -45,7 +46,6 @@ use crate::processors::{
 };
 use crate::sql::{Cursors, Sql};
 use crate::types::{Contract, ContractType};
-use crate::utils::health_check_provider;
 
 type EventProcessorMap<P> = HashMap<Felt, Vec<Box<dyn EventProcessor<P>>>>;
 

crates/torii/core/src/utils.rs

@@ -4,10 +4,8 @@ use anyhow::Result;
 use chrono::{DateTime, Utc};
 use futures_util::TryStreamExt;
 use ipfs_api_backend_hyper::{IpfsApi, IpfsClient, TryFromUri};
-use starknet::core::types::{BlockId, BlockTag};
-use starknet::providers::Provider;
 use tokio_util::bytes::Bytes;
-use tracing::{info, trace};
+use tracing::info;
 
 use crate::constants::{
     IPFS_CLIENT_MAX_RETRY, IPFS_CLIENT_PASSWORD, IPFS_CLIENT_URL, IPFS_CLIENT_USERNAME,
@@ -48,25 +46,6 @@ pub async fn fetch_content_from_ipfs(cid: &str, mut retries: u8) -> Result<Bytes
     )))
 }
 
-pub async fn health_check_provider<P: Provider + Sync + std::fmt::Debug + 'static>(
-    provider: P,
-) -> Result<(), anyhow::Error> {
-    match provider.get_block_with_tx_hashes(BlockId::Tag(BlockTag::Latest)).await {
-        Ok(block) => {
-            trace!(
-                latest_block = ?block,
-                "Provider health check."
-            );
-            Ok(())
-        }
-        Err(_) => {
-            let error_info =
-                format!("Unhealthy provider {:?}, please check your configuration.", provider);
-            Err(anyhow::anyhow!(error_info))
-        }
-    }
-}
-
 // tests
 #[cfg(test)]
 mod tests {