checksum: use array::from_fn

Along the way, fix a bunch of other instances of "manual" slice
construction that can be done with try_from or from_fn. Instances
where the closure to `from_fn` would be several lines long, I left
alone, but we could revisit those later.

Fixes rust-bitcoin/rust-miniscript#774

Author: heap-coder

src/descriptor/checksum.rs

@@ -8,8 +8,8 @@
 //! [BIP-380]: <https://github.com/bitcoin/bips/blob/master/bip-0380.mediawiki>
 
 use core::convert::TryFrom;
-use core::fmt;
 use core::iter::FromIterator;
+use core::{array, fmt};
 
 use bech32::primitives::checksum::PackedFe32;
 use bech32::{Checksum, Fe32};
@@ -115,10 +115,10 @@ pub fn verify_checksum(s: &str) -> Result<&str, Error> {
         eng.input_unchecked(s[..last_hash_pos].as_bytes());
 
         let expected = eng.checksum_chars();
-        let mut actual = ['_'; CHECKSUM_LENGTH];
-        for (act, ch) in actual.iter_mut().zip(checksum_str.chars()) {
-            *act = ch;
-        }
+
+        let mut iter = checksum_str.chars();
+        let actual: [char; CHECKSUM_LENGTH] =
+            array::from_fn(|_| iter.next().expect("length checked above"));
 
         if expected != actual {
             return Err(Error::InvalidChecksum { actual, expected });

src/interpreter/inner.rs

@@ -429,8 +429,7 @@ mod tests {
             ",
             )
             .unwrap();
-            let mut dummy_sig = [0u8; 48];
-            dummy_sig.copy_from_slice(&dummy_sig_vec[..]);
+            let dummy_sig = <[u8; 48]>::try_from(&dummy_sig_vec[..]).unwrap();
 
             let pkhash = key.to_pubkeyhash(SigType::Ecdsa).into();
             let wpkhash = key.to_pubkeyhash(SigType::Ecdsa).into();

src/interpreter/stack.rs

@@ -261,7 +261,7 @@ impl<'txin> Stack<'txin> {
                 self.push(Element::Satisfied);
                 Some(Ok(SatisfiedConstraint::HashLock {
                     hash: HashLockType::Sha256(*hash),
-                    preimage: preimage_from_sl(preimage),
+                    preimage: <[u8; 32]>::try_from(preimage).expect("length checked above"),
                 }))
             } else {
                 self.push(Element::Dissatisfied);
@@ -286,7 +286,7 @@ impl<'txin> Stack<'txin> {
                 self.push(Element::Satisfied);
                 Some(Ok(SatisfiedConstraint::HashLock {
                     hash: HashLockType::Hash256(*hash),
-                    preimage: preimage_from_sl(preimage),
+                    preimage: <[u8; 32]>::try_from(preimage).expect("length checked above"),
                 }))
             } else {
                 self.push(Element::Dissatisfied);
@@ -311,7 +311,7 @@ impl<'txin> Stack<'txin> {
                 self.push(Element::Satisfied);
                 Some(Ok(SatisfiedConstraint::HashLock {
                     hash: HashLockType::Hash160(*hash),
-                    preimage: preimage_from_sl(preimage),
+                    preimage: <[u8; 32]>::try_from(preimage).expect("length checked above"),
                 }))
             } else {
                 self.push(Element::Dissatisfied);
@@ -336,7 +336,7 @@ impl<'txin> Stack<'txin> {
                 self.push(Element::Satisfied);
                 Some(Ok(SatisfiedConstraint::HashLock {
                     hash: HashLockType::Ripemd160(*hash),
-                    preimage: preimage_from_sl(preimage),
+                    preimage: <[u8; 32]>::try_from(preimage).expect("length checked above"),
                 }))
             } else {
                 self.push(Element::Dissatisfied);
@@ -376,14 +376,3 @@ impl<'txin> Stack<'txin> {
         }
     }
 }
-
-// Helper function to compute preimage from slice
-fn preimage_from_sl(sl: &[u8]) -> [u8; 32] {
-    if sl.len() != 32 {
-        unreachable!("Internal: Preimage length checked to be 32")
-    } else {
-        let mut preimage = [0u8; 32];
-        preimage.copy_from_slice(sl);
-        preimage
-    }
-}

src/psbt/mod.rs

@@ -340,38 +340,28 @@ impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for PsbtInputSatisfier<'_> {
         self.psbt.inputs[self.index]
             .hash160_preimages
             .get(&Pk::to_hash160(h))
-            .and_then(|x: &Vec<u8>| try_vec_as_preimage32(x))
+            .and_then(|x: &Vec<u8>| <[u8; 32]>::try_from(&x[..]).ok())
     }
 
     fn lookup_sha256(&self, h: &Pk::Sha256) -> Option<Preimage32> {
         self.psbt.inputs[self.index]
             .sha256_preimages
             .get(&Pk::to_sha256(h))
-            .and_then(|x: &Vec<u8>| try_vec_as_preimage32(x))
+            .and_then(|x: &Vec<u8>| <[u8; 32]>::try_from(&x[..]).ok())
     }
 
     fn lookup_hash256(&self, h: &Pk::Hash256) -> Option<Preimage32> {
         self.psbt.inputs[self.index]
             .hash256_preimages
             .get(&sha256d::Hash::from_byte_array(Pk::to_hash256(h).to_byte_array())) // upstream psbt operates on hash256
-            .and_then(|x: &Vec<u8>| try_vec_as_preimage32(x))
+            .and_then(|x: &Vec<u8>| <[u8; 32]>::try_from(&x[..]).ok())
     }
 
     fn lookup_ripemd160(&self, h: &Pk::Ripemd160) -> Option<Preimage32> {
         self.psbt.inputs[self.index]
             .ripemd160_preimages
             .get(&Pk::to_ripemd160(h))
-            .and_then(|x: &Vec<u8>| try_vec_as_preimage32(x))
-    }
-}
-
-fn try_vec_as_preimage32(vec: &[u8]) -> Option<Preimage32> {
-    if vec.len() == 32 {
-        let mut arr = [0u8; 32];
-        arr.copy_from_slice(vec);
-        Some(arr)
-    } else {
-        None
+            .and_then(|x: &Vec<u8>| <[u8; 32]>::try_from(&x[..]).ok())
     }
 }