Qualify the BOLT 12 parse error

[rust-lightning] / lightning / src / offers / parse.rs

diff --git a/lightning/src/offers/parse.rs b/lightning/src/offers/parse.rs
index 42ed2e002d1f29b60169c86954f39cece3101647..064604f3afb35bc9472ad8d1707b399102963cb3 100644 (file)
--- a/lightning/src/offers/parse.rs
+++ b/lightning/src/offers/parse.rs
@@ -29,24 +29,24 @@ mod sealed {
        use bitcoin::bech32::{FromBase32, ToBase32};
        use core::convert::TryFrom;
        use core::fmt;
-       use super::ParseError;
+       use super::Bolt12ParseError;
 
        use crate::prelude::*;
 
        /// Indicates a message can be encoded using bech32.
-       pub trait Bech32Encode: AsRef<[u8]> + TryFrom<Vec<u8>, Error=ParseError> {
+       pub trait Bech32Encode: AsRef<[u8]> + TryFrom<Vec<u8>, Error=Bolt12ParseError> {
                /// Human readable part of the message's bech32 encoding.
                const BECH32_HRP: &'static str;
 
                /// Parses a bech32-encoded message into a TLV stream.
-               fn from_bech32_str(s: &str) -> Result<Self, ParseError> {
+               fn from_bech32_str(s: &str) -> Result<Self, Bolt12ParseError> {
                        // Offer encoding may be split by '+' followed by optional whitespace.
                        let encoded = match s.split('+').skip(1).next() {
                                Some(_) => {
                                        for chunk in s.split('+') {
                                                let chunk = chunk.trim_start();
                                                if chunk.is_empty() || chunk.contains(char::is_whitespace) {
-                                                       return Err(ParseError::InvalidContinuation);
+                                                       return Err(Bolt12ParseError::InvalidContinuation);
                                                }
                                        }
 
@@ -59,7 +59,7 @@ mod sealed {
                        let (hrp, data) = bech32::decode_without_checksum(encoded.as_ref())?;
 
                        if hrp != Self::BECH32_HRP {
-                               return Err(ParseError::InvalidBech32Hrp);
+                               return Err(Bolt12ParseError::InvalidBech32Hrp);
                        }
 
                        let data = Vec::<u8>::from_base32(&data)?;
@@ -116,10 +116,8 @@ impl<T: SeekReadable> TryFrom<Vec<u8>> for ParsedMessage<T> {
 }
 
 /// Error when parsing a bech32 encoded message using [`str::parse`].
-///
-/// This is not exported to bindings users as its name conflicts with the BOLT 11 ParseError type.
 #[derive(Debug, PartialEq)]
-pub enum ParseError {
+pub enum Bolt12ParseError {
        /// The bech32 encoding does not conform to the BOLT 12 requirements for continuing messages
        /// across multiple parts (i.e., '+' followed by whitespace).
        InvalidContinuation,
@@ -195,25 +193,25 @@ pub enum SemanticError {
        MissingSignature,
 }
 
-impl From<bech32::Error> for ParseError {
+impl From<bech32::Error> for Bolt12ParseError {
        fn from(error: bech32::Error) -> Self {
                Self::Bech32(error)
        }
 }
 
-impl From<DecodeError> for ParseError {
+impl From<DecodeError> for Bolt12ParseError {
        fn from(error: DecodeError) -> Self {
                Self::Decode(error)
        }
 }
 
-impl From<SemanticError> for ParseError {
+impl From<SemanticError> for Bolt12ParseError {
        fn from(error: SemanticError) -> Self {
                Self::InvalidSemantics(error)
        }
 }
 
-impl From<secp256k1::Error> for ParseError {
+impl From<secp256k1::Error> for Bolt12ParseError {
        fn from(error: secp256k1::Error) -> Self {
                Self::InvalidSignature(error)
        }