key.rs: remove a bunch of unwrap()s which are impossible

Now that we are consistent about the rules that a DerivedDescriptor must
obey, we no longer return a Result from derived_key(), which in turn
eliminates a bunch of other unwraps.

Author: heap-coder

bitcoind-tests/tests/test_cpp.rs

@@ -145,7 +145,7 @@ pub fn test_from_cpp_ms(cl: &Client, testdata: &TestData) {
     // Sign the transactions with all keys
     // AKA the signer role of psbt
     for i in 0..psbts.len() {
-        let wsh_derived = desc_vec[i].derived_descriptor(&secp).unwrap();
+        let wsh_derived = desc_vec[i].derived_descriptor(&secp);
         let ms = if let Descriptor::Wsh(wsh) = &wsh_derived {
             match wsh.as_inner() {
                 miniscript::descriptor::WshInner::Ms(ms) => ms,

bitcoind-tests/tests/test_desc.rs

@@ -89,7 +89,7 @@ pub fn test_desc_satisfy(
         .at_derivation_index(0)
         .unwrap();
 
-    let derived_desc = definite_desc.derived_descriptor(&secp).unwrap();
+    let derived_desc = definite_desc.derived_descriptor(&secp);
     let desc_address = derived_desc.address(bitcoin::Network::Regtest);
     let desc_address = desc_address.map_err(|_x| DescError::AddressComputationError)?;
 

examples/xpub_descriptors.rs

@@ -31,7 +31,6 @@ fn p2wsh<C: Verification>(secp: &Secp256k1<C>) -> Address {
     let address = Descriptor::<DefiniteDescriptorKey>::from_str(&s)
         .unwrap()
         .derived_descriptor(secp)
-        .unwrap()
         .address(Network::Bitcoin)
         .unwrap();
 

src/descriptor/key.rs

@@ -1254,29 +1254,26 @@ impl DefiniteDescriptorKey {
     ///
     /// Will return an error if the descriptor key has any hardened derivation steps in its path. To
     /// avoid this error you should replace any such public keys first with [`crate::Descriptor::translate_pk`].
-    pub fn derive_public_key<C: Verification>(
-        &self,
-        secp: &Secp256k1<C>,
-    ) -> Result<bitcoin::PublicKey, ConversionError> {
+    pub fn derive_public_key<C: Verification>(&self, secp: &Secp256k1<C>) -> bitcoin::PublicKey {
         match self.0 {
             DescriptorPublicKey::Single(ref pk) => match pk.key {
-                SinglePubKey::FullKey(pk) => Ok(pk),
-                SinglePubKey::XOnly(xpk) => Ok(xpk.to_public_key()),
+                SinglePubKey::FullKey(pk) => pk,
+                SinglePubKey::XOnly(xpk) => xpk.to_public_key(),
             },
             DescriptorPublicKey::XPub(ref xpk) => match xpk.wildcard {
                 Wildcard::Unhardened | Wildcard::Hardened => {
-                    unreachable!("we've excluded this error case")
+                    unreachable!("impossible by construction of DefiniteDescriptorKey")
                 }
                 Wildcard::None => match xpk.xkey.derive_pub(secp, &xpk.derivation_path.as_ref()) {
-                    Ok(xpub) => Ok(bitcoin::PublicKey::new(xpub.public_key)),
+                    Ok(xpub) => bitcoin::PublicKey::new(xpub.public_key),
                     Err(bip32::Error::CannotDeriveFromHardenedKey) => {
-                        Err(ConversionError::HardenedChild)
+                        unreachable!("impossible by construction of DefiniteDescriptorKey")
                     }
                     Err(e) => unreachable!("cryptographically unreachable: {}", e),
                 },
             },
             DescriptorPublicKey::MultiXPub(_) => {
-                unreachable!("A definite key cannot contain a multipath key.")
+                unreachable!("impossible by construction of DefiniteDescriptorKey")
             }
         }
     }
@@ -1346,7 +1343,7 @@ impl MiniscriptKey for DefiniteDescriptorKey {
 impl ToPublicKey for DefiniteDescriptorKey {
     fn to_public_key(&self) -> bitcoin::PublicKey {
         let secp = Secp256k1::verification_only();
-        self.derive_public_key(&secp).unwrap()
+        self.derive_public_key(&secp)
     }
 
     fn to_sha256(hash: &sha256::Hash) -> sha256::Hash { *hash }

src/descriptor/mod.rs

@@ -693,7 +693,7 @@ impl Descriptor<DescriptorPublicKey> {
     ///     .expect("Valid ranged descriptor");
     /// # let index = 42;
     /// # let secp = Secp256k1::verification_only();
-    /// let derived_descriptor = descriptor.at_derivation_index(index).unwrap().derived_descriptor(&secp).unwrap();
+    /// let derived_descriptor = descriptor.at_derivation_index(index).unwrap().derived_descriptor(&secp);
     /// # assert_eq!(descriptor.derived_descriptor(&secp, index).unwrap(), derived_descriptor);
     /// ```
     ///
@@ -712,7 +712,7 @@ impl Descriptor<DescriptorPublicKey> {
         secp: &secp256k1::Secp256k1<C>,
         index: u32,
     ) -> Result<Descriptor<bitcoin::PublicKey>, ConversionError> {
-        self.at_derivation_index(index)?.derived_descriptor(secp)
+        Ok(self.at_derivation_index(index)?.derived_descriptor(secp))
     }
 
     /// Parse a descriptor that may contain secret keys
@@ -948,7 +948,7 @@ impl Descriptor<DefiniteDescriptorKey> {
     /// let secp = secp256k1::Secp256k1::verification_only();
     /// let descriptor = Descriptor::<DescriptorPublicKey>::from_str("tr(xpub6BgBgsespWvERF3LHQu6CnqdvfEvtMcQjYrcRzx53QJjSxarj2afYWcLteoGVky7D3UKDP9QyrLprQ3VCECoY49yfdDEHGCtMMj92pReUsQ/0/*)")
     ///     .expect("Valid ranged descriptor");
-    /// let result = descriptor.at_derivation_index(0).unwrap().derived_descriptor(&secp).expect("Non-hardened derivation");
+    /// let result = descriptor.at_derivation_index(0).unwrap().derived_descriptor(&secp);
     /// assert_eq!(result.to_string(), "tr(03cc8a4bc64d897bddc5fbc2f670f7a8ba0b386779106cf1223c6fc5d7cd6fc115)#6qm9h8ym");
     /// ```
     ///
@@ -958,27 +958,26 @@ impl Descriptor<DefiniteDescriptorKey> {
     pub fn derived_descriptor<C: secp256k1::Verification>(
         &self,
         secp: &secp256k1::Secp256k1<C>,
-    ) -> Result<Descriptor<bitcoin::PublicKey>, ConversionError> {
+    ) -> Descriptor<bitcoin::PublicKey> {
         struct Derivator<'a, C: secp256k1::Verification>(&'a secp256k1::Secp256k1<C>);
 
         impl<C: secp256k1::Verification> Translator<DefiniteDescriptorKey> for Derivator<'_, C> {
             type TargetPk = bitcoin::PublicKey;
-            type Error = ConversionError;
+            type Error = core::convert::Infallible;
 
-            fn pk(
-                &mut self,
-                pk: &DefiniteDescriptorKey,
-            ) -> Result<bitcoin::PublicKey, ConversionError> {
-                pk.derive_public_key(self.0)
+            fn pk(&mut self, pk: &DefiniteDescriptorKey) -> Result<Self::TargetPk, Self::Error> {
+                Ok(pk.derive_public_key(self.0))
             }
 
             translate_hash_clone!(DefiniteDescriptorKey);
         }
 
         let derived = self.translate_pk(&mut Derivator(secp));
         match derived {
-            Ok(derived) => Ok(derived),
-            Err(e) => Err(e.expect_translator_err("No Context errors when deriving keys")),
+            Ok(derived) => derived,
+            // Impossible to hit, since deriving keys does not change any Miniscript-relevant
+            // properties of the key.
+            Err(e) => panic!("Context errors when deriving keys: {}", e.into_outer_err()),
         }
     }
 }
@@ -1825,14 +1824,12 @@ mod tests {
                 .at_derivation_index(index)
                 .unwrap()
                 .derived_descriptor(&secp_ctx)
-                .unwrap()
                 .address(bitcoin::Network::Bitcoin)
                 .unwrap();
             let addr_two = desc_two
                 .at_derivation_index(index)
                 .unwrap()
                 .derived_descriptor(&secp_ctx)
-                .unwrap()
                 .address(bitcoin::Network::Bitcoin)
                 .unwrap();
             let addr_expected = bitcoin::Address::from_str(raw_addr_expected)

src/psbt/mod.rs

@@ -981,19 +981,16 @@ struct KeySourceLookUp(
 
 impl Translator<DefiniteDescriptorKey> for KeySourceLookUp {
     type TargetPk = bitcoin::PublicKey;
-    type Error = descriptor::ConversionError;
+    type Error = core::convert::Infallible;
 
-    fn pk(
-        &mut self,
-        xpk: &DefiniteDescriptorKey,
-    ) -> Result<bitcoin::PublicKey, descriptor::ConversionError> {
-        let derived = xpk.derive_public_key(&self.1)?;
+    fn pk(&mut self, xpk: &DefiniteDescriptorKey) -> Result<Self::TargetPk, Self::Error> {
+        let derived = xpk.derive_public_key(&self.1);
         self.0.insert(
             derived.to_public_key().inner,
             (
                 xpk.master_fingerprint(),
                 xpk.full_derivation_path()
-                    .ok_or(descriptor::ConversionError::MultiKey)?,
+                    .expect("definite keys cannot be multikeys"),
             ),
         );
         Ok(derived)
@@ -1097,7 +1094,8 @@ fn update_item_with_descriptor_helper<F: PsbtFields>(
     let mut bip32_derivation = KeySourceLookUp(BTreeMap::new(), secp);
     let derived = descriptor
         .translate_pk(&mut bip32_derivation)
-        .map_err(|e| e.expect_translator_err("No Outer Context errors in translations"))?;
+        .map_err(crate::TranslateErr::into_outer_err)
+        .expect("No Context errors while translating");
 
     // 2. If we have a specific scriptpubkey we are targeting, bail out.
     if let Some(check_script) = check_script {