Skip to content

Commit 666d3c6

Browse files
apoelstraapoelstra
committed
update unit tests and examples to remove deprecated functions
1 parent 47ab5af commit 666d3c6

File tree

9 files changed

+62
-55
lines changed

9 files changed

+62
-55
lines changed

‎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
@@ -261,7 +261,7 @@ mod tests {
261261
let full = Secp256k1::new();
262262

263263
let msg = crate::random_32_bytes(&mut rand::rng());
264-
let msg = Message::from_digest_slice(&msg).unwrap();
264+
let msg = Message::from_digest(msg);
265265

266266
// Try key generation
267267
let (sk, pk) = full.generate_keypair(&mut rand::rng());
@@ -292,8 +292,8 @@ mod tests {
292292
let mut s = Secp256k1::new();
293293
s.randomize(&mut rand::rng());
294294

295-
let sk = SecretKey::from_slice(&ONE).unwrap();
296-
let msg = Message::from_digest_slice(&ONE).unwrap();
295+
let sk = SecretKey::from_byte_array(ONE).unwrap();
296+
let msg = Message::from_digest(ONE);
297297

298298
let sig = s.sign_ecdsa_recoverable(msg, &sk);
299299

@@ -317,8 +317,8 @@ mod tests {
317317
let mut s = Secp256k1::new();
318318
s.randomize(&mut rand::rng());
319319

320-
let sk = SecretKey::from_slice(&ONE).unwrap();
321-
let msg = Message::from_digest_slice(&ONE).unwrap();
320+
let sk = SecretKey::from_byte_array(ONE).unwrap();
321+
let msg = Message::from_digest(ONE);
322322
let noncedata = [42u8; 32];
323323

324324
let sig = s.sign_ecdsa_recoverable_with_noncedata(msg, &sk, &noncedata);
@@ -342,15 +342,15 @@ mod tests {
342342
s.randomize(&mut rand::rng());
343343

344344
let msg = crate::random_32_bytes(&mut rand::rng());
345-
let msg = Message::from_digest_slice(&msg).unwrap();
345+
let msg = Message::from_digest(msg);
346346

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

349349
let sigr = s.sign_ecdsa_recoverable(msg, &sk);
350350
let sig = sigr.to_standard();
351351

352352
let msg = crate::random_32_bytes(&mut rand::rng());
353-
let msg = Message::from_digest_slice(&msg).unwrap();
353+
let msg = Message::from_digest(msg);
354354
assert_eq!(s.verify_ecdsa(msg, &sig, &pk), Err(Error::IncorrectSignature));
355355

356356
let recovered_key = s.recover_ecdsa(msg, &sigr).unwrap();
@@ -364,7 +364,7 @@ mod tests {
364364
s.randomize(&mut rand::rng());
365365

366366
let msg = crate::random_32_bytes(&mut rand::rng());
367-
let msg = Message::from_digest_slice(&msg).unwrap();
367+
let msg = Message::from_digest(msg);
368368

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

@@ -380,7 +380,7 @@ mod tests {
380380
s.randomize(&mut rand::rng());
381381

382382
let msg = crate::random_32_bytes(&mut rand::rng());
383-
let msg = Message::from_digest_slice(&msg).unwrap();
383+
let msg = Message::from_digest(msg);
384384

385385
let noncedata = [42u8; 32];
386386

@@ -397,7 +397,7 @@ mod tests {
397397
let mut s = Secp256k1::new();
398398
s.randomize(&mut rand::rng());
399399

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

402402
// Zero is not a valid sig
403403
let sig = RecoverableSignature::from_compact(&[0; 64], RecoveryId::Zero).unwrap();
@@ -468,8 +468,8 @@ mod benches {
468468
pub fn bench_recover(bh: &mut Bencher) {
469469
let s = Secp256k1::new();
470470
let msg = crate::random_32_bytes(&mut rand::rng());
471-
let msg = Message::from_digest_slice(&msg).unwrap();
472-
let (sk, _) = s.generate_keypair(&mut rand::rng());
471+
let msg = Message::from_digest(msg);
472+
let (sk, _) = s.generate_keypair(&mut rand::thread_rng());
473473
let sig = s.sign_ecdsa_recoverable(&msg, &sk);
474474

475475
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
@@ -401,10 +401,10 @@ impl<'de> serde::Deserialize<'de> for SecretKey {
401401
"a hex string representing 32 byte SecretKey",
402402
))
403403
} else {
404-
let visitor =
405-
super::serde_util::Tuple32Visitor::new("raw 32 bytes SecretKey", |bytes| {
406-
SecretKey::from_byte_array(bytes)
407-
});
404+
let visitor = super::serde_util::Tuple32Visitor::new(
405+
"raw 32 bytes SecretKey",
406+
SecretKey::from_byte_array,
407+
);
408408
d.deserialize_tuple(constants::SECRET_KEY_SIZE, visitor)
409409
}
410410
}
@@ -790,10 +790,10 @@ impl<'de> serde::Deserialize<'de> for PublicKey {
790790
"an ASCII hex string representing a public key",
791791
))
792792
} else {
793-
let visitor =
794-
super::serde_util::Tuple33Visitor::new("33 bytes compressed public key", |bytes| {
795-
PublicKey::from_byte_array_compressed(bytes)
796-
});
793+
let visitor = super::serde_util::Tuple33Visitor::new(
794+
"33 bytes compressed public key",
795+
PublicKey::from_byte_array_compressed,
796+
);
797797
d.deserialize_tuple(constants::PUBLIC_KEY_SIZE, visitor)
798798
}
799799
}
@@ -1634,6 +1634,7 @@ mod test {
16341634
use crate::{constants, from_hex, to_hex, Scalar};
16351635

16361636
#[test]
1637+
#[allow(deprecated)]
16371638
fn skey_from_slice() {
16381639
let sk = SecretKey::from_slice(&[1; 31]);
16391640
assert_eq!(sk, Err(InvalidSecretKey));
@@ -1668,7 +1669,7 @@ mod test {
16681669
let s = Secp256k1::new();
16691670

16701671
let (sk1, pk1) = s.generate_keypair(&mut rand::rng());
1671-
assert_eq!(SecretKey::from_slice(&sk1[..]), Ok(sk1));
1672+
assert_eq!(SecretKey::from_byte_array(sk1.secret_bytes()), Ok(sk1));
16721673
assert_eq!(PublicKey::from_slice(&pk1.serialize()[..]), Ok(pk1));
16731674
assert_eq!(PublicKey::from_slice(&pk1.serialize_uncompressed()[..]), Ok(pk1));
16741675
}
@@ -1688,22 +1689,22 @@ mod test {
16881689
#[rustfmt::skip]
16891690
fn invalid_secret_key() {
16901691
// Zero
1691-
assert_eq!(SecretKey::from_slice(&[0; 32]), Err(InvalidSecretKey));
1692+
assert_eq!(SecretKey::from_byte_array([0; 32]), Err(InvalidSecretKey));
16921693
assert_eq!(
16931694
SecretKey::from_str("0000000000000000000000000000000000000000000000000000000000000000"),
16941695
Err(InvalidSecretKey)
16951696
);
16961697
// -1
1697-
assert_eq!(SecretKey::from_slice(&[0xff; 32]), Err(InvalidSecretKey));
1698+
assert_eq!(SecretKey::from_byte_array([0xff; 32]), Err(InvalidSecretKey));
16981699
// Top of range
1699-
assert!(SecretKey::from_slice(&[
1700+
assert!(SecretKey::from_byte_array([
17001701
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
17011702
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
17021703
0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
17031704
0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x40,
17041705
]).is_ok());
17051706
// One past top of range
1706-
assert!(SecretKey::from_slice(&[
1707+
assert!(SecretKey::from_byte_array([
17071708
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
17081709
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
17091710
0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
@@ -1772,6 +1773,7 @@ mod test {
17721773
}
17731774

17741775
#[test]
1776+
#[allow(deprecated)]
17751777
fn test_seckey_from_bad_slice() {
17761778
// Bad sizes
17771779
assert_eq!(
@@ -1825,7 +1827,7 @@ mod test {
18251827

18261828
#[cfg(not(secp256k1_fuzz))]
18271829
let s = Secp256k1::signing_only();
1828-
let sk = SecretKey::from_slice(&SK_BYTES).expect("sk");
1830+
let sk = SecretKey::from_byte_array(SK_BYTES).expect("sk");
18291831

18301832
// In fuzzing mode secret->public key derivation is different, so
18311833
// hard-code the expected result.
@@ -2180,7 +2182,7 @@ mod test {
21802182

21812183
#[cfg(not(secp256k1_fuzz))]
21822184
let s = Secp256k1::new();
2183-
let sk = SecretKey::from_slice(&SK_BYTES).unwrap();
2185+
let sk = SecretKey::from_byte_array(SK_BYTES).unwrap();
21842186

21852187
// In fuzzing mode secret->public key derivation is different, so
21862188
// hard-code the expected result.
@@ -2320,10 +2322,11 @@ mod test {
23202322
pk_bytes[0] = 0x02; // Use positive Y co-ordinate.
23212323
pk_bytes[1..].clone_from_slice(&PK_BYTES);
23222324

2323-
let sk = SecretKey::from_slice(&SK_BYTES).expect("failed to parse sk bytes");
2325+
let sk = SecretKey::from_byte_array(SK_BYTES).expect("failed to parse sk bytes");
23242326
let pk = PublicKey::from_slice(&pk_bytes).expect("failed to create pk from iterator");
23252327
let kp = Keypair::from_secret_key(&secp, &sk);
2326-
let xonly = XOnlyPublicKey::from_slice(&PK_BYTES).expect("failed to get xonly from slice");
2328+
let xonly =
2329+
XOnlyPublicKey::from_byte_array(PK_BYTES).expect("failed to get xonly from slice");
23272330

23282331
(sk, pk, kp, xonly)
23292332
}

‎src/lib.rs

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

642642
// Check that we can produce keys from slices with no precomputation
643-
let (pk_slice, sk_slice) = (&pk.serialize(), &sk[..]);
643+
let pk_slice = &pk.serialize();
644644
let new_pk = PublicKey::from_slice(pk_slice).unwrap();
645-
let new_sk = SecretKey::from_slice(sk_slice).unwrap();
645+
let new_sk = SecretKey::from_byte_array(sk.secret_bytes()).unwrap();
646646
assert_eq!(sk, new_sk);
647647
assert_eq!(pk, new_pk);
648648
}
@@ -792,7 +792,7 @@ mod tests {
792792
wild_keys[1][0] -= 1;
793793
wild_msgs[1][0] -= 1;
794794

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

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

‎src/schnorr.rs

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,7 @@ impl<'de> serde::Deserialize<'de> for Signature {
4242
} else {
4343
d.deserialize_bytes(super::serde_util::BytesVisitor::new(
4444
"raw 64 bytes schnorr signature",
45-
Signature::from_slice,
45+
|x| x.try_into().map(Signature::from_byte_array),
4646
))
4747
}
4848
}
@@ -317,6 +317,7 @@ mod tests {
317317
}
318318

319319
#[test]
320+
#[allow(deprecated)]
320321
fn test_pubkey_from_slice() {
321322
let pk = XOnlyPublicKey::from_slice(&[
322323
0xB3, 0x3C, 0xC9, 0xED, 0xC0, 0x96, 0xD0, 0xA8, 0x34, 0x16, 0x96, 0x4B, 0xD3, 0xC6,
@@ -327,6 +328,7 @@ mod tests {
327328
}
328329

329330
#[test]
331+
#[allow(deprecated)]
330332
fn test_pubkey_from_bad_slice() {
331333
// Bad sizes
332334
assert_eq!(XOnlyPublicKey::from_slice(&[]), Err(InvalidPublicKey));
@@ -363,7 +365,7 @@ mod tests {
363365
let (pk, _parity) = kp.x_only_public_key();
364366

365367
let ser = pk.serialize();
366-
let pubkey2 = XOnlyPublicKey::from_slice(&ser).unwrap();
368+
let pubkey2 = XOnlyPublicKey::from_byte_array(ser).unwrap();
367369
assert_eq!(pk, pubkey2);
368370
}
369371

@@ -492,7 +494,7 @@ mod tests {
492494
170, 12, 208, 84, 74, 200, 135, 254, 145, 221, 209, 102,
493495
];
494496
static PK_STR: &str = "18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd166";
495-
let pk = XOnlyPublicKey::from_slice(&PK_BYTES).unwrap();
497+
let pk = XOnlyPublicKey::from_byte_array(PK_BYTES).unwrap();
496498

497499
assert_tokens(&sig.compact(), &[Token::BorrowedBytes(&SIG_BYTES[..])]);
498500
assert_tokens(&sig.compact(), &[Token::Bytes(&SIG_BYTES[..])]);
@@ -712,7 +714,7 @@ mod tests {
712714
assert_eq!(sig.to_byte_array(), signature);
713715
}
714716
let sig = Signature::from_byte_array(signature);
715-
let is_verified = if let Ok(pubkey) = XOnlyPublicKey::from_slice(&public_key) {
717+
let is_verified = if let Ok(pubkey) = XOnlyPublicKey::from_byte_array(public_key) {
716718
secp.verify_schnorr(&sig, &message, &pubkey).is_ok()
717719
} else {
718720
false

0 commit comments

Comments
 (0)