Skip to content

Commit 3c2bee3

Browse files
elichaielichai
authored
Merge pull request #270 from thomaseizinger/serde-owned-types
Rebased version of `[Alternative] Allow deserializing from owned types` + support for new schnorr module
2 parents 63f4de7 + c2fd5ce commit 3c2bee3

File tree

6 files changed

+228
-134
lines changed

6 files changed

+228
-134
lines changed

‎src/ecdh.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -194,7 +194,7 @@ mod tests {
194194
let s = Secp256k1::signing_only();
195195
let (sk1, pk1) = s.generate_keypair(&mut thread_rng());
196196
let (sk2, pk2) = s.generate_keypair(&mut thread_rng());
197-
197+
198198
let sec1 = SharedSecret::new_with_hash(&pk1, &sk2, |x,_| x.into());
199199
let sec2 = SharedSecret::new_with_hash(&pk2, &sk1, |x,_| x.into());
200200
let sec_odd = SharedSecret::new_with_hash(&pk1, &sk1, |x,_| x.into());

‎src/key.rs

+65-3
Original file line numberDiff line numberDiff line change
@@ -213,7 +213,32 @@ impl SecretKey {
213213
}
214214
}
215215

216-
serde_impl!(SecretKey, constants::SECRET_KEY_SIZE);
216+
#[cfg(feature = "serde")]
217+
impl ::serde::Serialize for SecretKey {
218+
fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
219+
if s.is_human_readable() {
220+
s.collect_str(self)
221+
} else {
222+
s.serialize_bytes(&self[..])
223+
}
224+
}
225+
}
226+
227+
#[cfg(feature = "serde")]
228+
impl<'de> ::serde::Deserialize<'de> for SecretKey {
229+
fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
230+
if d.is_human_readable() {
231+
d.deserialize_str(super::serde_util::FromStrVisitor::new(
232+
"a hex string representing 32 byte SecretKey"
233+
))
234+
} else {
235+
d.deserialize_bytes(super::serde_util::BytesVisitor::new(
236+
"raw 32 bytes SecretKey",
237+
SecretKey::from_slice
238+
))
239+
}
240+
}
241+
}
217242

218243
impl PublicKey {
219244
/// Obtains a raw const pointer suitable for use with FFI functions
@@ -402,7 +427,32 @@ impl From<ffi::PublicKey> for PublicKey {
402427
}
403428
}
404429

405-
serde_impl_from_slice!(PublicKey);
430+
#[cfg(feature = "serde")]
431+
impl ::serde::Serialize for PublicKey {
432+
fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
433+
if s.is_human_readable() {
434+
s.collect_str(self)
435+
} else {
436+
s.serialize_bytes(&self.serialize())
437+
}
438+
}
439+
}
440+
441+
#[cfg(feature = "serde")]
442+
impl<'de> ::serde::Deserialize<'de> for PublicKey {
443+
fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<PublicKey, D::Error> {
444+
if d.is_human_readable() {
445+
d.deserialize_str(super::serde_util::FromStrVisitor::new(
446+
"an ASCII hex string representing a public key"
447+
))
448+
} else {
449+
d.deserialize_bytes(super::serde_util::BytesVisitor::new(
450+
"a bytestring representing a public key",
451+
PublicKey::from_slice
452+
))
453+
}
454+
}
455+
}
406456

