Skip to content

Commit c45c8c2

Browse files
apoelstraapoelstra
committed
update unit tests and examples to remove deprecated functions
1 parent 6d1f512 commit c45c8c2

File tree

11 files changed

+70
-65
lines changed

11 files changed

+70
-65
lines changed

‎examples/musig.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ fn main() {
3737
assert_eq!(agg_pk, tweaked_agg_pk.x_only_public_key().0);
3838

3939
let msg_bytes: [u8; 32] = *b"this_could_be_the_hash_of_a_msg!";
40-
let msg = Message::from_digest_slice(&msg_bytes).unwrap();
40+
let msg = Message::from_digest(msg_bytes);
4141

4242
let musig_session_sec_rand1 = SessionSecretRand::from_rng(&mut rng);
4343

‎examples/sign_verify.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ fn verify<C: Verification>(
1111
pubkey: [u8; 33],
1212
) -> Result<bool, Error> {
1313
let msg = sha256::Hash::hash(msg);
14-
let msg = Message::from_digest_slice(msg.as_ref())?;
14+
let msg = Message::from_digest(msg.to_byte_array());
1515
let sig = ecdsa::Signature::from_compact(&sig)?;
1616
let pubkey = PublicKey::from_slice(&pubkey)?;
1717

@@ -24,8 +24,8 @@ fn sign<C: Signing>(
2424
seckey: [u8; 32],
2525
) -> Result<ecdsa::Signature, Error> {
2626
let msg = sha256::Hash::hash(msg);
27-
let msg = Message::from_digest_slice(msg.as_ref())?;
28-
let seckey = SecretKey::from_slice(&seckey)?;
27+
let msg = Message::from_digest(msg.to_byte_array());
28+
let seckey = SecretKey::from_byte_array(seckey)?;
2929
Ok(secp.sign_ecdsa(msg, &seckey))
3030
}
3131

‎examples/sign_verify_recovery.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ fn recover<C: Verification>(
1111
recovery_id: u8,
1212
) -> Result<PublicKey, Error> {
1313
let msg = sha256::Hash::hash(msg);
14-
let msg = Message::from_digest_slice(msg.as_ref())?;
14+
let msg = Message::from_digest(msg.to_byte_array());
1515
let id = ecdsa::RecoveryId::try_from(i32::from(recovery_id))?;
1616
let sig = ecdsa::RecoverableSignature::from_compact(&sig, id)?;
1717

@@ -24,8 +24,8 @@ fn sign_recovery<C: Signing>(
2424
seckey: [u8; 32],
2525
) -> Result<ecdsa::RecoverableSignature, Error> {
2626
let msg = sha256::Hash::hash(msg);
27-
let msg = Message::from_digest_slice(msg.as_ref())?;
28-
let seckey = SecretKey::from_slice(&seckey)?;
27+
let msg = Message::from_digest(msg.to_byte_array());
28+
let seckey = SecretKey::from_byte_array(seckey)?;
2929
Ok(secp.sign_ecdsa_recoverable(msg, &seckey))
3030
}
3131

‎src/ecdh.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -178,7 +178,7 @@ impl<'de> ::serde::Deserialize<'de> for SharedSecret {
178178
} else {
179179
d.deserialize_bytes(super::serde_util::BytesVisitor::new(
180180
"raw 32 bytes SharedSecret",
181-
SharedSecret::from_slice,
181+
|x| x.try_into().map(SharedSecret::from_bytes),
182182
))
183183
}
184184
}
@@ -263,7 +263,7 @@ mod tests {
263263
];
264264
static STR: &str = "01010101010101010001020304050607ffff0000ffff00006363636363636363";
265265

266-
let secret = SharedSecret::from_slice(&BYTES).unwrap();
266+
let secret = SharedSecret::from_bytes(BYTES);
267267

268268
assert_tokens(&secret.compact(), &[Token::BorrowedBytes(&BYTES[..])]);
269269
assert_tokens(&secret.compact(), &[Token::Bytes(&BYTES)]);

‎src/ecdsa/recovery.rs

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -271,7 +271,7 @@ mod tests {
271271
let full = Secp256k1::new();
272272

273273
let msg = crate::random_32_bytes(&mut rand::rng());
274-
let msg = Message::from_digest_slice(&msg).unwrap();
274+
let msg = Message::from_digest(msg);
275275

276276
// Try key generation
277277
let (sk, pk) = full.generate_keypair(&mut rand::rng());
@@ -302,8 +302,8 @@ mod tests {
302302
let mut s = Secp256k1::new();
303303
s.randomize(&mut rand::rng());
304304

305-
let sk = SecretKey::from_slice(&ONE).unwrap();
306-
let msg = Message::from_digest_slice(&ONE).unwrap();
305+
let sk = SecretKey::from_byte_array(ONE).unwrap();
306+
let msg = Message::from_digest(ONE);
307307

308308
let sig = s.sign_ecdsa_recoverable(msg, &sk);
309309

@@ -327,8 +327,8 @@ mod tests {
327327
let mut s = Secp256k1::new();
328328
s.randomize(&mut rand::rng());
329329

330-
let sk = SecretKey::from_slice(&ONE).unwrap();
331-
let msg = Message::from_digest_slice(&ONE).unwrap();
330+
let sk = SecretKey::from_byte_array(ONE).unwrap();
331+
let msg = Message::from_digest(ONE);
332332
let noncedata = [42u8; 32];
333333

334334
let sig = s.sign_ecdsa_recoverable_with_noncedata(msg, &sk, &noncedata);
@@ -352,15 +352,15 @@ mod tests {
352352
s.randomize(&mut rand::rng());
353353

354354
let msg = crate::random_32_bytes(&mut rand::rng());
355-
let msg = Message::from_digest_slice(&msg).unwrap();
355+
let msg = Message::from_digest(msg);
356356

357357
let (sk, pk) = s.generate_keypair(&mut rand::rng());
358358

359359
let sigr = s.sign_ecdsa_recoverable(msg, &sk);
360360
let sig = sigr.to_standard();
361361

362362
let msg = crate::random_32_bytes(&mut rand::rng());
363-
let msg = Message::from_digest_slice(&msg).unwrap();
363+
let msg = Message::from_digest(msg);
364364
assert_eq!(s.verify_ecdsa(&sig, msg, &pk), Err(Error::IncorrectSignature));
365365

366366
let recovered_key = s.recover_ecdsa(msg, &sigr).unwrap();
@@ -374,7 +374,7 @@ mod tests {
374374
s.randomize(&mut rand::rng());
375375

376376
let msg = crate::random_32_bytes(&mut rand::rng());
377-
let msg = Message::from_digest_slice(&msg).unwrap();
377+
let msg = Message::from_digest(msg);
378378

379379
let (sk, pk) = s.generate_keypair(&mut rand::rng());
380380

@@ -390,7 +390,7 @@ mod tests {
390390
s.randomize(&mut rand::rng());
391391

392392
let msg = crate::random_32_bytes(&mut rand::rng());
393-
let msg = Message::from_digest_slice(&msg).unwrap();
393+
let msg = Message::from_digest(msg);
394394

395395
let noncedata = [42u8; 32];
396396

@@ -407,7 +407,7 @@ mod tests {
407407
let mut s = Secp256k1::new();
408408
s.randomize(&mut rand::rng());
409409

410-
let msg = Message::from_digest_slice(&[0x55; 32]).unwrap();
410+
let msg = Message::from_digest([0x55; 32]);
411411

412412
// Zero is not a valid sig
413413
let sig = RecoverableSignature::from_compact(&[0; 64], RecoveryId::Zero).unwrap();
@@ -478,8 +478,8 @@ mod benches {
478478
pub fn bench_recover(bh: &mut Bencher) {
479479
let s = Secp256k1::new();
480480
let msg = crate::random_32_bytes(&mut rand::rng());
481-
let msg = Message::from_digest_slice(&msg).unwrap();
482-
let (sk, _) = s.generate_keypair(&mut rand::rng());
481+
let msg = Message::from_digest(msg);
482+
let (sk, _) = s.generate_keypair(&mut rand::thread_rng());
483483
let sig = s.sign_ecdsa_recoverable(&msg, &sk);
484484

485485
bh.iter(|| {

‎src/ellswift.rs

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -378,7 +378,7 @@ mod tests {
378378
// Test that we can round trip an ElligatorSwift encoding
379379
let secp = crate::Secp256k1::new();
380380
let public_key =
381-
PublicKey::from_secret_key(&secp, &SecretKey::from_slice(&[1u8; 32]).unwrap());
381+
PublicKey::from_secret_key(&secp, &SecretKey::from_byte_array([1u8; 32]).unwrap());
382382

383383
let ell = ElligatorSwift::from_pubkey(public_key);
384384
let pk = PublicKey::from_ellswift(ell);
@@ -391,9 +391,11 @@ mod tests {
391391
let secp = crate::Secp256k1::new();
392392
let rand32 = [1u8; 32];
393393
let priv32 = [1u8; 32];
394-
let ell = ElligatorSwift::from_seckey(&secp, SecretKey::from_slice(&rand32).unwrap(), None);
394+
let ell =
395+
ElligatorSwift::from_seckey(&secp, SecretKey::from_byte_array(rand32).unwrap(), None);
395396
let pk = PublicKey::from_ellswift(ell);
396-
let expected = PublicKey::from_secret_key(&secp, &SecretKey::from_slice(&priv32).unwrap());
397+
let expected =
398+
PublicKey::from_secret_key(&secp, &SecretKey::from_byte_array(priv32).unwrap());
397399

398400
assert_eq!(pk, expected);
399401
}
@@ -406,13 +408,13 @@ mod tests {
406408
let priv32 = [2u8; 32];
407409
let ell = ElligatorSwift::from_seckey(
408410
&secp,
409-
SecretKey::from_slice(&rand32).unwrap(),
411+
SecretKey::from_byte_array(rand32).unwrap(),
410412
Some(rand32),
411413
);
412414
let pk = ElligatorSwift::shared_secret_with_hasher(
413415
ell,
414416
ell,
415-
SecretKey::from_slice(&priv32).unwrap(),
417+
SecretKey::from_byte_array(priv32).unwrap(),
416418
Party::Initiator,
417419
|_, _, _| ElligatorSwiftSharedSecret([0xff; 32]),
418420
);
@@ -626,7 +628,7 @@ mod tests {
626628
ElligatorSwift::from_array(ellswift_theirs),
627629
)
628630
};
629-
let sec_key = SecretKey::from_slice(&my_secret).unwrap();
631+
let sec_key = SecretKey::from_byte_array(my_secret).unwrap();
630632
let initiator = if initiator == 0 { Party::Responder } else { Party::Initiator };
631633

632634
let shared = ElligatorSwift::shared_secret(el_a, el_b, sec_key, initiator, None);

‎src/key.rs

Lines changed: 20 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -402,10 +402,10 @@ impl<'de> serde::Deserialize<'de> for SecretKey {
402402
"a hex string representing 32 byte SecretKey",
403403
))
404404
} else {
405-
let visitor =
406-
super::serde_util::Tuple32Visitor::new("raw 32 bytes SecretKey", |bytes| {
407-
SecretKey::from_byte_array(bytes)
408-
});
405+
let visitor = super::serde_util::Tuple32Visitor::new(
406+
"raw 32 bytes SecretKey",
407+
SecretKey::from_byte_array,
408+
);
409409
d.deserialize_tuple(constants::SECRET_KEY_SIZE, visitor)
410410
}
411411
}
@@ -791,10 +791,10 @@ impl<'de> serde::Deserialize<'de> for PublicKey {
791791
"an ASCII hex string representing a public key",
792792
))
793793
} else {
794-
let visitor =
795-
super::serde_util::Tuple33Visitor::new("33 bytes compressed public key", |bytes| {
796-
PublicKey::from_byte_array_compressed(bytes)
797-
});
794+
let visitor = super::serde_util::Tuple33Visitor::new(
795+
"33 bytes compressed public key",
796+
PublicKey::from_byte_array_compressed,
797+
);
798798
d.deserialize_tuple(constants::PUBLIC_KEY_SIZE, visitor)
799799
}
800800
}
@@ -1673,6 +1673,7 @@ mod test {
16731673
use crate::{constants, from_hex, to_hex, Scalar};
16741674

16751675
#[test]
1676+
#[allow(deprecated)]
16761677
fn skey_from_slice() {
16771678
let sk = SecretKey::from_slice(&[1; 31]);
16781679
assert_eq!(sk, Err(InvalidSecretKey));
@@ -1707,7 +1708,7 @@ mod test {
17071708
let s = Secp256k1::new();
17081709

17091710
let (sk1, pk1) = s.generate_keypair(&mut rand::rng());
1710-
assert_eq!(SecretKey::from_slice(&sk1[..]), Ok(sk1));
1711+
assert_eq!(SecretKey::from_byte_array(sk1.secret_bytes()), Ok(sk1));
17111712
assert_eq!(PublicKey::from_slice(&pk1.serialize()[..]), Ok(pk1));
17121713
assert_eq!(PublicKey::from_slice(&pk1.serialize_uncompressed()[..]), Ok(pk1));
17131714
}
@@ -1727,22 +1728,22 @@ mod test {
17271728
#[rustfmt::skip]
17281729
fn invalid_secret_key() {
17291730
// Zero
1730-
assert_eq!(SecretKey::from_slice(&[0; 32]), Err(InvalidSecretKey));
1731+
assert_eq!(SecretKey::from_byte_array([0; 32]), Err(InvalidSecretKey));
17311732
assert_eq!(
17321733
SecretKey::from_str("0000000000000000000000000000000000000000000000000000000000000000"),
17331734
Err(InvalidSecretKey)
17341735
);
17351736
// -1
1736-
assert_eq!(SecretKey::from_slice(&[0xff; 32]), Err(InvalidSecretKey));
1737+
assert_eq!(SecretKey::from_byte_array([0xff; 32]), Err(InvalidSecretKey));
17371738
// Top of range
1738-
assert!(SecretKey::from_slice(&[
1739+
assert!(SecretKey::from_byte_array([
17391740
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
17401741
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
17411742
0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
17421743
0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x40,
17431744
]).is_ok());
17441745
// One past top of range
1745-
assert!(SecretKey::from_slice(&[
1746+
assert!(SecretKey::from_byte_array([
17461747
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
17471748
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
17481749
0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
@@ -1811,6 +1812,7 @@ mod test {
18111812
}
18121813

18131814
#[test]
1815+
#[allow(deprecated)]
18141816
fn test_seckey_from_bad_slice() {
18151817
// Bad sizes
18161818
assert_eq!(
@@ -1864,7 +1866,7 @@ mod test {
18641866

18651867
#[cfg(not(secp256k1_fuzz))]
18661868
let s = Secp256k1::signing_only();
1867-
let sk = SecretKey::from_slice(&SK_BYTES).expect("sk");
1869+
let sk = SecretKey::from_byte_array(SK_BYTES).expect("sk");
18681870

18691871
// In fuzzing mode secret->public key derivation is different, so
18701872
// hard-code the expected result.
@@ -2219,7 +2221,7 @@ mod test {
22192221

22202222
#[cfg(not(secp256k1_fuzz))]
22212223
let s = Secp256k1::new();
2222-
let sk = SecretKey::from_slice(&SK_BYTES).unwrap();
2224+
let sk = SecretKey::from_byte_array(SK_BYTES).unwrap();
22232225

22242226
// In fuzzing mode secret->public key derivation is different, so
22252227
// hard-code the expected result.
@@ -2359,10 +2361,11 @@ mod test {
23592361
pk_bytes[0] = 0x02; // Use positive Y co-ordinate.
23602362
pk_bytes[1..].clone_from_slice(&PK_BYTES);
23612363

2362-
let sk = SecretKey::from_slice(&SK_BYTES).expect("failed to parse sk bytes");
2364+
let sk = SecretKey::from_byte_array(SK_BYTES).expect("failed to parse sk bytes");
23632365
let pk = PublicKey::from_slice(&pk_bytes).expect("failed to create pk from iterator");
23642366
let kp = Keypair::from_secret_key(&secp, &sk);
2365-
let xonly = XOnlyPublicKey::from_slice(&PK_BYTES).expect("failed to get xonly from slice");
2367+
let xonly =
2368+
XOnlyPublicKey::from_byte_array(PK_BYTES).expect("failed to get xonly from slice");
23662369

23672370
(sk, pk, kp, xonly)
23682371
}

‎src/lib.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -641,9 +641,9 @@ mod tests {
641641
assert!(full.verify_ecdsa(&sig, msg, &pk).is_ok());
642642

643643
// Check that we can produce keys from slices with no precomputation
644-
let (pk_slice, sk_slice) = (&pk.serialize(), &sk[..]);
644+
let pk_slice = &pk.serialize();
645645
let new_pk = PublicKey::from_slice(pk_slice).unwrap();
646-
let new_sk = SecretKey::from_slice(sk_slice).unwrap();
646+
let new_sk = SecretKey::from_byte_array(sk.secret_bytes()).unwrap();
647647
assert_eq!(sk, new_sk);
648648
assert_eq!(pk, new_pk);
649649
}
@@ -793,7 +793,7 @@ mod tests {
793793
wild_keys[1][0] -= 1;
794794
wild_msgs[1][0] -= 1;
795795

796-
for key in wild_keys.iter().map(|k| SecretKey::from_slice(&k[..]).unwrap()) {
796+
for key in wild_keys.iter().copied().map(SecretKey::from_byte_array).map(Result::unwrap) {
797797
for msg in wild_msgs.into_iter().map(Message::from_digest) {
798798
let sig = s.sign_ecdsa(msg, &key);
799799
let low_r_sig = s.sign_ecdsa_low_r(msg, &key);
@@ -965,7 +965,7 @@ mod tests {
965965
let s = Secp256k1::new();
966966

967967
let msg = Message::from_digest([1; 32]);
968-
let sk = SecretKey::from_slice(&[2; 32]).unwrap();
968+
let sk = SecretKey::from_byte_array([2; 32]).unwrap();
969969
let sig = s.sign_ecdsa(msg, &sk);
970970
static SIG_BYTES: [u8; 71] = [
971971
48, 69, 2, 33, 0, 157, 11, 173, 87, 103, 25, 211, 42, 231, 107, 237, 179, 76, 119, 72,
@@ -992,7 +992,7 @@ mod tests {
992992
fn test_global_context() {
993993
use crate::SECP256K1;
994994
let sk_data = hex!("e6dd32f8761625f105c39a39f19370b3521d845a12456d60ce44debd0a362641");
995-
let sk = SecretKey::from_slice(&sk_data).unwrap();
995+
let sk = SecretKey::from_byte_array(sk_data).unwrap();
996996
let msg_data = hex!("a4965ca63b7d8562736ceec36dfa5a11bf426eb65be8ea3f7a49ae363032da0d");
997997
let msg = Message::from_digest(msg_data);
998998

0 commit comments

Comments
 (0)