Change options to result for various APIs

Author: sanket1729

src/descriptor/bare.rs

@@ -111,11 +111,11 @@ where
         Ok(())
     }
 
-    fn address(&self, _network: bitcoin::Network) -> Option<bitcoin::Address>
+    fn address(&self, _network: bitcoin::Network) -> Result<bitcoin::Address, Error>
     where
         Pk: ToPublicKey,
     {
-        None
+        Err(Error::BareDescriptorAddr)
     }
 
     fn script_pubkey(&self) -> Script
@@ -150,9 +150,9 @@ where
         Ok((witness, script_sig))
     }
 
-    fn max_satisfaction_weight(&self) -> Option<usize> {
+    fn max_satisfaction_weight(&self) -> Result<usize, Error> {
         let scriptsig_len = self.ms.max_satisfaction_size()?;
-        Some(4 * (varint_len(scriptsig_len) + scriptsig_len))
+        Ok(4 * (varint_len(scriptsig_len) + scriptsig_len))
     }
 
     fn script_code(&self) -> Script
@@ -267,11 +267,11 @@ where
         Ok(())
     }
 
-    fn address(&self, network: bitcoin::Network) -> Option<bitcoin::Address>
+    fn address(&self, network: bitcoin::Network) -> Result<bitcoin::Address, Error>
     where
         Pk: ToPublicKey,
     {
-        Some(bitcoin::Address::p2pkh(&self.pk.to_public_key(), network))
+        Ok(bitcoin::Address::p2pkh(&self.pk.to_public_key(), network))
     }
 
     fn script_pubkey(&self) -> Script
@@ -315,8 +315,8 @@ where
         }
     }
 
-    fn max_satisfaction_weight(&self) -> Option<usize> {
-        Some(4 * (1 + 73 + self.pk.serialized_len()))
+    fn max_satisfaction_weight(&self) -> Result<usize, Error> {
+        Ok(4 * (1 + 73 + self.pk.serialized_len()))
     }
 
     fn script_code(&self) -> Script

src/descriptor/mod.rs

@@ -81,7 +81,8 @@ pub trait DescriptorTrait<Pk: MiniscriptKey> {
     fn sanity_check(&self) -> Result<(), Error>;
 
     /// Computes the Bitcoin address of the descriptor, if one exists
-    fn address(&self, network: bitcoin::Network) -> Option<bitcoin::Address>
+    /// Some descriptors like pk() don't have any address.
+    fn address(&self, network: bitcoin::Network) -> Result<bitcoin::Address, Error>
     where
         Pk: ToPublicKey;
 
@@ -137,7 +138,8 @@ pub trait DescriptorTrait<Pk: MiniscriptKey> {
     /// transaction. Assumes all signatures are 73 bytes, including push opcode
     /// and sighash suffix. Includes the weight of the VarInts encoding the
     /// scriptSig and witness stack length.
-    fn max_satisfaction_weight(&self) -> Option<usize>;
+    /// Returns Error when the descriptor is impossible to safisfy (ex: sh(OP_FALSE))
+    fn max_satisfaction_weight(&self) -> Result<usize, Error>;
 
     /// Get the `scriptCode` of a transaction output.
     ///
@@ -308,7 +310,7 @@ where
         }
     }
     /// Computes the Bitcoin address of the descriptor, if one exists
-    fn address(&self, network: bitcoin::Network) -> Option<bitcoin::Address>
+    fn address(&self, network: bitcoin::Network) -> Result<bitcoin::Address, Error>
     where
         Pk: ToPublicKey,
     {
@@ -394,7 +396,7 @@ where
     /// transaction. Assumes all signatures are 73 bytes, including push opcode
     /// and sighash suffix. Includes the weight of the VarInts encoding the
     /// scriptSig and witness stack length.
-    fn max_satisfaction_weight(&self) -> Option<usize> {
+    fn max_satisfaction_weight(&self) -> Result<usize, Error> {
         match *self {
             Descriptor::Bare(ref bare) => bare.max_satisfaction_weight(),
             Descriptor::Pkh(ref pkh) => pkh.max_satisfaction_weight(),
@@ -668,7 +670,12 @@ mod tests {
                 "512102000000000000000000000000000000000000000000000000000000000000000251ae"
             )
         );
-        assert_eq!(bare.address(bitcoin::Network::Bitcoin,), None);
+        assert_eq!(
+            bare.address(bitcoin::Network::Bitcoin)
+                .unwrap_err()
+                .to_string(),
+            "Bare descriptors don't have address"
+        );
 
         let pk = StdDescriptor::from_str(TEST_PK).unwrap();
         assert_eq!(

src/descriptor/segwitv0.rs

@@ -154,13 +154,13 @@ where
         Ok(())
     }
 
-    fn address(&self, network: bitcoin::Network) -> Option<bitcoin::Address>
+    fn address(&self, network: bitcoin::Network) -> Result<bitcoin::Address, Error>
     where
         Pk: ToPublicKey,
     {
         match self.inner {
-            WshInner::SortedMulti(ref smv) => Some(bitcoin::Address::p2wsh(&smv.encode(), network)),
-            WshInner::Ms(ref ms) => Some(bitcoin::Address::p2wsh(&ms.encode(), network)),
+            WshInner::SortedMulti(ref smv) => Ok(bitcoin::Address::p2wsh(&smv.encode(), network)),
+            WshInner::Ms(ref ms) => Ok(bitcoin::Address::p2wsh(&ms.encode(), network)),
         }
     }
 
@@ -202,7 +202,7 @@ where
         Ok((witness, script_sig))
     }
 
-    fn max_satisfaction_weight(&self) -> Option<usize> {
+    fn max_satisfaction_weight(&self) -> Result<usize, Error> {
         let (script_size, max_sat_elems, max_sat_size) = match self.inner {
             WshInner::SortedMulti(ref smv) => (
                 smv.script_size(),
@@ -215,13 +215,11 @@ where
                 ms.max_satisfaction_size()?,
             ),
         };
-        Some(
-            4 +  // scriptSig length byte
+        Ok(4 +  // scriptSig length byte
             varint_len(script_size) +
             script_size +
             varint_len(max_sat_elems) +
-            max_sat_size,
-        )
+            max_sat_size)
     }
 
     fn script_code(&self) -> Script
@@ -348,11 +346,12 @@ where
         }
     }
 
-    fn address(&self, network: bitcoin::Network) -> Option<bitcoin::Address>
+    fn address(&self, network: bitcoin::Network) -> Result<bitcoin::Address, Error>
     where
         Pk: ToPublicKey,
     {
-        bitcoin::Address::p2wpkh(&self.pk.to_public_key(), network).ok()
+        Ok(bitcoin::Address::p2wpkh(&self.pk.to_public_key(), network)
+            .expect("Rust Miniscript types don't allow uncompressed pks in segwit descriptors"))
     }
 
     fn script_pubkey(&self) -> Script
@@ -394,8 +393,8 @@ where
         }
     }
 
