Move lightning-invoice deser errors to lib.rs instead of `pub use`

[rust-lightning] / lightning-invoice / src / de.rs

diff --git a/lightning-invoice/src/de.rs b/lightning-invoice/src/de.rs
index 53f6b83da5fdf00fdd33fcf51c4f0502b32d0fa2..5de2b038e8b2d29a25df42705d5d7d378009a7fb 100644 (file)
--- a/lightning-invoice/src/de.rs
+++ b/lightning-invoice/src/de.rs
@@ -23,8 +23,8 @@ use secp256k1::recovery::{RecoveryId, RecoverableSignature};
 use secp256k1::key::PublicKey;
 
 use super::{Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiry, Fallback, PayeePubKey, InvoiceSignature, PositiveTimestamp,
-       SemanticError, PrivateRoute, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawInvoice, constants, SignedRawInvoice,
-       RawDataPart, CreationError, InvoiceFeatures};
+       SemanticError, PrivateRoute, ParseError, ParseOrSemanticError, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawInvoice,
+       constants, SignedRawInvoice, RawDataPart, InvoiceFeatures};
 
 use self::hrp_sm::parse_hrp;
 
@@ -359,7 +359,6 @@ impl FromBase32 for PositiveTimestamp {
                        .expect("7*5bit < 64bit, no overflow possible");
                match PositiveTimestamp::from_unix_timestamp(timestamp) {
                        Ok(t) => Ok(t),
-                       Err(CreationError::TimestampOutOfBounds) => Err(ParseError::TimestampOverflow),
                        Err(_) => unreachable!(),
                }
        }
@@ -516,7 +515,7 @@ impl FromBase32 for ExpiryTime {
 
        fn from_base32(field_data: &[u5]) -> Result<ExpiryTime, ParseError> {
                match parse_int_be::<u64, u5>(field_data, 32)
-                       .and_then(|t| ExpiryTime::from_seconds(t).ok()) // ok, since the only error is out of bounds
+                       .map(|t| ExpiryTime::from_seconds(t))
                {
                        Some(t) => Ok(t),
                        None => Err(ParseError::IntegerOverflowError),
@@ -620,47 +619,6 @@ impl FromBase32 for PrivateRoute {
        }
 }
 
-/// Errors that indicate what is wrong with the invoice. They have some granularity for debug
-/// reasons, but should generally result in an "invalid BOLT11 invoice" message for the user.
-#[allow(missing_docs)]
-#[derive(PartialEq, Debug, Clone)]
-pub enum ParseError {
-       Bech32Error(bech32::Error),
-       ParseAmountError(ParseIntError),
-       MalformedSignature(secp256k1::Error),
-       BadPrefix,
-       UnknownCurrency,
-       UnknownSiPrefix,
-       MalformedHRP,
-       TooShortDataPart,
-       UnexpectedEndOfTaggedFields,
-       DescriptionDecodeError(str::Utf8Error),
-       PaddingError,
-       IntegerOverflowError,
-       InvalidSegWitProgramLength,
-       InvalidPubKeyHashLength,
-       InvalidScriptHashLength,
-       InvalidRecoveryId,
-       InvalidSliceLength(String),
-
-       /// Not an error, but used internally to signal that a part of the invoice should be ignored
-       /// according to BOLT11
-       Skip,
-       TimestampOverflow,
-}
-
-/// Indicates that something went wrong while parsing or validating the invoice. Parsing errors
-/// should be mostly seen as opaque and are only there for debugging reasons. Semantic errors
-/// like wrong signatures, missing fields etc. could mean that someone tampered with the invoice.
-#[derive(PartialEq, Debug, Clone)]
-pub enum ParseOrSemanticError {
-       /// The invoice couldn't be decoded
-       ParseError(ParseError),
-
-       /// The invoice could be decoded but violates the BOLT11 standard
-       SemanticError(::SemanticError),
-}
-
 impl Display for ParseError {
        fn fmt(&self, f: &mut Formatter) -> fmt::Result {
                match *self {
@@ -709,9 +667,6 @@ impl Display for ParseError {
                        ParseError::Skip => {
                                f.write_str("the tagged field has to be skipped because of an unexpected, but allowed property")
                        },
-                       ParseError::TimestampOverflow => {
-                f.write_str("the invoice's timestamp could not be represented as SystemTime")
-            },
                }
        }
 }
@@ -877,7 +832,7 @@ mod test {
                use bech32::FromBase32;
 
                let input = from_bech32("pu".as_bytes());
-               let expected = Ok(ExpiryTime::from_seconds(60).unwrap());
+               let expected = Ok(ExpiryTime::from_seconds(60));
                assert_eq!(ExpiryTime::from_base32(&input), expected);
 
                let input_too_large = from_bech32("sqqqqqqqqqqqq".as_bytes());