node: add from_str method to Construct, Commit and RedeemNode

We cannot use the std from_str trait because these all construct an Arc<Self>
rather than a Self. And we cannot implement this generically on Node because
the rules for decoding are different for each node type (we have progressively
tighter correctness requirements, and with RedeemNode we need extra witness
data).

Author: apoelstra

src/lib.rs

@@ -113,6 +113,41 @@ impl std::error::Error for DecodeError {
     }
 }
 
+/// Error parsing a program or witness (decoding it from a string encoding).
+#[non_exhaustive]
+#[derive(Debug)]
+pub enum ParseError {
+    /// Bit-encoding error.
+    Decode(DecodeError),
+    /// Base64 decoding error
+    #[cfg(feature = "base64")]
+    Base64(base64::DecodeError),
+    /// Hex decoding error
+    Hex(hex::error::HexToBytesError),
+}
+
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Decode(ref e) => e.fmt(f),
+            #[cfg(feature = "base64")]
+            Self::Base64(ref e) => e.fmt(f),
+            Self::Hex(ref e) => e.fmt(f),
+        }
+    }
+}
+
+impl std::error::Error for ParseError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::Decode(ref e) => Some(e),
+            #[cfg(feature = "base64")]
+            Self::Base64(ref e) => Some(e),
+            Self::Hex(ref e) => Some(e),
+        }
+    }
+}
+
 /// Error finalizing a program (i.e. typechecking and pruning).
 #[non_exhaustive]
 #[derive(Debug)]

src/node/commit.rs

@@ -262,6 +262,19 @@ impl<J: Jet> CommitNode<J> {
         }
     }
 
+    #[cfg(feature = "base64")]
+    #[allow(clippy::should_implement_trait)] // returns Arc<Self>
+    pub fn from_str(s: &str) -> Result<Arc<Self>, crate::ParseError> {
+        use crate::base64::engine::general_purpose;
+        use crate::base64::Engine as _;
+
+        let v = general_purpose::STANDARD
+            .decode(s)
+            .map_err(crate::ParseError::Base64)?;
+        let iter = crate::BitIter::new(v.into_iter());
+        Self::decode(iter).map_err(crate::ParseError::Decode)
+    }
+
     /// Encode a Simplicity expression to bits without any witness data
     #[deprecated(since = "0.5.0", note = "use Self::encode_without_witness instead")]
     pub fn encode<W: io::Write>(&self, w: &mut BitWriter<W>) -> io::Result<usize> {
@@ -357,6 +370,7 @@ mod tests {
         {
             assert_eq!(prog.to_string(), b64_str);
             assert_eq!(prog.display().program().to_string(), b64_str);
+            assert_eq!(prog, CommitNode::from_str(b64_str).unwrap());
         }
 
         prog

src/node/construct.rs

@@ -237,6 +237,21 @@ impl<J: Jet> ConstructNode<J> {
         Ok(res)
     }
 
+    #[cfg(feature = "base64")]
+    #[allow(clippy::should_implement_trait)] // returns Arc<Self>
+    pub fn from_str(s: &str) -> Result<Arc<Self>, crate::ParseError> {
+        use crate::base64::engine::general_purpose;
+        use crate::base64::Engine as _;
+
+        let v = general_purpose::STANDARD
+            .decode(s)
+            .map_err(crate::ParseError::Base64)?;
+        let iter = crate::BitIter::new(v.into_iter());
+        Self::decode(iter)
+            .map_err(crate::DecodeError::Decode)
+            .map_err(crate::ParseError::Decode)
+    }
+
     /// Encode a Simplicity expression to bits, with no witness data
     #[deprecated(since = "0.5.0", note = "use Self::encode_without_witness instead")]
     pub fn encode<W: io::Write>(&self, w: &mut BitWriter<W>) -> io::Result<usize> {

src/node/mod.rs

@@ -125,6 +125,12 @@ pub trait Marker:
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
 pub struct NoWitness;
 
+impl From<NoWitness> for Option<Value> {
+    fn from(_: NoWitness) -> Self {
+        None
+    }
+}
+
 pub trait Constructible<J, X, W>:
     JetConstructible<J>
     + DisconnectConstructible<X>

src/node/redeem.rs

@@ -532,6 +532,23 @@ impl<J: Jet> RedeemNode<J> {
         Ok(program)
     }
 
+    #[cfg(feature = "base64")]
+    #[allow(clippy::should_implement_trait)] // returns Arc<Self>
+    pub fn from_str(prog: &str, wit: &str) -> Result<Arc<Self>, crate::ParseError> {
+        use crate::base64::engine::general_purpose;
+        use crate::base64::Engine as _;
+        use crate::hex::FromHex as _;
+
+        let v = general_purpose::STANDARD
+            .decode(prog)
+            .map_err(crate::ParseError::Base64)?;
+        let prog_iter = crate::BitIter::new(v.into_iter());
+
+        let v = Vec::from_hex(wit).map_err(crate::ParseError::Hex)?;
+        let wit_iter = crate::BitIter::new(v.into_iter());
+        Self::decode(prog_iter, wit_iter).map_err(crate::ParseError::Decode)
+    }
+
     /// Encode the program to bits.
     ///
     /// Includes witness data. Returns the number of written bits.