-    fn max_satisfaction_weight(&self) -> Option<usize> {
-        Some(4 + 1 + 73 + self.pk.serialized_len())
+    fn max_satisfaction_weight(&self) -> Result<usize, Error> {
+        Ok(4 + 1 + 73 + self.pk.serialized_len())
     }
 
     fn script_code(&self) -> Script

src/descriptor/sh.rs

@@ -196,15 +196,15 @@ where
         Ok(())
     }
 
-    fn address(&self, network: bitcoin::Network) -> Option<bitcoin::Address>
+    fn address(&self, network: bitcoin::Network) -> Result<bitcoin::Address, Error>
     where
         Pk: ToPublicKey,
     {
         match self.inner {
-            ShInner::Wsh(ref wsh) => Some(bitcoin::Address::p2sh(&wsh.script_pubkey(), network)),
-            ShInner::Wpkh(ref wpkh) => Some(bitcoin::Address::p2sh(&wpkh.script_pubkey(), network)),
-            ShInner::SortedMulti(ref smv) => Some(bitcoin::Address::p2sh(&smv.encode(), network)),
-            ShInner::Ms(ref ms) => Some(bitcoin::Address::p2sh(&ms.encode(), network)),
+            ShInner::Wsh(ref wsh) => Ok(bitcoin::Address::p2sh(&wsh.script_pubkey(), network)),
+            ShInner::Wpkh(ref wpkh) => Ok(bitcoin::Address::p2sh(&wpkh.script_pubkey(), network)),
+            ShInner::SortedMulti(ref smv) => Ok(bitcoin::Address::p2sh(&smv.encode(), network)),
+            ShInner::Ms(ref ms) => Ok(bitcoin::Address::p2sh(&ms.encode(), network)),
         }
     }
 
@@ -285,8 +285,8 @@ where
         }
     }
 
