feat: remove ApiError (#784)

TomasArrachea · SantiagoPittella · commit 7b225118a207 · 2025-05-15T12:04:07.000-03:00
* feat: remove `ApiError`

* review: update CHANGELOG

* review: use anyhow context on url conversion

* chore: lint
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/bin/faucet/src/server/get_tokens.rs b/bin/faucet/src/server/get_tokens.rs
@@ -5,7 +5,7 @@ use axum::{
 };
 use http::header;
 use http_body_util::Full;
-use miden_node_utils::errors::ErrorReport;
+use miden_node_utils::ErrorReport;
 use miden_objects::{
     AccountIdError,
     account::AccountId,
diff --git a/bin/faucet/src/stub_rpc_api.rs b/bin/faucet/src/stub_rpc_api.rs
@@ -1,3 +1,4 @@
+use anyhow::Context;
 use miden_node_proto::generated::{
     block::BlockHeader,
     digest::Digest,
@@ -15,7 +16,6 @@ use miden_node_proto::generated::{
     },
     rpc::api_server,
 };
-use miden_node_utils::errors::ApiError;
 use tokio::net::TcpListener;
 use tokio_stream::wrappers::TcpListenerStream;
 use tonic::{Request, Response, Status};
@@ -146,10 +146,10 @@ impl api_server::Api for StubRpcApi {
     }
 }
 
-pub async fn serve_stub(endpoint: &Url) -> Result<(), ApiError> {
+pub async fn serve_stub(endpoint: &Url) -> anyhow::Result<()> {
     let addr = endpoint
         .socket_addrs(|| None)
-        .map_err(ApiError::EndpointToSocketFailed)?
+        .context("failed to convert endpoint to socket address")?
         .into_iter()
         .next()
         .unwrap();
@@ -162,5 +162,5 @@ pub async fn serve_stub(endpoint: &Url) -> Result<(), ApiError> {
         .add_service(api_service)
         .serve_with_incoming(TcpListenerStream::new(listener))
         .await
-        .map_err(ApiError::ApiServeFailed)
+        .context("failed to serve stub RPC API")
 }
diff --git a/crates/block-producer/Cargo.toml b/crates/block-producer/Cargo.toml
@@ -19,6 +19,7 @@ testing        = []
 tracing-forest = ["miden-node-utils/tracing-forest"]
 
 [dependencies]
+anyhow = { workspace = true }
 async-trait = { version = "0.1" }
 futures = { workspace = true }
 itertools = { workspace = true }
diff --git a/crates/block-producer/src/errors.rs b/crates/block-producer/src/errors.rs
@@ -1,6 +1,6 @@
 use miden_block_prover::ProvenBlockError;
 use miden_node_proto::errors::ConversionError;
-use miden_node_utils::{errors::ErrorReport, formatting::format_opt};
+use miden_node_utils::{ErrorReport, formatting::format_opt};
 use miden_objects::{
     Digest, ProposedBatchError, ProposedBlockError,
     block::BlockNumber,
diff --git a/crates/block-producer/src/server.rs b/crates/block-producer/src/server.rs
@@ -1,11 +1,11 @@
 use std::{collections::HashMap, net::SocketAddr, time::Duration};
 
+use anyhow::{Context, Result};
 use miden_node_proto::generated::{
     block_producer::api_server, requests::SubmitProvenTransactionRequest,
     responses::SubmitProvenTransactionResponse, store::api_client as store_client,
 };
 use miden_node_utils::{
-    errors::ApiError,
     formatting::{format_input_notes, format_output_notes},
     tracing::grpc::{OtelInterceptor, block_producer_trace_fn},
 };
@@ -59,23 +59,20 @@ impl BlockProducer {
         block_prover: Option<Url>,
         batch_interval: Duration,
         block_interval: Duration,
-    ) -> Result<Self, ApiError> {
+    ) -> Result<Self> {
         info!(target: COMPONENT, endpoint=?listener, store=%store_address, "Initializing server");
 
         let store_url = format!("http://{store_address}");
-        let channel = tonic::transport::Endpoint::try_from(store_url)
-            .map_err(|err| ApiError::InvalidStoreUrl(err.to_string()))?
+        let channel = tonic::transport::Endpoint::try_from(store_url.clone())
+            .with_context(|| format!("failed to create store endpoint for {store_url}"))?
             .connect()
             .await
-            .map_err(|err| ApiError::DatabaseConnectionFailed(err.to_string()))?;
+            .with_context(|| format!("failed to connect to store on {store_url}"))?;
 
         let store = store_client::ApiClient::with_interceptor(channel, OtelInterceptor);
         let store = StoreClient::new(store);
 
-        let latest_header = store
-            .latest_header()
-            .await
-            .map_err(|err| ApiError::DatabaseConnectionFailed(err.to_string()))?;
+        let latest_header = store.latest_header().await.context("failed to get latest header")?;
         let chain_tip = latest_header.block_num();
 
         info!(target: COMPONENT, "Server initialized");
diff --git a/crates/rpc/Cargo.toml b/crates/rpc/Cargo.toml
@@ -15,6 +15,7 @@ version.workspace      = true
 workspace = true
 
 [dependencies]
+anyhow           = { workspace = true }
 miden-node-proto = { workspace = true }
 miden-node-utils = { workspace = true }
 miden-objects    = { workspace = true }
diff --git a/crates/rpc/src/server/mod.rs b/crates/rpc/src/server/mod.rs
@@ -1,8 +1,8 @@
 use std::net::SocketAddr;
 
+use anyhow::Context;
 use api::RpcService;
 use miden_node_proto::generated::rpc::api_server;
-use miden_node_utils::errors::ApiError;
 use tokio::net::TcpListener;
 use tokio_stream::wrappers::TcpListenerStream;
 use tracing::info;
@@ -27,12 +27,12 @@ impl Rpc {
         listener: TcpListener,
         store: SocketAddr,
         block_producer: SocketAddr,
-    ) -> Result<Self, ApiError> {
+    ) -> anyhow::Result<Self> {
         info!(target: COMPONENT, endpoint=?listener, %store, %block_producer, "Initializing server");
 
         let api = api::RpcService::new(store, block_producer)
             .await
-            .map_err(|err| ApiError::ApiInitialisationFailed(err.to_string()))?;
+            .context("failed to initialize RPC service")?;
         let api_service = api_server::ApiServer::new(api);
 
         info!(target: COMPONENT, "Server initialized");
@@ -43,12 +43,12 @@ impl Rpc {
     /// Serves the RPC API.
     ///
     /// Note: this blocks until the server dies.
-    pub async fn serve(self) -> Result<(), ApiError> {
+    pub async fn serve(self) -> anyhow::Result<()> {
         tonic::transport::Server::builder()
             .accept_http1(true)
             .add_service(self.api_service)
             .serve_with_incoming(TcpListenerStream::new(self.listener))
             .await
-            .map_err(ApiError::ApiServeFailed)
+            .context("failed to serve RPC API")
     }
 }
diff --git a/crates/store/src/server/mod.rs b/crates/store/src/server/mod.rs
@@ -6,7 +6,7 @@ use std::{
 
 use anyhow::Context;
 use miden_node_proto::generated::store::api_server;
-use miden_node_utils::{errors::ApiError, tracing::grpc::store_trace_fn};
+use miden_node_utils::tracing::grpc::store_trace_fn;
 use tokio::net::TcpListener;
 use tokio_stream::wrappers::TcpListenerStream;
 use tower_http::trace::TraceLayer;
@@ -70,22 +70,19 @@ impl Store {
     }
 
     /// Performs initialization tasks required before [`serve`](Self::serve) can be called.
-    pub async fn init(listener: TcpListener, data_directory: PathBuf) -> Result<Self, ApiError> {
+    pub async fn init(listener: TcpListener, data_directory: PathBuf) -> anyhow::Result<Self> {
         info!(target: COMPONENT, endpoint=?listener, ?data_directory, "Loading database");
 
         let data_directory = DataDirectory::load(data_directory)?;
 
         let block_store = Arc::new(BlockStore::load(data_directory.block_store_dir())?);
 
-        let db = Db::load(data_directory.database_path())
-            .await
-            .map_err(|err| ApiError::ApiInitialisationFailed(err.to_string()))?;
+        let database_filepath = data_directory.database_path();
+        let db = Db::load(database_filepath.clone()).await.with_context(|| {
+            format!("failed to load database at {}", database_filepath.display())
+        })?;
 
-        let state = Arc::new(
-            State::load(db, block_store)
-                .await
-                .map_err(|err| ApiError::DatabaseConnectionFailed(err.to_string()))?,
-        );
+        let state = Arc::new(State::load(db, block_store).await.context("failed to load state")?);
 
         let db_maintenance_service =
             DbMaintenance::new(Arc::clone(&state), DATABASE_MAINTENANCE_INTERVAL);
@@ -103,15 +100,15 @@ impl Store {
     /// Serves the store's RPC API and DB maintenance background task.
     ///
     /// Note: this blocks until the server dies.
-    pub async fn serve(self) -> Result<(), ApiError> {
+    pub async fn serve(self) -> anyhow::Result<()> {
         tokio::spawn(self.db_maintenance_service.run());
         // Build the gRPC server with the API service and trace layer.
         tonic::transport::Server::builder()
             .layer(TraceLayer::new_for_grpc().make_span_with(store_trace_fn))
             .add_service(self.api_service)
             .serve_with_incoming(TcpListenerStream::new(self.listener))
             .await
-            .map_err(ApiError::ApiServeFailed)
+            .context("failed to serve store API")
     }
 }
 
diff --git a/crates/utils/Cargo.toml b/crates/utils/Cargo.toml
@@ -29,7 +29,6 @@ opentelemetry-otlp    = { version = "0.29", default-features = false, features =
 opentelemetry_sdk     = { version = "0.29", features = ["rt-tokio", "testing"] }
 rand                  = { workspace = true }
 serde                 = { version = "1.0", features = ["derive"] }
-thiserror             = { workspace = true }
 tonic                 = { workspace = true }
 tracing               = { workspace = true }
 tracing-forest        = { version = "0.1", optional = true, features = ["chrono"] }
diff --git a/crates/utils/src/errors.rs b/crates/utils/src/errors.rs
diff --git a/crates/utils/src/grpc.rs b/crates/utils/src/grpc.rs
@@ -1,20 +1,19 @@
 use std::net::SocketAddr;
 
-use crate::errors::ApiError;
+use anyhow::Context;
 
 /// A sealed extension trait for [`url::Url`] that adds convenience functions for binding and
 /// connecting to the url.
 pub trait UrlExt: private::Sealed {
-    fn to_socket(&self) -> Result<SocketAddr, ApiError>;
+    fn to_socket(&self) -> anyhow::Result<SocketAddr>;
 }
 
 impl UrlExt for url::Url {
-    fn to_socket(&self) -> Result<SocketAddr, ApiError> {
-        self.socket_addrs(|| None)
-            .map_err(ApiError::EndpointToSocketFailed)?
+    fn to_socket(&self) -> anyhow::Result<SocketAddr> {
+        self.socket_addrs(|| None)?
             .into_iter()
             .next()
-            .ok_or_else(|| ApiError::AddressResolutionFailed(self.to_string()))
+            .with_context(|| format!("failed to convert url {self} to socket address"))
     }
 }
 
diff --git a/crates/utils/src/lib.rs b/crates/utils/src/lib.rs
@@ -1,8 +1,22 @@
 pub mod config;
 pub mod crypto;
-pub mod errors;
 pub mod formatting;
 pub mod grpc;
 pub mod logging;
 pub mod tracing;
 pub mod version;
+
+pub trait ErrorReport: std::error::Error {
+    fn as_report(&self) -> String {
+        use std::fmt::Write;
+        let mut report = self.to_string();
+
+        // SAFETY: write! is suggested by clippy, and is trivially safe usage.
+        std::iter::successors(self.source(), |child| child.source())
+            .for_each(|source| write!(report, "\nCaused by: {source}").unwrap());
+
+        report
+    }
+}
+
+impl<T: std::error::Error> ErrorReport for T {}
diff --git a/crates/utils/src/tracing/span_ext.rs b/crates/utils/src/tracing/span_ext.rs
@@ -4,7 +4,7 @@ use std::net::IpAddr;
 use miden_objects::{Digest, batch::BatchId, block::BlockNumber};
 use opentelemetry::{Key, Value, trace::Status};
 
-use crate::errors::ErrorReport;
+use crate::ErrorReport;
 
 /// Utility functions for converting types into [`opentelemetry::Value`].
 pub trait ToValue {
