update README

README.md

@@ -1,6 +1,6 @@
 # cobox-crypto
 
-The crypto primitives used in cobox, extracted into a separate module
+Crypto primitives used in cobox
 
 ```
 npm install cobox-crypto
@@ -9,22 +9,25 @@ npm install cobox-crypto
 ## Usage
 
 ```
-const Crypto = require('cobox-crypto')
-const crypto = Crypto()
-
-const accessKey = crypto.accessKey()
+const crypto = require('cobox-crypto')
 ```
 
 ## API
 
 ```js
-keyPair = crypto.keyPair()
+const address = crypto.address()
+```
+
+Returns a `ed25519` random 32 byte buffer
+
+```js
+const keyPair = crypto.keyPair()
 ```
 
 Returns an `ed25519` keypair that can used for tree signing.
 
 ```js
-const symKey = crypto.symmetricKey()
+const encKey = crypto.encryptionKey()
 ```
 
 Returns an `ed25519` symmetric key used for shared secret encryption
@@ -34,53 +37,37 @@ const accessKey = crypto.accessKey()
 
 // OR
 
-const accessKey = crypto.pack(pubKey, symKey)
+const accessKey = crypto.pack(address, encKey)
 ```
 
-Returns an access key, which consists of an `ed25519` public key, packed together with an `ed25519` symmetric key
+Returns an access key, which consists of an `ed25519` address, packed together with an `ed25519` symmetric key
 
 ```js
 const keys = crypto.unpack(key)
 ```
 
-Returns an object containing a public key, and a shared secret if accessible. Public key alone is used for blind replication. The shared secret can then be used for decryption.
+Returns an object containing an address, and a shared secret if accessible. Address alone is used for blind replication. The shared secret can then be used for decryption.
 
 ```js
-const valueEncoding = crypto.encoder(encryptionKey, {})
+const { publicKey, secretKey } = crypto.boxKeyPair(seed)
 ```
 
-Returns a message encoder used for encrypting messages in hypercore. Can be passed to hypercore doing the following:
+Returns an `ed25519` private box keypair used for identification, message signing and encryption
 
 ```js
-const accessKey = crypto.accessKey
-const keys = crypto.unpack(accessKey)
-var feed = hypercore(storage, keys.publicKey, {
-  valueEncoding: crypto.encoder(keys.symmetricKey, { valueEncoding: 'utf-8' })
-})
-
-feed.ready(() => {
-  feed.append("this is going to be encrypted", (err, seq) => {
-    // do other stuff...
-  })
-})
+const boxed = box(publicKey, message, [context])
 ```
 
-```js
-const { publicKey, secretKey } = boxKeypair(seed)
-```
-
-```js
-const boxed = box(publicKey, message, [contextMessage])
-```
 Encrypts a message to a given public key and returns it as a buffer
 - `publicKey` buffer or hex encoded string
 - `message` buffer or hex encoded string of any length
-- `contextMessage`, if passed, will be hashed in to the shared secret. Should be a buffer or hex encoded string.
+- `context`, if passed, will be hashed in to the shared secret. Should be a buffer or hex encoded string.
 
 ```js
-const unboxed = unbox(cipherText, keypair, [contextMessage])
+const unboxed = unbox(cipherText, keypair, [context])
 ```
+
 Decrypts a message using the given keypair.
 - `cipherText` the encrypted message given as a buffer.
 - `keypair` an object of the form `{ publicKey, secretKey }` both of which should be buffers or hex encoded strings.
-- `contextMessage`, if given, will be hashed into the shared secret. Should be a buffer or hex encoded string.
+- `context`, if given, will be hashed into the shared secret. Should be a buffer or hex encoded string.