Refactor error system

.changelog/unreleased/enhancement/164-refactor-error-system.md

@@ -0,0 +1 @@
+- Refactor error system ([#164](https://github.com/cosmos/ibc-rs/issues/164))

crates/ibc/Cargo.toml

@@ -18,7 +18,7 @@ all-features = true
 
 [features]
 default = ["std"]
-std = ["flex-error/std", "flex-error/eyre_tracer", "ibc-proto/std", "clock"]
+std = ["ibc-proto/std", "clock", "displaydoc/std" ]
 clock = ["tendermint/clock", "time/std"]
 
 # This feature grants access to development-time mocking libraries, such as `MockContext` or `MockHeader`.
@@ -40,7 +40,7 @@ bytes = { version = "1.2.1", default-features = false }
 safe-regex = { version = "0.2.5", default-features = false }
 subtle-encoding = { version = "0.5", default-features = false }
 sha2 = { version = "0.10.6", default-features = false }
-flex-error = { version = "0.4.4", default-features = false }
+displaydoc = { version = "0.2", default-features = false }
 num-traits = { version = "0.2.15", default-features = false }
 derive_more = { version = "0.99.17", default-features = false, features = ["from", "into", "display"] }
 uint = { version = "0.9", default-features = false }

crates/ibc/src/applications/transfer/amount.rs

@@ -25,7 +25,7 @@ impl FromStr for Amount {
     type Err = Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let amount = U256::from_dec_str(s).map_err(Error::invalid_amount)?;
+        let amount = U256::from_dec_str(s).map_err(Error::InvalidAmount)?;
         Ok(Self(amount))
     }
 }

crates/ibc/src/applications/transfer/coin.rs

@@ -51,14 +51,17 @@ where
         // https://github.com/cosmos/cosmos-sdk/blob/v0.45.5/types/coin.go#L760-L762
         let matcher = regex!(br"([0-9]+)([a-zA-Z0-9/:\\._\x2d]+)");
 
-        let (m1, m2) = matcher
-            .match_slices(coin_str.as_bytes())
-            .ok_or_else(|| Error::invalid_coin(coin_str.to_string()))?;
+        let (m1, m2) =
+            matcher
+                .match_slices(coin_str.as_bytes())
+                .ok_or_else(|| Error::InvalidCoin {
+                    coin: coin_str.to_string(),
+                })?;
 
-        let amount = from_utf8(m1).map_err(Error::utf8_decode)?.parse()?;
+        let amount = from_utf8(m1).map_err(Error::Utf8Decode)?.parse()?;
 
         let denom = from_utf8(m2)
-            .map_err(Error::utf8_decode)?
+            .map_err(Error::Utf8Decode)?
             .parse()
             .map_err(Into::into)?;
 

crates/ibc/src/applications/transfer/context.rs

@@ -165,15 +165,24 @@ pub fn on_chan_open_init(
     version: &Version,
 ) -> Result<(ModuleExtras, Version), Ics20Error> {
     if order != Order::Unordered {
-        return Err(Ics20Error::channel_not_unordered(order));
+        return Err(Ics20Error::ChannelNotUnordered {
+            expect_order: Order::Unordered,
+            got_order: order,
+        });
     }
     let bound_port = ctx.get_port()?;
     if port_id != &bound_port {
-        return Err(Ics20Error::invalid_port(port_id.clone(), bound_port));
+        return Err(Ics20Error::InvalidPort {
+            port_id: port_id.clone(),
+            exp_port_id: bound_port,
+        });
     }
 
     if !version.is_empty() && version != &Version::ics20() {
-        return Err(Ics20Error::invalid_version(version.clone()));
+        return Err(Ics20Error::InvalidVersion {
+            expect_version: Version::ics20(),
+            got_version: version.clone(),
+        });
     }
 
     Ok((ModuleExtras::empty(), Version::ics20()))
@@ -190,12 +199,16 @@ pub fn on_chan_open_try(
     counterparty_version: &Version,
 ) -> Result<(ModuleExtras, Version), Ics20Error> {
     if order != Order::Unordered {
-        return Err(Ics20Error::channel_not_unordered(order));
+        return Err(Ics20Error::ChannelNotUnordered {
+            expect_order: Order::Unordered,
+            got_order: order,
+        });
     }
     if counterparty_version != &Version::ics20() {
-        return Err(Ics20Error::invalid_counterparty_version(
-            counterparty_version.clone(),
-        ));
+        return Err(Ics20Error::InvalidCounterpartyVersion {
+            expect_version: Version::ics20(),
+            got_version: counterparty_version.clone(),
+        });
     }
 
     Ok((ModuleExtras::empty(), Version::ics20()))
@@ -208,9 +221,10 @@ pub fn on_chan_open_ack(
     counterparty_version: &Version,
 ) -> Result<ModuleExtras, Ics20Error> {
     if counterparty_version != &Version::ics20() {
-        return Err(Ics20Error::invalid_counterparty_version(
-            counterparty_version.clone(),
-        ));
+        return Err(Ics20Error::InvalidCounterpartyVersion {
+            expect_version: Version::ics20(),
+            got_version: counterparty_version.clone(),
+        });
     }
 
     Ok(ModuleExtras::empty())
@@ -229,7 +243,7 @@ pub fn on_chan_close_init(
     _port_id: &PortId,
     _channel_id: &ChannelId,
 ) -> Result<ModuleExtras, Ics20Error> {
-    Err(Ics20Error::cant_close_channel())
+    Err(Ics20Error::CantCloseChannel)
 }
 
 pub fn on_chan_close_confirm(
@@ -250,7 +264,7 @@ pub fn on_recv_packet<Ctx: 'static + TokenTransferContext>(
         Ok(data) => data,
         Err(_) => {
             return OnRecvPacketAck::Failed(Box::new(Acknowledgement::Error(
-                Ics20Error::packet_data_deserialization().to_string(),
+                Ics20Error::PacketDataDeserialization.to_string(),
             )));
         }
     };
@@ -279,10 +293,10 @@ pub fn on_acknowledgement_packet(
     _relayer: &Signer,
 ) -> Result<(), Ics20Error> {
     let data = serde_json::from_slice::<PacketData>(&packet.data)
-        .map_err(|_| Ics20Error::packet_data_deserialization())?;
+        .map_err(|_| Ics20Error::PacketDataDeserialization)?;
 
     let acknowledgement = serde_json::from_slice::<Acknowledgement>(acknowledgement.as_ref())
-        .map_err(|_| Ics20Error::ack_deserialization())?;
+        .map_err(|_| Ics20Error::AckDeserialization)?;
 
     process_ack_packet(ctx, packet, &data, &acknowledgement)?;
 
@@ -305,7 +319,7 @@ pub fn on_timeout_packet(
     _relayer: &Signer,
 ) -> Result<(), Ics20Error> {
     let data = serde_json::from_slice::<PacketData>(&packet.data)
-        .map_err(|_| Ics20Error::packet_data_deserialization())?;
+        .map_err(|_| Ics20Error::PacketDataDeserialization)?;
 
     process_timeout_packet(ctx, packet, &data)?;
 
@@ -343,7 +357,9 @@ pub(crate) mod test {
         output: &mut HandlerOutputBuilder<()>,
         msg: MsgTransfer<PrefixedCoin>,
     ) -> Result<(), Error> {
-        send_transfer(ctx, output, msg).map_err(|e: Ics20Error| Error::app_module(e.to_string()))
+        send_transfer(ctx, output, msg).map_err(|e: Ics20Error| Error::AppModule {
+            description: e.to_string(),
+        })
     }
 
     fn get_defaults() -> (

crates/ibc/src/applications/transfer/denom.rs

@@ -26,7 +26,7 @@ impl FromStr for BaseDenom {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         if s.trim().is_empty() {
-            Err(Error::empty_base_denom())
+            Err(Error::EmptyBaseDenom)
         } else {
             Ok(BaseDenom(s.to_owned()))
         }
@@ -90,16 +90,21 @@ impl<'a> TryFrom<Vec<&'a str>> for TracePath {
 
     fn try_from(v: Vec<&'a str>) -> Result<Self, Self::Error> {
         if v.len() % 2 != 0 {
-            return Err(Error::invalid_trace_length(v.len()));
+            return Err(Error::InvalidTraceLength { len: v.len() });
         }
 
         let mut trace = vec![];
         let id_pairs = v.chunks_exact(2).map(|paths| (paths[0], paths[1]));
         for (pos, (port_id, channel_id)) in id_pairs.rev().enumerate() {
-            let port_id =
-                PortId::from_str(port_id).map_err(|e| Error::invalid_trace_port_id(pos, e))?;
-            let channel_id = ChannelId::from_str(channel_id)
-                .map_err(|e| Error::invalid_trace_channel_id(pos, e))?;
+            let port_id = PortId::from_str(port_id).map_err(|e| Error::InvalidTracePortId {
+                pos,
+                validation_error: e,
+            })?;
+            let channel_id =
+                ChannelId::from_str(channel_id).map_err(|e| Error::InvalidTraceChannelId {
+                    pos,
+                    validation_error: e,
+                })?;
             trace.push(TracePrefix {
                 port_id,
                 channel_id,