Skip to content

Commit b787418

Browse files
apoelstraapoelstra
committed
musig: fix all the doctests
Pretty-much all of the doctests included in rust-bitcoin#716 corresponded to an old version of the API. I'm unsure why it is that my local CI accepted this. The Github CI did not.
1 parent 768720a commit b787418

File tree

1 file changed

+85
-83
lines changed

1 file changed

+85
-83
lines changed

‎src/musig.rs

Lines changed: 85 additions & 83 deletions
Original file line numberDiff line numberDiff line change
@@ -141,20 +141,20 @@ impl fmt::Display for InvalidTweakErr {
141141
/// Example:
142142
///
143143
/// ```rust
144-
/// # # [cfg(any(test, feature = "rand-std"))] {
145-
/// # use secp256k1::rand::{rng, RngCore};
146-
/// # use secp256k1::{PublicKey, Secp256k1, SecretKey, new_nonce_pair, SessionSecretRand};
144+
/// # #[cfg(feature = "std")]
145+
/// # #[cfg(feature = "rand")] {
146+
/// # use secp256k1::{PublicKey, Secp256k1, SecretKey};
147+
/// # use secp256k1::musig::{new_nonce_pair, SessionSecretRand};
147148
/// # let secp = Secp256k1::new();
148149
/// // The session id must be sampled at random. Read documentation for more details.
149-
/// let session_secrand = SessionSecretRand::new(&mut rng());
150-
/// let sk = SecretKey::new(&mut rng());
150+
/// let session_secrand = SessionSecretRand::from_rng(&mut rand::rng());
151+
/// let sk = SecretKey::new(&mut rand::rng());
151152
/// let pk = PublicKey::from_secret_key(&secp, &sk);
152153
///
153154
/// // Supply extra auxillary randomness to prevent misuse(for example, time of day)
154155
/// let extra_rand : Option<[u8; 32]> = None;
155156
///
156-
/// let (_sec_nonce, _pub_nonce) = new_nonce_pair(&secp, session_secrand, None, Some(sk), pk, None, None)
157-
/// .expect("non zero session id");
157+
/// let (_sec_nonce, _pub_nonce) = new_nonce_pair(&secp, session_secrand, None, Some(sk), pk, None, None);
158158
/// # }
159159
/// ```
160160
pub fn new_nonce_pair<C: Signing>(
@@ -297,16 +297,17 @@ impl KeyAggCache {
297297
/// Example:
298298
///
299299
/// ```rust
300-
/// # # [cfg(any(test, feature = "rand-std"))] {
301-
/// # use secp256k1::rand::{rng, RngCore};
302-
/// # use secp256k1::{KeyAggCache, Secp256k1, SecretKey, Keypair, PublicKey};
300+
/// # #[cfg(feature = "std")]
301+
/// # #[cfg(feature = "rand")] {
302+
/// # use secp256k1::{Secp256k1, SecretKey, Keypair, PublicKey};
303+
/// # use secp256k1::musig::KeyAggCache;
303304
/// # let secp = Secp256k1::new();
304-
/// # let sk1 = SecretKey::new(&mut rng());
305+
/// # let sk1 = SecretKey::new(&mut rand::rng());
305306
/// # let pub_key1 = PublicKey::from_secret_key(&secp, &sk1);
306-
/// # let sk2 = SecretKey::new(&mut rng());
307+
/// # let sk2 = SecretKey::new(&mut rand::rng());
307308
/// # let pub_key2 = PublicKey::from_secret_key(&secp, &sk2);
308309
/// #
309-
/// let key_agg_cache = KeyAggCache::new(&secp, &[pub_key1, pub_key2]);
310+
/// let key_agg_cache = KeyAggCache::new(&secp, &[&pub_key1, &pub_key2]);
310311
/// let _agg_pk = key_agg_cache.agg_pk();
311312
/// # }
312313
/// ```
@@ -386,20 +387,22 @@ impl KeyAggCache {
386387
/// Example:
387388
///
388389
/// ```rust
389-
/// # # [cfg(any(test, feature = "rand-std"))] {
390-
/// # use secp256k1::rand::{rng, RngCore};
391-
/// # use secp256k1::{KeyAggCache, Secp256k1, SecretKey, Keypair, PublicKey};
390+
/// # #[cfg(not(secp256k1_fuzz))]
391+
/// # #[cfg(feature = "std")]
392+
/// # #[cfg(feature = "rand")] {
393+
/// # use secp256k1::{Scalar, Secp256k1, SecretKey, Keypair, PublicKey};
394+
/// # use secp256k1::musig::KeyAggCache;
392395
/// # let secp = Secp256k1::new();
393-
/// # let sk1 = SecretKey::new(&mut rng());
396+
/// # let sk1 = SecretKey::new(&mut rand::rng());
394397
/// # let pub_key1 = PublicKey::from_secret_key(&secp, &sk1);
395-
/// # let sk2 = SecretKey::new(&mut rng());
398+
/// # let sk2 = SecretKey::new(&mut rand::rng());
396399
/// # let pub_key2 = PublicKey::from_secret_key(&secp, &sk2);
397400
/// #
398-
/// let mut key_agg_cache = KeyAggCache::new(&secp, &[pub_key1, pub_key2]);
401+
/// let mut key_agg_cache = KeyAggCache::new(&secp, &[&pub_key1, &pub_key2]);
399402
///
400403
/// let tweak: [u8; 32] = *b"this could be a BIP32 tweak....\0";
401404
/// let tweak = Scalar::from_be_bytes(tweak).unwrap();
402-
/// let tweaked_key = key_agg_cache.pubkey_ec_tweak_add(&secp, tweak).unwrap();
405+
/// let tweaked_key = key_agg_cache.pubkey_ec_tweak_add(&secp, &tweak).unwrap();
403406
/// # }
404407
/// ```
405408
pub fn pubkey_ec_tweak_add<C: Verification>(
@@ -445,19 +448,21 @@ impl KeyAggCache {
445448
/// Example:
446449
///
447450
/// ```rust
448-
/// # # [cfg(any(test, feature = "rand-std"))] {
449-
/// # use secp256k1::rand::{rng, RngCore};
450-
/// # use secp256k1::{KeyAggCache, Secp256k1, SecretKey, Keypair, PublicKey};
451+
/// # #[cfg(not(secp256k1_fuzz))]
452+
/// # #[cfg(feature = "std")]
453+
/// # #[cfg(feature = "rand")] {
454+
/// # use secp256k1::{Scalar, Secp256k1, SecretKey, Keypair, PublicKey};
455+
/// # use secp256k1::musig::KeyAggCache;
451456
/// # let secp = Secp256k1::new();
452-
/// # let sk1 = SecretKey::new(&mut rng());
457+
/// # let sk1 = SecretKey::new(&mut rand::rng());
453458
/// # let pub_key1 = PublicKey::from_secret_key(&secp, &sk1);
454-
/// # let sk2 = SecretKey::new(&mut rng());
459+
/// # let sk2 = SecretKey::new(&mut rand::rng());
455460
/// # let pub_key2 = PublicKey::from_secret_key(&secp, &sk2);
456461
///
457-
/// let mut key_agg_cache = KeyAggCache::new(&secp, &[pub_key1, pub_key2]);
462+
/// let mut key_agg_cache = KeyAggCache::new(&secp, &[&pub_key1, &pub_key2]);
458463
///
459-
/// let tweak = SecretKey::from_slice(b"Insecure tweak, Don't use this!!").unwrap(); // tweak could be from tap
460-
/// let _x_only_key_tweaked = key_agg_cache.pubkey_xonly_tweak_add(&secp, tweak).unwrap();
464+
/// let tweak = Scalar::from_be_bytes(*b"Insecure tweak, Don't use this!!").unwrap(); // tweak could be from tap
465+
/// let _x_only_key_tweaked = key_agg_cache.pubkey_xonly_tweak_add(&secp, &tweak).unwrap();
461466
/// # }
462467
/// ```
463468
pub fn pubkey_xonly_tweak_add<C: Verification>(
@@ -519,25 +524,25 @@ impl KeyAggCache {
519524
/// Example:
520525
///
521526
/// ```rust
522-
/// # # [cfg(any(test, feature = "rand-std"))] {
523-
/// # use secp256k1::rand::{rng, RngCore};
524-
/// # use secp256k1::{KeyAggCache, Secp256k1, SecretKey, Keypair, PublicKey, SessionSecretRand, Message};
527+
/// # #[cfg(feature = "std")]
528+
/// # #[cfg(feature = "rand")] {
529+
/// # use secp256k1::{Secp256k1, SecretKey, Keypair, PublicKey, Message};
530+
/// # use secp256k1::musig::{KeyAggCache, SessionSecretRand};
525531
/// # let secp = Secp256k1::new();
526-
/// # let sk1 = SecretKey::new(&mut rng());
532+
/// # let sk1 = SecretKey::new(&mut rand::rng());
527533
/// # let pub_key1 = PublicKey::from_secret_key(&secp, &sk1);
528-
/// # let sk2 = SecretKey::new(&mut rng());
534+
/// # let sk2 = SecretKey::new(&mut rand::rng());
529535
/// # let pub_key2 = PublicKey::from_secret_key(&secp, &sk2);
530536
/// #
531-
/// let key_agg_cache = KeyAggCache::new(&secp, &[pub_key1, pub_key2]);
537+
/// let key_agg_cache = KeyAggCache::new(&secp, &[&pub_key1, &pub_key2]);
532538
/// // The session id must be sampled at random. Read documentation for more details.
533-
/// let session_secrand = SessionSecretRand::new(&mut rng());
539+
/// let session_secrand = SessionSecretRand::from_rng(&mut rand::rng());
534540
///
535541
/// let msg = Message::from_digest_slice(b"Public Message we want to sign!!").unwrap();
536542
///
537543
/// // Provide the current time for mis-use resistance
538544
/// let extra_rand : Option<[u8; 32]> = None;
539-
/// let (_sec_nonce, _pub_nonce) = key_agg_cache.nonce_gen(&secp, session_secrand, pub_key1, msg, extra_rand)
540-
/// .expect("non zero session id");
545+
/// let (_sec_nonce, _pub_nonce) = key_agg_cache.nonce_gen(&secp, session_secrand, pub_key1, msg, extra_rand);
541546
/// # }
542547
/// ```
543548
pub fn nonce_gen<C: Signing>(
@@ -707,30 +712,29 @@ impl AggregatedNonce {
707712
/// Example:
708713
///
709714
/// ```rust
710-
/// # # [cfg(any(test, feature = "rand-std"))] {
711-
/// # use secp256k1::rand::{rng, RngCore};
712-
/// # use secp256k1::{KeyAggCache, Secp256k1, SecretKey, Keypair, PublicKey, SessionSecretRand, Message, AggregatedNonce};
715+
/// # #[cfg(feature = "std")]
716+
/// # #[cfg(feature = "rand")] {
717+
/// # use secp256k1::{Secp256k1, SecretKey, Keypair, PublicKey, Message};
718+
/// # use secp256k1::musig::{AggregatedNonce, KeyAggCache, SessionSecretRand};
713719
/// # let secp = Secp256k1::new();
714-
/// # let sk1 = SecretKey::new(&mut rng());
720+
/// # let sk1 = SecretKey::new(&mut rand::rng());
715721
/// # let pub_key1 = PublicKey::from_secret_key(&secp, &sk1);
716-
/// # let sk2 = SecretKey::new(&mut rng());
722+
/// # let sk2 = SecretKey::new(&mut rand::rng());
717723
/// # let pub_key2 = PublicKey::from_secret_key(&secp, &sk2);
718724
///
719-
/// # let key_agg_cache = KeyAggCache::new(&secp, &[pub_key1, pub_key2]);
725+
/// # let key_agg_cache = KeyAggCache::new(&secp, &[&pub_key1, &pub_key2]);
720726
/// // The session id must be sampled at random. Read documentation for more details.
721727
///
722728
/// let msg = Message::from_digest_slice(b"Public Message we want to sign!!").unwrap();
723729
///
724-
/// let session_secrand1 = SessionSecretRand::new(&mut rng());
725-
/// let (_sec_nonce1, pub_nonce1) = key_agg_cache.nonce_gen(&secp, session_secrand1, pub_key1, msg, None)
726-
/// .expect("non zero session id");
730+
/// let session_secrand1 = SessionSecretRand::from_rng(&mut rand::rng());
731+
/// let (_sec_nonce1, pub_nonce1) = key_agg_cache.nonce_gen(&secp, session_secrand1, pub_key1, msg, None);
727732
///
728733
/// // Signer two does the same: Possibly on a different device
729-
/// let session_secrand2 = SessionSecretRand::new(&mut rng());
730-
/// let (_sec_nonce2, pub_nonce2) = key_agg_cache.nonce_gen(&secp, session_secrand2, pub_key2, msg, None)
731-
/// .expect("non zero session id");
734+
/// let session_secrand2 = SessionSecretRand::from_rng(&mut rand::rng());
735+
/// let (_sec_nonce2, pub_nonce2) = key_agg_cache.nonce_gen(&secp, session_secrand2, pub_key2, msg, None);
732736
///
733-
/// let aggnonce = AggregatedNonce::new(&secp, &[pub_nonce1, pub_nonce2]);
737+
/// let aggnonce = AggregatedNonce::new(&secp, &[&pub_nonce1, &pub_nonce2]);
734738
/// # }
735739
/// ```
736740
pub fn new<C: Signing>(secp: &Secp256k1<C>, nonces: &[&PublicNonce]) -> Self {
@@ -869,33 +873,32 @@ impl Session {
869873
/// Example:
870874
///
871875
/// ```rust
872-
/// # # [cfg(any(test, feature = "rand-std"))] {
873-
/// # use secp256k1::rand::{rng, RngCore};
874-
/// # use secp256k1::{KeyAggCache, Secp256k1, SecretKey, Keypair, PublicKey, SessionSecretRand, Message, AggregatedNonce, Session};
876+
/// # #[cfg(feature = "std")]
877+
/// # #[cfg(feature = "rand")] {
878+
/// # use secp256k1::{Secp256k1, SecretKey, Keypair, PublicKey, Message};
879+
/// # use secp256k1::musig::{AggregatedNonce, KeyAggCache, Session, SessionSecretRand};
875880
/// # let secp = Secp256k1::new();
876-
/// # let sk1 = SecretKey::new(&mut rng());
881+
/// # let sk1 = SecretKey::new(&mut rand::rng());
877882
/// # let pub_key1 = PublicKey::from_secret_key(&secp, &sk1);
878-
/// # let sk2 = SecretKey::new(&mut rng());
883+
/// # let sk2 = SecretKey::new(&mut rand::rng());
879884
/// # let pub_key2 = PublicKey::from_secret_key(&secp, &sk2);
880885
///
881-
/// # let key_agg_cache = KeyAggCache::new(&secp, &[pub_key1, pub_key2]);
886+
/// # let key_agg_cache = KeyAggCache::new(&secp, &[&pub_key1, &pub_key2]);
882887
/// // The session id must be sampled at random. Read documentation for more details.
883888
///
884889
/// let msg = Message::from_digest_slice(b"Public Message we want to sign!!").unwrap();
885890
///
886891
/// // Provide the current time for mis-use resistance
887-
/// let session_secrand1 = SessionSecretRand::new(&mut rng());
892+
/// let session_secrand1 = SessionSecretRand::from_rng(&mut rand::rng());
888893
/// let extra_rand1 : Option<[u8; 32]> = None;
889-
/// let (_sec_nonce1, pub_nonce1) = key_agg_cache.nonce_gen(&secp, session_secrand1, pub_key1, msg, extra_rand1)
890-
/// .expect("non zero session id");
894+
/// let (_sec_nonce1, pub_nonce1) = key_agg_cache.nonce_gen(&secp, session_secrand1, pub_key1, msg, extra_rand1);
891895
///
892896
/// // Signer two does the same. Possibly on a different device
893-
/// let session_secrand2 = SessionSecretRand::new(&mut rng());
897+
/// let session_secrand2 = SessionSecretRand::from_rng(&mut rand::rng());
894898
/// let extra_rand2 : Option<[u8; 32]> = None;
895-
/// let (_sec_nonce2, pub_nonce2) = key_agg_cache.nonce_gen(&secp, session_secrand2, pub_key2, msg, extra_rand2)
896-
/// .expect("non zero session id");
899+
/// let (_sec_nonce2, pub_nonce2) = key_agg_cache.nonce_gen(&secp, session_secrand2, pub_key2, msg, extra_rand2);
897900
///
898-
/// let aggnonce = AggregatedNonce::new(&secp, &[pub_nonce1, pub_nonce2]);
901+
/// let aggnonce = AggregatedNonce::new(&secp, &[&pub_nonce1, &pub_nonce2]);
899902
///
900903
/// let session = Session::new(
901904
/// &secp,
@@ -1005,31 +1008,31 @@ impl Session {
10051008
/// Example:
10061009
///
10071010
/// ```rust
1008-
/// # # [cfg(any(test, feature = "rand-std"))] {
1009-
/// # use secp256k1::rand::{rng, RngCore};
1010-
/// # use secp256k1::{KeyAggCache, Secp256k1, SecretKey, Keypair, PublicKey, SessionSecretRand, Message, AggregatedNonce, Session};
1011+
/// # #[cfg(not(secp256k1_fuzz))]
1012+
/// # #[cfg(feature = "std")]
1013+
/// # #[cfg(feature = "rand")] {
1014+
/// # use secp256k1::{Secp256k1, SecretKey, Keypair, PublicKey, Message};
1015+
/// # use secp256k1::musig::{AggregatedNonce, KeyAggCache, SessionSecretRand, Session};
10111016
/// # let secp = Secp256k1::new();
1012-
/// # let sk1 = SecretKey::new(&mut rng());
1017+
/// # let sk1 = SecretKey::new(&mut rand::rng());
10131018
/// # let pub_key1 = PublicKey::from_secret_key(&secp, &sk1);
1014-
/// # let sk2 = SecretKey::new(&mut rng());
1019+
/// # let sk2 = SecretKey::new(&mut rand::rng());
10151020
/// # let pub_key2 = PublicKey::from_secret_key(&secp, &sk2);
10161021
///
1017-
/// # let key_agg_cache = KeyAggCache::new(&secp, &[pub_key1, pub_key2]);
1022+
/// # let key_agg_cache = KeyAggCache::new(&secp, &[&pub_key1, &pub_key2]);
10181023
/// // The session id must be sampled at random. Read documentation for more details.
10191024
///
10201025
/// let msg = Message::from_digest_slice(b"Public Message we want to sign!!").unwrap();
10211026
///
10221027
/// // Provide the current time for mis-use resistance
1023-
/// let session_secrand1 = SessionSecretRand::new(&mut rng());
1024-
/// let (mut sec_nonce1, pub_nonce1) = key_agg_cache.nonce_gen(&secp, session_secrand1, pub_key1, msg, None)
1025-
/// .expect("non zero session id");
1028+
/// let session_secrand1 = SessionSecretRand::from_rng(&mut rand::rng());
1029+
/// let (mut sec_nonce1, pub_nonce1) = key_agg_cache.nonce_gen(&secp, session_secrand1, pub_key1, msg, None);
10261030
///
10271031
/// // Signer two does the same. Possibly on a different device
1028-
/// let session_secrand2 = SessionSecretRand::new(&mut rng());
1029-
/// let (_sec_nonce2, pub_nonce2) = key_agg_cache.nonce_gen(&secp, session_secrand2, pub_key2, msg, None)
1030-
/// .expect("non zero session id");
1032+
/// let session_secrand2 = SessionSecretRand::from_rng(&mut rand::rng());
1033+
/// let (_sec_nonce2, pub_nonce2) = key_agg_cache.nonce_gen(&secp, session_secrand2, pub_key2, msg, None);
10311034
///
1032-
/// let aggnonce = AggregatedNonce::new(&secp, &[pub_nonce1, pub_nonce2]);
1035+
/// let aggnonce = AggregatedNonce::new(&secp, &[&pub_nonce1, &pub_nonce2]);
10331036
///
10341037
/// let session = Session::new(
10351038
/// &secp,
@@ -1044,7 +1047,7 @@ impl Session {
10441047
/// sec_nonce1,
10451048
/// &keypair,
10461049
/// &key_agg_cache,
1047-
/// ).unwrap();
1050+
/// );
10481051
///
10491052
/// assert!(session.partial_verify(
10501053
/// &secp,
@@ -1088,13 +1091,12 @@ impl Session {
10881091
/// * `partial_sigs`: Array of [`PartialSignature`] to be aggregated
10891092
///
10901093
/// ```rust
1091-
/// # # [cfg(any(test, feature = "rand-std"))] {
1092-
/// # use secp256k1::rand::{rng, RngCore};
1094+
/// # #[cfg(feature = "rand-std")] {
10931095
/// # use secp256k1::{KeyAggCache, Secp256k1, SecretKey, Keypair, PublicKey, SessionSecretRand, Message, AggregatedNonce, Session};
10941096
/// # let secp = Secp256k1::new();
1095-
/// # let sk1 = SecretKey::new(&mut rng());
1097+
/// # let sk1 = SecretKey::new(&mut rand::rng());
10961098
/// # let pub_key1 = PublicKey::from_secret_key(&secp, &sk1);
1097-
/// # let sk2 = SecretKey::new(&mut rng());
1099+
/// # let sk2 = SecretKey::new(&mut rand::rng());
10981100
/// # let pub_key2 = PublicKey::from_secret_key(&secp, &sk2);
10991101
///
11001102
/// let key_agg_cache = KeyAggCache::new(&secp, &[pub_key1, pub_key2]);
@@ -1103,12 +1105,12 @@ impl Session {
11031105
/// let msg = Message::from_digest_slice(b"Public Message we want to sign!!").unwrap();
11041106
///
11051107
/// // Provide the current time for mis-use resistance
1106-
/// let session_secrand1 = SessionSecretRand::new(&mut rng());
1108+
/// let session_secrand1 = SessionSecretRand::from_rng(&mut rand::rng());
11071109
/// let (mut sec_nonce1, pub_nonce1) = key_agg_cache.nonce_gen(&secp, session_secrand1, pub_key1, msg, None)
11081110
/// .expect("non zero session id");
11091111
///
11101112
/// // Signer two does the same. Possibly on a different device
1111-
/// let session_secrand2 = SessionSecretRand::new(&mut rng());
1113+
/// let session_secrand2 = SessionSecretRand::from_rng(&mut rand::rng());
11121114
/// let (mut sec_nonce2, pub_nonce2) = key_agg_cache.nonce_gen(&secp, session_secrand2, pub_key2, msg, None)
11131115
/// .expect("non zero session id");
11141116
///

0 commit comments

Comments
 (0)