Radmap#3

src/backend.rs

@@ -139,33 +139,29 @@ impl Backend {
         let kind = Some(CRYPTO_KIND_VLD0);
 
         let dht_record = routing_context.create_dht_record(schema, kind).await?;
-        let record_key = dht_record.key().clone();
         let keypair = vld0_generate_keypair();
         let crypto_system = CryptoSystemVLD0::new(veilid.crypto()?);
 
         let encryption_key = crypto_system.random_shared_secret();
 
         let group = Group::new(
-            keypair.key.clone(),
-            record_key,
             dht_record,
             encryption_key,
-            Some(CryptoTyped::new(CRYPTO_KIND_VLD0, keypair.secret)),
             Arc::new(routing_context),
             crypto_system,
         );
 
         let protected_store = veilid.protected_store().unwrap();
         CommonKeypair {
-            public_key: group.get_id(),
+            public_key: group.id(),
             secret_key: group.get_secret_key(),
             encryption_key: group.get_encryption_key(),
         }
-        .store_keypair(&protected_store, &record_key.value)
+        .store_keypair(&protected_store, &group.id())
         .await
         .map_err(|e| anyhow!(e))?;
 
-        self.groups.insert(record_key.value, Box::new(group.clone()));
+        self.groups.insert(group.id(), Box::new(group.clone()));
 
         Ok(group)
     }
@@ -200,18 +196,13 @@ impl Backend {
 
 
         let group = Group {
-            id: retrieved_keypair.public_key.clone(),  
-            record_key, 
-            dht_record,
+            dht_record: dht_record.clone(),
             encryption_key: retrieved_keypair.encryption_key.clone(),
-            secret_key: retrieved_keypair
-                .secret_key
-                .map(|sk| CryptoTyped::new(CRYPTO_KIND_VLD0, sk)),
             routing_context: Arc::new(routing_context),
             crypto_system,
             repos: Vec::new(),
         };
-        self.groups.insert(record_key.value, Box::new(group.clone()));
+        self.groups.insert(group.id(), Box::new(group.clone()));
 
         Ok(Box::new(group))
     }

src/group.rs

