Cleanup error types

crates/chia-sdk-parser/src/conditions.rs

@@ -2,37 +2,26 @@ use std::collections::HashSet;
 
 use chia_protocol::{Coin, CoinSpend};
 use chia_sdk_types::conditions::Condition;
-use clvm_traits::{FromClvm, FromClvmError, ToClvmError, ToNodePtr};
-use clvmr::{
-    reduction::{EvalErr, Reduction},
-    Allocator, NodePtr,
-};
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum ConditionError {
-    #[error("eval error: {0}")]
-    Eval(#[from] EvalErr),
-
-    #[error("clvm error: {0}")]
-    Clvm(#[from] FromClvmError),
-}
+use clvm_traits::{FromClvm, ToNodePtr};
+use clvmr::{reduction::Reduction, Allocator, NodePtr};
+
+use crate::ParseError;
 
 pub fn parse_conditions(
     allocator: &mut Allocator,
     conditions: NodePtr,
-) -> Result<Vec<Condition<NodePtr>>, FromClvmError> {
+) -> Result<Vec<Condition<NodePtr>>, ParseError> {
     Vec::<NodePtr>::from_clvm(allocator, conditions)?
         .into_iter()
-        .map(|condition| Condition::from_clvm(allocator, condition))
+        .map(|condition| Ok(Condition::from_clvm(allocator, condition)?))
         .collect()
 }
 
 pub fn run_puzzle(
     allocator: &mut Allocator,
     puzzle: NodePtr,
     solution: NodePtr,
-) -> Result<NodePtr, EvalErr> {
+) -> Result<NodePtr, ParseError> {
     let Reduction(_cost, output) = clvmr::run_program(
         allocator,
         &clvmr::ChiaDialect::new(0),
@@ -47,24 +36,12 @@ pub fn puzzle_conditions(
     allocator: &mut Allocator,
     puzzle: NodePtr,
     solution: NodePtr,
-) -> Result<Vec<Condition<NodePtr>>, ConditionError> {
+) -> Result<Vec<Condition<NodePtr>>, ParseError> {
     let output = run_puzzle(allocator, puzzle, solution)?;
-    Ok(parse_conditions(allocator, output)?)
-}
-
-#[derive(Debug, Error)]
-pub enum ParseBundleError {
-    #[error("condition error: {0}")]
-    Condition(#[from] ConditionError),
-
-    #[error("to clvm error: {0}")]
-    ToClvm(#[from] ToClvmError),
-
-    #[error("from clvm error: {0}")]
-    From(#[from] FromClvmError),
+    parse_conditions(allocator, output)
 }
 
-pub fn non_ephemeral_coins(coin_spends: &[CoinSpend]) -> Result<Vec<Coin>, ParseBundleError> {
+pub fn non_ephemeral_coins(coin_spends: &[CoinSpend]) -> Result<Vec<Coin>, ParseError> {
     let mut allocator = Allocator::new();
     let mut created_coins = HashSet::new();
 

crates/chia-sdk-parser/src/error.rs

@@ -1,15 +1,17 @@
-use clvm_traits::FromClvmError;
+use clvm_traits::{FromClvmError, ToClvmError};
+use clvmr::reduction::EvalErr;
 use thiserror::Error;
 
-use crate::ConditionError;
-
 #[derive(Debug, Error)]
 pub enum ParseError {
-    #[error("failed to parse clvm value: {0}")]
+    #[error("failed to serialize clvm value: {0}")]
+    ToClvm(#[from] ToClvmError),
+
+    #[error("failed to deserialize clvm value: {0}")]
     FromClvm(#[from] FromClvmError),
 
-    #[error("condition error: {0}")]
-    Condition(#[from] ConditionError),
+    #[error("clvm eval error: {0}")]
+    Eval(#[from] EvalErr),
 
     #[error("invalid mod hash")]
     InvalidModHash,

crates/chia-sdk-signer/src/error.rs

@@ -0,0 +1,15 @@
+use chia_sdk_parser::ParseError;
+use clvm_traits::ToClvmError;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum SignerError {
+    #[error("parse error: {0}")]
+    Parse(#[from] ParseError),
+
+    #[error("clvm error")]
+    ToClvm(#[from] ToClvmError),
+
+    #[error("infinity public key")]
+    InfinityPublicKey,
+}

crates/chia-sdk-signer/src/lib.rs

@@ -1,5 +1,5 @@
+mod error;
 mod required_signature;
-mod sign_error;
 
+pub use error::*;
 pub use required_signature::*;
-pub use sign_error::*;

crates/chia-sdk-signer/src/required_signature.rs

@@ -10,7 +10,7 @@ use clvmr::{
     Allocator,
 };
 
-use crate::SignError;
+use crate::SignerError;
 
 #[derive(Debug, Clone)]
 pub struct RequiredSignature {
@@ -93,7 +93,7 @@ impl RequiredSignature {
         allocator: &mut Allocator,
         coin_spend: &CoinSpend,
         agg_sig_me: Bytes32,
-    ) -> Result<Vec<Self>, SignError> {
+    ) -> Result<Vec<Self>, SignerError> {
         let puzzle = coin_spend.puzzle_reveal.to_node_ptr(allocator)?;
         let solution = coin_spend.solution.to_node_ptr(allocator)?;
         let conditions = puzzle_conditions(allocator, puzzle, solution)?;
@@ -106,7 +106,7 @@ impl RequiredSignature {
             };
 
             if agg_sig.public_key.is_inf() {
-                return Err(SignError::InfinityPublicKey);
+                return Err(SignerError::InfinityPublicKey);
             }
 
             result.push(Self::from_condition(&coin_spend.coin, agg_sig, agg_sig_me));
@@ -122,7 +122,7 @@ impl RequiredSignature {
         allocator: &mut Allocator,
         coin_spends: &[CoinSpend],
         agg_sig_me: Bytes32,
-    ) -> Result<Vec<Self>, SignError> {
+    ) -> Result<Vec<Self>, SignerError> {
         let mut required_signatures = Vec::new();
         for coin_spend in coin_spends {
             required_signatures.extend(Self::from_coin_spend(allocator, coin_spend, agg_sig_me)?);

crates/chia-sdk-test/src/simulator.rs

@@ -4,20 +4,20 @@ use bip39::Mnemonic;
 use chia_bls::SecretKey;
 use chia_client::Peer;
 use chia_protocol::{Bytes32, Coin, CoinState};
+use error::SimulatorError;
 use peer_map::PeerMap;
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 use simulator_config::SimulatorConfig;
 use simulator_data::SimulatorData;
-use simulator_error::SimulatorError;
 use tokio::{net::TcpListener, sync::Mutex, task::JoinHandle};
 use tokio_tungstenite::connect_async;
 use ws_connection::ws_connection;
 
+mod error;
 mod peer_map;
 mod simulator_config;
 mod simulator_data;
-mod simulator_error;
 mod ws_connection;
 
 #[derive(Debug)]

crates/chia-sdk-test/src/simulator/simulator_error.rs → crates/chia-sdk-test/src/simulator/error.rs

@@ -2,7 +2,7 @@ use std::io;
 
 use chia_consensus::gen::validation_error::ValidationErr;
 use chia_protocol::ProtocolMessageTypes;
-use chia_sdk_signer::SignError;
+use chia_sdk_signer::SignerError;
 use futures_channel::mpsc::SendError;
 use thiserror::Error;
 use tokio_tungstenite::tungstenite;
@@ -21,8 +21,8 @@ pub enum SimulatorError {
     #[error("consensus error: {0}")]
     Consensus(#[from] chia_consensus::error::Error),
 
-    #[error("sign error: {0}")]
-    Sign(#[from] SignError),
+    #[error("signer error: {0}")]
+    Signer(#[from] SignerError),
 
     #[error("validation error: {0}")]
     Validation(#[from] ValidationErr),

crates/chia-sdk-test/src/simulator/simulator_data.rs

@@ -18,7 +18,7 @@ use clvmr::{
 use indexmap::{IndexMap, IndexSet};
 use tokio::sync::MutexGuard;
 
-use super::{simulator_config::SimulatorConfig, simulator_error::SimulatorError};
+use super::{error::SimulatorError, simulator_config::SimulatorConfig};
 
 #[derive(Debug, Default, Clone)]
 pub(crate) struct SimulatorData {

crates/chia-sdk-test/src/simulator/ws_connection.rs

@@ -21,10 +21,10 @@ use tokio::{
 use tokio_tungstenite::{tungstenite::Message as WsMessage, WebSocketStream};
 
 use super::{
+    error::SimulatorError,
     peer_map::Ws,
     simulator_config::SimulatorConfig,
     simulator_data::{new_transaction, SimulatorData},
-    simulator_error::SimulatorError,
     PeerMap,
 };