Use SecretKey::from_secret_bytes

Author: tcharding

src/benchmarks.rs

@@ -26,7 +26,7 @@ fn keygen(n: u32) -> DescriptorPublicKey {
     sk[30] = (n >> 8) as u8;
     sk[29] = (n >> 16) as u8;
     sk[28] = (n >> 24) as u8;
-    let sk = SecretKey::from_byte_array(sk).unwrap();
+    let sk = SecretKey::from_secret_bytes(sk).unwrap();
     let pk = bitcoin::PublicKey { inner: sk.public_key(&secp), compressed: true };
     DescriptorPublicKey::Single(SinglePub { origin: None, key: SinglePubKey::FullKey(pk) })
 }

src/interpreter/mod.rs

@@ -1088,7 +1088,7 @@ mod tests {
             sk[1] = (i >> 8) as u8;
             sk[2] = (i >> 16) as u8;
 
-            let sk = secp256k1::SecretKey::from_byte_array(sk).expect("secret key");
+            let sk = secp256k1::SecretKey::from_secret_bytes(sk).expect("secret key");
             let pk = bitcoin::PublicKey {
                 inner: secp256k1::PublicKey::from_secret_key(&sk),
                 compressed: true,

src/miniscript/iter.rs

@@ -228,7 +228,7 @@ pub mod test {
             sk[2] = (i >> 16) as u8;
 
             ret.push(secp256k1::PublicKey::from_secret_key(
-                &secp256k1::SecretKey::from_byte_array(sk).unwrap(),
+                &secp256k1::SecretKey::from_secret_bytes(sk).unwrap(),
             ));
         }
         ret

src/miniscript/mod.rs

@@ -1116,7 +1116,7 @@ mod tests {
 
             let pk = bitcoin::PublicKey {
                 inner: secp256k1::PublicKey::from_secret_key(
-                    &secp256k1::SecretKey::from_byte_array(sk).expect("secret key"),
+                    &secp256k1::SecretKey::from_secret_bytes(sk).expect("secret key"),
                 ),
                 compressed: true,
             };

src/policy/compiler.rs

@@ -1251,15 +1251,15 @@ mod tests {
 
             let pk = bitcoin::PublicKey {
                 inner: secp256k1::PublicKey::from_secret_key(
-                    &secp256k1::SecretKey::from_byte_array(sk).expect("sk"),
+                    &secp256k1::SecretKey::from_secret_bytes(sk).expect("sk"),
                 ),
                 compressed: true,
             };
             ret.push(pk);
         }
         let sig = secp.sign_ecdsa(
             secp256k1::Message::from_digest(sk), // Not a digest but 32 bytes nonetheless.
-            &secp256k1::SecretKey::from_byte_array(sk).expect("secret key"),
+            &secp256k1::SecretKey::from_secret_bytes(sk).expect("secret key"),
         );
         (ret, sig)
     }

src/test_utils.rs

@@ -129,7 +129,7 @@ fn random_sks(n: usize) -> Vec<secp256k1::SecretKey> {
         sk[2] = (i >> 16) as u8;
         sk[3] = (i >> 24) as u8;
 
-        let sk = secp256k1::SecretKey::from_byte_array(sk).expect("secret key");
+        let sk = secp256k1::SecretKey::from_secret_bytes(sk).expect("secret key");
         sks.push(sk)
     }
     sks