@@ -10,38 +10,40 @@ use crate::repo::Repo;
 
 #[derive(Clone)]
 pub struct Group {
-    pub id: CryptoKey,
-    pub record_key: TypedKey,
     pub dht_record: DHTRecordDescriptor,
     pub encryption_key: SharedSecret,
-    pub secret_key: Option<CryptoTyped<CryptoKey>>,
     pub routing_context: Arc<RoutingContext>,
     pub crypto_system: CryptoSystemVLD0,
     pub repos: Vec<Repo>,
 }
 
 impl Group {
     pub fn new(
-        id: CryptoKey,
-        record_key: TypedKey,
         dht_record: DHTRecordDescriptor,
         encryption_key: SharedSecret,
-        secret_key: Option<CryptoTyped<CryptoKey>>,
         routing_context: Arc<RoutingContext>,
         crypto_system: CryptoSystemVLD0,
     ) -> Self {
         Self {
-            id,
-            record_key,
             dht_record,
             encryption_key,
-            secret_key,
             routing_context,
             crypto_system,
             repos: Vec::new(), 
         }
     }
 
+    pub fn id(&self) -> CryptoKey {
+        self.dht_record.key().value.clone()
+    }
+
+    pub fn owner_key(&self) -> CryptoKey {
+        self.dht_record.owner().clone()
+    }
+
+    pub fn owner_secret(&self) -> Option<CryptoKey> {
+        self.dht_record.owner_secret().cloned()
+    }
 
     pub async fn add_repo(&mut self, repo: Repo) -> Result<()> {
         self.repos.push(repo);
@@ -63,7 +65,7 @@ impl Group {
 
 impl DHTEntity for Group {
     fn get_id(&self) -> CryptoKey {
-        self.id.clone()
+        self.id().clone()
     }
 
     fn get_encryption_key(&self) -> SharedSecret {
@@ -83,6 +85,6 @@ impl DHTEntity for Group {
     }
 
     fn get_secret_key(&self) -> Option<CryptoKey> {
-        self.secret_key.clone().map(|key| key.value)
+        self.owner_secret()
     }
 }

src/lib.rs

@@ -8,7 +8,9 @@ use crate::constants::{GROUP_NOT_FOUND, UNABLE_TO_SET_GROUP_NAME, UNABLE_TO_GET_
 
 use crate::backend::Backend;
 use crate::common::{CommonKeypair, DHTEntity};
-use veilid_core::vld0_generate_keypair;
+use veilid_core::{
+    vld0_generate_keypair, TypedKey, CRYPTO_KIND_VLD0
+};
 
 #[cfg(test)]
 mod tests {
@@ -28,36 +30,33 @@ mod tests {
         backend.start().await.expect("Unable to start");
         let group = backend.create_group().await.expect("Unable to create group");
 
-        let group_key = group.get_id();  
-        let record_key = group.record_key.clone();
-
         group.set_name(TEST_GROUP_NAME).await.expect(UNABLE_TO_SET_GROUP_NAME);
         let name = group.get_name().await.expect(UNABLE_TO_GET_GROUP_NAME);
         assert_eq!(name, TEST_GROUP_NAME);
 
         backend.stop().await.expect("Unable to stop");
 
         backend.start().await.expect("Unable to restart");
-        let loaded_group = backend.get_group(record_key.clone()).await.expect(GROUP_NOT_FOUND);
+        let loaded_group = backend.get_group(TypedKey::new(CRYPTO_KIND_VLD0, group.id())).await.expect(GROUP_NOT_FOUND);
 
         let protected_store = backend.get_protected_store().unwrap();
-        let keypair_data = protected_store.load_user_secret(record_key.value.to_string())
+        let keypair_data = protected_store.load_user_secret(group.id().to_string())
             .await
             .expect(FAILED_TO_LOAD_KEYPAIR)
             .expect(KEYPAIR_NOT_FOUND);
         let retrieved_keypair: CommonKeypair = serde_cbor::from_slice(&keypair_data).expect(FAILED_TO_DESERIALIZE_KEYPAIR);
 
-        assert_eq!(retrieved_keypair.public_key, group.get_id());
+        assert_eq!(retrieved_keypair.public_key, group.id());
         assert_eq!(retrieved_keypair.secret_key, group.get_secret_key());
         assert_eq!(retrieved_keypair.encryption_key, group.get_encryption_key());
 
-        let mut loaded_group = backend.get_group(record_key.clone()).await.expect(GROUP_NOT_FOUND);
+        let mut loaded_group = backend.get_group(TypedKey::new(CRYPTO_KIND_VLD0, group.id())).await.expect(GROUP_NOT_FOUND);
 
         // Check if we can get group name
         let group_name = loaded_group.get_name().await.expect(UNABLE_TO_GET_GROUP_NAME);
         assert_eq!(group_name, TEST_GROUP_NAME);
 
-        assert_eq!(loaded_group.get_id(), retrieved_keypair.public_key);
+        assert_eq!(loaded_group.id(), retrieved_keypair.public_key);
 
         // Create a repo
         let repo = backend.create_repo().await.expect("Unable to create repo");

src/main.rs

@@ -53,8 +53,7 @@ async fn main() -> anyhow::Result<()> {
         println!("Provided Encryption Key: {:?}", enckey);
     } else {
         let group = backend.create_group().await?;
-        println!("Group created with Public Key: {:?}", group.get_id());
-        println!("Group created with Record Key: {:?}", group.record_key);
+        println!("Group created with Record Key: {:?}", group.id());
         println!("Group created with Secret Key: {:?}", group.get_secret_key().unwrap());
         println!("Group created with Encryption Key: {:?}", group.get_encryption_key());
     }