407457
impl PartialOrd for PublicKey {
408458
fn partial_cmp(&self, other: &PublicKey) -> Option<::core::cmp::Ordering> {
@@ -818,7 +868,7 @@ mod test {
818868

819869
#[cfg(feature = "serde")]
820870
#[test]
821-
fn test_signature_serde() {
871+
fn test_serde() {
822872
use serde_test::{Configure, Token, assert_tokens};
823873
static SK_BYTES: [u8; 32] = [
824874
1, 1, 1, 1, 1, 1, 1, 1,
@@ -846,8 +896,20 @@ mod test {
846896
let pk = PublicKey::from_secret_key(&s, &sk);
847897

848898
assert_tokens(&sk.compact(), &[Token::BorrowedBytes(&SK_BYTES[..])]);
899+
assert_tokens(&sk.compact(), &[Token::Bytes(&SK_BYTES)]);
900+
assert_tokens(&sk.compact(), &[Token::ByteBuf(&SK_BYTES)]);
901+
849902
assert_tokens(&sk.readable(), &[Token::BorrowedStr(SK_STR)]);
903+
assert_tokens(&sk.readable(), &[Token::Str(SK_STR)]);
904+
assert_tokens(&sk.readable(), &[Token::String(SK_STR)]);
905+
850906
assert_tokens(&pk.compact(), &[Token::BorrowedBytes(&PK_BYTES[..])]);
907+
assert_tokens(&pk.compact(), &[Token::Bytes(&PK_BYTES)]);
908+
assert_tokens(&pk.compact(), &[Token::ByteBuf(&PK_BYTES)]);
909+
851910
assert_tokens(&pk.readable(), &[Token::BorrowedStr(PK_STR)]);
911+
assert_tokens(&pk.readable(), &[Token::Str(PK_STR)]);
912+
assert_tokens(&pk.readable(), &[Token::String(PK_STR)]);
913+
852914
}
853915
}

‎src/lib.rs

+17-9
Original file line numberDiff line numberDiff line change
@@ -147,6 +147,8 @@ pub mod key;
147147
pub mod schnorrsig;
148148
#[cfg(feature = "recovery")]
149149
pub mod recovery;
150+
#[cfg(feature = "serde")]
151+
mod serde_util;
150152

151153
pub use key::SecretKey;
152154
pub use key::PublicKey;
@@ -435,21 +437,21 @@ impl ::serde::Serialize for Signature {
435437
} else {
436438
s.serialize_bytes(&self.serialize_der())
437439
}
438-
439440
}
440441
}
441442

442443
#[cfg(feature = "serde")]
443444
impl<'de> ::serde::Deserialize<'de> for Signature {
444-
fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<Signature, D::Error> {
445-
use ::serde::de::Error;
446-
use str::FromStr;
445+
fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
447446
if d.is_human_readable() {
448-
let sl: &str = ::serde::Deserialize::deserialize(d)?;
449-
Signature::from_str(sl).map_err(D::Error::custom)
447+
d.deserialize_str(serde_util::FromStrVisitor::new(
448+
"a hex string representing a DER encoded Signature"
449+
))
450450
} else {
451-
let sl: &[u8] = ::serde::Deserialize::deserialize(d)?;
452-
Signature::from_der(sl).map_err(D::Error::custom)
451+
d.deserialize_bytes(serde_util::BytesVisitor::new(
452+
"raw byte stream, that represents a DER encoded Signature",
453+
Signature::from_der
454+
))
453455
}
454456
}
455457
}
@@ -1237,7 +1239,7 @@ mod tests {
12371239
#[cfg(feature = "serde")]
12381240
#[cfg(not(fuzzing))] // fixed sig vectors can't work with fuzz-sigs
12391241
#[test]
1240-
fn test_signature_serde() {
1242+
fn test_serde() {
12411243
use serde_test::{Configure, Token, assert_tokens};
12421244

12431245
let s = Secp256k1::new();
@@ -1258,7 +1260,13 @@ mod tests {
12581260
";
12591261

12601262
assert_tokens(&sig.compact(), &[Token::BorrowedBytes(&SIG_BYTES[..])]);
1263+
assert_tokens(&sig.compact(), &[Token::Bytes(&SIG_BYTES)]);
1264+
assert_tokens(&sig.compact(), &[Token::ByteBuf(&SIG_BYTES)]);
1265+
12611266
assert_tokens(&sig.readable(), &[Token::BorrowedStr(SIG_STR)]);
1267+
assert_tokens(&sig.readable(), &[Token::Str(SIG_STR)]);
1268+
assert_tokens(&sig.readable(), &[Token::String(SIG_STR)]);
1269+
12621270
}
12631271

12641272
#[cfg(feature = "global-context")]

‎src/macros.rs

-118
Original file line numberDiff line numberDiff line change
@@ -43,121 +43,3 @@ macro_rules! impl_from_array_len {
4343
)+
4444
}
4545
}
46-
47-
#[cfg(feature="serde")]
48-
/// Implements `Serialize` and `Deserialize` for a type `$t` which represents
49-
/// a newtype over a byte-slice over length `$len`. Type `$t` must implement
50-
/// the `FromStr` and `Display` trait.
51-
macro_rules! serde_impl(
52-
($t:ident, $len:expr) => (
53-
impl ::serde::Serialize for $t {
54-
fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
55-
if s.is_human_readable() {
56-
s.collect_str(self)
57-
} else {
58-
s.serialize_bytes(&self[..])
59-
}
60-
}
61-
}
62-
63-
impl<'de> ::serde::Deserialize<'de> for $t {
64-
fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<$t, D::Error> {
65-
use ::serde::de::Error;
66-
use core::str::FromStr;
67-
68-
if d.is_human_readable() {
69-
let sl: &str = ::serde::Deserialize::deserialize(d)?;
70-
$t::from_str(sl).map_err(D::Error::custom)
71-
} else {
72-
let sl: &[u8] = ::serde::Deserialize::deserialize(d)?;
73-
if sl.len() != $len {
74-
Err(D::Error::invalid_length(sl.len(), &stringify!($len)))
75-
} else {
76-
let mut ret = [0; $len];
77-
ret.copy_from_slice(sl);
78-
Ok($t(ret))
79-
}
80-
}
81-
}
82-
}
83-
)
84-
);
85-
86-
#[cfg(not(feature="serde"))]
87-
macro_rules! serde_impl(
88-
($t:ident, $len:expr) => ()
89-
);
90-
91-
#[cfg(feature = "serde")]
92-
macro_rules! serde_impl_from_slice {
93-
($t: ident) => {
94-
impl ::serde::Serialize for $t {
95-
fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
96-
if s.is_human_readable() {
97-
s.collect_str(self)
98-
} else {
99-
s.serialize_bytes(&self.serialize())
100-
}
101-
}
102-
}
103-
104-
impl<'de> ::serde::Deserialize<'de> for $t {
105-
fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<$t, D::Error> {
106-
if d.is_human_readable() {
107-
struct HexVisitor;
108-
109-
impl<'de> ::serde::de::Visitor<'de> for HexVisitor {
110-
type Value = $t;
111-
112-
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
113-
formatter.write_str("an ASCII hex string")
114-
}
115-
116-
fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
117-
where
118-
E: ::serde::de::Error,
119-
{
120-
if let Ok(hex) = str::from_utf8(v) {
121-
str::FromStr::from_str(hex).map_err(E::custom)
122-
} else {
123-
Err(E::invalid_value(::serde::de::Unexpected::Bytes(v), &self))
124-
}
125-
}
126-
127-
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
128-
where
129-
E: ::serde::de::Error,
130-
{
131-
str::FromStr::from_str(v).map_err(E::custom)
132-
}
133-
}
134-
d.deserialize_str(HexVisitor)
135-
} else {
136-
struct BytesVisitor;
137-
138-
impl<'de> ::serde::de::Visitor<'de> for BytesVisitor {
139-
type Value = $t;
140-
141-
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
142-
formatter.write_str("a bytestring")
143-
}
144-
145-
fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
146-
where
147-
E: ::serde::de::Error,
148-
{
149-
$t::from_slice(v).map_err(E::custom)
150-
}
151-
}
152-
153-
d.deserialize_bytes(BytesVisitor)
154-
}
155-
}
156-
}
157-
};
158-
}
159-
160-
#[cfg(not(feature = "serde"))]
161-
macro_rules! serde_impl_from_slice(
162-
($t:ident) => ()
163-
);

