1- pub use secp256k1:: util:: { MESSAGE_SIZE , SIGNATURE_SIZE } ;
1+ pub use secp256k1:: constants:: { COMPACT_SIGNATURE_SIZE as SIGNATURE_SIZE , MESSAGE_SIZE } ;
2+ use secp256k1:: ecdsa:: Signature as SecpSignature ;
23
3- use cosmwasm_std:: StdError ;
4+ use cosmwasm_std:: { Api , StdError } ;
45
5- pub const PRIVATE_KEY_SIZE : usize = secp256k1:: util :: SECRET_KEY_SIZE ;
6- pub const PUBLIC_KEY_SIZE : usize = secp256k1:: util :: FULL_PUBLIC_KEY_SIZE ;
7- pub const COMPRESSED_PUBLIC_KEY_SIZE : usize = secp256k1:: util :: COMPRESSED_PUBLIC_KEY_SIZE ;
6+ pub const PRIVATE_KEY_SIZE : usize = secp256k1:: constants :: SECRET_KEY_SIZE ;
7+ pub const PUBLIC_KEY_SIZE : usize = secp256k1:: constants :: UNCOMPRESSED_PUBLIC_KEY_SIZE ;
8+ pub const COMPRESSED_PUBLIC_KEY_SIZE : usize = secp256k1:: constants :: PUBLIC_KEY_SIZE ;
89
910pub struct PrivateKey {
1011 inner : secp256k1:: SecretKey ,
@@ -15,70 +16,75 @@ pub struct PublicKey {
1516}
1617
1718pub struct Signature {
18- inner : secp256k1 :: Signature ,
19+ inner : SecpSignature ,
1920}
2021
2122impl PrivateKey {
2223 pub fn parse ( raw : & [ u8 ; PRIVATE_KEY_SIZE ] ) -> Result < Self , StdError > {
23- secp256k1:: SecretKey :: parse ( raw)
24+ secp256k1:: SecretKey :: from_slice ( raw)
2425 . map ( |key| PrivateKey { inner : key } )
2526 . map_err ( |err| StdError :: generic_err ( format ! ( "Error parsing PrivateKey: {}" , err) ) )
2627 }
2728
2829 pub fn serialize ( & self ) -> [ u8 ; PRIVATE_KEY_SIZE ] {
29- self . inner . serialize ( )
30+ self . inner . serialize_secret ( )
3031 }
3132
3233 pub fn pubkey ( & self ) -> PublicKey {
34+ let secp = secp256k1:: Secp256k1 :: new ( ) ;
3335 PublicKey {
34- inner : secp256k1:: PublicKey :: from_secret_key ( & self . inner ) ,
36+ inner : secp256k1:: PublicKey :: from_secret_key ( & secp , & self . inner ) ,
3537 }
3638 }
3739
38- pub fn sign ( & self , data : & [ u8 ; MESSAGE_SIZE ] ) -> Signature {
39- let msg = secp256k1:: Message :: parse ( data) ;
40- let sig = secp256k1:: sign ( & msg, & self . inner ) ;
40+ pub fn sign < A : Api > ( & self , data : & [ u8 ] , api : A ) -> Signature {
41+ let serialized_key = & self . serialize ( ) ;
42+ // will never fail since we guarantee that the inputs are valid.
43+ let sig_bytes = api. secp256k1_sign ( data, serialized_key) . unwrap ( ) ;
44+ let sig = SecpSignature :: from_compact ( & sig_bytes) . unwrap ( ) ;
4145
42- Signature { inner : sig. 0 }
46+ Signature { inner : sig }
4347 }
4448}
4549
4650impl PublicKey {
4751 pub fn parse ( p : & [ u8 ] ) -> Result < PublicKey , StdError > {
48- secp256k1:: PublicKey :: parse_slice ( p , None )
52+ secp256k1:: PublicKey :: from_slice ( p )
4953 . map ( |key| PublicKey { inner : key } )
5054 . map_err ( |err| StdError :: generic_err ( format ! ( "Error parsing PublicKey: {}" , err) ) )
5155 }
5256
5357 pub fn serialize ( & self ) -> [ u8 ; PUBLIC_KEY_SIZE ] {
54- self . inner . serialize ( )
58+ self . inner . serialize_uncompressed ( )
5559 }
5660
5761 pub fn serialize_compressed ( & self ) -> [ u8 ; COMPRESSED_PUBLIC_KEY_SIZE ] {
58- self . inner . serialize_compressed ( )
62+ self . inner . serialize ( )
5963 }
6064
61- pub fn verify ( & self , data : & [ u8 ; MESSAGE_SIZE ] , signature : Signature ) -> bool {
62- let msg = secp256k1:: Message :: parse ( data) ;
63- secp256k1:: verify ( & msg, & signature. inner , & self . inner )
65+ pub fn verify < A : Api > ( & self , data : & [ u8 ; MESSAGE_SIZE ] , signature : Signature , api : A ) -> bool {
66+ let sig = & signature. serialize ( ) ;
67+ let pk = & self . serialize ( ) ;
68+ // will never fail since we guarantee that the inputs are valid.
69+ api. secp256k1_verify ( data, sig, pk) . unwrap ( )
6470 }
6571}
6672
6773impl Signature {
68- pub fn parse ( p : & [ u8 ; SIGNATURE_SIZE ] ) -> Signature {
69- Signature {
70- inner : secp256k1 :: Signature :: parse ( p ) ,
71- }
74+ pub fn parse ( p : & [ u8 ; SIGNATURE_SIZE ] ) -> Result < Signature , StdError > {
75+ SecpSignature :: from_compact ( p )
76+ . map ( |sig| Signature { inner : sig } )
77+ . map_err ( |err| StdError :: generic_err ( format ! ( "Error parsing Signature: {}" , err ) ) )
7278 }
7379
7480 pub fn parse_slice ( p : & [ u8 ] ) -> Result < Signature , StdError > {
75- secp256k1 :: Signature :: parse_slice ( p)
81+ SecpSignature :: from_compact ( p)
7682 . map ( |sig| Signature { inner : sig } )
7783 . map_err ( |err| StdError :: generic_err ( format ! ( "Error parsing Signature: {}" , err) ) )
7884 }
7985
8086 pub fn serialize ( & self ) -> [ u8 ; SIGNATURE_SIZE ] {
81- self . inner . serialize ( )
87+ self . inner . serialize_compact ( )
8288 }
8389}
8490
0 commit comments