units: Hide amount decoder error internals

Introduces new policy on how we implement decoder error types.

- All internals are hidden
- No `From<OtherError>` impls
- Private constructors 
- Inner enum is private (does not need non_exhaustive).

Author: tcharding

units/src/amount/error.rs

@@ -394,8 +394,24 @@ impl std::error::Error for PossiblyConfusingDenominationError {
 /// An error consensus decoding an `Amount`.
 #[cfg(feature = "encoding")]
 #[derive(Debug, Clone, PartialEq, Eq)]
-#[non_exhaustive]
-pub enum AmountDecoderError {
+pub struct AmountDecoderError(pub(super) AmountDecoderErrorInner);
+
+#[cfg(feature = "encoding")]
+impl AmountDecoderError {
+    /// Constructs an EOF error.
+    pub(super) fn eof(e: encoding::UnexpectedEofError) -> Self {
+        Self(AmountDecoderErrorInner::UnexpectedEof(e))
+    }
+
+    /// Constructs an out of range (`Amount::from_sat`) error.
+    pub(super) fn out_of_range(e: OutOfRangeError) -> Self {
+        Self(AmountDecoderErrorInner::OutOfRange(e))
+    }
+}
+
+#[cfg(feature = "encoding")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(super) enum AmountDecoderErrorInner {
     /// Not enough bytes given to decoder.
     UnexpectedEof(encoding::UnexpectedEofError),
     /// Decoded amount is too big.
@@ -407,27 +423,26 @@ impl From<Infallible> for AmountDecoderError {
     fn from(never: Infallible) -> Self { match never {} }
 }
 
-#[cfg(feature = "encoding")]
-impl From<encoding::UnexpectedEofError> for AmountDecoderError {
-    fn from(e: encoding::UnexpectedEofError) -> Self { Self::UnexpectedEof(e) }
-}
-
 #[cfg(feature = "encoding")]
 impl fmt::Display for AmountDecoderError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Self::UnexpectedEof(ref e) => write_err!(f, "decode error"; e),
-            Self::OutOfRange(ref e) => write_err!(f, "decode error"; e),
+        use AmountDecoderErrorInner as E;
+
+        match self.0 {
+            E::UnexpectedEof(ref e) => write_err!(f, "decode error"; e),
+            E::OutOfRange(ref e) => write_err!(f, "decode error"; e),
         }
     }
 }
 
 #[cfg(all(feature = "std", feature = "encoding"))]
 impl std::error::Error for AmountDecoderError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        match *self {
-            Self::UnexpectedEof(ref e) => Some(e),
-            Self::OutOfRange(ref e) => Some(e),
+        use AmountDecoderErrorInner as E;
+
+        match self.0 {
+            E::UnexpectedEof(ref e) => Some(e),
+            E::OutOfRange(ref e) => Some(e),
         }
     }
 }

units/src/amount/unsigned.rs

@@ -589,13 +589,13 @@ impl encoding::Decoder for AmountDecoder {
 
     #[inline]
     fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
-        Ok(self.0.push_bytes(bytes)?)
+        self.0.push_bytes(bytes).map_err(AmountDecoderError::eof)
     }
 
     #[inline]
     fn end(self) -> Result<Self::Output, Self::Error> {
-        let a = u64::from_le_bytes(self.0.end()?);
-        Ok(Amount::from_sat(a).map_err(AmountDecoderError::OutOfRange)?)
+        let a = u64::from_le_bytes(self.0.end().map_err(AmountDecoderError::eof)?);
+        Amount::from_sat(a).map_err(AmountDecoderError::out_of_range)
     }
 }