input-output-hk
diff --git a/‎hermes/Cargo.lock‎
Lines changed: 3 additions & 2 deletions b/‎hermes/Cargo.lock‎
Lines changed: 3 additions & 2 deletions
diff --git a/‎hermes/bin/Cargo.toml‎
Lines changed: 2 additions & 1 deletion b/‎hermes/bin/Cargo.toml‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎hermes/bin/src/ipfs/api.rs‎
Lines changed: 45 additions & 4 deletions b/‎hermes/bin/src/ipfs/api.rs‎
Lines changed: 45 additions & 4 deletions
diff --git a/‎hermes/bin/src/ipfs/mod.rs‎
Lines changed: 45 additions & 2 deletions b/‎hermes/bin/src/ipfs/mod.rs‎
Lines changed: 45 additions & 2 deletions
diff --git a/‎hermes/bin/src/ipfs/task.rs‎
Lines changed: 49 additions & 1 deletion b/‎hermes/bin/src/ipfs/task.rs‎
Lines changed: 49 additions & 1 deletion
@@ -31,7 +31,7 @@ path = "tests/integration/tests/mod.rs"
 
 [dependencies]
 # Catalyst Internal Crates
-hermes-ipfs = { version = "0.0.6", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "hermes-ipfs/v0.0.6" }
+hermes-ipfs = { version = "0.0.7", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "hermes-ipfs/v0.0.7" }
 cardano-blockchain-types = { version = "0.0.9", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "cardano-blockchain-types/v0.0.9" }
 cardano-chain-follower = { version = "0.0.19", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "cardano-chain-follower/v0.0.19" }
 catalyst-types = { version = "0.0.7", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "catalyst-types/v0.0.7" }
@@ -113,6 +113,7 @@ serial_test = { version = "3.2.0", features = ["file_locks"] }
 wasmtime = { version = "38.0.3", default-features = false, features = ["runtime", "cranelift", "component-model", "wat", "addr2line"] }
 httpmock = "0.8.2"
 wasmtime-wasi = "38.0.3"
+test-case = "3.3.1"
 
 [package.metadata.cargo-machete]
 # This is required for HDF5.
 
