fix tests

veilid-core/src/crypto/crypto_system.rs

@@ -20,7 +20,7 @@ pub trait CryptoSystem {
         key: &PublicKey,
         secret: &SecretKey,
     ) -> Result<SharedSecret, VeilidAPIError>;
-    fn generate_keypair(&self) -> (PublicKey, SecretKey);
+    fn generate_keypair(&self) -> KeyPair;
     fn generate_hash(&self, data: &[u8]) -> PublicKey;
     fn generate_hash_reader(
         &self,

veilid-core/src/crypto/mod.rs

@@ -117,16 +117,15 @@ impl Crypto {
         let mut cache_validity_key: Vec<u8> = Vec::new();
         {
             let c = self.unlocked_inner.config.get();
-            for ck in &VALID_CRYPTO_KINDS {
+            for ck in VALID_CRYPTO_KINDS {
                 cache_validity_key.append(
                     &mut c
                         .network
                         .routing_table
-                        .node_ids
+                        .node_id
                         .get(ck)
                         .unwrap()
-                        .node_id
-                        .unwrap()
+                        .value
                         .bytes
                         .to_vec(),
                 );
@@ -223,14 +222,14 @@ impl Crypto {
         node_ids: &[TypedKey],
         data: &[u8],
         typed_signatures: &[TypedSignature],
-    ) -> Result<Vec<CryptoKind>, VeilidAPIError> {
-        let mut out = Vec::with_capacity(node_ids.len());
+    ) -> Result<TypedKeySet, VeilidAPIError> {
+        let mut out = TypedKeySet::with_capacity(node_ids.len());
         for sig in typed_signatures {
             for nid in node_ids {
                 if nid.kind == sig.kind {
                     if let Some(vcrypto) = self.get(sig.kind) {
                         vcrypto.verify(&nid.value, data, &sig.value)?;
-                        out.push(nid.kind);
+                        out.add(*nid);
                     }
                 }
             }
@@ -260,6 +259,16 @@ impl Crypto {
         Ok(out)
     }
 
+    /// Generate keypair
+    /// Does not require startup/init
+    pub fn generate_keypair(crypto_kind: CryptoKind) -> Result<TypedKeyPair, VeilidAPIError> {
+        if crypto_kind == CRYPTO_KIND_VLD0 {
+            let kp = vld0_generate_keypair();
+            return Ok(TypedKeyPair::new(crypto_kind, kp));
+        }
+        Err(VeilidAPIError::generic("invalid crypto kind"))
+    }
+
     // Internal utilities
 
     fn cached_dh_internal<T: CryptoSystem>(

veilid-core/src/crypto/tests/test_crypto.rs

@@ -138,8 +138,8 @@ pub async fn test_no_auth(vcrypto: CryptoSystemVersion) {
 
 pub async fn test_dh(vcrypto: CryptoSystemVersion) {
     trace!("test_dh");
-    let (dht_key, dht_key_secret) = vcrypto.generate_keypair();
-    let (dht_key2, dht_key_secret2) = vcrypto.generate_keypair();
+    let (dht_key, dht_key_secret) = vcrypto.generate_keypair().into_split();
+    let (dht_key2, dht_key_secret2) = vcrypto.generate_keypair().into_split();
 
     let r1 = vcrypto.compute_dh(&dht_key, &dht_key_secret2).unwrap();
     let r2 = vcrypto.compute_dh(&dht_key2, &dht_key_secret).unwrap();

veilid-core/src/crypto/tests/test_envelope_receipt.rs

@@ -9,8 +9,8 @@ pub async fn test_envelope_round_trip(
     // Create envelope
     let ts = Timestamp::from(0x12345678ABCDEF69u64);
     let nonce = vcrypto.random_nonce();
-    let (sender_id, sender_secret) = vcrypto.generate_keypair();
-    let (recipient_id, recipient_secret) = vcrypto.generate_keypair();
+    let (sender_id, sender_secret) = vcrypto.generate_keypair().into_split();
+    let (recipient_id, recipient_secret) = vcrypto.generate_keypair().into_split();
     let envelope = Envelope::new(
         envelope_version,
         vcrypto.kind(),
@@ -66,7 +66,7 @@ pub async fn test_receipt_round_trip(
 
     // Create receipt
     let nonce = vcrypto.random_nonce();
-    let (sender_id, sender_secret) = vcrypto.generate_keypair();
+    let (sender_id, sender_secret) = vcrypto.generate_keypair().into_split();
     let receipt = Receipt::try_new(envelope_version, vcrypto.kind(), nonce, sender_id, body)
         .expect("should not fail");
 

veilid-core/src/crypto/tests/test_types.rs

@@ -10,8 +10,8 @@ static EMPTY_KEY_SECRET: [u8; SECRET_KEY_LENGTH] = [0u8; SECRET_KEY_LENGTH];
 
 pub async fn test_generate_secret(vcrypto: CryptoSystemVersion) {
     // Verify keys generate
-    let (dht_key, dht_key_secret) = vcrypto.generate_keypair();
-    let (dht_key2, dht_key_secret2) = vcrypto.generate_keypair();
+    let (dht_key, dht_key_secret) = vcrypto.generate_keypair().into_split();
+    let (dht_key2, dht_key_secret2) = vcrypto.generate_keypair().into_split();
 
     // Verify byte patterns are different between public and secret
     assert_ne!(dht_key.bytes, dht_key_secret.bytes);
@@ -24,8 +24,8 @@ pub async fn test_generate_secret(vcrypto: CryptoSystemVersion) {
 
 pub async fn test_sign_and_verify(vcrypto: CryptoSystemVersion) {
     // Make two keys
-    let (dht_key, dht_key_secret) = vcrypto.generate_keypair();
-    let (dht_key2, dht_key_secret2) = vcrypto.generate_keypair();
+    let (dht_key, dht_key_secret) = vcrypto.generate_keypair().into_split();
+    let (dht_key2, dht_key_secret2) = vcrypto.generate_keypair().into_split();
     // Sign the same message twice
     let dht_sig = vcrypto
         .sign(&dht_key, &dht_key_secret, LOREM_IPSUM.as_bytes())
@@ -133,10 +133,10 @@ pub async fn test_key_conversions(vcrypto: CryptoSystemVersion) {
     assert_eq!(dht_key_secret_string, dht_key_string);
 
     // Make different keys
-    let (dht_key2, dht_key_secret2) = vcrypto.generate_keypair();
+    let (dht_key2, dht_key_secret2) = vcrypto.generate_keypair().into_split();
     trace!("dht_key2: {:?}", dht_key2);
     trace!("dht_key_secret2: {:?}", dht_key_secret2);
-    let (dht_key3, _dht_key_secret3) = vcrypto.generate_keypair();
+    let (dht_key3, _dht_key_secret3) = vcrypto.generate_keypair().into_split();
     trace!("dht_key3: {:?}", dht_key3);
     trace!("_dht_key_secret3: {:?}", _dht_key_secret3);
 
@@ -196,7 +196,7 @@ pub async fn test_encode_decode(vcrypto: CryptoSystemVersion) {
     assert_eq!(dht_key, dht_key_b);
     assert_eq!(dht_key_secret, dht_key_secret_b);
 
-    let (dht_key2, dht_key_secret2) = vcrypto.generate_keypair();
+    let (dht_key2, dht_key_secret2) = vcrypto.generate_keypair().into_split();
 
     let e1 = dht_key.encode();
     trace!("e1:  {:?}", e1);

veilid-core/src/crypto/types/keypair.rs

@@ -24,6 +24,12 @@ impl KeyPair {
     pub fn new(key: PublicKey, secret: SecretKey) -> Self {
         Self { key, secret }
     }
+    pub fn split(&self) -> (PublicKey, SecretKey) {
+        (self.key, self.secret)
+    }
+    pub fn into_split(self) -> (PublicKey, SecretKey) {
+        (self.key, self.secret)
+    }
 }
 
 impl Encodable for KeyPair {

veilid-core/src/crypto/vld0/mod.rs

@@ -32,13 +32,13 @@ fn ed25519_to_x25519_sk(key: &ed::SecretKey) -> Result<xd::StaticSecret, VeilidA
     Ok(xd::StaticSecret::from(lowbytes))
 }
 
-pub fn vld0_generate_keypair() -> (PublicKey, SecretKey) {
+pub fn vld0_generate_keypair() -> KeyPair {
     let mut csprng = VeilidRng {};
     let keypair = ed::Keypair::generate(&mut csprng);
     let dht_key = PublicKey::new(keypair.public.to_bytes());
     let dht_key_secret = SecretKey::new(keypair.secret.to_bytes());
 
-    (dht_key, dht_key_secret)
+    KeyPair::new(dht_key, dht_key_secret)
 }
 
 /// V0 CryptoSystem
@@ -95,7 +95,7 @@ impl CryptoSystem for CryptoSystemVLD0 {
         let sk_xd = ed25519_to_x25519_sk(&sk_ed)?;
         Ok(SharedSecret::new(sk_xd.diffie_hellman(&pk_xd).to_bytes()))
     }
-    fn generate_keypair(&self) -> (PublicKey, SecretKey) {
+    fn generate_keypair(&self) -> KeyPair {
         vld0_generate_keypair()
     }
     fn generate_hash(&self, data: &[u8]) -> PublicKey {