‎src/schnorrsig.rs

+76-3
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,33 @@ use {Message, Signing, Verification};
1818
pub struct Signature([u8; constants::SCHNORRSIG_SIGNATURE_SIZE]);
1919
impl_array_newtype!(Signature, u8, constants::SCHNORRSIG_SIGNATURE_SIZE);
2020
impl_pretty_debug!(Signature);
21-
serde_impl!(Signature, constants::SCHNORRSIG_SIGNATURE_SIZE);
21+
22+
#[cfg(feature = "serde")]
23+
impl ::serde::Serialize for Signature {
24+
fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
25+
if s.is_human_readable() {
26+
s.collect_str(self)
27+
} else {
28+
s.serialize_bytes(&self[..])
29+
}
30+
}
31+
}
32+
33+
#[cfg(feature = "serde")]
34+
impl<'de> ::serde::Deserialize<'de> for Signature {
35+
fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
36+
if d.is_human_readable() {
37+
d.deserialize_str(super::serde_util::FromStrVisitor::new(
38+
"a hex string representing 64 byte schnorr signature"
39+
))
40+
} else {
41+
d.deserialize_bytes(super::serde_util::BytesVisitor::new(
42+
"raw 64 bytes schnorr signature",
43+
Signature::from_slice
44+
))
45+
}
46+
}
47+
}
2248

