Rename SecretKey to PrivateKey throughout identity.rs code base. (#409)

* Rename SecretKey to PrivateKey throughout identity.rs codebase.

* Fix formatting issues.

* Resolve cycraig review (more secret->private renamings)

bindings/wasm/examples/src/create_vc.js

@@ -45,7 +45,7 @@ async function createVC(clientConfig) {
     const signedVc = issuer.doc.signCredential(unsignedVc, {
         method: issuer.doc.id.toString() + "#newKey",
         public: issuer.newKey.public,
-        secret: issuer.newKey.secret,
+        private: issuer.newKey.private,
     });
 
     // Check if the credential is verifiable.

bindings/wasm/examples/src/create_vp.js

@@ -27,7 +27,7 @@ async function createVP(clientConfig) {
 
     const signedVp = alice.doc.signPresentation(unsignedVp, {
         method: "#key",
-        secret: alice.key.secret,
+        private: alice.key.private,
     })
 
     // Check the validation status of the Verifiable Presentation

bindings/wasm/examples/src/merkle_key.js

@@ -70,7 +70,7 @@ async function merkleKey(clientConfig) {
     const signedVc = issuer.doc.signCredential(unsignedVc, {
         method: method.id.toString(),
         public: keys.public(0),
-        secret: keys.secret(0),
+        private: keys.private(0),
         proof: keys.merkleProof(Digest.Sha256, 0)
     });
 

bindings/wasm/src/crypto/key_collection.rs

@@ -7,8 +7,8 @@ use identity::crypto::merkle_key::Blake2b256;
 use identity::crypto::merkle_key::Sha256;
 use identity::crypto::merkle_tree::Proof;
 use identity::crypto::KeyCollection as KeyCollection_;
+use identity::crypto::PrivateKey;
 use identity::crypto::PublicKey;
-use identity::crypto::SecretKey;
 use wasm_bindgen::prelude::*;
 
 use crate::crypto::Digest;
@@ -26,7 +26,7 @@ struct JsonData {
 #[derive(Deserialize, Serialize)]
 struct KeyData {
   public: String,
-  secret: String,
+  private: String,
 }
 
 // =============================================================================
@@ -68,10 +68,10 @@ impl KeyCollection {
     self.0.public(index).map(encode_b58)
   }
 
-  /// Returns the secret key at the specified `index` as a base58-encoded string.
+  /// Returns the private key at the specified `index` as a base58-encoded string.
   #[wasm_bindgen]
-  pub fn secret(&self, index: usize) -> Option<String> {
-    self.0.secret(index).map(encode_b58)
+  pub fn private(&self, index: usize) -> Option<String> {
+    self.0.private(index).map(encode_b58)
   }
 
   #[wasm_bindgen(js_name = merkleRoot)]
@@ -108,13 +108,13 @@ impl KeyCollection {
   #[wasm_bindgen(js_name = toJSON)]
   pub fn to_json(&self) -> Result<JsValue, JsValue> {
     let public: _ = self.0.iter_public();
-    let secret: _ = self.0.iter_secret();
+    let private: _ = self.0.iter_private();
 
     let keys: Vec<KeyData> = public
-      .zip(secret)
-      .map(|(public, secret)| KeyData {
+      .zip(private)
+      .map(|(public, private)| KeyData {
         public: encode_b58(public),
-        secret: encode_b58(secret),
+        private: encode_b58(private),
       })
       .collect();
 
@@ -132,10 +132,10 @@ impl KeyCollection {
     let data: JsonData = json.into_serde().map_err(wasm_error)?;
 
     let iter: _ = data.keys.iter().flat_map(|data| {
-      let pk: PublicKey = decode_b58(&data.public).ok()?.into();
-      let sk: SecretKey = decode_b58(&data.secret).ok()?.into();
+      let public_key: PublicKey = decode_b58(&data.public).ok()?.into();
+      let private_key: PrivateKey = decode_b58(&data.private).ok()?.into();
 
-      Some((pk, sk))
+      Some((public_key, private_key))
     });
 
     KeyCollection_::from_iterator(data.type_.into(), iter)

bindings/wasm/src/crypto/key_pair.rs

@@ -4,8 +4,8 @@
 use identity::core::decode_b58;
 use identity::core::encode_b58;
 use identity::crypto::KeyPair as KeyPair_;
+use identity::crypto::PrivateKey;
 use identity::crypto::PublicKey;
-use identity::crypto::SecretKey;
 use wasm_bindgen::prelude::*;
 
 use crate::crypto::KeyType;
@@ -16,7 +16,7 @@ struct JsonData {
   #[serde(rename = "type")]
   type_: KeyType,
   public: String,
-  secret: String,
+  private: String,
 }
 
 // =============================================================================
@@ -34,13 +34,13 @@ impl KeyPair {
     KeyPair_::new(type_.into()).map_err(wasm_error).map(Self)
   }
 
-  /// Parses a `KeyPair` object from base58-encoded public/secret keys.
+  /// Parses a `KeyPair` object from base58-encoded public/private keys.
   #[wasm_bindgen(js_name = fromBase58)]
-  pub fn from_base58(type_: KeyType, public_key: &str, secret_key: &str) -> Result<KeyPair, JsValue> {
+  pub fn from_base58(type_: KeyType, public_key: &str, private_key: &str) -> Result<KeyPair, JsValue> {
     let public: PublicKey = decode_b58(public_key).map_err(wasm_error)?.into();
-    let secret: SecretKey = decode_b58(secret_key).map_err(wasm_error)?.into();
+    let private: PrivateKey = decode_b58(private_key).map_err(wasm_error)?.into();
 
-    Ok(Self((type_.into(), public, secret).into()))
+    Ok(Self((type_.into(), public, private).into()))
   }
 
   /// Returns the public key as a base58-encoded string.
@@ -49,10 +49,10 @@ impl KeyPair {
     encode_b58(self.0.public())
   }
 
-  /// Returns the secret key as a base58-encoded string.
+  /// Returns the private key as a base58-encoded string.
   #[wasm_bindgen(getter)]
-  pub fn secret(&self) -> String {
-    encode_b58(self.0.secret())
+  pub fn private(&self) -> String {
+    encode_b58(self.0.private())
   }
 
   /// Serializes a `KeyPair` object as a JSON object.
@@ -61,7 +61,7 @@ impl KeyPair {
     let data: JsonData = JsonData {
       type_: self.0.type_().into(),
       public: self.public(),
-      secret: self.secret(),
+      private: self.private(),
     };
 
     JsValue::from_serde(&data).map_err(wasm_error)
@@ -72,6 +72,6 @@ impl KeyPair {
   pub fn from_json(json: &JsValue) -> Result<KeyPair, JsValue> {
     let data: JsonData = json.into_serde().map_err(wasm_error)?;
 
-    Self::from_base58(data.type_, &data.public, &data.secret)
+    Self::from_base58(data.type_, &data.public, &data.private)
   }
 }

bindings/wasm/src/did/wasm_document.rs

@@ -8,8 +8,8 @@ use identity::crypto::merkle_key::MerkleDigestTag;
 use identity::crypto::merkle_key::MerkleKey;
 use identity::crypto::merkle_key::Sha256;
 use identity::crypto::merkle_tree::Proof;
+use identity::crypto::PrivateKey;
 use identity::crypto::PublicKey;
-use identity::crypto::SecretKey;
 use identity::did::verifiable;
 use identity::did::MethodScope;
 use identity::iota::Error;
@@ -209,7 +209,7 @@ impl WasmDocument {
   /// Signs the DID Document with the default authentication method.
   #[wasm_bindgen]
   pub fn sign(&mut self, key: &KeyPair) -> Result<()> {
-    self.0.sign(key.0.secret()).wasm_result()
+    self.0.sign(key.0.private()).wasm_result()
   }
 
   /// Verify the signature with the authentication_key
@@ -247,12 +247,12 @@ impl WasmDocument {
       MerkleKey {
         method: String,
         public: String,
-        secret: String,
+        private: String,
         proof: String,
       },
       Default {
         method: String,
-        secret: String,
+        private: String,
       },
     }
 
@@ -263,7 +263,7 @@ impl WasmDocument {
       Args::MerkleKey {
         method,
         public,
-        secret,
+        private,
         proof,
       } => {
         let merkle_key: Vec<u8> = self
@@ -273,12 +273,12 @@ impl WasmDocument {
           .wasm_result()?;
 
         let public: PublicKey = decode_b58(&public).map(Into::into).wasm_result()?;
-        let secret: SecretKey = decode_b58(&secret).map(Into::into).wasm_result()?;
+        let private: PrivateKey = decode_b58(&private).map(Into::into).wasm_result()?;
 
         let digest: MerkleDigestTag = MerkleKey::extract_tags(&merkle_key).wasm_result()?.1;
         let proof: Vec<u8> = decode_b58(&proof).wasm_result()?;
 
-        let signer: _ = self.0.signer(&secret).method(&method);
+        let signer: _ = self.0.signer(&private).method(&method);
 
         match digest {
           MerkleDigestTag::SHA256 => match Proof::<Sha256>::decode(&proof) {
@@ -288,10 +288,10 @@ impl WasmDocument {
           _ => return Err("Invalid Merkle Key Digest".into()),
         }
       }
-      Args::Default { method, secret } => {
-        let secret: SecretKey = decode_b58(&secret).wasm_result().map(Into::into)?;
+      Args::Default { method, private } => {
+        let private: PrivateKey = decode_b58(&private).wasm_result().map(Into::into)?;
 
-        self.0.signer(&secret).method(&method).sign(&mut data).wasm_result()?;
+        self.0.signer(&private).method(&method).sign(&mut data).wasm_result()?;
       }
     }
 
@@ -332,7 +332,7 @@ impl WasmDocument {
   pub fn diff(&self, other: &WasmDocument, message: &str, key: &KeyPair) -> Result<WasmDocumentDiff> {
     self
       .0
-      .diff(&other.0, MessageId::from_str(message).wasm_result()?, key.0.secret())
+      .diff(&other.0, MessageId::from_str(message).wasm_result()?, key.0.private())
       .map(WasmDocumentDiff::from)
       .wasm_result()
   }

bindings/wasm/tests/wasm.rs

@@ -15,9 +15,9 @@ use std::borrow::Cow;
 #[wasm_bindgen_test]
 fn test_keypair() {
   let key1 = KeyPair::new(KeyType::Ed25519).unwrap();
-  let pk = key1.public();
-  let sk = key1.secret();
-  let key2 = KeyPair::from_base58(KeyType::Ed25519, &pk, &sk).unwrap();
+  let public_key = key1.public();
+  let private_key = key1.private();
+  let key2 = KeyPair::from_base58(KeyType::Ed25519, &public_key, &private_key).unwrap();
 
   let json1 = key1.to_json().unwrap();
   let json2 = key2.to_json().unwrap();
@@ -26,10 +26,10 @@ fn test_keypair() {
   let from2 = KeyPair::from_json(&json2).unwrap();
 
   assert_eq!(from1.public(), key1.public());
-  assert_eq!(from1.secret(), key1.secret());
+  assert_eq!(from1.private(), key1.private());
 
   assert_eq!(from2.public(), key2.public());
-  assert_eq!(from2.secret(), key2.secret());
+  assert_eq!(from2.private(), key2.private());
 }
 
 #[wasm_bindgen_test]
@@ -44,7 +44,7 @@ fn test_key_collection() {
     let key = keys.keypair(index).unwrap();
 
     assert_eq!(key.public(), keys.public(index).unwrap());
-    assert_eq!(key.secret(), keys.secret(index).unwrap());
+    assert_eq!(key.private(), keys.private(index).unwrap());
 
     assert!(keys.merkle_proof(Digest::Sha256, index).is_some());
   }
@@ -57,7 +57,7 @@ fn test_key_collection() {
 
   for index in 0..keys.length() {
     assert_eq!(keys.public(index).unwrap(), from.public(index).unwrap());
-    assert_eq!(keys.secret(index).unwrap(), from.secret(index).unwrap());
+    assert_eq!(keys.private(index).unwrap(), from.private(index).unwrap());
   }
 }
 

examples/low-level-api/common.rs

@@ -76,7 +76,7 @@ pub async fn add_new_key(
   // Prepare the update
   updated_doc.set_previous_message_id(*receipt.message_id());
   updated_doc.set_updated(Timestamp::now_utc());
-  updated_doc.sign(key.secret())?;
+  updated_doc.sign(key.private())?;
 
   // Publish the update to the Tangle
   let update_receipt: Receipt = client.publish_document(&updated_doc).await?;

examples/low-level-api/create_did.rs

@@ -21,7 +21,7 @@ pub async fn run() -> Result<(IotaDocument, KeyPair, Receipt)> {
   let mut document: IotaDocument = IotaDocument::from_keypair(&keypair)?;
 
   // Sign the DID Document with the default authentication key.
-  document.sign(keypair.secret())?;
+  document.sign(keypair.private())?;
 
   println!("DID Document JSON > {:#}", document);
 

examples/low-level-api/create_vc.rs

@@ -29,8 +29,8 @@ pub async fn create_vc() -> Result<()> {
   // Create an unsigned Credential with claims about `subject` specified by `issuer`.
   let mut credential: Credential = common::issue_degree(&issuer_doc, &subject_doc)?;
 
-  // Sign the Credential with the issuer's secret key
-  issuer_doc.sign_data(&mut credential, issuer_key.secret())?;
+  // Sign the Credential with the issuer's private key.
+  issuer_doc.sign_data(&mut credential, issuer_key.private())?;
 
   println!("Credential JSON > {:#}", credential);
 

examples/low-level-api/create_vp.rs

@@ -30,8 +30,8 @@ pub async fn create_vp() -> Result<Presentation> {
   // Create an unsigned Credential with claims about `subject` specified by `issuer`.
   let mut credential: Credential = common::issue_degree(&doc_iss, &doc_sub)?;
 
-  // Sign the Credential with the issuers secret key
-  doc_iss.sign_data(&mut credential, key_iss.secret())?;
+  // Sign the Credential with the issuers private key.
+  doc_iss.sign_data(&mut credential, key_iss.private())?;
 
   // Create an unsigned Presentation from the previously issued Verifiable Credential.
   let mut presentation: Presentation = PresentationBuilder::default()
@@ -40,8 +40,8 @@ pub async fn create_vp() -> Result<Presentation> {
     .credential(credential)
     .build()?;
 
-  // Sign the presentation with the holders secret key
-  doc_sub.sign_data(&mut presentation, key_sub.secret())?;
+  // Sign the presentation with the holders private key.
+  doc_sub.sign_data(&mut presentation, key_sub.private())?;
 
   Ok(presentation)
 }

examples/low-level-api/diff_chain.rs

@@ -38,7 +38,7 @@ async fn main() -> Result<()> {
   };
 
   // Generate a signed diff object.
-  let diff: DocumentDiff = document.diff(&updated_document, *receipt.message_id(), keypair.secret())?;
+  let diff: DocumentDiff = document.diff(&updated_document, *receipt.message_id(), keypair.private())?;
 
   println!("Diff > {:#?}", diff);
 

examples/low-level-api/manipulate_did.rs

@@ -44,7 +44,7 @@ pub async fn run() -> Result<(IotaDocument, KeyPair, KeyPair, Receipt, Receipt)>
   document.set_updated(Timestamp::now_utc());
 
   // Sign the DID Document with the original private key.
-  document.sign(keypair.secret())?;
+  document.sign(keypair.private())?;
 
   // Publish the updated DID Document to the Tangle.
   let update_receipt: Receipt = client.publish_document(&document).await?;

examples/low-level-api/merkle_key.rs

@@ -13,8 +13,8 @@ use identity::credential::Credential;
 use identity::crypto::merkle_key::Sha256;
 use identity::crypto::merkle_tree::Proof;
 use identity::crypto::KeyCollection;
+use identity::crypto::PrivateKey;
 use identity::crypto::PublicKey;
-use identity::crypto::SecretKey;
 use identity::did::MethodScope;
 use identity::iota::ClientMap;
 use identity::iota::CredentialValidation;
@@ -46,7 +46,7 @@ async fn main() -> Result<()> {
   // Add to the DID Document as a general-purpose verification method
   issuer_doc.insert_method(MethodScope::VerificationMethod, method);
   issuer_doc.set_previous_message_id(*issuer_receipt.message_id());
-  issuer_doc.sign(issuer_key.secret())?;
+  issuer_doc.sign(issuer_key.private())?;
 
   // Publish the Identity to the IOTA Network and log the results.
   // This may take a few seconds to complete proof-of-work.
@@ -60,14 +60,14 @@ async fn main() -> Result<()> {
   let index: usize = OsRng.gen_range(0..keys.len());
 
   let public: &PublicKey = keys.public(index).unwrap();
-  let secret: &SecretKey = keys.secret(index).unwrap();
+  let private: &PrivateKey = keys.private(index).unwrap();
 
   // Generate an inclusion proof for the selected key
   let proof: Proof<Sha256> = keys.merkle_proof(index).unwrap();
 
-  // Sign the Credential with the issuers secret key
+  // Sign the Credential with the issuers private key
   issuer_doc
-    .signer(secret)
+    .signer(private)
     .method("merkle-key")
     .merkle_key((public, &proof))
     .sign(&mut credential)?;
@@ -89,7 +89,7 @@ async fn main() -> Result<()> {
     .and_then(IotaVerificationMethod::try_from_mut)?
     .revoke_merkle_key(index)?;
   issuer_doc.set_previous_message_id(*receipt.message_id());
-  issuer_doc.sign(issuer_key.secret())?;
+  issuer_doc.sign(issuer_key.private())?;
 
   let receipt: Receipt = client.publish_document(&issuer_doc).await?;