WIP: Offer semantic checks

Author: jkczyz

lightning/src/offers/mod.rs

@@ -17,6 +17,7 @@ use bitcoin::hash_types::BlockHash;
 use bitcoin::network::constants::Network;
 use bitcoin::secp256k1::{PublicKey, XOnlyPublicKey};
 use bitcoin::secp256k1::schnorr::Signature;
+use core::convert::TryFrom;
 use core::str::FromStr;
 use core::time::Duration;
 use ln::PaymentHash;
@@ -132,6 +133,8 @@ pub enum Amount {
 	},
 }
 
+const ISO4217_CODE_LEN: usize = 3;
+
 ///
 #[derive(Debug)]
 pub enum Destination {
@@ -225,6 +228,31 @@ pub enum ParseError {
 	Bech32(bech32::Error),
 	/// The bech32 decoded string could not be decoded as the expected message type.
 	Decode(DecodeError),
+	/// The parsed message has invalid semantics.
+	InvalidSemantics(SemanticError),
+}
+
+#[derive(Debug, PartialEq)]
+///
+pub enum SemanticError {
+	///
+	UnsupportedChain,
+	///
+	UnexpectedCurrency,
+	///
+	InvalidCurrencyEncoding,
+	///
+	MissingDescription,
+	///
+	MissingDestination,
+	///
+	DuplicateDestination,
+	///
+	MissingPaths,
+	///
+	InvalidQuantity,
+	///
+	UnexpectedRefund,
 }
 
 impl From<bech32::Error> for ParseError {
@@ -239,6 +267,111 @@ impl From<DecodeError> for ParseError {
 	}
 }
 
+impl From<SemanticError> for ParseError {
+	fn from(error: SemanticError) -> Self {
+		Self::InvalidSemantics(error)
+	}
+}
+
+impl FromStr for Offer {
+	type Err = ParseError;
+
+	fn from_str(s: &str) -> Result<Self, <Self as FromStr>::Err> {
+		let tlv_stream = OfferTlvStream::from_str(s)?;
+		Ok(Offer::try_from(tlv_stream)?)
+	}
+}
+
+impl TryFrom<OfferTlvStream> for Offer {
+	type Error = SemanticError;
+
+	fn try_from(tlv_stream: OfferTlvStream) -> Result<Self, Self::Error> {
+		let OfferTlvStream {
+			chains, currency, amount, description, features, absolute_expiry, paths, issuer,
+			quantity_min, quantity_max, recurrence, node_id, send_invoice, refund_for, signature,
+		} = tlv_stream;
+
+		let supported_chains = [
+			genesis_block(Network::Bitcoin).block_hash(),
+			genesis_block(Network::Testnet).block_hash(),
+			genesis_block(Network::Signet).block_hash(),
+			genesis_block(Network::Regtest).block_hash(),
+		];
+		let chains = match chains {
+			None => None,
+			Some(WithoutLength(chains)) => match chains.first() {
+				None => Some(chains),
+				Some(chain) if supported_chains.contains(chain) => Some(chains),
+				_ => return Err(SemanticError::UnsupportedChain),
+			},
+		};
+
+		let amount = match (currency, amount) {
+			(None, None) => None,
+			(None, Some(amount_msats)) => Some(Amount::Bitcoin { amount_msats: amount_msats.0 }),
+			(Some(_), None) => return Err(SemanticError::UnexpectedCurrency),
+			(Some(WithoutLength(iso4217_code)), Some(HighZeroBytesDroppedVarInt(amount))) => {
+				if iso4217_code.len() != ISO4217_CODE_LEN {
+					return Err(SemanticError::InvalidCurrencyEncoding);
+				}
+				Some(Amount::Currency { iso4217_code, amount })
+			},
+		};
+
+		if description.is_none() {
+			return Err(SemanticError::MissingDescription);
+		}
+
+		let destination = match (node_id, paths) {
+			(None, None) => return Err(SemanticError::MissingDestination),
+			(Some(_), Some(_)) => return Err(SemanticError::DuplicateDestination),
+			(Some(node_id), None) => Destination::NodeId(node_id),
+			(None, Some(paths)) if paths.0.is_empty() => return Err(SemanticError::MissingPaths),
+			(None, Some(WithoutLength(paths))) => Destination::Paths(paths),
+		};
+
+		if let Some(HighZeroBytesDroppedVarInt(quantity_min)) = quantity_min {
+			if quantity_min < 1 {
+				return Err(SemanticError::InvalidQuantity);
+			}
+
+			if let Some(HighZeroBytesDroppedVarInt(quantity_max)) = quantity_max {
+				if quantity_min > quantity_max {
+					return Err(SemanticError::InvalidQuantity);
+				}
+			}
+		}
+
+		if let Some(HighZeroBytesDroppedVarInt(quantity_max)) = quantity_max {
+			if quantity_max < 1 {
+				return Err(SemanticError::InvalidQuantity);
+			}
+		}
+
+		let send_invoice = match (send_invoice, refund_for) {
+			(None, None) => None,
+			(None, Some(_)) => return Err(SemanticError::UnexpectedRefund),
+			(Some(_), _) => Some(SendInvoice { refund_for }),
+		};
+
+		Ok(Offer {
+			chains,
+			amount,
+			description: description.unwrap().0,
+			features,
+			absolute_expiry:
+				absolute_expiry.map(|seconds_from_epoch| Duration::from_secs(seconds_from_epoch.0)),
+			issuer: issuer.map(|issuer| issuer.0),
+			destination,
+			quantity_min: quantity_min.map(|quantity_min| quantity_min.0),
+			quantity_max: quantity_max.map(|quantity_max| quantity_max.0),
+			recurrence,
+			send_invoice,
+			signature,
+		})
+	}
+}
+
 const OFFER_BECH32_HRP: &str = "lno";
 
 impl FromStr for OfferTlvStream {