feat: get rid of Box<dyn Error>

cartesi · Apr 17, 2024 · 754c0c4 · 754c0c4
1 parent 686c614
commit 754c0c4
Show file tree

Hide file tree

Showing 14 changed files with 88 additions and 86 deletions.
diff --git a/offchain/Cargo.lock b/offchain/Cargo.lock
diff --git a/offchain/Cargo.toml b/offchain/Cargo.toml
@@ -22,6 +22,7 @@ readme = "README.md"
 repository = "https://github.com/cartesi/dave"
 
 [workspace.dependencies]
+anyhow = "1.0.63"
 async-recursion = "1"
 async-trait = "0.1.74"
 ethers = "2.0.11"

diff --git a/offchain/core/Cargo.toml b/offchain/core/Cargo.toml
@@ -7,6 +7,7 @@ build = "build.rs"
 [dependencies]
 cartesi-machine = { path = "../../machine-bindings/cartesi-machine" }
 cartesi-machine-sys = { path = "../../machine-bindings/cartesi-machine-sys" }
+anyhow = { workspace = true }
 async-recursion = { workspace = true }
 async-trait = { workspace = true }
 ethers = { workspace = true }

diff --git a/offchain/core/src/arena/reader.rs b/offchain/core/src/arena/reader.rs
@@ -1,8 +1,9 @@
 //! This module defines the struct [StateReader] that is responsible for the reading the states
 //! of tournaments
 
-use std::{collections::HashMap, error::Error, str::FromStr, sync::Arc, time::Duration};
+use std::{collections::HashMap, str::FromStr, sync::Arc, time::Duration};
 
