diff --git a/identity/src/public_key.rs b/identity/src/public_key.rs index edac73d..72ffae3 100644 --- a/identity/src/public_key.rs +++ b/identity/src/public_key.rs @@ -24,9 +24,9 @@ use thiserror::Error as ThisError; #[derive(ThisError, Debug)] pub enum PKError { #[error("Cannot decode public key from bytes: {0}")] - FromBytesError(SignatureError), + FromBytesError(#[source] SignatureError), #[error("Cannot decode public key from base58 format: {0}")] - FromBase58Error(bs58::decode::Error), + FromBase58Error(#[source] bs58::decode::Error), } #[derive(Copy, Clone, Default, Eq, PartialEq, Serialize, Deserialize)] diff --git a/identity/src/signature.rs b/identity/src/signature.rs index 81db973..d479f6b 100644 --- a/identity/src/signature.rs +++ b/identity/src/signature.rs @@ -21,8 +21,12 @@ use thiserror::Error as ThisError; #[derive(ThisError, Debug)] pub enum SignatureError { - #[error(transparent)] - Error(#[from] SigError), + #[error("{0}")] + Error( + #[from] + #[source] + SigError, + ), } #[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] diff --git a/src/certificate.rs b/src/certificate.rs index bb24d7f..a94697b 100644 --- a/src/certificate.rs +++ b/src/certificate.rs @@ -46,7 +46,7 @@ pub enum CertificateError { #[error("Incorrect length of an array. Should be 2 bytes of a format, 4 bytes of a version and 104 bytes for each trust")] IncorrectByteLength, #[error("Error while decoding a trust in a certificate: {0}")] - DecodeError(TrustError), + DecodeError(#[source] TrustError), #[error("Certificate is expired. Issued at {issued_at} and expired at {expires_at}")] ExpirationError { expires_at: String, @@ -55,15 +55,15 @@ pub enum CertificateError { #[error("Certificate does not contain a trusted root.")] NoTrustedRoot, #[error("Root trust did not pass verification: {0}")] - MalformedRoot(TrustError), + MalformedRoot(#[source] TrustError), #[error("There is no `issued_by` public key in a certificate")] KeyInCertificateError, #[error("The certificate must have at least 1 trust")] CertificateLengthError, #[error("Cannot convert trust number {0} from string: {1}")] - DecodeTrustError(usize, TrustError), + DecodeTrustError(usize, #[source] TrustError), #[error("Trust {0} in chain did not pass verification: {1}")] - VerificationError(usize, TrustError), + VerificationError(usize, #[source] TrustError), #[error("there cannot be paths without any nodes after adding verified certificates")] Unexpected, } diff --git a/src/revoke.rs b/src/revoke.rs index cd7d42e..b40c82f 100644 --- a/src/revoke.rs +++ b/src/revoke.rs @@ -27,7 +27,7 @@ use thiserror::Error as ThisError; #[derive(ThisError, Debug)] pub enum RevokeError { #[error("Signature is incorrect: {0}")] - IncorrectSignature(SignatureError), + IncorrectSignature(#[source] SignatureError), } /// "A document" that cancels trust created before. diff --git a/src/trust.rs b/src/trust.rs index 685689c..8d65c5f 100644 --- a/src/trust.rs +++ b/src/trust.rs @@ -67,24 +67,32 @@ pub enum TrustError { Expired(Duration, Duration), /// Errors occured on signature verification - #[error(transparent)] - SignatureError(#[from] ed25519_dalek::SignatureError), + #[error("{0}")] + SignatureError( + #[from] + #[source] + ed25519_dalek::SignatureError, + ), /// Errors occured on trust decoding from differrent formats #[error("Cannot decode the public key: {0} in the trust: {1}")] - DecodePublicKeyError(String, PKError), + DecodePublicKeyError(String, #[source] PKError), #[error("Cannot parse `{0}` field in the trust '{1}': {2}")] - ParseError(String, String, ParseIntError), + ParseError(String, String, #[source] ParseIntError), #[error("Cannot decode `{0}` from base58 format in the trust '{1}': {2}")] - Base58DecodeError(String, String, bs58::decode::Error), + Base58DecodeError(String, String, #[source] bs58::decode::Error), #[error("Cannot decode a signature from bytes: {0}")] SignatureFromBytesError(#[from] SigError), - #[error(transparent)] - PublicKeyError(#[from] PKError), + #[error("{0}")] + PublicKeyError( + #[from] + #[source] + PKError, + ), #[error( "Trust length should be 104: public key(32) + signature(64) + expiration date(8), was: {0}" diff --git a/src/trust_graph.rs b/src/trust_graph.rs index 4ce0b61..2b12a17 100644 --- a/src/trust_graph.rs +++ b/src/trust_graph.rs @@ -21,7 +21,7 @@ use crate::revoke::Revoke; use crate::revoke::RevokeError; use crate::trust::Trust; use crate::trust_graph::TrustGraphError::{ - CertificateCheckError, EmptyChain, InternalStorageError, NoRoot, RevokeCheckError, + CertificateCheckError, EmptyChain, InternalStorageError, NoRoot, }; use crate::trust_graph_storage::Storage; use crate::trust_node::{Auth, TrustNode}; @@ -57,9 +57,17 @@ pub enum TrustGraphError { #[error("Chain is empty")] EmptyChain, #[error("Certificate check error: {0}")] - CertificateCheckError(CertificateError), + CertificateCheckError( + #[from] + #[source] + CertificateError, + ), #[error("Error on revoking a trust: {0}")] - RevokeCheckError(RevokeError), + RevokeCheckError( + #[from] + #[source] + RevokeError, + ), } impl From for TrustGraphError { @@ -68,24 +76,12 @@ impl From for TrustGraphError { } } -impl From for TrustGraphError { - fn from(err: CertificateError) -> Self { - CertificateCheckError(err) - } -} - impl From for String { fn from(err: TrustGraphError) -> Self { format!("{}", err) } } -impl From for TrustGraphError { - fn from(err: RevokeError) -> Self { - RevokeCheckError(err) - } -} - #[allow(dead_code)] impl TrustGraph where diff --git a/wasm/src/dto.rs b/wasm/src/dto.rs index f1628c4..5e2e068 100644 --- a/wasm/src/dto.rs +++ b/wasm/src/dto.rs @@ -9,11 +9,23 @@ use thiserror::Error as ThisError; #[derive(ThisError, Debug)] pub enum DtoConversionError { #[error("Cannot convert base58 string to bytes: {0}")] - Base58Error(#[from] bs58::decode::Error), + Base58Error( + #[from] + #[source] + bs58::decode::Error, + ), #[error("Cannot convert string to PublicKey: {0}")] - PublicKeyDecodeError(#[from] PKError), + PublicKeyDecodeError( + #[from] + #[source] + PKError, + ), #[error("Cannot convert string to PublicKey: {0}")] - SignatureDecodeError(#[from] SignatureError), + SignatureDecodeError( + #[from] + #[source] + SignatureError, + ), } #[fce] diff --git a/wasm/src/service_impl.rs b/wasm/src/service_impl.rs index 5c7cd80..99842e2 100644 --- a/wasm/src/service_impl.rs +++ b/wasm/src/service_impl.rs @@ -10,14 +10,30 @@ use trust_graph::{CertificateError, TrustGraphError}; #[derive(ThisError, Debug)] pub enum ServiceError { - #[error(transparent)] - PublicKeyDecodeError(#[from] PKError), - #[error(transparent)] - TGError(#[from] TrustGraphError), - #[error(transparent)] - CertError(#[from] CertificateError), - #[error(transparent)] - DtoError(#[from] DtoConversionError), + #[error("{0}")] + PublicKeyDecodeError( + #[from] + #[source] + PKError, + ), + #[error("{0}")] + TGError( + #[from] + #[source] + TrustGraphError, + ), + #[error("{0}")] + CertError( + #[from] + #[source] + CertificateError, + ), + #[error("{0}")] + DtoError( + #[from] + #[source] + DtoConversionError, + ), } pub fn get_weight_impl(public_key: String) -> Result, ServiceError> { diff --git a/wasm/src/storage_impl.rs b/wasm/src/storage_impl.rs index ef43234..0bc22b9 100644 --- a/wasm/src/storage_impl.rs +++ b/wasm/src/storage_impl.rs @@ -3,8 +3,8 @@ // if there is an older trust - don't add received trust use crate::storage_impl::SQLiteStorageError::{ - DecodeError, EncodeError, PublcKeyNotFound, PublicKeyConversion, PublicKeyFromStr, SQLiteError, - TrustNodeConversion, WeightConversionDB, + PublcKeyNotFound, PublicKeyConversion, PublicKeyFromStr, TrustNodeConversion, + WeightConversionDB, }; use core::convert::TryFrom; use fce_sqlite_connector; @@ -58,14 +58,26 @@ impl SQLiteStorage { #[derive(ThisError, Debug)] pub enum SQLiteStorageError { - #[error(transparent)] - SQLiteError(InternalSqliteError), + #[error("{0}")] + SQLiteError( + #[from] + #[source] + InternalSqliteError, + ), #[error("{0}")] PublicKeyFromStr(String), - #[error(transparent)] - EncodeError(RmpEncodeError), - #[error(transparent)] - DecodeError(RmpDecodeError), + #[error("{0}")] + EncodeError( + #[from] + #[source] + RmpEncodeError, + ), + #[error("{0}")] + DecodeError( + #[from] + #[source] + RmpDecodeError, + ), #[error("Cannot convert weight as integer from DB")] WeightConversionDB, #[error("Cannot convert public key as binary from DB")] @@ -76,24 +88,6 @@ pub enum SQLiteStorageError { PublcKeyNotFound, } -impl From for SQLiteStorageError { - fn from(err: InternalSqliteError) -> Self { - SQLiteError(err) - } -} - -impl From for SQLiteStorageError { - fn from(err: RmpEncodeError) -> Self { - EncodeError(err) - } -} - -impl From for SQLiteStorageError { - fn from(err: RmpDecodeError) -> Self { - DecodeError(err) - } -} - impl From for String { fn from(err: SQLiteStorageError) -> Self { err.into()