@@ -11,12 +11,13 @@ use crate::{
 pub(crate) fn hermes_ipfs_add_file(
     app_name: &ApplicationName,
     contents: IpfsFile,
-) -> Result<IpfsPath, Errno> {
+) -> Result<hermes_ipfs::IpfsPath, Errno> {
     tracing::debug!(app_name = %app_name, "adding IPFS file");
     let ipfs = HERMES_IPFS.get().ok_or(Errno::ServiceUnavailable)?;
-    let ipfs_path = ipfs.file_add(contents)?.to_string();
-    tracing::debug!(app_name = %app_name, path = %ipfs_path, "added IPFS file");
-    ipfs.apps.pinned_file(app_name.clone(), &ipfs_path)?;
+    let ipfs_path = ipfs.file_add(contents)?;
+    let ipfs_path_str = ipfs_path.to_string();
+    tracing::debug!(app_name = %app_name, path = %ipfs_path_str, "added IPFS file");
+    ipfs.apps.pinned_file(app_name.clone(), &ipfs_path_str)?;
     Ok(ipfs_path)
 }
 
@@ -106,6 +107,46 @@ pub(crate) fn hermes_ipfs_put_dht_value(
     Ok(status)
 }
 
+/// Marks a node as a provider for the content under the given key.
+pub(crate) fn hermes_ipfs_dht_provide(
+    app_name: &ApplicationName,
+    key: DhtKey,
+) -> Result<(), Errno> {
+    let ipfs = HERMES_IPFS.get().ok_or(Errno::ServiceUnavailable)?;
+    let key_str = format!("{key:x?}");
+    tracing::debug!(app_name = %app_name, dht_key = %key_str, "DHT provide");
+    ipfs.dht_provide(key)?;
+    tracing::debug!(app_name = %app_name, dht_key = %key_str, "DHT provided");
+    Ok(())
+}
+
+/// Gets providers of the content under the given key.
+pub(crate) fn hermes_ipfs_dht_get_providers(
+    app_name: &ApplicationName,
+    key: DhtKey,
+) -> Result<Vec<PeerId>, Errno> {
+    let ipfs = HERMES_IPFS.get().ok_or(Errno::ServiceUnavailable)?;
+    let key_str = format!("{key:x?}");
+    tracing::debug!(app_name = %app_name, dht_key = %key_str, "get DHT providers");
+    let providers = ipfs.dht_get_providers(key)?;
+    tracing::debug!(app_name = %app_name, dht_key = %key_str, "got DHT providers");
+
+    let providers = providers.iter().map(ToString::to_string).collect();
+    Ok(providers)
+}
+
+/// Returns the peer id of the node.
+pub(crate) fn hermes_ipfs_get_peer_identity(
+    app_name: &ApplicationName
+) -> Result<hermes_ipfs::PeerInfo, Errno> {
+    let ipfs = HERMES_IPFS.get().ok_or(Errno::ServiceUnavailable)?;
+    tracing::debug!(app_name = %app_name, "Get peer identity");
+    let identity = ipfs.get_peer_identity()?;
+    tracing::debug!(app_name = %app_name, "Got peer identity");
+
+    Ok(identity)
+}
+
 /// Subscribe to a topic
 pub(crate) fn hermes_ipfs_subscribe(
     app_name: &ApplicationName,
 
@@ -7,8 +7,9 @@ use std::{
 };
 
 pub(crate) use api::{
-    hermes_ipfs_add_file, hermes_ipfs_content_validate, hermes_ipfs_evict_peer,
-    hermes_ipfs_get_dht_value, hermes_ipfs_get_file, hermes_ipfs_pin_file, hermes_ipfs_publish,
+    hermes_ipfs_add_file, hermes_ipfs_content_validate, hermes_ipfs_dht_get_providers,
+    hermes_ipfs_dht_provide, hermes_ipfs_evict_peer, hermes_ipfs_get_dht_value,
+    hermes_ipfs_get_file, hermes_ipfs_get_peer_identity, hermes_ipfs_pin_file, hermes_ipfs_publish,
     hermes_ipfs_put_dht_value, hermes_ipfs_subscribe, hermes_ipfs_unpin_file,
 };
 use dashmap::DashMap;
@@ -252,6 +253,48 @@ where N: hermes_ipfs::rust_ipfs::NetworkBehaviour<ToSwarm = Infallible> + Send +
         cmd_rx.blocking_recv().map_err(|_| Errno::DhtGetError)?
     }
 
+    /// Provide a DHT value
+    fn dht_provide(
+        &self,
+        key: DhtKey,
+    ) -> Result<(), Errno> {
+        let (cmd_tx, cmd_rx) = oneshot::channel();
+        self.sender
+            .as_ref()
+            .ok_or(Errno::DhtProvideError)?
+            .blocking_send(IpfsCommand::DhtProvide(key, cmd_tx))
+            .map_err(|_| Errno::DhtProvideError)?;
+        cmd_rx.blocking_recv().map_err(|_| Errno::DhtProvideError)?
+    }
+
+    /// Get providers of a DHT value
+    fn dht_get_providers(
+        &self,
+        key: DhtKey,
+    ) -> Result<HashSet<hermes_ipfs::PeerId>, Errno> {
+        let (cmd_tx, cmd_rx) = oneshot::channel();
+        self.sender
+            .as_ref()
+            .ok_or(Errno::DhtGetProvidersError)?
+            .blocking_send(IpfsCommand::DhtGetProviders(key, cmd_tx))
+            .map_err(|_| Errno::DhtGetProvidersError)?;
+        cmd_rx
+            .blocking_recv()
+            .map_err(|_| Errno::DhtGetProvidersError)?
+    }
+
+    /// Get the peer identity
+    // TODO[rafal-ch]: We should not be using API errors here.
+    fn get_peer_identity(&self) -> Result<hermes_ipfs::PeerInfo, Errno> {
+        let (cmd_tx, cmd_rx) = oneshot::channel();
+        self.sender
+            .as_ref()
+            .ok_or(Errno::GetPeerIdError)?
+            .blocking_send(IpfsCommand::Identity(None, cmd_tx))
+            .map_err(|_| Errno::GetPeerIdError)?;
+        cmd_rx.blocking_recv().map_err(|_| Errno::GetPeerIdError)?
+    }
+
     /// Publish message to a `PubSub` topic
     fn pubsub_publish(
         &self,
 
@@ -1,5 +1,5 @@
 //! IPFS Task
-use std::str::FromStr;
+use std::{collections::HashSet, str::FromStr};
 
 use hermes_ipfs::{AddIpfsFile, Cid, HermesIpfs, IpfsPath as PathIpfsFile, PeerId as TargetPeerId};
 use tokio::{
@@ -32,15 +32,28 @@ pub(crate) enum IpfsCommand {
     GetDhtValue(DhtKey, oneshot::Sender<Result<DhtValue, Errno>>),
     /// Put DHT value
     PutDhtValue(DhtKey, DhtValue, oneshot::Sender<Result<bool, Errno>>),
+    /// Provide a DHT value
+    DhtProvide(DhtKey, oneshot::Sender<Result<(), Errno>>),
+    /// Get providers of a DHT value
+    DhtGetProviders(
+        DhtKey,
+        oneshot::Sender<Result<HashSet<hermes_ipfs::PeerId>, Errno>>,
+    ),
     /// Publish to a topic
     Publish(PubsubTopic, MessageData, oneshot::Sender<Result<(), Errno>>),
     /// Subscribe to a topic
     Subscribe(PubsubTopic, oneshot::Sender<Result<JoinHandle<()>, Errno>>),
     /// Evict Peer from node
     EvictPeer(PeerId, oneshot::Sender<Result<bool, Errno>>),
+    /// Gets the peer identity
+    Identity(
+        Option<PeerId>,
+        oneshot::Sender<Result<hermes_ipfs::PeerInfo, Errno>>,
+    ),
 }
 
 /// Handle IPFS commands in asynchronous task.
+#[allow(clippy::too_many_lines)]
 pub(crate) async fn ipfs_command_handler(
     hermes_node: HermesIpfs,
     mut queue_rx: mpsc::Receiver<IpfsCommand>,
@@ -130,6 +143,41 @@ pub(crate) async fn ipfs_command_handler(
                 let status = hermes_node.ban_peer(peer_id).await.is_ok();
                 send_response(Ok(status), tx);
             },
+            IpfsCommand::DhtProvide(key, tx) => {
+                let response = hermes_node.dht_provide(key.clone()).await.map_err(|err| {
+                    tracing::error!(dht_key = ?key, "DHT provide failed: {}", err);
+                    Errno::DhtProvideError
+                });
+                send_response(response, tx);
+            },
+            IpfsCommand::DhtGetProviders(key, tx) => {
+                let response = hermes_node
+                    .dht_get_providers(key.clone())
+                    .await
+                    .map_err(|err| {
+                        tracing::error!(dht_key = ?key, "DHT get providers failed: {}", err);
+                        Errno::DhtGetProvidersError
+                    });
+                send_response(response, tx);
+            },
+            IpfsCommand::Identity(peer_id, tx) => {
+                let peer_id = match peer_id {
+                    Some(peer_id) => {
+                        Some(
+                            hermes_ipfs::PeerId::from_str(&peer_id)
+                                .map_err(|_| Errno::InvalidPeerId)?,
+                        )
+                    },
+                    None => None,
+                };
+
+                let response = hermes_node.identity(peer_id).await.map_err(|err| {
+                    tracing::error!(peer_id = ?peer_id, "Identity failed: {}", err);
+                    Errno::GetPeerIdError
+                });
+
+                send_response(response, tx);
+            },
         }
     }
     hermes_node.stop().await;