+use anyhow::Result;
 use async_recursion::async_recursion;
 
 use ethers::{
@@ -31,7 +32,7 @@ pub struct StateReader {
 }
 
 impl StateReader {
-    pub fn new(config: ArenaConfig) -> Result<Self, Box<dyn Error>> {
+    pub fn new(config: ArenaConfig) -> Result<Self> {
         let provider = Provider::<Http>::try_from(config.web3_rpc_url.clone())?
             .interval(Duration::from_millis(10u64));
         let wallet = LocalWallet::from_str(config.web3_private_key.as_str())?;
@@ -47,7 +48,7 @@ impl StateReader {
         &self,
         tournament_address: Address,
         match_id: MatchID,
-    ) -> Result<Option<TournamentCreatedEvent>, Box<dyn Error>> {
+    ) -> Result<Option<TournamentCreatedEvent>> {
         let tournament =
             non_leaf_tournament::NonLeafTournament::new(tournament_address, self.client.clone());
         let events = tournament
@@ -68,10 +69,7 @@ impl StateReader {
         }
     }
 
-    async fn created_matches(
-        &self,
-        tournament_address: Address,
-    ) -> Result<Vec<MatchCreatedEvent>, Box<dyn Error>> {
+    async fn created_matches(&self, tournament_address: Address) -> Result<Vec<MatchCreatedEvent>> {
         let tournament = tournament::Tournament::new(tournament_address, self.client.clone());
         let events: Vec<MatchCreatedEvent> = tournament
             .match_created_filter()
@@ -95,7 +93,7 @@ impl StateReader {
     async fn joined_commitments(
         &self,
         tournament_address: Address,
-    ) -> Result<Vec<CommitmentJoinedEvent>, Box<dyn Error>> {
+    ) -> Result<Vec<CommitmentJoinedEvent>> {
         let tournament = tournament::Tournament::new(tournament_address, self.client.clone());
         let events = tournament
             .commitment_joined_filter()
@@ -116,7 +114,7 @@ impl StateReader {
         &self,
         tournament: Address,
         commitment_hash: Digest,
-    ) -> Result<CommitmentState, Box<dyn Error>> {
+    ) -> Result<CommitmentState> {
         let tournament = tournament::Tournament::new(tournament, self.client.clone());
         let (clock_state, hash) = tournament
             .get_commitment(commitment_hash.into())
@@ -140,10 +138,7 @@ impl StateReader {
         })
     }
 
-    pub async fn fetch_from_root(
-        &self,
-        root_tournament: Address,
-    ) -> Result<TournamentStateMap, Box<dyn Error>> {
+    pub async fn fetch_from_root(&self, root_tournament: Address) -> Result<TournamentStateMap> {
         self.fetch_tournament(TournamentState::new_root(root_tournament), HashMap::new())
             .await
     }
@@ -153,7 +148,7 @@ impl StateReader {
         &self,
         tournament_state: TournamentState,
         states: TournamentStateMap,
-    ) -> Result<TournamentStateMap, Box<dyn Error>> {
+    ) -> Result<TournamentStateMap> {
         let tournament = tournament::Tournament::new(tournament_state.address, self.client.clone());
         let mut state = tournament_state.clone();
 
@@ -247,7 +242,7 @@ impl StateReader {
         match_state: MatchState,
         states: TournamentStateMap,
         tournament_level: u64,
-    ) -> Result<(MatchState, TournamentStateMap), Box<dyn Error>> {
+    ) -> Result<(MatchState, TournamentStateMap)> {
         let mut state = match_state.clone();
         let created_tournament = self
             .created_tournament(match_state.tournament_address, match_state.id)
@@ -271,7 +266,7 @@ impl StateReader {
     async fn root_tournament_winner(
         &self,
         root_tournament: Address,
-    ) -> Result<Option<TournamentWinner>, Box<dyn Error>> {
+    ) -> Result<Option<TournamentWinner>> {
         let root_tournament =
             root_tournament::RootTournament::new(root_tournament, self.client.clone());
         let (finished, commitment, state) = root_tournament.arbitration_result().call().await?;
@@ -285,10 +280,7 @@ impl StateReader {
         }
     }
 
-    async fn tournament_winner(
-        &self,
-        tournament: Address,
-    ) -> Result<Option<TournamentWinner>, Box<dyn Error>> {
+    async fn tournament_winner(&self, tournament: Address) -> Result<Option<TournamentWinner>> {
         let tournament =
             non_root_tournament::NonRootTournament::new(tournament, self.client.clone());
         let (finished, parent_commitment, dangling_commitment) =

diff --git a/offchain/core/src/arena/sender.rs b/offchain/core/src/arena/sender.rs
@@ -1,8 +1,9 @@
 //! This module defines the struct [EthArenaSender] that is responsible for the sending transactions
 //! to tournaments
 
-use std::{error::Error, str::FromStr, sync::Arc, time::Duration};
+use std::{ str::FromStr, sync::Arc, time::Duration};
 
+use anyhow::Result;
 use async_trait::async_trait;
 
 use ethers::{
@@ -25,7 +26,7 @@ pub struct EthArenaSender {
 }
 
 impl EthArenaSender {
-    pub fn new(config: ArenaConfig) -> Result<Self, Box<dyn Error>> {
+    pub fn new(config: ArenaConfig) -> Result<Self> {
         let provider = Provider::<Http>::try_from(config.web3_rpc_url.clone())?
             .interval(Duration::from_millis(10u64));
         let wallet = LocalWallet::from_str(config.web3_private_key.as_str())?;
@@ -48,7 +49,7 @@ pub trait ArenaSender: Send + Sync {
         proof: MerkleProof,
         left_child: Digest,
         right_child: Digest,
-    ) -> Result<(), Box<dyn Error>>;
+    ) -> Result<()>;
 
     async fn advance_match(
         &self,
@@ -58,7 +59,7 @@ pub trait ArenaSender: Send + Sync {
         right_node: Digest,
         new_left_node: Digest,
         new_right_node: Digest,
-    ) -> Result<(), Box<dyn Error>>;
+    ) -> Result<()>;
 
     async fn seal_inner_match(
         &self,
@@ -68,15 +69,15 @@ pub trait ArenaSender: Send + Sync {
         right_leaf: Digest,
         initial_hash: Digest,
         initial_hash_proof: MerkleProof,
-    ) -> Result<(), Box<dyn Error>>;
+    ) -> Result<()>;
 
     async fn win_inner_match(
         &self,
         tournament: Address,
         child_tournament: Address,
         left_node: Digest,
         right_node: Digest,
-    ) -> Result<(), Box<dyn Error>>;
+    ) -> Result<()>;
 
     async fn seal_leaf_match(
         &self,
@@ -86,7 +87,7 @@ pub trait ArenaSender: Send + Sync {
         right_leaf: Digest,
         initial_hash: Digest,
         initial_hash_proof: MerkleProof,
-    ) -> Result<(), Box<dyn Error>>;
+    ) -> Result<()>;
 
     async fn win_leaf_match(
         &self,
@@ -95,13 +96,9 @@ pub trait ArenaSender: Send + Sync {
         left_node: Digest,
         right_node: Digest,
         proofs: MachineProof,
-    ) -> Result<(), Box<dyn Error>>;
+    ) -> Result<()>;
 
-    async fn eliminate_match(
-        &self,
-        tournament: Address,
-        match_id: MatchID,
-    ) -> Result<(), Box<dyn Error>>;
+    async fn eliminate_match(&self, tournament: Address, match_id: MatchID) -> Result<()>;
 }
 
 #[async_trait]
@@ -113,7 +110,7 @@ impl ArenaSender for EthArenaSender {
         proof: MerkleProof,
         left_child: Digest,
         right_child: Digest,
-    ) -> Result<(), Box<dyn Error>> {
+    ) -> Result<()> {
         let tournament = tournament::Tournament::new(tournament, self.client.clone());
         let proof = proof.iter().map(|h| -> [u8; 32] { (*h).into() }).collect();
         tournament
@@ -137,7 +134,7 @@ impl ArenaSender for EthArenaSender {
         right_node: Digest,
         new_left_node: Digest,
         new_right_node: Digest,
-    ) -> Result<(), Box<dyn Error>> {
+    ) -> Result<()> {
         let tournament = tournament::Tournament::new(tournament, self.client.clone());
         let match_id = tournament::Id {
             commitment_one: match_id.commitment_one.into(),
@@ -165,7 +162,7 @@ impl ArenaSender for EthArenaSender {
         right_leaf: Digest,
         initial_hash: Digest,
         initial_hash_proof: MerkleProof,
-    ) -> Result<(), Box<dyn Error>> {
+    ) -> Result<()> {
         let tournament =
             non_leaf_tournament::NonLeafTournament::new(tournament, self.client.clone());
         let match_id = non_leaf_tournament::Id {
@@ -196,7 +193,7 @@ impl ArenaSender for EthArenaSender {
         child_tournament: Address,
         left_node: Digest,
         right_node: Digest,
-    ) -> Result<(), Box<dyn Error>> {
+    ) -> Result<()> {
         let tournament =
             non_leaf_tournament::NonLeafTournament::new(tournament, self.client.clone());
         tournament
@@ -215,7 +212,7 @@ impl ArenaSender for EthArenaSender {
         right_leaf: Digest,
         initial_hash: Digest,
         initial_hash_proof: MerkleProof,
-    ) -> Result<(), Box<dyn Error>> {
+    ) -> Result<()> {
         let tournament = leaf_tournament::LeafTournament::new(tournament, self.client.clone());
         let match_id = leaf_tournament::Id {
             commitment_one: match_id.commitment_one.into(),
@@ -246,7 +243,7 @@ impl ArenaSender for EthArenaSender {
         left_node: Digest,
         right_node: Digest,
         proofs: MachineProof,
-    ) -> Result<(), Box<dyn Error>> {
+    ) -> Result<()> {
         let tournament = leaf_tournament::LeafTournament::new(tournament, self.client.clone());
         let match_id = leaf_tournament::Id {
             commitment_one: match_id.commitment_one.into(),
@@ -265,11 +262,7 @@ impl ArenaSender for EthArenaSender {
         Ok(())
     }
 
-    async fn eliminate_match(
-        &self,
-        tournament: Address,
-        match_id: MatchID,
-    ) -> Result<(), Box<dyn Error>> {
+    async fn eliminate_match(&self, tournament: Address, match_id: MatchID) -> Result<()> {
         let tournament = tournament::Tournament::new(tournament, self.client.clone());
         let match_id = tournament::Id {
             commitment_one: match_id.commitment_one.into(),

diff --git a/offchain/core/src/machine/commitment.rs b/offchain/core/src/machine/commitment.rs
@@ -1,7 +1,8 @@
 //! This module defines a struct [MachineCommitment] that is used to represent a `computation hash`
 //! described on the paper https://arxiv.org/pdf/2212.12439.pdf.
 
-use std::{error::Error, ops::ControlFlow, sync::Arc};
+use anyhow::Result;
+use std::{ops::ControlFlow, sync::Arc};
 
 use crate::{
     machine::{constants, MachineInstance},
@@ -23,7 +24,7 @@ pub fn build_machine_commitment(
     base_cycle: u64,
     log2_stride: u64,
     log2_stride_count: u64,
-) -> Result<MachineCommitment, Box<dyn Error>> {
+) -> Result<MachineCommitment> {
     if log2_stride >= constants::LOG2_UARCH_SPAN {
         assert!(
             log2_stride + log2_stride_count
@@ -42,7 +43,7 @@ pub fn build_big_machine_commitment(
     base_cycle: u64,
     log2_stride: u64,
     log2_stride_count: u64,
-) -> Result<MachineCommitment, Box<dyn Error>> {
+) -> Result<MachineCommitment> {
     machine.run(base_cycle)?;
     let initial_state = machine.machine_state()?;
 
@@ -78,7 +79,7 @@ fn advance_instruction(
     base_cycle: u64,
     builder: &mut MerkleBuilder,
     instruction_count: u64,
-) -> Result<ControlFlow<()>, Box<dyn Error>> {
+) -> Result<ControlFlow<()>> {
     let cycle = (instruction + 1) << (log2_stride - constants::LOG2_UARCH_SPAN);
     machine.run(base_cycle + cycle)?;
     let state = machine.machine_state()?;
@@ -99,7 +100,7 @@ pub fn build_small_machine_commitment(
     machine: &mut MachineInstance,
     base_cycle: u64,
     log2_stride_count: u64,
-) -> Result<MachineCommitment, Box<dyn Error>> {
+) -> Result<MachineCommitment> {
     machine.run(base_cycle)?;
     let initial_state = machine.machine_state()?;
 
@@ -131,7 +132,7 @@ pub fn build_small_machine_commitment(
     })
 }
 
-fn run_uarch_span(machine: &mut MachineInstance) -> Result<MerkleTree, Box<dyn Error>> {
+fn run_uarch_span(machine: &mut MachineInstance) -> Result<MerkleTree> {
     let (_, ucycle) = machine.position();
     assert!(ucycle == 0);
 

diff --git a/offchain/core/src/machine/commitment_builder.rs b/offchain/core/src/machine/commitment_builder.rs
@@ -2,10 +2,8 @@
 //! [MachineCommitment]. It is used by the [Arena] to build the commitments of the tournaments.
 
 use crate::machine::{build_machine_commitment, MachineCommitment, MachineInstance};
-use std::{
-    collections::{hash_map::Entry, HashMap},
-    error::Error,
-};
+use anyhow::Result;
+use std::collections::{hash_map::Entry, HashMap};
 
 pub struct CachingMachineCommitmentBuilder {
     machine_path: String,
@@ -26,7 +24,7 @@ impl CachingMachineCommitmentBuilder {
         level: u64,
         log2_stride: u64,
         log2_stride_count: u64,
-    ) -> Result<MachineCommitment, Box<dyn Error>> {
+    ) -> Result<MachineCommitment> {
         if let Entry::Vacant(e) = self.commitments.entry(level) {
             e.insert(HashMap::new());
         } else if self.commitments[&level].contains_key(&base_cycle) {