Refactor errors

Author: Rigidity

crates/sage-wallet/src/child_kind.rs

@@ -7,7 +7,7 @@ use chia_wallet_sdk::{run_puzzle, Cat, Condition, Did, DidInfo, HashedPtr, Nft,
 use clvmr::Allocator;
 use tracing::{debug_span, warn};
 
-use crate::ParseError;
+use crate::WalletError;
 
 #[derive(Debug, Clone)]
 #[allow(clippy::large_enum_variant)]
@@ -38,7 +38,7 @@ impl ChildKind {
         parent_puzzle: &Program,
         parent_solution: &Program,
         coin: Coin,
-    ) -> Result<Self, ParseError> {
+    ) -> Result<Self, WalletError> {
         let parse_span = debug_span!(
             "parse from parent",
             parent_coin = %parent_coin.coin_id(),
@@ -52,21 +52,12 @@ impl ChildKind {
 
         let mut allocator = Allocator::new();
 
-        let parent_puzzle_ptr = parent_puzzle
-            .to_clvm(&mut allocator)
-            .map_err(|_| ParseError::AllocatePuzzle)?;
-
+        let parent_puzzle_ptr = parent_puzzle.to_clvm(&mut allocator)?;
         let parent_puzzle = Puzzle::parse(&allocator, parent_puzzle_ptr);
+        let parent_solution = parent_solution.to_clvm(&mut allocator)?;
 
-        let parent_solution = parent_solution
-            .to_clvm(&mut allocator)
-            .map_err(|_| ParseError::AllocateSolution)?;
-
-        let output = run_puzzle(&mut allocator, parent_puzzle_ptr, parent_solution)
-            .map_err(|_| ParseError::Eval)?;
-
-        let conditions = Vec::<Condition>::from_clvm(&allocator, output)
-            .map_err(|_| ParseError::InvalidConditions)?;
+        let output = run_puzzle(&mut allocator, parent_puzzle_ptr, parent_solution)?;
+        let conditions = Vec::<Condition>::from_clvm(&allocator, output)?;
 
         let Some(mut create_coin) = conditions
             .into_iter()
@@ -140,9 +131,7 @@ impl ChildKind {
                     return Ok(unknown);
                 };
 
-                let metadata_program = Program::from_clvm(&allocator, nft.info.metadata.ptr())
-                    .map_err(|_| ParseError::Serialize)?;
-
+                let metadata_program = Program::from_clvm(&allocator, nft.info.metadata.ptr())?;
                 let metadata = NftMetadata::from_clvm(&allocator, nft.info.metadata.ptr()).ok();
 
                 return Ok(Self::Nft {
@@ -176,8 +165,7 @@ impl ChildKind {
                     return Ok(unknown);
                 };
 
-                let metadata = Program::from_clvm(&allocator, did.info.metadata.ptr())
-                    .map_err(|_| ParseError::Serialize)?;
+                let metadata = Program::from_clvm(&allocator, did.info.metadata.ptr())?;
 
                 return Ok(Self::Did {
                     lineage_proof,

crates/sage-wallet/src/coin_kind.rs

@@ -7,7 +7,7 @@ use chia_wallet_sdk::{CatLayer, DidInfo, HashedPtr, Layer, NftInfo, Puzzle};
 use clvmr::Allocator;
 use tracing::{debug_span, warn};
 
-use crate::ParseError;
+use crate::WalletError;
 
 #[derive(Debug, Clone)]
 #[allow(clippy::large_enum_variant)]
@@ -28,16 +28,13 @@ pub enum CoinKind {
 }
 
 impl CoinKind {
-    pub fn from_puzzle(puzzle: &Program) -> Result<Self, ParseError> {
+    pub fn from_puzzle(puzzle: &Program) -> Result<Self, WalletError> {
         let parse_span = debug_span!("parse puzzle");
         let _span = parse_span.enter();
 
         let mut allocator = Allocator::new();
 
-        let puzzle_ptr = puzzle
-            .to_clvm(&mut allocator)
-            .map_err(|_| ParseError::AllocatePuzzle)?;
-
+        let puzzle_ptr = puzzle.to_clvm(&mut allocator)?;
         let puzzle = Puzzle::parse(&allocator, puzzle_ptr);
 
         if puzzle.curried_puzzle_hash() == SINGLETON_LAUNCHER_PUZZLE_HASH {
@@ -72,9 +69,7 @@ impl CoinKind {
 
             // If the coin is a NFT coin, return the relevant information.
             Ok(Some((nft, _inner_puzzle))) => {
-                let metadata_program = Program::from_clvm(&allocator, nft.metadata.ptr())
-                    .map_err(|_| ParseError::Serialize)?;
-
+                let metadata_program = Program::from_clvm(&allocator, nft.metadata.ptr())?;
                 let metadata = NftMetadata::from_clvm(&allocator, nft.metadata.ptr()).ok();
 
                 return Ok(Self::Nft {
@@ -96,8 +91,7 @@ impl CoinKind {
 
             // If the coin is a DID coin, return the relevant information.
             Ok(Some((did, _inner_puzzle))) => {
-                let metadata = Program::from_clvm(&allocator, did.metadata.ptr())
-                    .map_err(|_| ParseError::Serialize)?;
+                let metadata = Program::from_clvm(&allocator, did.metadata.ptr())?;
 
                 return Ok(Self::Did {
                     info: did.with_metadata(metadata),

crates/sage-wallet/src/error.rs

@@ -1,10 +1,14 @@
 use std::time::SystemTimeError;
 
-use chia::{bls::PublicKey, protocol::Bytes32};
+use chia::{
+    clvm_traits::{FromClvmError, ToClvmError},
+    protocol::Bytes32,
+};
 use chia_wallet_sdk::{ClientError, CoinSelectionError, DriverError, SignerError};
+use clvmr::reduction::EvalErr;
 use sage_database::DatabaseError;
 use thiserror::Error;
-use tokio::task::JoinError;
+use tokio::{task::JoinError, time::error::Elapsed};
 
 #[derive(Debug, Error)]
 pub enum WalletError {
@@ -14,90 +18,63 @@ pub enum WalletError {
     #[error("Client error: {0}")]
     Client(#[from] ClientError),
 
-    #[error("Sync error: {0}")]
-    Sync(#[from] SyncError),
-
-    #[error("Parse error: {0}")]
-    Parse(#[from] ParseError),
-
     #[error("Driver error: {0}")]
     Driver(#[from] DriverError),
 
     #[error("Signer error: {0}")]
     Signer(#[from] SignerError),
 
-    #[error("Join error: {0}")]
-    Join(#[from] JoinError),
-
     #[error("Coin selection error: {0}")]
     CoinSelection(#[from] CoinSelectionError),
 
-    #[error("Output amount exceeds input coin total")]
-    InsufficientFunds,
-
-    #[error("Not enough keys have been derived")]
-    InsufficientDerivations,
-
-    #[error("Spendable DID not found: {0}")]
-    MissingDid(Bytes32),
-
-    #[error("Spendable NFT not found: {0}")]
-    MissingNft(Bytes32),
-
-    #[error("Unknown public key in transaction: {0:?}")]
-    UnknownPublicKey(PublicKey),
-
-    #[error("Time error: {0}")]
-    Time(#[from] SystemTimeError),
-}
+    #[error("Request error: {0}")]
+    Request(#[from] reqwest::Error),
 
-#[derive(Debug, Error)]
-pub enum SyncError {
     #[error("Timeout exceeded")]
-    Timeout,
+    Elapsed(#[from] Elapsed),
+
+    #[error("Missing coin with id {0}")]
+    MissingCoin(Bytes32),
 
-    #[error("Unexpected rejection")]
-    Rejection,
+    #[error("Missing spend with id {0}")]
+    MissingSpend(Bytes32),
 
-    #[error("Subscription limit exceeded")]
-    SubscriptionLimit,
+    #[error("Missing child of id {0}")]
+    MissingChild(Bytes32),
 
-    #[error("Missing coin state {0}")]
-    MissingCoinState(Bytes32),
+    #[error("Peer misbehaved")]
+    PeerMisbehaved,
 
-    #[error("Missing child coin")]
-    MissingChild,
+    #[error("Subscription limit reached")]
+    SubscriptionLimitReached,
 
-    #[error("Unconfirmed coin {0}")]
-    UnconfirmedCoin(Bytes32),
+    #[error("System time error: {0}")]
+    SystemTime(#[from] SystemTimeError),
 
-    #[error("Unspent coin {0}")]
-    UnspentCoin(Bytes32),
+    #[error("Join error: {0}")]
+    Join(#[from] JoinError),
 
-    #[error("Missing puzzle and solution for {0}")]
-    MissingPuzzleAndSolution(Bytes32),
+    #[error("CLVM encoding error: {0}")]
+    ToClvm(#[from] ToClvmError),
 
-    #[error("Error fetching CAT {0}: {1}")]
-    FetchCat(Bytes32, reqwest::Error),
-}
+    #[error("CLVM decoding error: {0}")]
+    FromClvm(#[from] FromClvmError),
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)]
-pub enum ParseError {
-    #[error("Could not allocate puzzle reveal")]
-    AllocatePuzzle,
+    #[error("CLVM error: {0}")]
+    Clvm(#[from] EvalErr),
 
-    #[error("Could not allocate solution")]
-    AllocateSolution,
+    #[error("Insufficient funds")]
+    InsufficientFunds,
 
-    #[error("Could not allocate metadata")]
-    AllocateMetadata,
+    #[error("Insufficient derivations")]
+    InsufficientDerivations,
 
-    #[error("Could not serialize CLVM")]
-    Serialize,
+    #[error("Missing secret key")]
+    UnknownPublicKey,
 
-    #[error("Could not evaluate puzzle and solution")]
-    Eval,
+    #[error("Missing DID with id {0}")]
+    MissingDid(Bytes32),
 
-    #[error("Invalid condition list")]
-    InvalidConditions,
+    #[error("Missing NFT with id {0}")]
+    MissingNft(Bytes32),
 }

crates/sage-wallet/src/queues/cat_queue.rs

@@ -10,7 +10,7 @@ use tokio::{
 };
 use tracing::info;
 
-use crate::{SyncError, SyncEvent, WalletError};
+use crate::{SyncEvent, WalletError};
 
 #[derive(Deserialize)]
 struct Response {
@@ -107,7 +107,7 @@ impl CatQueue {
     }
 }
 
-async fn lookup_cat(network: &Network, asset_id: Bytes32) -> Result<Response, SyncError> {
+async fn lookup_cat(network: &Network, asset_id: Bytes32) -> Result<Response, WalletError> {
     let dexie_base_url = if network.genesis_challenge == TESTNET11_CONSTANTS.genesis_challenge {
         "https://api-testnet.dexie.space/v1"
     } else {
@@ -120,14 +120,9 @@ async fn lookup_cat(network: &Network, asset_id: Bytes32) -> Result<Response, Sy
             "{dexie_base_url}/assets?page_size=25&page=1&type=all&code={asset_id}"
         )),
     )
-    .await
-    .map_err(|_| SyncError::Timeout)?
-    .map_err(|error| SyncError::FetchCat(asset_id, error))?;
-
-    let response = response
-        .json::<Response>()
-        .await
-        .map_err(|error| SyncError::FetchCat(asset_id, error))?;
+    .await??
+    .json::<Response>()
+    .await?;
 
     Ok(response)
 }

crates/sage-wallet/src/queues/puzzle_queue.rs

@@ -12,8 +12,8 @@ use tokio::{
 use tracing::{debug, instrument};
 
 use crate::{
-    database::insert_puzzle, fetch_nft_did, ChildKind, PeerState, SyncCommand, SyncError,
-    SyncEvent, WalletError,
+    database::insert_puzzle, fetch_nft_did, ChildKind, PeerState, SyncCommand, SyncEvent,
+    WalletError,
 };
 
 #[derive(Debug)]
@@ -96,17 +96,15 @@ impl PuzzleQueue {
             let addr = peer.socket_addr();
             let coin_id = coin_state.coin.coin_id();
 
-            futures.push(tokio::spawn(async move {
+            futures.push(async move {
                 let result = fetch_puzzle(&peer, &db, genesis_challenge, coin_state).await;
                 (addr, coin_id, result)
-            }));
+            });
         }
 
         let mut subscriptions = Vec::new();
 
-        while let Some(result) = futures.next().await {
-            let (addr, coin_id, result) = result?;
-
+        while let Some((addr, coin_id, result)) = futures.next().await {
             match result {
                 Ok(subscribe) => {
                     if subscribe {
@@ -147,26 +145,24 @@ async fn fetch_puzzle(
         Duration::from_secs(5),
         peer.request_coin_state(vec![parent_id], None, genesis_challenge, false),
     )
-    .await
-    .map_err(|_| SyncError::Timeout)??
-    .map_err(|_| SyncError::Rejection)?
+    .await??
+    .map_err(|_| WalletError::PeerMisbehaved)?
     .coin_states
     .into_iter()
     .next() else {
-        return Err(SyncError::MissingCoinState(parent_id).into());
+        return Err(WalletError::MissingCoin(parent_id));
     };
 
     let height = coin_state
         .created_height
-        .ok_or(SyncError::UnconfirmedCoin(parent_id))?;
+        .ok_or(WalletError::MissingCoin(parent_id))?;
 
     let response = timeout(
         Duration::from_secs(10),
         peer.request_puzzle_and_solution(parent_id, height),
     )
-    .await
-    .map_err(|_| SyncError::Timeout)??
-    .map_err(|_| SyncError::MissingPuzzleAndSolution(parent_id))?;
+    .await??
+    .map_err(|_| WalletError::MissingSpend(parent_id))?;
 
     let info = spawn_blocking(move || {
         ChildKind::from_parent(