Merge commit '6d44fe818ea4c74f476cc6d79434cc8619b45c0c' into simon/instrumented

common/mixnode-common/src/packet_processor/error.rs

@@ -1,66 +1,25 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use nymsphinx_acknowledgements::surb_ack::SurbAckRecoveryError;
-use nymsphinx_addressing::nodes::NymNodeRoutingAddressError;
-use nymsphinx_types::Error as SphinxError;
-use std::fmt::{self, Display, Formatter};
+use nym_sphinx_acknowledgements::surb_ack::SurbAckRecoveryError;
+use nym_sphinx_addressing::nodes::NymNodeRoutingAddressError;
+use nym_sphinx_types::Error as SphinxError;
+use thiserror::Error;
 
-#[derive(Debug)]
+#[derive(Error, Debug)]
 pub enum MixProcessingError {
-    SphinxProcessingError(SphinxError),
-    InvalidHopAddress(NymNodeRoutingAddressError),
-    NoSurbAckInFinalHop,
-    MalformedSurbAck(SurbAckRecoveryError),
+    #[error("failed to process received packet: {0}")]
+    SphinxProcessingError(#[from] SphinxError),
 
+    #[error("the forward hop address was malformed: {0}")]
+    InvalidForwardHopAddress(#[from] NymNodeRoutingAddressError),
+
+    #[error("the final hop did not contain a SURB-Ack")]
+    NoSurbAckInFinalHop,
+
+    #[error("failed to recover the expected SURB-Ack packet: {0}")]
+    MalformedSurbAck(#[from] SurbAckRecoveryError),
+
+    #[error("the received packet was set to use the very old and very much deprecated 'VPN' mode")]
     ReceivedOldTypeVpnPacket,
 }
-
-impl From<SphinxError> for MixProcessingError {
-    // for the time being just have a single error instance for all possible results of SphinxError
-    fn from(err: SphinxError) -> Self {
-        use MixProcessingError::*;
-
-        SphinxProcessingError(err)
-    }
-}
-
-impl From<NymNodeRoutingAddressError> for MixProcessingError {
-    fn from(err: NymNodeRoutingAddressError) -> Self {
-        use MixProcessingError::*;
-
-        InvalidHopAddress(err)
-    }
-}
-
-impl From<SurbAckRecoveryError> for MixProcessingError {
-    fn from(err: SurbAckRecoveryError) -> Self {
-        use MixProcessingError::*;
-
-        MalformedSurbAck(err)
-    }
-}
-
-impl Display for MixProcessingError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            MixProcessingError::SphinxProcessingError(sphinx_err) => {
-                write!(f, "Sphinx Processing Error - {}", sphinx_err)
-            }
-            MixProcessingError::InvalidHopAddress(address_err) => {
-                write!(f, "Invalid Hop Address - {:?}", address_err)
-            }
-            MixProcessingError::NoSurbAckInFinalHop => {
-                write!(f, "No SURBAck present in the final hop data")
-            }
-            MixProcessingError::MalformedSurbAck(surb_ack_err) => {
-                write!(f, "Malformed SURBAck - {:?}", surb_ack_err)
-            }
-            MixProcessingError::ReceivedOldTypeVpnPacket => {
-                write!(f, "Received an old-type unsafe 'VPN' mode packet")
-            }
-        }
-    }
-}
-
-impl std::error::Error for MixProcessingError {}

common/mixnode-common/src/packet_processor/processor.rs

@@ -3,12 +3,12 @@
 
 use crate::packet_processor::error::MixProcessingError;
 use tracing::*;
-use nymsphinx_acknowledgements::surb_ack::SurbAck;
-use nymsphinx_addressing::nodes::NymNodeRoutingAddress;
-use nymsphinx_forwarding::packet::MixPacket;
-use nymsphinx_framing::packet::FramedSphinxPacket;
-use nymsphinx_params::{PacketMode, PacketSize};
-use nymsphinx_types::{
+use nym_sphinx_acknowledgements::surb_ack::SurbAck;
+use nym_sphinx_addressing::nodes::NymNodeRoutingAddress;
+use nym_sphinx_forwarding::packet::MixPacket;
+use nym_sphinx_framing::packet::FramedSphinxPacket;
+use nym_sphinx_params::{PacketMode, PacketSize};
+use nym_sphinx_types::{
     Delay as SphinxDelay, DestinationAddressBytes, NodeAddressBytes, Payload, PrivateKey,
     ProcessedPacket, SphinxPacket,
 };
@@ -51,7 +51,7 @@ impl SphinxPacketProcessor {
         packet: SphinxPacket,
     ) -> Result<ProcessedPacket, MixProcessingError> {
         packet.process(&self.sphinx_key).map_err(|err| {
-            debug!("Failed to unwrap Sphinx packet: {:?}", err);
+            debug!("Failed to unwrap Sphinx packet: {err}");
             MixProcessingError::SphinxProcessingError(err)
         })
     }
@@ -195,7 +195,7 @@ impl SphinxPacketProcessor {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use nymsphinx_types::crypto::keygen;
+    use nym_sphinx_types::crypto::keygen;
 
     fn fixture() -> SphinxPacketProcessor {
         let local_keys = keygen();