units: Implement decoding traits

In a similar fashion to what we did for encoding; for each of the
types that implements encoding add logic for decoding.

Author: tcharding

units/src/amount/error.rs

@@ -137,8 +137,9 @@ impl fmt::Display for ParseAmountError {
             E::TooPrecise(ref error) => write_err!(f, "amount has a too high precision"; error),
             E::MissingDigits(ref error) => write_err!(f, "the input has too few digits"; error),
             E::InputTooLarge(ref error) => write_err!(f, "the input is too large"; error),
-            E::InvalidCharacter(ref error) =>
-                write_err!(f, "invalid character in the input"; error),
+            E::InvalidCharacter(ref error) => {
+                write_err!(f, "invalid character in the input"; error)
+            }
         }
     }
 }
@@ -389,3 +390,44 @@ impl fmt::Display for PossiblyConfusingDenominationError {
 impl std::error::Error for PossiblyConfusingDenominationError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
 }
+
+/// An error consensus decoding an `Amount`.
+#[cfg(feature = "encoding")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum AmountDecoderError {
+    /// Not enough bytes given to decoder.
+    UnexpectedEof(encoding::UnexpectedEofError),
+    /// Decoded amount is too big.
+    OutOfRange(OutOfRangeError),
+}
+
+#[cfg(feature = "encoding")]
+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),
+        }
+    }
+}
+
+#[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),
+        }
+    }
+}

units/src/amount/mod.rs

@@ -37,6 +37,9 @@ pub use self::{
     signed::SignedAmount,
     unsigned::Amount,
 };
+#[cfg(feature = "encoding")]
+#[doc(no_inline)]
+pub use self::error::AmountDecoderError;
 #[doc(no_inline)]
 pub use self::error::{OutOfRangeError, ParseAmountError, ParseDenominationError, ParseError};
 

units/src/amount/unsigned.rs

@@ -12,6 +12,8 @@ use arbitrary::{Arbitrary, Unstructured};
 use internals::const_casts;
 use NumOpResult as R;
 
+#[cfg(feature = "encoding")]
+use super::error::AmountDecoderError;
 use super::error::{ParseAmountErrorInner, ParseErrorInner};
 use super::{
     parse_signed_to_satoshi, split_amount_and_denomination, Denomination, Display, DisplayStyle,
@@ -576,6 +578,33 @@ impl encoding::Encodable for Amount {
     }
 }
 
+/// The decoder for the [`Amount`] type.
+#[cfg(feature = "encoding")]
+pub struct AmountDecoder(encoding::ArrayDecoder<8>);
+
+#[cfg(feature = "encoding")]
+impl encoding::Decoder for AmountDecoder {
+    type Output = Amount;
+    type Error = AmountDecoderError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        Ok(self.0.push_bytes(bytes)?)
+    }
+
+    #[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)?)
+    }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decodable for Amount {
+    type Decoder = AmountDecoder;
+    fn decoder() -> Self::Decoder { AmountDecoder(encoding::ArrayDecoder::<8>::new()) }
+}
+
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Amount {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {

units/src/block.rs

@@ -157,6 +157,33 @@ impl encoding::Encodable for BlockHeight {
     }
 }
 
+/// The decoder for the [`BlockHeight`] type.
+#[cfg(feature = "encoding")]
+pub struct BlockHeightDecoder(encoding::ArrayDecoder<4>);
+
+#[cfg(feature = "encoding")]
+impl encoding::Decoder for BlockHeightDecoder {
+    type Output = BlockHeight;
+    type Error = encoding::UnexpectedEofError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let n = u32::from_le_bytes(self.0.end()?);
+        Ok(BlockHeight::from_u32(n))
+    }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decodable for BlockHeight {
+    type Decoder = BlockHeightDecoder;
+    fn decoder() -> Self::Decoder { BlockHeightDecoder(encoding::ArrayDecoder::<4>::new()) }
+}
+
 impl_u32_wrapper! {
     /// An unsigned block interval.
     ///

units/src/locktime/absolute/mod.rs

@@ -417,6 +417,33 @@ impl encoding::Encodable for LockTime {
     }
 }
 
+/// The decoder for the [`LockTime`] type.
+#[cfg(feature = "encoding")]
+pub struct LockTimeDecoder(encoding::ArrayDecoder<4>);
+
+#[cfg(feature = "encoding")]
+impl encoding::Decoder for LockTimeDecoder {
+    type Output = LockTime;
+    type Error = encoding::UnexpectedEofError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let n = u32::from_le_bytes(self.0.end()?);
+        Ok(LockTime::from_consensus(n))
+    }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decodable for LockTime {
+    type Decoder = LockTimeDecoder;
+    fn decoder() -> Self::Decoder { LockTimeDecoder(encoding::ArrayDecoder::<4>::new()) }
+}
+
 impl From<Height> for LockTime {
     #[inline]
     fn from(h: Height) -> Self { LockTime::Blocks(h) }

units/src/sequence.rs

@@ -280,6 +280,33 @@ impl encoding::Encodable for Sequence {
     }
 }
 
+/// The decoder for the [`Sequence`] type.
+#[cfg(feature = "encoding")]
+pub struct SequenceDecoder(encoding::ArrayDecoder<4>);
+
+#[cfg(feature = "encoding")]
+impl encoding::Decoder for SequenceDecoder {
+    type Output = Sequence;
+    type Error = encoding::UnexpectedEofError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let n = u32::from_le_bytes(self.0.end()?);
+        Ok(Sequence::from_consensus(n))
+    }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decodable for Sequence {
+    type Decoder = SequenceDecoder;
+    fn decoder() -> Self::Decoder { SequenceDecoder(encoding::ArrayDecoder::<4>::new()) }
+}
+
 #[cfg(feature = "arbitrary")]
 #[cfg(feature = "alloc")]
 impl<'a> Arbitrary<'a> for Sequence {

units/src/time.rs

@@ -87,6 +87,33 @@ impl encoding::Encodable for BlockTime {
     }
 }
 
+/// The decoder for the [`BlockTime`] type.
+#[cfg(feature = "encoding")]
+pub struct BlockTimeDecoder(encoding::ArrayDecoder<4>);
+
+#[cfg(feature = "encoding")]
+impl encoding::Decoder for BlockTimeDecoder {
+    type Output = BlockTime;
+    type Error = encoding::UnexpectedEofError;
+
+    #[inline]
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
+        self.0.push_bytes(bytes)
+    }
+
+    #[inline]
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let t = u32::from_le_bytes(self.0.end()?);
+        Ok(BlockTime::from_u32(t))
+    }
+}
+
+#[cfg(feature = "encoding")]
+impl encoding::Decodable for BlockTime {
+    type Decoder = BlockTimeDecoder;
+    fn decoder() -> Self::Decoder { BlockTimeDecoder(encoding::ArrayDecoder::<4>::new()) }
+}
+
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for BlockTime {
     #[inline]