feat: upgrade to Veilid 0.4.8 and

 veilid-iroh-blobs v0.2.0

 BREAKING CHANGE: Upgrade to Veilid 0.4.8 with breaking
 API changes

 - Upgrade veilid-core to v0.4.8
 - Update veilid-iroh-blobs dependency to v0.2.0 (git
 tag)
 - Update all source files for Veilid 0.4.8 API
 compatibility
 - Fix breaking changes (VeilidConfigInner →
 VeilidConfig, CryptoKey → RouteId)
 - Switch from path dependency to git tag for
 veilid-iroh-blobs

 Dependencies:
 - veilid-core: v0.4.8
 - veilid-iroh-blobs: v0.2.0

 Version: 0.2.0

Author: tripledoublev

Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "save-dweb-backend"
-version = "0.1.3"
+version = "0.2.0"
 edition = "2021"
 
 [dependencies]
 iroh = "0.24.0"
 iroh-blobs = "0.24.0"
-veilid-core = { git = "https://gitlab.com/veilid/veilid.git", version = "0.4.3" }
-veilid-iroh-blobs = { git = "https://github.com/RangerMauve/veilid-iroh-blobs.git", version = "0.1.1" }
+veilid-core = { git = "https://gitlab.com/veilid/veilid.git", tag = "v0.4.8" }
+veilid-iroh-blobs = { git = "https://github.com/RangerMauve/veilid-iroh-blobs.git", tag = "v0.2.0" }
 tracing = "0.1"
 xdg = "2.4"
 tmpdir = "1"

src/backend.rs

