feat: add token_wallet module to allow funding IOTA DIDs

Cargo.toml

@@ -9,7 +9,16 @@ repository = "https://github.com/impierce/did-manager"
 
 [workspace]
 resolver = "2"
-members = ["consumer", "did_jwk", "did_key", "did_web", "producer", "shared"]
+members = [
+    "consumer",
+    "did_iota",
+    "did_jwk",
+    "did_key",
+    "did_web",
+    "producer",
+    "shared",
+    "token_wallet",
+]
 
 [dependencies]
 consumer = { path = "consumer" }
@@ -26,6 +35,8 @@ identity_iota = { version = "1.2.0" }
 identity_stronghold = { version = "1.2.0", features = ["send-sync-storage"] }
 iota-sdk = { version = "1.0", features = ["stronghold"] }
 log = "0.4"
+rand = "0.8"
 signature = "2.2"
 test-log = "0.2"
+thiserror = "1.0"
 tokio = { version = "1", features = ["full"] }

README.md

@@ -15,3 +15,29 @@ Implementation of [identity.rs](https://github.com/iotaledger/identity.rs) inter
 | [did:iota](https://wiki.iota.org/identity.rs/references/specifications/iota-did-method-spec/)     | :ballot_box_with_check: |                         |
 | [did:iota:smr](https://wiki.iota.org/identity.rs/references/specifications/iota-did-method-spec/) | :ballot_box_with_check: |                         |
 | [did:iota:rms](https://wiki.iota.org/identity.rs/references/specifications/iota-did-method-spec/) | :ballot_box_with_check: |                         |
+
+## Usage
+
+> [!NOTE]  
+> This workspace is structured in a way that keeps the individual DID method implementations as separate crates to allow easier replacement and extensibility.
+
+### Consuming DIDs
+
+```rust
+use did_manager::Resolver;
+use identity_iota::document::CoreDocument;
+
+let resolver = Resolver::new().await;
+let did = "did:key:z6Mkk7yqnGF3YwTrLpqrW6PGsKci7dNqh1CjnvMbzrMerSeL";
+let document: CoreDocument = resolver.resolve(did).await.unwrap();
+```
+
+### Producing DIDs
+
+```rust
+use did_manager::{DidMethod, SecretManager};
+use identity_iota::document::CoreDocument;
+
+let secret_manager = SecretManager::generate("/path/to/file", "p4ssw0rd").await.unwrap();
+let document: CoreDocument = secret_manager.produce_document(DidMethod::Jwk).await.unwrap();
+```

consumer/Cargo.toml

@@ -8,10 +8,15 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
+did_iota = { path = "../did_iota" }
 did_jwk = { path = "../did_jwk" }
 did_key = { path = "../did_key" }
 did_web = { path = "../did_web" }
+shared = { path = "../shared" }
+
 identity_iota.workspace = true
-iota-sdk.workspace = true
 signature.workspace = true
 tokio.workspace = true
+
+[dev-dependencies]
+test-log.workspace = true

consumer/src/resolver.rs

@@ -1,75 +1,47 @@
+use did_iota::consumer::iota_clients;
 use did_jwk::consumer::resolve_did_jwk;
 use did_key::consumer::resolve_did_key;
 use did_web::consumer::resolve_did_web;
 use identity_iota::did::CoreDID;
 use identity_iota::document::CoreDocument;
 use identity_iota::resolver::Resolver as IdentityResolver;
-use iota_sdk::client::Client;
+use shared::error::ConsumerError;
 
 pub struct Resolver {
     pub(crate) resolver: IdentityResolver,
 }
 
 impl Resolver {
     pub async fn new() -> Self {
-        let resolver = configure_resolver(IdentityResolver::new()).await;
+        let resolver = configure_resolver(IdentityResolver::new())
+            .await
+            .expect("Failed to configure resolver");
         Self { resolver }
     }
 
-    pub async fn resolve(&self, did: &str) -> std::result::Result<CoreDocument, Box<dyn std::error::Error>> {
+    pub async fn resolve(&self, did: &str) -> Result<CoreDocument, ConsumerError> {
         let did = CoreDID::parse(did)?;
         let document: CoreDocument = self.resolver.resolve(&did).await?;
         Ok(document)
     }
 }
 
-// TODO: error handling (return Result), use expect() for Client::builder()
-async fn configure_resolver(mut resolver: IdentityResolver) -> IdentityResolver {
+async fn configure_resolver(mut resolver: IdentityResolver) -> 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?);
 
-    // ------------------ IOTA resolvers ------------------
-    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";
-    // ----------------------------------------------------
-
-    let iota_client: Client = Client::builder()
-        .with_primary_node(MAINNET_URL, None)
-        .unwrap()
-        .finish()
-        .await
-        .unwrap();
-
-    let smr_client: Client = Client::builder()
-        .with_primary_node(SHIMMER_URL, None)
-        .unwrap()
-        .finish()
-        .await
-        .unwrap();
-
-    let shimmer_testnet_client: Client = Client::builder()
-        .with_primary_node(TESTNET_URL, None)
-        .unwrap()
-        .finish()
-        .await
-        .unwrap();
-
-    resolver.attach_multiple_iota_handlers(vec![
-        ("iota", iota_client),
-        ("smr", smr_client),
-        ("rms", shimmer_testnet_client),
-    ]);
-
-    resolver
+    Ok(resolver)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[tokio::test]
+    use test_log::test;
+
+    #[test(tokio::test)]
     async fn resolve_all_supported_methods() {
         let resolver = Resolver::new().await;
         let did = "did:key:z6Mkk7yqnGF3YwTrLpqrW6PGsKci7dNqh1CjnvMbzrMerSeL";
@@ -83,7 +55,7 @@ mod tests {
         // TODO: add more ...
     }
 
-    #[tokio::test]
+    #[test(tokio::test)]
     async fn fails_on_unsupported_method() {
         let resolver = Resolver::new().await;
         let did = "did:foo:bar";
@@ -92,8 +64,8 @@ mod tests {
         assert!(result.is_err());
     }
 
-    #[tokio::test]
     #[ignore]
+    #[test(tokio::test)]
     async fn resolves_did_iota() {
         let resolver = Resolver::new().await;
         let did = "did:iota:0xe4edef97da1257e83cbeb49159cfdd2da6ac971ac447f233f8439cf29376ebfe";
@@ -105,8 +77,8 @@ mod tests {
         );
     }
 
-    #[tokio::test]
     #[ignore]
+    #[test(tokio::test)]
     async fn resolves_did_iota_smr() {
         let resolver = Resolver::new().await;
         let did = "did:iota:smr:0xe4edef97da1257e83cbeb49159cfdd2da6ac971ac447f233f8439cf29376ebfe";
@@ -118,16 +90,17 @@ mod tests {
         );
     }
 
-    #[tokio::test]
+    #[ignore = "unnecessary"]
+    #[test(tokio::test)]
     async fn resolves_did_iota_rms() {
         // TODO: are these tests really necessary? (they're essentially just testing the resolver from identity.rs and require internet)
         let resolver = Resolver::new().await;
-        let did = "did:iota:rms:0x4868d61773a9f8e54741261a0e82fc883e299c2614c94b2400e2423d4c5bbe6a";
+        let did = "did:iota:rms:0x29418b0a0120d10e20d0dacc78896c200ecd1cc1e3b153be482f150859a96739";
         let document = resolver.resolve(did).await.unwrap();
 
         assert_eq!(
             document.id(),
-            "did:iota:rms:0x4868d61773a9f8e54741261a0e82fc883e299c2614c94b2400e2423d4c5bbe6a"
+            "did:iota:rms:0x29418b0a0120d10e20d0dacc78896c200ecd1cc1e3b153be482f150859a96739"
         );
     }
 }

did_iota/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "did_iota"
+version = "0.1.0"
+edition = "2021"
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+shared = { path = "../shared" }
+token_wallet = { path = "../token_wallet" }
+
+identity_iota.workspace = true
+identity_stronghold.workspace = true
+iota-sdk.workspace = true
+log.workspace = true
+tokio.workspace = true
+
+[dev-dependencies]
+iota_stronghold = { version = "2.0" }
+test-log.workspace = true

did_iota/README.md

@@ -0,0 +1,43 @@
+# Producing IOTA DIDs
+
+## Flowchart
+
+```mermaid
+flowchart TD
+%% ======== Define nodes ========
+    crypto_wallet([Crypto wallet])
+    faucet([Faucet])
+    funding_address[Funding address]
+    stronghold{{Stronghold}}
+    governor["`Governor address
+        State Controller
+        address`"]
+
+%% ======== Style nodes ========
+    style faucet stroke-dasharray: 5 5;
+
+%% ======== Flow ========
+    crypto_wallet --send tokens--> funding_address
+    faucet -.send tokens.-> funding_address
+    stronghold --key A, index 0--> funding_address
+    stronghold --key B, index 0--> governor
+    funding_address --> AliasOutput
+```
+
+### Description
+
+#### Creation
+
+1. Stronghold generates an Ed25519 keypair.
+2. Stronghold generates a funding address deterministically.
+3. Stronghold generates a `Governor` address deterministically from another key.
+4. queries tangle for existing alias outputs for that governor.
+5. if none, `DID Manager` produces an `AliasOutput` containing the DID document and determines the cost for storage deposit.
+6. User sends tokens to funding address.
+7. Funding address pays for storage deposit and instantly returns the remaining tokens to the user's address.
+8. DID Manager published the AliasOutput.
+
+#### Destruction
+
+1. DID Manager destroys the Alias Outputs and sends the remaining tokens back to the funding address.
+2. New DID can be created or tokens send to another address or returned to same initial address of the user.

did_iota/src/consumer.rs

@@ -0,0 +1,36 @@
+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";
+
+/// Gets all IOTA clients.
+pub async fn iota_clients() -> Result<Vec<(&'static str, Client)>, Error> {
+    let mainnet_client: Client = Client::builder()
+        .with_primary_node(MAINNET_URL, None)
+        .unwrap()
+        .finish()
+        .await
+        .unwrap();
+
+    let shimmer_client: Client = Client::builder()
+        .with_primary_node(SHIMMER_URL, None)
+        .unwrap()
+        .finish()
+        .await
+        .unwrap();
+
+    let testnet_client: Client = Client::builder()
+        .with_primary_node(TESTNET_URL, None)
+        .unwrap()
+        .finish()
+        .await
+        .unwrap();
+
+    Ok(vec![
+        ("iota", mainnet_client),
+        ("smr", shimmer_client),
+        ("rms", testnet_client),
+    ])
+}

did_iota/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod consumer;
+pub mod producer;