Move url_ext-specific errors to url_ext.rs

Author: shinghim

payjoin/src/send/error.rs

@@ -5,7 +5,7 @@ use bitcoin::transaction::Version;
 use bitcoin::{AddressType, Sequence};
 
 #[cfg(feature = "v2")]
-use crate::uri::error::ParseReceiverPubkeyParamError;
+use crate::uri::url_ext::ParseReceiverPubkeyParamError;
 
 /// Error that may occur when the response from receiver is malformed.
 ///

payjoin/src/send/mod.rs

@@ -331,7 +331,7 @@ impl Sender {
     #[cfg(feature = "v2")]
     fn extract_rs_pubkey(
         &self,
-    ) -> Result<HpkePublicKey, crate::uri::error::ParseReceiverPubkeyParamError> {
+    ) -> Result<HpkePublicKey, crate::uri::url_ext::ParseReceiverPubkeyParamError> {
         use crate::uri::UrlExt;
         self.endpoint.receiver_pubkey()
     }

payjoin/src/uri/error.rs

@@ -11,86 +11,6 @@ pub(crate) enum InternalPjParseError {
     UnsecureEndpoint,
 }
 
-#[cfg(feature = "v2")]
-#[derive(Debug)]
-pub(crate) enum ParseOhttpKeysParamError {
-    MissingOhttpKeys,
-    InvalidOhttpKeys(crate::ohttp::ParseOhttpKeysError),
-}
-
-#[cfg(feature = "v2")]
-#[derive(Debug)]
-pub(crate) enum ParseExpParamError {
-    MissingExp,
-    InvalidHrp(bitcoin::bech32::Hrp),
-    DecodeBech32(bitcoin::bech32::primitives::decode::CheckedHrpstringError),
-    InvalidExp(bitcoin::consensus::encode::Error),
-}
-
-#[cfg(feature = "v2")]
-impl std::fmt::Display for ParseExpParamError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        use ParseExpParamError::*;
-
-        match &self {
-            MissingExp => write!(f, "exp is missing"),
-            InvalidHrp(h) => write!(f, "incorrect hrp for exp: {}", h),
-            DecodeBech32(d) => write!(f, "exp is not valid bech32: {}", d),
-            InvalidExp(i) => write!(f, "exp param does not contain a bitcoin consensus encoded u32: {}", i),
-        }
-    }
-}
-
-#[cfg(feature = "v2")]
-impl std::fmt::Display for ParseOhttpKeysParamError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        use ParseOhttpKeysParamError::*;
-
-        match &self {
-            MissingOhttpKeys => write!(f, "ohttp keys are missing"),
-            InvalidOhttpKeys(o) => write!(f, "invalid ohttp keys: {}", o),
-        }
-    }
-}
-
-#[cfg(feature = "v2")]
-#[derive(Debug)]
-pub(crate) enum ParseReceiverPubkeyParamError {
-    MissingPubkey,
-    InvalidHrp(bitcoin::bech32::Hrp),
-    DecodeBech32(bitcoin::bech32::primitives::decode::CheckedHrpstringError),
-    InvalidPubkey(crate::hpke::HpkeError),
-}
-
-#[cfg(feature = "v2")]
-impl std::fmt::Display for ParseReceiverPubkeyParamError {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        use ParseReceiverPubkeyParamError::*;
-
-        match &self {
-            MissingPubkey => write!(f, "receiver public key is missing"),
-            InvalidHrp(h) => write!(f, "incorrect hrp for receiver key: {}", h),
-            DecodeBech32(e) => write!(f, "receiver public is not valid base64: {}", e),
-            InvalidPubkey(e) =>
-                write!(f, "receiver public key does not represent a valid pubkey: {}", e),
-        }
-    }
-}
-
-#[cfg(feature = "v2")]
-impl std::error::Error for ParseReceiverPubkeyParamError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParseReceiverPubkeyParamError::*;
-
-        match &self {
-            MissingPubkey => None,
-            InvalidHrp(_) => None,
-            DecodeBech32(error) => Some(error),
-            InvalidPubkey(error) => Some(error),
-        }
-    }
-}
-
 impl From<InternalPjParseError> for PjParseError {
     fn from(value: InternalPjParseError) -> Self { PjParseError(value) }
 }