@@ -25,9 +25,9 @@ use tokio::sync::{
 use tracing::info;
 use url::Url;
 use veilid_core::{
-    api_startup_config, vld0_generate_keypair, CryptoKey, CryptoSystem, CryptoSystemVLD0,
-    CryptoTyped, DHTSchema, KeyPair, ProtectedStore, RoutingContext, SharedSecret, TypedKey,
-    UpdateCallback, VeilidAPI, VeilidConfigInner, VeilidConfigProtectedStore, VeilidUpdate,
+    api_startup_config, PublicKey, SecretKey, RecordKey, CryptoSystem,
+    CryptoTyped, DHTSchema, KeyPair, ProtectedStore, RoutingContext, SharedSecret, TypedRecordKey,
+    UpdateCallback, VeilidAPI, VeilidConfig, VeilidConfigProtectedStore, VeilidUpdate,
     CRYPTO_KEY_LENGTH, CRYPTO_KIND_VLD0,
 };
 use veilid_iroh_blobs::iroh::VeilidIrohBlobs;
@@ -36,14 +36,14 @@ use xdg::BaseDirectories;
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct KnownGroupList {
-    groups: Vec<CryptoKey>,
+    groups: Vec<RecordKey>,
 }
 
 pub struct BackendInner {
     path: PathBuf,
     veilid_api: Option<VeilidAPI>,
     update_rx: Option<broadcast::Receiver<VeilidUpdate>>,
-    groups: HashMap<CryptoKey, Box<Group>>,
+    groups: HashMap<RecordKey, Box<Group>>,
     pub iroh_blobs: Option<VeilidIrohBlobs>,
     on_new_route_callback: Option<OnNewRouteCallback>,
 }
@@ -54,7 +54,7 @@ impl BackendInner {
 
         let info = KnownGroupList { groups };
 
-        println!("Saving group IDs {:?}", info);
+        println!("Saving group IDs {info:?}");
         let data =
             serde_cbor::to_vec(&info).map_err(|e| anyhow!("Failed to serialize keypair: {}", e))?;
         self.veilid()?
@@ -160,16 +160,17 @@ impl Backend {
         let mut inner = backend.inner.lock().await;
 
         // Initialize iroh_blobs
-        inner.iroh_blobs = Some(VeilidIrohBlobs::new(
-            veilid_api.clone(),
-            routing_context,
+        let config = veilid_iroh_blobs::iroh::VeilidIrohBlobsConfig {
+            veilid: veilid_api.clone(),
+            router: routing_context,
             route_id_blob,
             route_id,
-            inner.update_rx.as_ref().unwrap().resubscribe(),
+            updates: inner.update_rx.as_ref().unwrap().resubscribe(),
             store,
-            Some(on_disconnected_callback), // TODO: Notify application of route closure?
-            Some(on_new_route_callback),
-        ));
+            on_route_disconnected_callback: Some(on_disconnected_callback), // TODO: Notify application of route closure?
+            on_new_route_callback: Some(on_new_route_callback),
+        };
+        inner.iroh_blobs = Some(VeilidIrohBlobs::new(config));
 
         drop(inner);
 
@@ -229,16 +230,17 @@ impl Backend {
         });
 
         // Initialize iroh_blobs
-        inner.iroh_blobs = Some(VeilidIrohBlobs::new(
-            veilid_api.clone(),
-            routing_context,
+        let config = veilid_iroh_blobs::iroh::VeilidIrohBlobsConfig {
+            veilid: veilid_api.clone(),
+            router: routing_context,
             route_id_blob,
             route_id,
-            update_rx.resubscribe(),
+            updates: update_rx.resubscribe(),
             store,
-            None, // TODO: Notify application of route closure?
-            Some(on_new_route_callback),
-        ));
+            on_route_disconnected_callback: None, // TODO: Notify application of route closure?
+            on_new_route_callback: Some(on_new_route_callback),
+        };
+        inner.iroh_blobs = Some(VeilidIrohBlobs::new(config));
 
         drop(inner);
 
@@ -300,7 +302,7 @@ impl Backend {
             .get(CRYPTO_KIND_VLD0)
             .ok_or_else(|| anyhow!("Unable to init crypto system"));
 
-        let record_key = TypedKey::new(CRYPTO_KIND_VLD0, keys.id);
+        let record_key = TypedRecordKey::new(CRYPTO_KIND_VLD0, keys.id);
         // First open the DHT record
         let dht_record = routing_context
             .open_dht_record(record_key.clone(), None) // Don't pass a writer here yet
@@ -385,7 +387,7 @@ impl Backend {
         Ok(group)
     }
 
-    pub async fn get_group(&self, record_key: &CryptoKey) -> Result<Box<Group>> {
+    pub async fn get_group(&self, record_key: &RecordKey) -> Result<Box<Group>> {
         let mut inner = self.inner.lock().await;
         if let Some(group) = inner.groups.get(record_key) {
             return Ok(group.clone());
@@ -409,7 +411,7 @@ impl Backend {
         // Use the owner key from the DHT record as the default writer
         let owner_key = retrieved_keypair.public_key; // Call the owner() method to get the owner key
         let owner_secret = retrieved_keypair.secret_key;
-        let record_key = TypedKey::new(CRYPTO_KIND_VLD0, *record_key);
+        let record_key = TypedRecordKey::new(CRYPTO_KIND_VLD0, *record_key);
 
         let owner = owner_secret.map(|secret| KeyPair::new(owner_key, secret));
 
@@ -448,7 +450,7 @@ impl Backend {
         Ok(())
     }
 
-    pub async fn list_known_group_ids(&self) -> Result<Vec<CryptoKey>> {
+    pub async fn list_known_group_ids(&self) -> Result<Vec<RecordKey>> {
         let mut inner = self.inner.lock().await;
         let veilid = inner.veilid()?;
         let data = veilid
@@ -461,7 +463,7 @@ impl Backend {
         Ok(info.groups)
     }
 
-    pub async fn close_group(&self, key: CryptoKey) -> Result<()> {
+    pub async fn close_group(&self, key: RecordKey) -> Result<()> {
         let mut inner = self.inner.lock().await;
         if let Some(group) = inner.groups.remove(&key) {
             group.close().await.map_err(|e| anyhow!(e))?;
@@ -540,23 +542,45 @@ fn find_query(url: &Url, key: &str) -> Result<String> {
     Err(anyhow!("Unable to find parameter {} in URL {:?}", key, url))
 }
 
-pub fn crypto_key_from_query(url: &Url, key: &str) -> Result<CryptoKey> {
+pub fn record_key_from_query(url: &Url, key: &str) -> Result<RecordKey> {
+    let value = find_query(url, key)?;
+    let bytes = hex::decode(value)?;
+    let mut key_vec: [u8; 32] = [0; 32];
+    key_vec.copy_from_slice(bytes.as_slice());
+    Ok(RecordKey::new(key_vec))
+}
+
+pub fn public_key_from_query(url: &Url, key: &str) -> Result<PublicKey> {
     let value = find_query(url, key)?;
     let bytes = hex::decode(value)?;
-    let mut key_vec: [u8; CRYPTO_KEY_LENGTH] = [0; CRYPTO_KEY_LENGTH];
+    let mut key_vec: [u8; 32] = [0; 32];
     key_vec.copy_from_slice(bytes.as_slice());
+    Ok(PublicKey::new(key_vec))
+}
 
-    let key = CryptoKey::from(key_vec);
-    Ok(key)
+pub fn secret_key_from_query(url: &Url, key: &str) -> Result<SecretKey> {
+    let value = find_query(url, key)?;
+    let bytes = hex::decode(value)?;
+    let mut key_vec: [u8; 32] = [0; 32];
+    key_vec.copy_from_slice(bytes.as_slice());
+    Ok(SecretKey::new(key_vec))
+}
+
+pub fn shared_secret_from_query(url: &Url, key: &str) -> Result<SharedSecret> {
+    let value = find_query(url, key)?;
+    let bytes = hex::decode(value)?;
+    let mut key_vec: [u8; 32] = [0; 32];
+    key_vec.copy_from_slice(bytes.as_slice());
+    Ok(SharedSecret::new(key_vec))
 }
 
 pub fn parse_url(url_string: &str) -> Result<CommonKeypair> {
     let url = Url::parse(url_string)?;
 
-    let id = crypto_key_from_query(&url, URL_DHT_KEY)?;
-    let encryption_key = crypto_key_from_query(&url, URL_ENCRYPTION_KEY)?;
-    let public_key = crypto_key_from_query(&url, URL_PUBLIC_KEY)?;
-    let secret_key = Some(crypto_key_from_query(&url, URL_SECRET_KEY)?);
+    let id = record_key_from_query(&url, URL_DHT_KEY)?;
+    let encryption_key = shared_secret_from_query(&url, URL_ENCRYPTION_KEY)?;
+    let public_key = public_key_from_query(&url, URL_PUBLIC_KEY)?;
+    let secret_key = Some(secret_key_from_query(&url, URL_SECRET_KEY)?);
 
     Ok(CommonKeypair {
         id,

src/common.rs

@@ -7,9 +7,9 @@ use std::{path::Path, path::PathBuf, sync::Arc};
 use tokio::sync::broadcast::{self, Receiver};
 use url::Url;
 use veilid_core::{
-    CryptoKey, CryptoSystem, CryptoSystemVLD0, CryptoTyped, DHTRecordDescriptor, KeyPair, Nonce,
+    PublicKey, SecretKey, RecordKey, CryptoSystem, CryptoTyped, DHTRecordDescriptor, KeyPair, Nonce,
     ProtectedStore, RouteId, RoutingContext, Sequencing, SharedSecret, Stability, UpdateCallback,
-    VeilidAPI, VeilidConfigInner, VeilidUpdate, CRYPTO_KIND_VLD0, VALID_CRYPTO_KINDS,
+    VeilidAPI, VeilidConfig, VeilidUpdate, CRYPTO_KIND_VLD0, VALID_CRYPTO_KINDS,
 };
 
 use crate::constants::ROUTE_ID_DHT_KEY;
@@ -29,7 +29,7 @@ pub async fn make_route(veilid: &VeilidAPI) -> Result<(RouteId, Vec<u8>)> {
         if let Ok(value) = result {
             return Ok(value);
         } else if let Err(e) = &result {
-            eprintln!("Failed to create route: {}", e);
+            eprintln!("Failed to create route: {e}");
         }
     }
     Err(anyhow!("Unable to create route, reached max retries"))
@@ -62,20 +62,29 @@ pub async fn init_veilid(
 
     //println!("Wait for veilid network");
 
-    while let Ok(update) = rx.recv().await {
-        if let VeilidUpdate::Attachment(attachment_state) = update {
-            if attachment_state.public_internet_ready && attachment_state.state.is_attached() {
-                println!("Public internet ready!");
-                break;
+    // Use a timeout to avoid hanging forever
+    let timeout_duration = tokio::time::Duration::from_secs(60);
+    let result = tokio::time::timeout(timeout_duration, async {
+        while let Ok(update) = rx.recv().await {
+            if let VeilidUpdate::Attachment(attachment_state) = update {
+                if attachment_state.public_internet_ready && attachment_state.state.is_attached() {
+                    println!("Public internet ready!");
+                    return Ok(());
+                }
             }
         }
-    }
+        Err(anyhow!("Update channel closed before network ready"))
+    }).await;
 
-    Ok((veilid, rx))
+    match result {
+        Ok(Ok(())) => Ok((veilid, rx)),
+        Ok(Err(e)) => Err(e),
+        Err(_) => Err(anyhow!("Timeout waiting for Veilid network to become ready")),
+    }
 }
 
-pub fn config_for_dir(base_dir: PathBuf, namespace: String) -> VeilidConfigInner {
-    VeilidConfigInner {
+pub fn config_for_dir(base_dir: PathBuf, namespace: String) -> VeilidConfig {
+    VeilidConfig {
         program_name: "save-dweb-backend".to_string(),
         namespace,
         protected_store: veilid_core::VeilidConfigProtectedStore {
@@ -101,9 +110,9 @@ pub fn config_for_dir(base_dir: PathBuf, namespace: String) -> VeilidConfigInner
 
 #[derive(Serialize, Deserialize, Clone)]
 pub struct CommonKeypair {
-    pub id: CryptoKey,
-    pub public_key: CryptoKey,
-    pub secret_key: Option<CryptoKey>,
+    pub id: RecordKey,
+    pub public_key: PublicKey,
+    pub secret_key: Option<SecretKey>,
     pub encryption_key: SharedSecret,
 }
 
@@ -117,7 +126,7 @@ impl CommonKeypair {
         Ok(())
     }
 
-    pub async fn load_keypair(protected_store: &ProtectedStore, id: &CryptoKey) -> Result<Self> {
+    pub async fn load_keypair(protected_store: &ProtectedStore, id: &RecordKey) -> Result<Self> {
         let keypair_data = protected_store
             .load_user_secret(id.to_string())
             .map_err(|_| anyhow!("Failed to load keypair"))?
@@ -129,21 +138,21 @@ impl CommonKeypair {
 }
 
 pub trait DHTEntity {
-    fn get_id(&self) -> CryptoKey;
+    fn get_id(&self) -> RecordKey;
     fn get_encryption_key(&self) -> SharedSecret;
     fn get_routing_context(&self) -> RoutingContext;
     fn get_veilid_api(&self) -> VeilidAPI;
     fn get_dht_record(&self) -> DHTRecordDescriptor;
-    fn get_secret_key(&self) -> Option<CryptoKey>;
+    fn get_secret_key(&self) -> Option<SecretKey>;
 
     // Default method to get the owner key
-    fn owner_key(&self) -> CryptoKey {
-        self.get_dht_record().owner().clone()
+    fn owner_key(&self) -> PublicKey {
+        *self.get_dht_record().owner()
     }
 
     // Default method to get the owner secret
-    fn owner_secret(&self) -> Option<CryptoKey> {
-        self.get_dht_record().owner_secret().cloned()
+    fn owner_secret(&self) -> Option<SecretKey> {
+        self.get_dht_record().owner_secret().copied()
     }
 
     fn encrypt_aead(&self, data: &[u8], associated_data: Option<&[u8]>) -> Result<Vec<u8>> {
@@ -153,8 +162,8 @@ pub trait DHTEntity {
             .get(CRYPTO_KIND_VLD0)
             .ok_or_else(|| anyhow!("Unable to init crypto system"))?;
         let nonce = crypto_system.random_nonce();
-        let mut buffer = Vec::with_capacity(nonce.as_slice().len() + data.len());
-        buffer.extend_from_slice(nonce.as_slice());
+        let mut buffer = Vec::with_capacity(nonce.bytes.len() + data.len());
+        buffer.extend_from_slice(&nonce.bytes);
         let encrypted_chunk = crypto_system
             .encrypt_aead(data, &nonce, &self.get_encryption_key(), associated_data)
             .map_err(|e| anyhow!("Failed to encrypt data: {}", e))?;
@@ -262,7 +271,7 @@ pub trait DHTEntity {
         let route_id = match veilid.import_remote_private_route(route_id_blob) {
             Ok(route) => route,
             Err(e) => {
-                eprintln!("Failed to import remote private route: {:?}", e);
+                eprintln!("Failed to import remote private route: {e:?}");
                 return Err(e.into());
             }
         };
@@ -272,18 +281,18 @@ pub trait DHTEntity {
             .app_message(veilid_core::Target::PrivateRoute(route_id), message)
             .await
         {
-            eprintln!("Failed to send message: {:?}", e);
+            eprintln!("Failed to send message: {e:?}");
             return Err(e.into());
         }
 
         Ok(())
     }
 
-    fn get_write_key(&self) -> Option<CryptoKey> {
+    fn get_write_key(&self) -> Option<PublicKey> {
         unimplemented!("WIP")
     }
 
-    async fn members(&self) -> Result<Vec<CryptoKey>> {
+    async fn members(&self) -> Result<Vec<PublicKey>> {
         unimplemented!("WIP")
     }