Refactor error system (#255)

* Redefine Ics20Error by displaydoc

* Redefine Ics02Error by displaydoc

* Update client_state.rs

* Redefine Ics07Error by displaydoc

* Redefine Ics03Error by displaydoc

* Redefine Ics04Error by displaydoc

* Redefine Ics05Error by displaydoc

* Redefine Ics23Error by displaydoc

* Redefine Ics24Error by displaydoc

* Redefine Ics26Error by displaydoc

* Redefine Ics18Error by displaydoc

* Redefine ParseFailure Error

* Redefine HeightError

* Redefine ProofError

* Redefine SignerError

* Redefine TimestampOverflowError, ParseTimestampError

* Redefine event Error

* update ics03Error

* Update Ics04Error

* Update Ics26Error

* Remove flex-error

* Update error.rs

* Create 164-refactor-error-system.md

* Impl std::erorr::Error for IbcError

* Add #![allow(clippy::result_large_err)]

* Rename Ics02Error to ClientError

* Rename Ics03Error to ConnectionError

* Disassembling out PacketError

* Rename Ics04Error to ChannelError

* Rename Ics05Error to PortError

* Rename Ics23Error to CommitmentError

* Rename Ics26Error to RouterError

* Rename Ics18Error to RelayerError

* Rename Ics20Error to TokenTransferError

* Add ContextError for ValidationContext and ExecutionContext

* Update RouterError

* fix clippy

* Update context.rs

* Update lib.rs

* Secondary error display output

* Remove unused Error variant

* Remove unused Error variant

* Update 164-refactor-error-system.md

Author: DaviRain-Su

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

@@ -0,0 +1 @@
+- Remove `flex-error` and remove unused error variants([#164](https://github.com/cosmos/ibc-rs/issues/164))

crates/ibc/Cargo.toml

@@ -18,7 +18,24 @@ all-features = true
 
 [features]
 default = ["std"]
-std = ["flex-error/std", "flex-error/eyre_tracer", "ibc-proto/std", "clock"]
+std = [ 
+    "ibc-proto/std",
+    "ics23/std",
+    "serde/std",
+    "serde_json/std",
+    "erased-serde/std",
+    "tracing/std",
+    "prost/std",
+    "bytes/std",
+    "subtle-encoding/std",
+    "sha2/std",
+    "displaydoc/std",
+    "num-traits/std",
+    "uint/std",
+    "primitive-types/std",
+    "clock",
+    "tendermint/std",
+]
 clock = ["tendermint/clock", "time/std"]
 
 # This feature grants access to development-time mocking libraries, such as `MockContext` or `MockHeader`.
@@ -40,7 +57,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/acknowledgement.rs

@@ -2,7 +2,7 @@ use core::fmt::{Display, Error as FmtError, Formatter};
 
 use serde::{Deserialize, Serialize};
 
-use super::error::Error;
+use super::error::TokenTransferError;
 use crate::core::ics26_routing::context::Acknowledgement as AckTrait;
 use crate::prelude::*;
 
@@ -36,7 +36,7 @@ impl Acknowledgement {
         Self::Success(ConstAckSuccess::Success)
     }
 
-    pub fn from_error(err: Error) -> Self {
+    pub fn from_error(err: TokenTransferError) -> Self {
         Self::Error(format!("{}: {}", ACK_ERR_STR, err))
     }
 }

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

@@ -2,7 +2,7 @@ use core::str::FromStr;
 use derive_more::{Display, From, Into};
 use serde::{Deserialize, Serialize};
 
-use super::error::Error;
+use super::error::TokenTransferError;
 use crate::bigint::U256;
 
 /// A type for representing token transfer amounts.
@@ -22,10 +22,10 @@ impl Amount {
 }
 
 impl FromStr for Amount {
-    type Err = Error;
+    type Err = TokenTransferError;
 
     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(TokenTransferError::InvalidAmount)?;
         Ok(Self(amount))
     }
 }

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

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 
 use super::amount::Amount;
 use super::denom::{BaseDenom, PrefixedDenom};
-use super::error::Error;
+use super::error::TokenTransferError;
 use crate::prelude::*;
 use crate::serializers::serde_string;
 
@@ -30,35 +30,39 @@ pub struct Coin<D> {
 
 impl<D: FromStr> Coin<D>
 where
-    D::Err: Into<Error>,
+    D::Err: Into<TokenTransferError>,
 {
-    pub fn from_string_list(coin_str: &str) -> Result<Vec<Self>, Error> {
+    pub fn from_string_list(coin_str: &str) -> Result<Vec<Self>, TokenTransferError> {
         coin_str.split(',').map(FromStr::from_str).collect()
     }
 }
 
 impl<D: FromStr> FromStr for Coin<D>
 where
-    D::Err: Into<Error>,
+    D::Err: Into<TokenTransferError>,
 {
-    type Err = Error;
+    type Err = TokenTransferError;
 
     #[allow(clippy::assign_op_pattern)]
-    fn from_str(coin_str: &str) -> Result<Self, Error> {
+    fn from_str(coin_str: &str) -> Result<Self, TokenTransferError> {
         // Denominations can be 3 ~ 128 characters long and support letters, followed by either
         // a letter, a number or a separator ('/', ':', '.', '_' or '-').
         // Loosely copy the regex from here:
         // 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(|| {
+            TokenTransferError::InvalidCoin {
+                coin: coin_str.to_string(),
+            }
+        })?;
 
-        let amount = from_utf8(m1).map_err(Error::utf8_decode)?.parse()?;
+        let amount = from_utf8(m1)
+            .map_err(TokenTransferError::Utf8Decode)?
+            .parse()?;
 
         let denom = from_utf8(m2)
-            .map_err(Error::utf8_decode)?
+            .map_err(TokenTransferError::Utf8Decode)?
             .parse()
             .map_err(Into::into)?;
 
@@ -68,9 +72,9 @@ where
 
 impl<D: FromStr> TryFrom<ProtoCoin> for Coin<D>
 where
-    D::Err: Into<Error>,
+    D::Err: Into<TokenTransferError>,
 {
-    type Error = Error;
+    type Error = TokenTransferError;
 
     fn try_from(proto: ProtoCoin) -> Result<Coin<D>, Self::Error> {
         let denom = D::from_str(&proto.denom).map_err(Into::into)?;
@@ -108,7 +112,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_parse_raw_coin() -> Result<(), Error> {
+    fn test_parse_raw_coin() -> Result<(), TokenTransferError> {
         {
             let coin = RawCoin::from_str("123stake")?;
             assert_eq!(coin.denom, "stake");
@@ -137,7 +141,7 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_raw_coin_list() -> Result<(), Error> {
+    fn test_parse_raw_coin_list() -> Result<(), TokenTransferError> {
         {
             let coins = RawCoin::from_string_list("123stake,1a1,999den0m")?;
             assert_eq!(coins.len(), 3);