payjoin/src/uri/url_ext.rs

@@ -5,7 +5,6 @@ use bitcoin::consensus::encode::Decodable;
 use bitcoin::consensus::Encodable;
 use url::Url;
 
-use super::error::{ParseExpParamError, ParseOhttpKeysParamError, ParseReceiverPubkeyParamError};
 use crate::hpke::HpkePublicKey;
 use crate::ohttp::OhttpKeys;
 
@@ -131,6 +130,87 @@ fn set_param(url: &mut Url, prefix: &str, param: &str) {
     url.set_fragment(if fragment.is_empty() { None } else { Some(&fragment) });
 }
 
+#[cfg(feature = "v2")]
+#[derive(Debug)]
+pub(crate) enum ParseOhttpKeysParamError {
+    MissingOhttpKeys,
+    InvalidOhttpKeys(crate::ohttp::ParseOhttpKeysError),
+}
+
+#[cfg(feature = "v2")]
+impl std::fmt::Display for ParseOhttpKeysParamError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use ParseOhttpKeysParamError::*;
+
+        match &self {
+            MissingOhttpKeys => write!(f, "ohttp keys are missing"),
+            InvalidOhttpKeys(o) => write!(f, "invalid ohttp keys: {}", o),
+        }
+    }
+}
+
+#[cfg(feature = "v2")]
+#[derive(Debug)]
+pub(crate) enum ParseExpParamError {
+    MissingExp,
+    InvalidHrp(bitcoin::bech32::Hrp),
+    DecodeBech32(bitcoin::bech32::primitives::decode::CheckedHrpstringError),
+    InvalidExp(bitcoin::consensus::encode::Error),
+}
+
+#[cfg(feature = "v2")]
+impl std::fmt::Display for ParseExpParamError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use ParseExpParamError::*;
+
+        match &self {
+            MissingExp => write!(f, "exp is missing"),
+            InvalidHrp(h) => write!(f, "incorrect hrp for exp: {}", h),
+            DecodeBech32(d) => write!(f, "exp is not valid bech32: {}", d),
+            InvalidExp(i) =>
+                write!(f, "exp param does not contain a bitcoin consensus encoded u32: {}", i),
+        }
+    }
+}
+
+#[cfg(feature = "v2")]
+#[derive(Debug)]
+pub(crate) enum ParseReceiverPubkeyParamError {
+    MissingPubkey,
+    InvalidHrp(bitcoin::bech32::Hrp),
+    DecodeBech32(bitcoin::bech32::primitives::decode::CheckedHrpstringError),
+    InvalidPubkey(crate::hpke::HpkeError),
+}
+
+#[cfg(feature = "v2")]
+impl std::fmt::Display for ParseReceiverPubkeyParamError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        use ParseReceiverPubkeyParamError::*;
+
+        match &self {
+            MissingPubkey => write!(f, "receiver public key is missing"),
+            InvalidHrp(h) => write!(f, "incorrect hrp for receiver key: {}", h),
+            DecodeBech32(e) => write!(f, "receiver public is not valid base64: {}", e),
+            InvalidPubkey(e) =>
+                write!(f, "receiver public key does not represent a valid pubkey: {}", e),
+        }
+    }
+}
+
+#[cfg(feature = "v2")]
+impl std::error::Error for ParseReceiverPubkeyParamError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use ParseReceiverPubkeyParamError::*;
+
+        match &self {
+            MissingPubkey => None,
+            InvalidHrp(_) => None,
+            DecodeBech32(error) => Some(error),
+            InvalidPubkey(error) => Some(error),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;