feat: update identity_* dependencies to v1.6.0-beta.2 (#38)

Co-authored-by: Daniel Mader <[email protected]>

Author: nanderstabel

Cargo.toml

@@ -31,11 +31,20 @@ repository = "https://github.com/impierce/did-manager"
 rust-version = "1.75"
 
 [workspace.dependencies]
-identity_iota = { version = "1.5", default-features = false, features = ["resolver", "iota-client"] }
-identity_storage = { version = "1.5", default-features = false }
-identity_stronghold = { version = "1.5", features = ["send-sync-storage"] }
-identity_verification = { version = "1.5", default-features = false }
-iota-sdk = { version = "1.1", features = ["stronghold"] }
+identity_iota = { git = "https://github.com/iotaledger/identity", tag = "v1.6.0-beta.2", default-features = false, features = [
+    "resolver",
+    "iota-client",
+    "send-sync",
+] }
+identity_storage = { git = "https://github.com/iotaledger/identity", tag = "v1.6.0-beta.2", default-features = false }
+identity_stronghold = { git = "https://github.com/iotaledger/identity", tag = "v1.6.0-beta.2", features = [
+    "send-sync-storage",
+] }
+identity_verification = { git = "https://github.com/iotaledger/identity", tag = "v1.6.0-beta.2", default-features = false }
+iota-sdk = { git = "https://github.com/impierce/iota", package = "iota-sdk", branch = "temp/fix" }
+iota-sdk-legacy = { package = "iota-sdk", version = "1.1", features = [
+    "stronghold",
+] }
 iota_stronghold = { version = "2.1" }
 log = "0.4"
 rand = "0.8"
@@ -48,4 +57,18 @@ ssi-jwk = { version = "0.1.2", default-features = false, features = [
 ] }
 test-log = "0.2"
 thiserror = "1.0"
-tokio = { version = "1", features = ["full"] }
+tokio = { version = "1.43", features = ["full"] }
+
+# TODO: Remove these patches once configuratble TLS is available in `iota-sdk`
+[patch.'https://github.com/iotaledger/iota']
+iota-sdk = { git = "https://github.com/impierce/iota", package = "iota-sdk", branch = "temp/fix" }
+move-core-types = { git = "https://github.com/impierce/iota.git", package = "move-core-types", branch = "temp/fix" }
+shared-crypto = { git = "https://github.com/impierce/iota.git", package = "shared-crypto", branch = "temp/fix" }
+iota-network-stack = { git = "https://github.com/impierce/iota.git", package = "iota-network-stack", branch = "temp/fix" }
+iota-types = { git = "https://github.com/impierce/iota.git", package = "iota-types", branch = "temp/fix" }
+iota-metrics = { git = "https://github.com/impierce/iota.git", package = "iota-metrics", branch = "temp/fix" }
+move-binary-format = { git = "https://github.com/impierce/iota.git", package = "move-binary-format", branch = "temp/fix" }
+iota-protocol-config = { git = "https://github.com/impierce/iota.git", package = "iota-protocol-config", branch = "temp/fix" }
+move-vm-config = { git = "https://github.com/impierce/iota.git", package = "move-vm-config", branch = "temp/fix" }
+iota-adapter-latest = { git = "https://github.com/impierce/iota.git", package = "iota-adapter-latest", branch = "temp/fix" }
+iota-execution = { git = "https://github.com/impierce/iota.git", package = "iota-execution", branch = "temp/fix" }

consumer/Cargo.toml

@@ -15,6 +15,7 @@ did_web = { path = "../did_web" }
 shared = { path = "../shared" }
 
 identity_iota.workspace = true
+rustls = { version = "0.23", features = ["ring"] }
 signature.workspace = true
 tokio.workspace = true
 

consumer/src/resolver.rs

@@ -7,13 +7,21 @@ use identity_iota::document::CoreDocument;
 use identity_iota::resolver::Resolver as IdentityResolver;
 use shared::error::ConsumerError;
 
+#[derive(Debug)]
 pub struct Resolver {
     pub(crate) resolver: IdentityResolver,
 }
 
 impl Resolver {
     pub async fn new() -> Self {
-        let resolver = configure_resolver(IdentityResolver::new())
+        let resolver = configure_resolver(IdentityResolver::new(), None)
+            .await
+            .expect("Failed to configure resolver");
+        Self { resolver }
+    }
+
+    pub async fn new_with_tls_config(tls_config: rustls::ClientConfig) -> Self {
+        let resolver = configure_resolver(IdentityResolver::new(), Some(tls_config))
             .await
             .expect("Failed to configure resolver");
         Self { resolver }
@@ -26,11 +34,18 @@ impl Resolver {
     }
 }
 
-async fn configure_resolver(mut resolver: IdentityResolver) -> Result<IdentityResolver, ConsumerError> {
+async fn configure_resolver(
+    mut resolver: IdentityResolver,
+    tls_config: Option<rustls::ClientConfig>,
+) -> Result<IdentityResolver, ConsumerError> {
     resolver.attach_handler("jwk".to_owned(), resolve_did_jwk);
     resolver.attach_handler("key".to_owned(), resolve_did_key);
     resolver.attach_handler("web".to_owned(), resolve_did_web);
-    resolver.attach_multiple_iota_handlers(iota_clients().await?);
+    resolver.attach_multiple_iota_handlers(
+        iota_clients(tls_config)
+            .await
+            .map_err(|e| ConsumerError::Generic(format!("Failed to attach IOTA handlers: {e}")))?,
+    );
 
     Ok(resolver)
 }

did_iota/Cargo.toml

@@ -10,13 +10,16 @@ rust-version.workspace = true
 [dependencies]
 shared = { path = "../shared" }
 
+anyhow = "1.0"
 identity_iota.workspace = true
 identity_stronghold.workspace = true
 iota-sdk.workspace = true
 log.workspace = true
+rustls = { version = "0.23", features = ["ring"] }
 tokio.workspace = true
 
 [dev-dependencies]
+iota-sdk-legacy.workspace = true
 iota_stronghold = { version = "2.1" }
 serde_json.workspace = true
 test-log.workspace = true

did_iota/src/consumer.rs

@@ -1,19 +1,38 @@
-use iota_sdk::client::error::Error;
-use iota_sdk::client::Client;
-
-static MAINNET_URL: &str = "https://api.stardust-mainnet.iotaledger.net";
-static SHIMMER_URL: &str = "https://api.shimmer.network";
-static TESTNET_URL: &str = "https://api.testnet.shimmer.network";
+use identity_iota::iota::rebased::client::IdentityClientReadOnly;
+use identity_iota::iota::rebased::Error;
+use iota_sdk::IotaClientBuilder;
 
 /// Builds clients for all IOTA networks.
-pub async fn iota_clients() -> Result<Vec<(&'static str, Client)>, Error> {
-    let mainnet_client: Client = Client::builder().with_primary_node(MAINNET_URL, None)?.finish().await?;
-    let shimmer_client: Client = Client::builder().with_primary_node(SHIMMER_URL, None)?.finish().await?;
-    let testnet_client: Client = Client::builder().with_primary_node(TESTNET_URL, None)?.finish().await?;
+pub async fn iota_clients(
+    tls_config: Option<rustls::ClientConfig>,
+) -> Result<Vec<(&'static str, IdentityClientReadOnly)>, Error> {
+    let mut iota_testnet_client_builder = IotaClientBuilder::default();
+
+    if let Some(tls_config) = &tls_config {
+        iota_testnet_client_builder = iota_testnet_client_builder.tls_config(tls_config.clone());
+    }
+
+    let iota_testnet = iota_testnet_client_builder.build_testnet().await?;
+
+    let mut iota_devnet_client_builder = IotaClientBuilder::default();
+
+    if let Some(tls_config) = &tls_config {
+        iota_devnet_client_builder = iota_devnet_client_builder.tls_config(tls_config.clone());
+    }
+
+    let iota_devnet = iota_devnet_client_builder.build_devnet().await?;
+
+    let mut iota_mainnet_client_builder = IotaClientBuilder::default();
+
+    if let Some(tls_config) = tls_config {
+        iota_mainnet_client_builder = iota_mainnet_client_builder.tls_config(tls_config);
+    }
+
+    let iota_mainnet = iota_mainnet_client_builder.build_mainnet().await?;
 
     Ok(vec![
-        ("iota", mainnet_client),
-        ("smr", shimmer_client),
-        ("rms", testnet_client),
+        ("testnet", IdentityClientReadOnly::new(iota_testnet).await?),
+        ("devnet", IdentityClientReadOnly::new(iota_devnet).await?),
+        ("iota", IdentityClientReadOnly::new(iota_mainnet).await?),
     ])
 }

did_iota/src/producer/produce.rs

@@ -1,14 +1,15 @@
 use identity_iota::{
     core::{FromJson, ToJson},
     document::CoreDocument,
-    iota::{IotaDID, NetworkName},
+    iota::IotaDID,
     verification::{jwk::Jwk, jws::JwsAlgorithm},
 };
 use log::{debug, info};
 use shared::{error::ProducerError, JwkStorageWrapper};
 
 use crate::producer::resolve::resolve;
 
+// TODO: Remove `Testnet` and `Shimmer`. Add `Devnet`.
 pub enum IotaMethod {
     Testnet,
     Shimmer,
@@ -27,23 +28,22 @@ pub async fn produce_did_iota(
 ) -> Result<CoreDocument, ProducerError> {
     let public_key_jwk = storage.get_public_key(key_id, alg).await?;
 
-    let _ = match iota_method {
+    match iota_method {
         IotaMethod::Testnet => {
             info!("Producing `did:iota:rms` for key_id `{key_id}` ({alg}) ...");
-            NetworkName::try_from("rms").expect("Invalid network")
         }
         IotaMethod::Shimmer => {
             info!("Producing `did:iota:smr` for key_id `{key_id}` ({alg}) ...");
-            NetworkName::try_from("smr").expect("Invalid network")
         }
         IotaMethod::Mainnet => {
             info!("Producing `did:iota` for key_id `{key_id}` ({alg}) ...");
-            NetworkName::try_from("iota").expect("Invalid network")
         }
     };
 
     // Sanity check: Can the document be resolved from the ledger?
-    let published_document = resolve(managed_did).await?;
+    let published_document = resolve(managed_did)
+        .await
+        .map_err(|e| ProducerError::Generic(e.to_string()))?;
 
     // Sanity check: Is the method in the document?
     let verification_method = published_document.resolve_method(&managed_fragment, None).unwrap();
@@ -66,14 +66,15 @@ mod tests {
     use super::*;
 
     use identity_stronghold::StrongholdStorage;
-    use iota_sdk::client::{secret::stronghold::StrongholdSecretManager, Password};
+    use iota_sdk_legacy::client::{secret::stronghold::StrongholdSecretManager, Password};
     use serde_json::json;
     use test_log::test;
 
     const SNAPSHOT_PATH: &str = "../shared/tests/res/selv.stronghold";
     const PASSWORD: &str = "VNvRtH4tKyWwvJDpL6Vuc2aoLiKAecGQ";
     const KEY_ID: &str = "UVDxWhG2rB39FkaR7I27mHeUNrGtUgcr";
 
+    #[ignore = "This test needs to be updated to use `Devnet`"]
     #[test(tokio::test)]
     async fn produce_did_iota_testnet() {
         let stronghold_adapter = StrongholdSecretManager::builder()

did_iota/src/producer/resolve.rs

@@ -1,14 +1,10 @@
-use identity_iota::{
-    document::CoreDocument,
-    iota::IotaDID,
-    resolver::{Error, Resolver},
-};
+use identity_iota::{document::CoreDocument, iota::IotaDID, resolver::Resolver};
 
 use crate::consumer::iota_clients;
 
-pub async fn resolve(did: IotaDID) -> Result<CoreDocument, Error> {
+pub async fn resolve(did: IotaDID) -> Result<CoreDocument, anyhow::Error> {
     let mut resolver = Resolver::<CoreDocument>::new();
-    resolver.attach_multiple_iota_handlers(iota_clients().await.unwrap());
+    resolver.attach_multiple_iota_handlers(iota_clients(None).await.unwrap());
     let document = resolver.resolve(&did).await?;
     Ok(document)
 }

did_web/src/consumer.rs

@@ -13,13 +13,13 @@ pub async fn resolve_did_web(did: CoreDID) -> Result<CoreDocument, ConsumerError
     let (result, document, metadata) = resolver.resolve(did.as_str(), &input_metadata).await;
 
     if let Some(error) = result.error.clone() {
-        info!("Error: {:?}", error);
+        info!("Error: {error:?}");
         return Err(ConsumerError::Generic(error));
     }
 
-    debug!("Result: {:#?}", result);
-    debug!("Document: {:#?}", document);
-    debug!("Metadata: {:#?}", metadata);
+    debug!("Result: {result:#?}");
+    debug!("Document: {document:#?}");
+    debug!("Metadata: {metadata:#?}");
     CoreDocument::from_json(&document.to_json().unwrap()).map_err(|e| ConsumerError::Generic(e.to_string()))
 }
 

did_web/src/producer.rs

@@ -47,10 +47,10 @@ pub async fn produce_did_web(
     // Omit default HTTPS port
     let host_port_encoded = match port {
         443 => host.to_string(),
-        _ => urlencoding::encode(format!("{}:{}", host, port).as_str()).to_string(),
+        _ => urlencoding::encode(format!("{host}:{port}").as_str()).to_string(),
     };
 
-    let did_str = format!("did:web:{}", host_port_encoded);
+    let did_str = format!("did:web:{host_port_encoded}");
 
     info!("DID: `{did_str}`");
 
@@ -76,7 +76,7 @@ pub async fn produce_did_web(
 
     info!("Host the following json under the following url:");
     info!("================================================");
-    info!("{}", well_known);
+    info!("{well_known}");
     info!("================================================");
     info!("{}", document.to_json_pretty().unwrap());
     info!("================================================");

identity_stronghold_ext/Cargo.toml

@@ -13,12 +13,13 @@ async-trait = { version = "0.1.64", default-features = false }
 elliptic-curve = { version = "0.13", features = ["jwk"] }
 identity_storage.workspace = true
 identity_verification.workspace = true
-iota-sdk.workspace = true
+iota-sdk-legacy.workspace = true
 iota_stronghold.workspace = true
 k256 = { version = "0.13", features = ["jwk"] }
 log.workspace = true
 p256 = { version = "0.13", features = ["jwk"] }
 serde_json.workspace = true
+secret-storage = { git = "https://github.com/iotaledger/secret-storage", tag = "v0.3.0" }
 stronghold_ext = { git = "https://github.com/impierce/stronghold_ext.git", features = [
     "crypto",
 ] }