From cb18af7c1b18b9b4e2f60b196d431adbbd8e923d Mon Sep 17 00:00:00 2001
From: DebugSteven <debugsteven@gmail.com>
Date: Sat, 10 Nov 2018 16:17:19 -0500
Subject: [PATCH] update readme & fix benches

---
 README.md         | 21 ++++++++++-----------
 benches/x25519.rs | 15 ++++++++-------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/README.md b/README.md
index dca2a2e..cbf6a33 100644
--- a/README.md
+++ b/README.md
@@ -25,28 +25,27 @@ up on modern public key cryptography and have learned a nifty trick called
 kittens will be able to secretly organise to find their mittens, and then spend
 the rest of the afternoon nomming some yummy pie!
 
-First, Alice uses `x25519_dalek::generate_secret()` and then
-`x25519_dalek::generate_public()` to produce her secret and public keys:
+First, Alice uses `x25519_dalek::Ephemeral::generate_secret()` and then
+`x25519_dalek::Ephemeral::generate_public()` to produce her secret and public keys:
 
 ```rust
 extern crate x25519_dalek;
 extern crate rand;
 
-use x25519_dalek::generate_secret;
-use x25519_dalek::generate_public;
+use x25519_dalek::Ephemeral;
 use rand::OsRng;
 
 let mut alice_csprng = OsRng::new().unwrap();
-let     alice_secret = generate_secret(&mut alice_csprng);
-let     alice_public = generate_public(&alice_secret);
+let     alice_secret = Ephemeral::generate_secret(&mut alice_csprng);
+let     alice_public = Ephemeral::generate_public(&alice_secret);
 ```
 
 Bob does the same:
 
 ```rust
 let mut bob_csprng = OsRng::new().unwrap();
-let     bob_secret = generate_secret(&mut bob_csprng);
-let     bob_public = generate_public(&bob_secret);
+let     bob_secret = Ephemeral::generate_secret(&mut bob_csprng);
+let     bob_public = Ephemeral::generate_public(&bob_secret);
 ```
 
 Alice meows across the room, telling `alice_public` to Bob, and Bob
@@ -54,15 +53,15 @@ loudly meows `bob_public` back to Alice.  Alice now computes her
 shared secret with Bob by doing:
 
 ```rust
-use x25519_dalek::diffie_hellman;
+use x25519_dalek::Ephemeral;
 
-let shared_secret = diffie_hellman(&alice_secret, &bob_public.as_bytes());
+let shared_secret = Ephemeral::diffie_hellman(&alice_secret, &bob_public);
 ```
 
 Similarly, Bob computes the same shared secret by doing:
 
 ```rust
-let shared_secret = diffie_hellman(&bob_secret, &alice_public.as_bytes());
+let shared_secret = Ephemeral::diffie_hellman(&bob_secret, &alice_public);
 ```
 
 Voilá!  Alice and Bob can now use their shared secret to encrypt their
diff --git a/benches/x25519.rs b/benches/x25519.rs
index 8203785..76cc00b 100644
--- a/benches/x25519.rs
+++ b/benches/x25519.rs
@@ -11,26 +11,27 @@
 
 #[macro_use]
 extern crate criterion;
+extern crate curve25519_dalek;
 extern crate rand;
 extern crate x25519_dalek;
 
 use criterion::Criterion;
 
+use curve25519_dalek::montgomery::MontgomeryPoint;
+
 use rand::OsRng;
 
-use x25519_dalek::generate_public;
-use x25519_dalek::generate_secret;
-use x25519_dalek::diffie_hellman;
+use x25519_dalek::Ephemeral;
 
 fn bench_diffie_hellman(c: &mut Criterion) {
     let mut csprng: OsRng = OsRng::new().unwrap();
-    let alice_secret: [u8; 32] = generate_secret(&mut csprng);
-    let bob_secret: [u8; 32] = generate_secret(&mut csprng);
-    let bob_public: [u8; 32] = generate_public(&bob_secret).to_bytes();
+    let alice_secret: Ephemeral = Ephemeral::generate_secret(&mut csprng);
+    let bob_secret: Ephemeral = Ephemeral::generate_secret(&mut csprng);
+    let bob_public: MontgomeryPoint = Ephemeral::generate_public(&bob_secret);
 
     c.bench_function("diffie_hellman", move |b| {
         b.iter(||
-               diffie_hellman(&alice_secret, &bob_public)
+               Ephemeral::diffie_hellman(&alice_secret, &bob_public)
         )
     });
 }