Offer raw byte encoding and decoding

Offers are typically encoded as bech32 strings for use in QR codes.
However, a more compact encoding is useful when storing offers
long-term. Implement Writeable for Offer and have a corresponding
TryFrom implementation for decoding the raw bytes.

Author: jkczyz

lightning/src/offers/offer.rs

@@ -18,12 +18,14 @@
 //! extern crate core;
 //! extern crate lightning;
 //!
+//! use core::convert::TryFrom;
 //! use core::num::NonZeroU64;
 //! use core::time::Duration;
 //!
 //! use bitcoin::secp256k1::{KeyPair, PublicKey, Secp256k1, SecretKey};
 //! use lightning::offers::offer::{Amount, Offer, OfferBuilder};
 //! use lightning::offers::parse::ParseError;
+//! use lightning::util::ser::{Readable, Writeable};
 //!
 //! # use lightning::onion_message::BlindedPath;
 //! # #[cfg(feature = "std")]
@@ -54,6 +56,13 @@
 //!
 //! // Parse from a bech32 string after scanning from a QR code.
 //! let offer = encoded_offer.parse::<Offer>()?;
+//!
+//! // Encode offer as raw bytes.
+//! let mut bytes = Vec::new();
+//! offer.write(&mut bytes).unwrap();
+//!
+//! // Decode raw bytes into an offer.
+//! let offer = Offer::try_from(bytes)?;
 //! # Ok(())
 //! # }
 //! ```
@@ -71,7 +80,7 @@ use ln::features::OfferFeatures;
 use ln::msgs::MAX_VALUE_MSAT;
 use offers::parse::{Bech32Encode, ParseError, SemanticError};
 use onion_message::BlindedPath;
-use util::ser::{HighZeroBytesDroppedBigSize, WithoutLength, Writeable, Writer};
+use util::ser::{HighZeroBytesDroppedBigSize, Readable, WithoutLength, Writeable, Writer};
 
 use prelude::*;
 
@@ -408,12 +417,27 @@ impl OfferContents {
 	}
 }
 
+impl Writeable for Offer {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+		WithoutLength(&self.bytes).write(writer)
+	}
+}
+
 impl Writeable for OfferContents {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
 		self.as_tlv_stream().write(writer)
 	}
 }
 
+impl TryFrom<Vec<u8>> for Offer {
+	type Error = ParseError;
+
+	fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
+		let tlv_stream: OfferTlvStream = Readable::read(&mut &bytes[..])?;
+		Offer::try_from((bytes, tlv_stream))
+	}
+}
+
 /// The minimum amount required for an item in an [`Offer`], denominated in either bitcoin or
 /// another currency.
 #[derive(Clone, Debug, PartialEq)]
@@ -466,6 +490,8 @@ impl Bech32Encode for Offer {
 	const BECH32_HRP: &'static str = "lno";
 }
 
+type ParsedOffer = (Vec<u8>, OfferTlvStream);
+
 impl FromStr for Offer {
 	type Err = ParseError;
 
@@ -476,6 +502,16 @@ impl FromStr for Offer {
 	}
 }
 
+impl TryFrom<ParsedOffer> for Offer {
+	type Error = ParseError;
+
+	fn try_from(offer: ParsedOffer) -> Result<Self, Self::Error> {
+		let (bytes, tlv_stream) = offer;
+		let contents = OfferContents::try_from(tlv_stream)?;
+		Ok(Offer { bytes, contents })
+	}
+}
+
 impl TryFrom<OfferTlvStream> for OfferContents {
 	type Error = SemanticError;
 
@@ -544,11 +580,12 @@ impl core::fmt::Display for Offer {
 
 #[cfg(test)]
 mod tests {
-	use super::{Amount, OfferBuilder};
+	use super::{Amount, Offer, OfferBuilder};
 
 	use bitcoin::blockdata::constants::ChainHash;
 	use bitcoin::network::constants::Network;
 	use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
+	use core::convert::TryFrom;
 	use core::num::NonZeroU64;
 	use core::time::Duration;
 	use ln::features::OfferFeatures;
@@ -571,7 +608,7 @@ mod tests {
 		let offer = OfferBuilder::new("foo".into(), pubkey(42)).build().unwrap();
 		let tlv_stream = offer.as_tlv_stream();
 		let mut buffer = Vec::new();
-		offer.contents.write(&mut buffer).unwrap();
+		offer.write(&mut buffer).unwrap();
 
 		assert_eq!(offer.bytes, buffer.as_slice());
 		assert_eq!(offer.chains(), vec![ChainHash::using_genesis_block(Network::Bitcoin)]);
@@ -600,6 +637,10 @@ mod tests {
 		assert_eq!(tlv_stream.quantity_min, None);
 		assert_eq!(tlv_stream.quantity_max, None);
 		assert_eq!(tlv_stream.node_id, Some(&pubkey(42)));
+
+		if let Err(e) = Offer::try_from(buffer) {
+			panic!("error parsing offer: {:?}", e);
+		}
 	}
 
 	#[test]