2349
impl fmt::LowerHex for Signature {
2450
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -376,7 +402,32 @@ impl From<::key::PublicKey> for PublicKey {
376402
}
377403
}
378404

379-
serde_impl_from_slice!(PublicKey);
405+
#[cfg(feature = "serde")]
406+
impl ::serde::Serialize for PublicKey {
407+
fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
408+
if s.is_human_readable() {
409+
s.collect_str(self)
410+
} else {
411+
s.serialize_bytes(&self.serialize())
412+
}
413+
}
414+
}
415+
416+
#[cfg(feature = "serde")]
417+
impl<'de> ::serde::Deserialize<'de> for PublicKey {
418+
fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
419+
if d.is_human_readable() {
420+
d.deserialize_str(super::serde_util::FromStrVisitor::new(
421+
"a hex string representing 32 byte schnorr public key"
422+
))
423+
} else {
424+
d.deserialize_bytes(super::serde_util::BytesVisitor::new(
425+
"raw 32 bytes schnorr public key",
426+
PublicKey::from_slice
427+
))
428+
}
429+
}
430+
}
380431

381432
impl<C: Signing> Secp256k1<C> {
382433
fn schnorrsig_sign_helper(
@@ -724,7 +775,7 @@ mod tests {
724775
#[cfg(feature = "serde")]
725776
#[cfg(not(fuzzing))] // fixed sig vectors can't work with fuzz-sigs
726777
#[test]
727-
fn test_signature_serde() {
778+
fn test_serde() {
728779
use serde_test::{assert_tokens, Configure, Token};
729780

730781
let s = Secp256k1::new();
@@ -745,8 +796,30 @@ mod tests {
745796
14d0bf1a8953506fb460f58be141af767fd112535fb3922ef217308e2c26706f1eeb432b3dba9a01082f9e4d4ef5678ad0d9d532c0dfa907b568722d0b0119ba\
746797
";
747798

799+
static PK_BYTES: [u8; 32] = [
800+
24, 132, 87, 129, 246, 49, 196, 143, 28, 151, 9, 226, 48, 146, 6, 125, 6, 131, 127,
801+
48, 170, 12, 208, 84, 74, 200, 135, 254, 145, 221, 209, 102
802+
];
803+
static PK_STR: &'static str = "\
804+
18845781f631c48f1c9709e23092067d06837f30aa0cd0544ac887fe91ddd166\
805+
";
806+
let pk = PublicKey::from_slice(&PK_BYTES).unwrap();
807+
748808
assert_tokens(&sig.compact(), &[Token::BorrowedBytes(&SIG_BYTES[..])]);
809+
assert_tokens(&sig.compact(), &[Token::Bytes(&SIG_BYTES[..])]);
810+
assert_tokens(&sig.compact(), &[Token::ByteBuf(&SIG_BYTES[..])]);
811+
749812
assert_tokens(&sig.readable(), &[Token::BorrowedStr(SIG_STR)]);
813+
assert_tokens(&sig.readable(), &[Token::Str(SIG_STR)]);
814+
assert_tokens(&sig.readable(), &[Token::String(SIG_STR)]);
815+
816+
assert_tokens(&pk.compact(), &[Token::BorrowedBytes(&PK_BYTES[..])]);
817+
assert_tokens(&pk.compact(), &[Token::Bytes(&PK_BYTES[..])]);
818+
assert_tokens(&pk.compact(), &[Token::ByteBuf(&PK_BYTES[..])]);
819+
820+
assert_tokens(&pk.readable(), &[Token::BorrowedStr(PK_STR)]);
821+
assert_tokens(&pk.readable(), &[Token::Str(PK_STR)]);
822+
assert_tokens(&pk.readable(), &[Token::String(PK_STR)]);
750823
}
751824
#[test]
752825
fn test_addition() {

0 commit comments

Comments
 (0)