Skip to content
This repository was archived by the owner on Dec 22, 2020. It is now read-only.

Commit fdf1d29

Browse files
tony-iqlusiontony-iqlusion
committed
Remove redundant "namespacing" from type names
* `Ed25519PublicKey` => `ed25519::PublicKey` * `Ed25519Signature` => `ed25519::Signature` * `EcdsaPublicKey` => `ecdsa::PublicKey` * `EcdsaSignature` => `ecdsa::Signature` These names were prefixed with the signature type previously to avoid clashes with traits of the same name (i.e. `signatory::PublicKey` and `signatory::Signature`) however the namespace clash can also be avoided by using the `ed25519` and `ecdsa` module names. This is considered a Rust best practice: rust-lang/rfcs#356
1 parent 5ff4c73 commit fdf1d29

File tree

26 files changed

+172
-178
lines changed

26 files changed

+172
-178
lines changed

‎providers/signatory-dalek/benches/ed25519.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ extern crate signatory_dalek;
1010

1111
use criterion::Criterion;
1212
use signatory::{
13-
ed25519::{Ed25519PublicKey, Ed25519Signature, Seed, TEST_VECTORS},
13+
ed25519::{Ed25519PublicKey, Seed, Signature, TEST_VECTORS},
1414
test_vector::TestVector,
1515
Signature, Verifier,
1616
};
@@ -29,7 +29,7 @@ fn sign_ed25519(c: &mut Criterion) {
2929

3030
fn verify_ed25519(c: &mut Criterion) {
3131
let verifier = Ed25519Verifier::from(&Ed25519PublicKey::from_bytes(TEST_VECTOR.pk).unwrap());
32-
let signature = Ed25519Signature::from_bytes(TEST_VECTOR.sig).unwrap();
32+
let signature = Signature::from_bytes(TEST_VECTOR.sig).unwrap();
3333

3434
c.bench_function("dalek: Ed25519 verifier", move |b| {
3535
b.iter(|| verifier.verify(TEST_VECTOR.msg, &signature).unwrap())

‎providers/signatory-dalek/src/lib.rs

Lines changed: 27 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -21,63 +21,62 @@ use ed25519_dalek::{Keypair, SecretKey};
2121
use sha2::Sha512;
2222

2323
use signatory::{
24+
ed25519,
2425
error::{Error, ErrorKind},
2526
generic_array::typenum::U64,
26-
DigestSigner, DigestVerifier, Ed25519PublicKey, Ed25519Seed, Ed25519Signature, PublicKeyed,
27-
Signature, Signer, Verifier,
27+
DigestSigner, DigestVerifier, PublicKeyed, Signature, Signer, Verifier,
2828
};
2929

3030
/// Ed25519 signature provider for ed25519-dalek
3131
pub struct Ed25519Signer(Keypair);
3232

33-
impl<'a> From<&'a Ed25519Seed> for Ed25519Signer {
33+
impl<'a> From<&'a ed25519::Seed> for Ed25519Signer {
3434
/// Create a new DalekSigner from an unexpanded seed value
35-
fn from(seed: &'a Ed25519Seed) -> Self {
35+
fn from(seed: &'a ed25519::Seed) -> Self {
3636
Ed25519Signer(keypair_from_seed(seed))
3737
}
3838
}
3939

40-
impl PublicKeyed<Ed25519PublicKey> for Ed25519Signer {
41-
fn public_key(&self) -> Result<Ed25519PublicKey, Error> {
42-
Ok(Ed25519PublicKey::from_bytes(self.0.public.as_bytes()).unwrap())
40+
impl PublicKeyed<ed25519::PublicKey> for Ed25519Signer {
41+
fn public_key(&self) -> Result<ed25519::PublicKey, Error> {
42+
Ok(ed25519::PublicKey::from_bytes(self.0.public.as_bytes()).unwrap())
4343
}
4444
}
4545

46-
impl Signer<Ed25519Signature> for Ed25519Signer {
47-
fn sign(&self, msg: &[u8]) -> Result<Ed25519Signature, Error> {
46+
impl Signer<ed25519::Signature> for Ed25519Signer {
47+
fn sign(&self, msg: &[u8]) -> Result<ed25519::Signature, Error> {
4848
let signature = self.0.sign::<Sha512>(msg).to_bytes();
49-
Ok(Ed25519Signature::from_bytes(&signature[..]).unwrap())
49+
Ok(Signature::from_bytes(&signature[..]).unwrap())
5050
}
5151
}
5252

5353
/// Ed25519ph (i.e. pre-hashed) signature provider for ed25519-dalek
5454
pub struct Ed25519PhSigner(Keypair);
5555

56-
impl<'a> From<&'a Ed25519Seed> for Ed25519PhSigner {
56+
impl<'a> From<&'a ed25519::Seed> for Ed25519PhSigner {
5757
/// Create a new DalekSigner from an unexpanded seed value
58-
fn from(seed: &'a Ed25519Seed) -> Self {
58+
fn from(seed: &'a ed25519::Seed) -> Self {
5959
Ed25519PhSigner(keypair_from_seed(seed))
6060
}
6161
}
6262

63-
impl PublicKeyed<Ed25519PublicKey> for Ed25519PhSigner {
64-
fn public_key(&self) -> Result<Ed25519PublicKey, Error> {
65-
Ok(Ed25519PublicKey::from_bytes(self.0.public.as_bytes()).unwrap())
63+
impl PublicKeyed<ed25519::PublicKey> for Ed25519PhSigner {
64+
fn public_key(&self) -> Result<ed25519::PublicKey, Error> {
65+
Ok(ed25519::PublicKey::from_bytes(self.0.public.as_bytes()).unwrap())
6666
}
6767
}
6868

6969
// TODO: tests!
70-
impl<D> DigestSigner<D, Ed25519Signature> for Ed25519PhSigner
70+
impl<D> DigestSigner<D, ed25519::Signature> for Ed25519PhSigner
7171
where
7272
D: Digest<OutputSize = U64> + Default,
7373
{
74-
fn sign(&self, digest: D) -> Result<Ed25519Signature, Error> {
74+
fn sign(&self, digest: D) -> Result<ed25519::Signature, Error> {
7575
// TODO: context support
7676
let context: Option<&'static [u8]> = None;
7777

7878
let signature =
79-
Ed25519Signature::from_bytes(&self.0.sign_prehashed(digest, context).to_bytes()[..])
80-
.unwrap();
79+
Signature::from_bytes(&self.0.sign_prehashed(digest, context).to_bytes()[..]).unwrap();
8180

8281
Ok(signature)
8382
}
@@ -87,14 +86,14 @@ where
8786
#[derive(Clone, Debug, Eq, PartialEq)]
8887
pub struct Ed25519Verifier(ed25519_dalek::PublicKey);
8988

90-
impl<'a> From<&'a Ed25519PublicKey> for Ed25519Verifier {
91-
fn from(public_key: &'a Ed25519PublicKey) -> Self {
89+
impl<'a> From<&'a ed25519::PublicKey> for Ed25519Verifier {
90+
fn from(public_key: &'a ed25519::PublicKey) -> Self {
9291
Ed25519Verifier(ed25519_dalek::PublicKey::from_bytes(public_key.as_ref()).unwrap())
9392
}
9493
}
9594

96-
impl Verifier<Ed25519Signature> for Ed25519Verifier {
97-
fn verify(&self, msg: &[u8], sig: &Ed25519Signature) -> Result<(), Error> {
95+
impl Verifier<ed25519::Signature> for Ed25519Verifier {
96+
fn verify(&self, msg: &[u8], sig: &ed25519::Signature) -> Result<(), Error> {
9897
let dalek_sig = ed25519_dalek::Signature::from_bytes(sig.as_ref()).unwrap();
9998
self.0
10099
.verify::<Sha512>(msg, &dalek_sig)
@@ -106,18 +105,18 @@ impl Verifier<Ed25519Signature> for Ed25519Verifier {
106105
#[derive(Clone, Debug, Eq, PartialEq)]
107106
pub struct Ed25519PhVerifier(ed25519_dalek::PublicKey);
108107

109-
impl<'a> From<&'a Ed25519PublicKey> for Ed25519PhVerifier {
110-
fn from(public_key: &'a Ed25519PublicKey) -> Self {
108+
impl<'a> From<&'a ed25519::PublicKey> for Ed25519PhVerifier {
109+
fn from(public_key: &'a ed25519::PublicKey) -> Self {
111110
Ed25519PhVerifier(ed25519_dalek::PublicKey::from_bytes(public_key.as_ref()).unwrap())
112111
}
113112
}
114113

115114
// TODO: tests!
116-
impl<D> DigestVerifier<D, Ed25519Signature> for Ed25519PhVerifier
115+
impl<D> DigestVerifier<D, ed25519::Signature> for Ed25519PhVerifier
117116
where
118117
D: Digest<OutputSize = U64> + Default,
119118
{
120-
fn verify(&self, digest: D, sig: &Ed25519Signature) -> Result<(), Error> {
119+
fn verify(&self, digest: D, sig: &ed25519::Signature) -> Result<(), Error> {
121120
// TODO: context support
122121
let context: Option<&'static [u8]> = None;
123122
let dalek_sig = ed25519_dalek::Signature::from_bytes(sig.as_ref()).unwrap();
@@ -128,7 +127,7 @@ where
128127
}
129128

130129
/// Convert a Signatory seed into a Dalek keypair
131-
fn keypair_from_seed(seed: &Ed25519Seed) -> Keypair {
130+
fn keypair_from_seed(seed: &ed25519::Seed) -> Keypair {
132131
let secret = SecretKey::from_bytes(seed.as_secret_slice()).unwrap();
133132
let public = ed25519_dalek::PublicKey::from_secret::<Sha512>(&secret);
134133
Keypair { secret, public }

‎providers/signatory-ledger-cosval/src/lib.rs

Lines changed: 7 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -16,8 +16,7 @@ use std::sync::Arc;
1616
use std::sync::Mutex;
1717

1818
use signatory::{
19-
ed25519::Ed25519PublicKey,
20-
ed25519::Ed25519Signature,
19+
ed25519::{PublicKey, Signature},
2120
error::{Error, ErrorKind},
2221
PublicKeyed, Signer,
2322
};
@@ -43,25 +42,25 @@ impl Ed25519CosmosAppSigner {
4342
}
4443
}
4544

46-
impl PublicKeyed<Ed25519PublicKey> for Ed25519CosmosAppSigner {
45+
impl PublicKeyed<PublicKey> for Ed25519CosmosAppSigner {
4746
/// Returns the public key that corresponds cosmos validator app connected to this signer
48-
fn public_key(&self) -> Result<Ed25519PublicKey, Error> {
47+
fn public_key(&self) -> Result<PublicKey, Error> {
4948
let app = self.app.lock().unwrap();
5049

5150
match app.public_key() {
52-
Ok(pk) => Ok(Ed25519PublicKey(pk)),
51+
Ok(pk) => Ok(PublicKey(pk)),
5352
Err(err) => Err(Error::new(ErrorKind::ProviderError, Some(&err.to_string()))),
5453
}
5554
}
5655
}
5756

58-
impl Signer<Ed25519Signature> for Ed25519CosmosAppSigner {
57+
impl Signer<Signature> for Ed25519CosmosAppSigner {
5958
/// c: Compute a compact, fixed-sized signature of the given amino/json vote
60-
fn sign(&self, msg: &[u8]) -> Result<Ed25519Signature, Error> {
59+
fn sign(&self, msg: &[u8]) -> Result<Signature, Error> {
6160
let app = self.app.lock().unwrap();
6261

6362
match app.sign(&msg) {
64-
Ok(sig) => Ok(Ed25519Signature(sig)),
63+
Ok(sig) => Ok(Signature(sig)),
6564
Err(err) => Err(Error::new(ErrorKind::ProviderError, Some(&err.to_string()))),
6665
}
6766
}

‎providers/signatory-ring/benches/ecdsa.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ extern crate signatory_ring;
1010
use criterion::Criterion;
1111
use signatory::{
1212
curve::nistp256::{self, FixedSignature},
13-
ecdsa::EcdsaPublicKey,
13+
ecdsa::PublicKey,
1414
encoding::FromPkcs8,
1515
generic_array::GenericArray,
1616
test_vector::TestVector,
@@ -31,9 +31,9 @@ fn sign_ecdsa_p256(c: &mut Criterion) {
3131

3232
fn verify_ecdsa_p256(c: &mut Criterion) {
3333
let signature = FixedSignature::from_bytes(TEST_VECTOR.sig).unwrap();
34-
let verifier = P256Verifier::from(&EcdsaPublicKey::from_untagged_point(
35-
GenericArray::from_slice(TEST_VECTOR.pk),
36-
));
34+
let verifier = P256Verifier::from(&PublicKey::from_untagged_point(GenericArray::from_slice(
35+
TEST_VECTOR.pk,
36+
)));
3737

3838
c.bench_function("ring: ECDSA (nistp256) verifier", move |b| {
3939
b.iter(|| verifier.verify_sha256(TEST_VECTOR.msg, &signature).unwrap())

‎providers/signatory-ring/benches/ed25519.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -9,8 +9,8 @@ extern crate signatory_ring;
99

1010
use criterion::Criterion;
1111
use signatory::{
12-
ed25519::TEST_VECTORS, test_vector::TestVector, Ed25519PublicKey, Ed25519Seed,
13-
Ed25519Signature, Signature, Verifier,
12+
ed25519::TEST_VECTORS, test_vector::TestVector, Ed25519PublicKey, Ed25519Seed, Signature,
13+
Signature, Verifier,
1414
};
1515
use signatory_ring::ed25519::{Ed25519Signer, Ed25519Verifier};
1616

@@ -26,7 +26,7 @@ fn sign_ed25519(c: &mut Criterion) {
2626
}
2727

2828
fn verify_ed25519(c: &mut Criterion) {
29-
let signature = Ed25519Signature::from_bytes(TEST_VECTOR.sig).unwrap();
29+
let signature = Signature::from_bytes(TEST_VECTOR.sig).unwrap();
3030
let verifier = Ed25519Verifier::from(&Ed25519PublicKey::from_bytes(TEST_VECTOR.pk).unwrap());
3131

3232
c.bench_function("ring: Ed25519 verifier", move |b| {

‎providers/signatory-ring/src/ecdsa/p256.rs

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ use ring::{rand::SystemRandom, signature::ECDSAKeyPair};
1313
use signatory::encoding::pkcs8::{self, GeneratePkcs8};
1414
use signatory::{
1515
curve::nistp256::NistP256,
16-
ecdsa::{Asn1Signature, EcdsaPublicKey, EcdsaSignature, FixedSignature},
16+
ecdsa::{Asn1Signature, FixedSignature, PublicKey, Signature},
1717
encoding::pkcs8::FromPkcs8,
1818
error::{Error, ErrorKind::SignatureInvalid},
1919
PublicKeyed, Sha256Signer, Sha256Verifier,
@@ -61,11 +61,11 @@ impl GeneratePkcs8 for P256Signer<FixedSignature<NistP256>> {
6161
}
6262
}
6363

64-
impl<S> PublicKeyed<EcdsaPublicKey<NistP256>> for P256Signer<S>
64+
impl<S> PublicKeyed<PublicKey<NistP256>> for P256Signer<S>
6565
where
66-
S: EcdsaSignature + Send + Sync,
66+
S: Signature + Send + Sync,
6767
{
68-
fn public_key(&self) -> Result<EcdsaPublicKey<NistP256>, Error> {
68+
fn public_key(&self) -> Result<PublicKey<NistP256>, Error> {
6969
Ok(self.public_key.clone())
7070
}
7171
}
@@ -84,10 +84,10 @@ impl Sha256Signer<FixedSignature<NistP256>> for P256Signer<FixedSignature<NistP2
8484

8585
/// NIST P-256 ECDSA verifier
8686
#[derive(Clone, Debug, Eq, PartialEq)]
87-
pub struct P256Verifier(EcdsaPublicKey<NistP256>);
87+
pub struct P256Verifier(PublicKey<NistP256>);
8888

89-
impl<'a> From<&'a EcdsaPublicKey<NistP256>> for P256Verifier {
90-
fn from(public_key: &'a EcdsaPublicKey<NistP256>) -> Self {
89+
impl<'a> From<&'a PublicKey<NistP256>> for P256Verifier {
90+
fn from(public_key: &'a PublicKey<NistP256>) -> Self {
9191
P256Verifier(public_key.clone())
9292
}
9393
}

‎providers/signatory-ring/src/ecdsa/p384.rs

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ use ring::{rand::SystemRandom, signature::ECDSAKeyPair};
1313
use signatory::encoding::pkcs8::{self, GeneratePkcs8};
1414
use signatory::{
1515
curve::nistp384::NistP384,
16-
ecdsa::{Asn1Signature, EcdsaPublicKey, EcdsaSignature, FixedSignature},
16+
ecdsa::{Asn1Signature, FixedSignature, PublicKey, Signature},
1717
encoding::FromPkcs8,
1818
error::{Error, ErrorKind::SignatureInvalid},
1919
PublicKeyed, Sha384Signer, Sha384Verifier,
@@ -61,12 +61,12 @@ impl GeneratePkcs8 for P384Signer<FixedSignature<NistP384>> {
6161
}
6262
}
6363

64-
impl<S> PublicKeyed<EcdsaPublicKey<NistP384>> for P384Signer<S>
64+
impl<S> PublicKeyed<PublicKey<NistP384>> for P384Signer<S>
6565
where
66-
S: EcdsaSignature + Send + Sync,
66+
S: Signature + Send + Sync,
6767
{
6868
/// Obtain the public key which identifies this signer
69-
fn public_key(&self) -> Result<EcdsaPublicKey<NistP384>, Error> {
69+
fn public_key(&self) -> Result<PublicKey<NistP384>, Error> {
7070
Ok(self.public_key.clone())
7171
}
7272
}
@@ -85,10 +85,10 @@ impl Sha384Signer<FixedSignature<NistP384>> for P384Signer<FixedSignature<NistP3
8585

8686
/// NIST P-384 ECDSA verifier
8787
#[derive(Clone, Debug, Eq, PartialEq)]
88-
pub struct P384Verifier(EcdsaPublicKey<NistP384>);
88+
pub struct P384Verifier(PublicKey<NistP384>);
8989

90-
impl<'a> From<&'a EcdsaPublicKey<NistP384>> for P384Verifier {
91-
fn from(public_key: &'a EcdsaPublicKey<NistP384>) -> Self {
90+
impl<'a> From<&'a PublicKey<NistP384>> for P384Verifier {
91+
fn from(public_key: &'a PublicKey<NistP384>) -> Self {
9292
P384Verifier(public_key.clone())
9393
}
9494
}

‎providers/signatory-ring/src/ecdsa/signer.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -8,21 +8,21 @@ use ring::{
88
};
99
use signatory::{
1010
curve::WeierstrassCurve,
11-
ecdsa::{EcdsaPublicKey, EcdsaSignature},
11+
ecdsa::{PublicKey, Signature},
1212
error::{Error, ErrorKind},
1313
generic_array::{typenum::Unsigned, GenericArray},
1414
};
1515
use untrusted;
1616

1717
/// Generic ECDSA signer which is wrapped with curve and signature-specific types
18-
pub struct EcdsaSigner<C: WeierstrassCurve, S: EcdsaSignature> {
18+
pub struct EcdsaSigner<C: WeierstrassCurve, S: Signature> {
1919
/// *ring* ECDSA keypair
2020
keypair: KeyPair,
2121

2222
/// ECDSA public key for this signer
2323
// *ring* does not presently keep a copy of this.
2424
// See https://github.com/briansmith/ring/issues/672#issuecomment-404669397
25-
pub(super) public_key: EcdsaPublicKey<C>,
25+
pub(super) public_key: PublicKey<C>,
2626

2727
/// Cryptographically secure random number generator
2828
csrng: SystemRandom,
@@ -34,7 +34,7 @@ pub struct EcdsaSigner<C: WeierstrassCurve, S: EcdsaSignature> {
3434
impl<C, S> EcdsaSigner<C, S>
3535
where
3636
C: WeierstrassCurve,
37-
S: EcdsaSignature,
37+
S: Signature,
3838
{
3939
/// Create an ECDSA signer and public key from a PKCS#8
4040
pub(super) fn new(alg: &'static SigningAlgorithm, pkcs8_bytes: &[u8]) -> Result<Self, Error> {
@@ -48,7 +48,7 @@ where
4848
.checked_sub(<C as WeierstrassCurve>::UntaggedPointSize::to_usize())
4949
.unwrap();
5050

51-
let public_key = EcdsaPublicKey::from_untagged_point(&GenericArray::from_slice(
51+
let public_key = PublicKey::from_untagged_point(&GenericArray::from_slice(
5252
&pkcs8_bytes[pubkey_bytes_pos..],
5353
));
5454

0 commit comments

Comments
 (0)