@@ -104,7 +104,7 @@ mod message_signing {
104
104
pub fn serialize ( & self ) -> [ u8 ; 65 ] {
105
105
let ( recid, raw) = self . signature . serialize_compact ( ) ;
106
106
let mut serialized = [ 0u8 ; 65 ] ;
107
- serialized[ 0 ] = i32 :: from ( recid) as u8 + if self . compressed { 31 } else { 27 } ;
107
+ serialized[ 0 ] = recid. to_u8 ( ) + if self . compressed { 31 } else { 27 } ;
108
108
serialized[ 1 ..] . copy_from_slice ( & raw [ ..] ) ;
109
109
serialized
110
110
}
@@ -139,7 +139,7 @@ mod message_signing {
139
139
msg_hash : sha256d:: Hash ,
140
140
) -> Result < PublicKey , MessageSignatureError > {
141
141
let msg = secp256k1:: Message :: from_digest ( msg_hash. to_byte_array ( ) ) ;
142
- let pubkey = secp_ctx . recover_ecdsa ( msg, & self . signature ) ?;
142
+ let pubkey = self . signature . recover_ecdsa ( msg) ?;
143
143
Ok ( PublicKey { inner : pubkey, compressed : self . compressed } )
144
144
}
145
145
@@ -217,14 +217,15 @@ pub fn signed_msg_hash(msg: impl AsRef<[u8]>) -> sha256d::Hash {
217
217
218
218
/// Sign message using Bitcoin's message signing format.
219
219
#[ cfg( feature = "secp-recovery" ) ]
220
- pub fn sign < C : secp256k1:: Signing > (
221
- secp_ctx : & secp256k1:: Secp256k1 < C > ,
220
+ pub fn sign (
222
221
msg : impl AsRef < [ u8 ] > ,
223
222
privkey : SecretKey ,
224
223
) -> MessageSignature {
224
+ use secp256k1:: ecdsa:: RecoverableSignature ;
225
+
225
226
let msg_hash = signed_msg_hash ( msg) ;
226
227
let msg_to_sign = secp256k1:: Message :: from_digest ( msg_hash. to_byte_array ( ) ) ;
227
- let secp_sig = secp_ctx . sign_ecdsa_recoverable ( msg_to_sign, & privkey) ;
228
+ let secp_sig = RecoverableSignature :: sign_ecdsa_recoverable ( msg_to_sign, & privkey) ;
228
229
MessageSignature { signature : secp_sig, compressed : true }
229
230
}
230
231
@@ -244,17 +245,19 @@ mod tests {
244
245
#[ test]
245
246
#[ cfg( all( feature = "secp-recovery" , feature = "base64" , feature = "rand-std" ) ) ]
246
247
fn message_signature ( ) {
248
+ use secp256k1:: ecdsa:: RecoverableSignature ;
249
+
247
250
use crate :: { Address , AddressType , Network , NetworkKind } ;
248
251
249
252
let secp = secp256k1:: Secp256k1 :: new ( ) ;
250
253
let message = "rust-bitcoin MessageSignature test" ;
251
254
let msg_hash = super :: signed_msg_hash ( message) ;
252
255
let msg = secp256k1:: Message :: from_digest ( msg_hash. to_byte_array ( ) ) ;
253
256
let privkey = secp256k1:: SecretKey :: new ( & mut secp256k1:: rand:: rng ( ) ) ;
254
- let secp_sig = secp . sign_ecdsa_recoverable ( msg, & privkey) ;
257
+ let secp_sig = RecoverableSignature :: sign_ecdsa_recoverable ( msg, & privkey) ;
255
258
let signature = super :: MessageSignature { signature : secp_sig, compressed : true } ;
256
259
257
- assert_eq ! ( signature. to_string( ) , super :: sign( & secp , message, privkey) . to_string( ) ) ;
260
+ assert_eq ! ( signature. to_string( ) , super :: sign( message, privkey) . to_string( ) ) ;
258
261
assert_eq ! ( signature. to_base64( ) , signature. to_string( ) ) ;
259
262
let signature2 = & signature. to_string ( ) . parse :: < super :: MessageSignature > ( ) . unwrap ( ) ;
260
263
let pubkey = signature2
0 commit comments