-    fn max_satisfaction_weight(&self) -> Option<usize> {
-        Some(match self.inner {
+    fn max_satisfaction_weight(&self) -> Result<usize, Error> {
+        Ok(match self.inner {
             // add weighted script sig, len byte stays the same
             ShInner::Wsh(ref wsh) => 4 * 35 + wsh.max_satisfaction_weight()?,
             ShInner::SortedMulti(ref smv) => {

src/lib.rs

@@ -481,6 +481,10 @@ pub enum Error {
     NonStandardBareScript,
     /// Analysis Error
     AnalysisError(miniscript::analyzable::AnalysisError),
+    /// Miniscript is equivalent to false. No possible satisfaction
+    ImpossibleSatisfaction,
+    /// Bare descriptors don't have any addresses
+    BareDescriptorAddr,
 }
 
 #[doc(hidden)]
@@ -600,6 +604,8 @@ impl fmt::Display for Error {
                 "
             ),
             Error::AnalysisError(ref e) => e.fmt(f),
+            Error::ImpossibleSatisfaction => write!(f, "Impossible to satisfy Miniscript"),
+            Error::BareDescriptorAddr => write!(f, "Bare descriptors don't have address"),
         }
     }
 }

src/miniscript/context.rs

@@ -51,6 +51,8 @@ pub enum ScriptContextError {
     MaxRedeemScriptSizeExceeded,
     /// The policy rules of bitcoin core only permit Script size upto 1650 bytes
     MaxScriptSigSizeExceeded,
+    /// Impossible to satisfy the miniscript under the current context
+    ImpossibleSatisfaction,
 }
 
 impl fmt::Display for ScriptContextError {
@@ -89,6 +91,12 @@ impl fmt::Display for ScriptContextError {
                 "At least one satisfaction in Miniscript would be larger than \
                 MAX_SCRIPTSIG_SIZE scriptsig"
             ),
+            ScriptContextError::ImpossibleSatisfaction => {
+                write!(
+                    f,
+                    "Impossible to satisfy Miniscript under the current context"
+                )
+            }
         }
     }
 }
@@ -293,8 +301,8 @@ impl ScriptContext for Legacy {
         // on P2SH size, it is not possible to reach the 1000 elements limit and hence
         // we do not check it.
         match ms.max_satisfaction_size() {
-            None => Err(ScriptContextError::MaxScriptSigSizeExceeded),
-            Some(size) if size > MAX_SCRIPTSIG_SIZE => {
+            Err(_e) => Err(ScriptContextError::ImpossibleSatisfaction),
+            Ok(size) if size > MAX_SCRIPTSIG_SIZE => {
                 Err(ScriptContextError::MaxScriptSigSizeExceeded)
             }
             _ => Ok(()),
@@ -375,8 +383,9 @@ impl ScriptContext for Segwitv0 {
         // other Segwitv0 defined programs all require (much) less than 100 elements.
         // The witness script item is accounted for in max_satisfaction_witness_elements().
         match ms.max_satisfaction_witness_elements() {
-            None => Err(ScriptContextError::MaxWitnessItemssExceeded),
-            Some(max_witness_items) if max_witness_items > MAX_STANDARD_P2WSH_STACK_ITEMS => {
+            // No possible satisfactions
+            Err(_e) => Err(ScriptContextError::ImpossibleSatisfaction),
+            Ok(max_witness_items) if max_witness_items > MAX_STANDARD_P2WSH_STACK_ITEMS => {
                 Err(ScriptContextError::MaxWitnessItemssExceeded)
             }
             _ => Ok(()),

src/miniscript/mod.rs

@@ -206,11 +206,13 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     /// the weight of the `VarInt` that specifies this number in a serialized
     /// transaction.
     ///
-    /// This function may return None on malformed `Miniscript` objects which do
-    /// not correspond to semantically sane Scripts. (Such scripts should be
-    /// rejected at parse time. Any exceptions are bugs.)
-    pub fn max_satisfaction_witness_elements(&self) -> Option<usize> {
-        self.ext.stack_elem_count_sat.map(|x| x + 1)
+    /// This function may returns Error when the Miniscript is
+    /// impossible to satisfy
+    pub fn max_satisfaction_witness_elements(&self) -> Result<usize, Error> {
+        self.ext
+            .stack_elem_count_sat
+            .map(|x| x + 1)
+            .ok_or(Error::ImpossibleSatisfaction)
     }
 
     /// Maximum size, in bytes, of a satisfying witness. For Segwit outputs
@@ -225,8 +227,8 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     /// All signatures are assumed to be 73 bytes in size, including the
     /// length prefix (segwit) or push opcode (pre-segwit) and sighash
     /// postfix.
-    pub fn max_satisfaction_size(&self) -> Option<usize> {
-        Ctx::max_satisfaction_size(self)
+    pub fn max_satisfaction_size(&self) -> Result<usize, Error> {
+        Ctx::max_satisfaction_size(self).ok_or(Error::ImpossibleSatisfaction)
     }
 }