feat: add additional features to enable specific features (#417)

Author: dariusc93

CHANGELOG.md

@@ -7,6 +7,7 @@
 - chore: use async-rt in place of rt utils. [PR 362](https://github.com/dariusc93/rust-ipfs/pull/362)
 - feat: Implement configuration for connecting to IPFS Private Network. [PR 398](https://github.com/dariusc93/rust-ipfs/pull/398)
 - refactor: use CommunicationTask to handle sending message to IpfsTask. [PR 404](https://github.com/dariusc93/rust-ipfs/pull/404)
+- feat: add additional features to enable different features. [PR 417](https://github.com/dariusc93/rust-ipfs/pull/417)
 - feat: Use RepoType in Repo and impl DefaultStorage. [PR 414](https://github.com/dariusc93/rust-ipfs/pull/414)
 
 # 0.14.1

Cargo.toml

@@ -10,11 +10,27 @@ description = "IPFS node implementation"
 version = "0.15.0"
 
 [features]
-default = []
+default = ["rsa", "dns", "ed25519", "secp256k1", "ecdsa", "tls", "noise", "tcp", "quic", "pnet", "websocket"]
 
-experimental_stream = ["dep:libp2p-stream"]
+rsa = ["libp2p/rsa", "rust-ipns/rsa"]
+ed25519 = ["libp2p/ed25519", "rust-ipns/ed25519"]
+secp256k1 = ["libp2p/secp256k1", "rust-ipns/secp256k1"]
+ecdsa = ["libp2p/ecdsa", "rust-ipns/ecdsa"]
 
-webrtc_transport = ["dep:libp2p-webrtc"]
+stream = ["dep:libp2p-stream"]
+
+x509_dep = ["dep:simple_x509", "rcgen", "pem", "p256", "rand_chacha", "hkdf", "sec1"]
+
+dns = ["libp2p/dns"]
+tls = ["libp2p/tls"]
+noise = ["libp2p/noise"]
+tcp = ["libp2p/tcp"]
+quic = ["libp2p/quic"]
+pnet = ["libp2p/pnet"]
+
+webrtc = ["dep:libp2p-webrtc", "dep:libp2p-webrtc-websys", "x509_dep"]
+websocket = ["libp2p/websocket", "libp2p/websocket-websys", "x509_dep"]
+webtransport = ["libp2p/webtransport-websys"]
 
 test_go_interop = []
 test_js_interop = []
@@ -64,7 +80,7 @@ rand = "0.8.5"
 rand_chacha = "0.3.1"
 rcgen = { version = "0.13.2", features = ["pem", "x509-parser"] }
 rlimit = "0.10.2"
-rust-ipns = { version = "0.7.0", path = "packages/rust-ipns" }
+rust-ipns = { version = "0.7.0", path = "packages/rust-ipns", default-features = false }
 rust-unixfs = { version = "0.5.0", path = "unixfs" }
 sec1 = { version = "0.7.3", features = ["pem", "pkcs8"] }
 send_wrapper = "0.6.0"
@@ -100,7 +116,7 @@ chrono.workspace = true
 either.workspace = true
 futures-timeout.workspace = true
 futures.workspace = true
-hkdf.workspace = true
+hkdf = { workspace = true, optional = true }
 indexmap.workspace = true
 ipld-core.workspace = true
 ipld-dagpb.workspace = true
@@ -112,17 +128,17 @@ multibase.workspace = true
 multihash.workspace = true
 multihash-codetable.workspace = true
 multihash-derive.workspace = true
-p256.workspace = true
+p256 = { workspace = true, optional = true }
 parking_lot.workspace = true
-pem.workspace = true
+pem = { workspace = true, optional = true }
 pollable-map.workspace = true
 quick-protobuf-codec.workspace = true
 quick-protobuf.workspace = true
 rand.workspace = true
-rand_chacha.workspace = true
-rust-ipns = { workspace = true }
+rand_chacha = { workspace = true, optional = true }
+rust-ipns = { workspace = true, features = ["libp2p"] }
 rust-unixfs = { workspace = true }
-sec1.workspace = true
+sec1 = { workspace = true, optional = true }
 serde = { features = ["derive"], workspace = true }
 serde_ipld_dagcbor.workspace = true
 serde_ipld_dagjson.workspace = true
@@ -139,11 +155,11 @@ zeroize.workspace = true
 futures-timer.workspace = true
 fs2.workspace = true
 hickory-resolver.workspace = true
-libp2p = { features = ["gossipsub", "autonat", "relay", "dcutr", "identify", "kad", "websocket", "tcp", "macros", "tokio", "noise", "tls", "ping", "yamux", "dns", "mdns", "ed25519", "secp256k1", "ecdsa", "rsa", "serde", "request-response", "json", "cbor", "rendezvous", "upnp", "quic", "pnet"], workspace = true }
+libp2p = { features = ["gossipsub", "autonat", "relay", "dcutr", "identify", "kad", "macros", "tokio", "ping", "yamux", "mdns", "serde", "request-response", "json", "cbor", "rendezvous", "upnp"], workspace = true }
 libp2p-webrtc = { workspace = true, features = ["tokio", ], optional = true }
-rcgen.workspace = true
+rcgen = { workspace = true, optional = true }
 rlimit.workspace = true
-simple_x509.workspace = true
+simple_x509 = { workspace = true, optional = true }
 tokio = { features = ["full"], workspace = true }
 tokio-stream = { workspace = true, features = ["fs"] }
 tokio-util = { workspace = true, features = ["full"] }
@@ -152,8 +168,8 @@ tokio-util = { workspace = true, features = ["full"] }
 futures-timer = { workspace = true, features = ["wasm-bindgen"] }
 getrandom = { workspace = true, features = ["js"] }
 idb.workspace = true
-libp2p = { features = ["gossipsub", "autonat", "relay", "dcutr", "identify", "kad", "websocket-websys", "webtransport-websys", "macros", "noise", "ping", "yamux", "dns", "ed25519", "secp256k1", "ecdsa", "serde", "request-response", "json", "cbor", "rendezvous", "wasm-bindgen", ], workspace = true }
-libp2p-webrtc-websys = { workspace = true }
+libp2p = { features = ["gossipsub", "autonat", "relay", "identify", "kad", "noise", "macros", "ping", "yamux", "serde", "request-response", "json", "cbor", "rendezvous", "wasm-bindgen"], workspace = true }
+libp2p-webrtc-websys = { workspace = true, optional = true }
 send_wrapper.workspace = true
 serde-wasm-bindgen.workspace = true
 tokio = { default-features = false, features = ["sync", "macros"], workspace = true }

examples/echo-stream.rs

@@ -1,5 +1,5 @@
 // echo example based on libp2p-stream example
-#[cfg(feature = "experimental_stream")]
+#[cfg(feature = "stream")]
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     use std::time::Duration;
@@ -130,7 +130,7 @@ async fn main() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[cfg(not(feature = "experimental_stream"))]
+#[cfg(not(feature = "stream"))]
 fn main() {
-    unimplemented!("\"experimental_stream\" not enabled")
+    unimplemented!("\"stream\" not enabled")
 }

packages/rust-ipns/Cargo.toml

@@ -20,14 +20,7 @@ serde = { workspace = true, features = ["derive"] }
 multihash.workspace = true
 chrono.workspace = true
 
-libp2p-identity = { version = "0.2.10", optional = true, features = [
-    "ecdsa",
-    "ed25519",
-    "peerid",
-    "rand",
-    "rsa",
-    "secp256k1",
-] }
+libp2p-identity = { version = "0.2.10", optional = true, features = ["peerid", "rand"] }
 derive_more = { version = "2.0.1", features = ["full"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
@@ -37,5 +30,11 @@ getrandom = { workspace = true, features = ["js"] }
 clap = { workspace = true, features = ["derive"] }
 
 [features]
-default = ["libp2p"]
 libp2p = ["dep:libp2p-identity"]
+
+default = ["libp2p", "rsa", "ed25519", "secp256k1", "ecdsa"]
+
+rsa = ["libp2p-identity?/rsa"]
+ed25519 = ["libp2p-identity?/ed25519"]
+secp256k1 = ["libp2p-identity?/secp256k1"]
+ecdsa = ["libp2p-identity?/ecdsa"]

src/ipns/dnslink.rs

@@ -1,4 +1,5 @@
 use crate::error::Error;
+#[cfg(feature = "dns")]
 use crate::p2p::DnsResolver;
 use crate::path::IpfsPath;
 

src/ipns/mod.rs

@@ -3,17 +3,20 @@
 use futures_timeout::TimeoutExt;
 use std::borrow::Borrow;
 
+#[cfg(feature = "dns")]
 use crate::p2p::DnsResolver;
 use crate::path::{IpfsPath, PathRoot};
 use crate::repo::DataStore;
 use crate::Ipfs;
 
+#[cfg(feature = "dns")]
 mod dnslink;
 
 /// IPNS facade around [`Ipns`].
 #[derive(Clone, Debug)]
 pub struct Ipns {
     ipfs: Ipfs,
+    #[cfg(feature = "dns")]
     resolver: DnsResolver,
 }
 
@@ -28,11 +31,13 @@ impl Ipns {
     pub fn new(ipfs: Ipfs) -> Self {
         Ipns {
             ipfs,
+            #[cfg(feature = "dns")]
             resolver: DnsResolver::default(),
         }
     }
 
     /// Set dns resolver
+    #[cfg(feature = "dns")]
     pub fn set_resolver(&mut self, resolver: DnsResolver) {
         self.resolver = resolver;
     }
@@ -128,6 +133,7 @@ impl Ipns {
                         Ok(internal_path)
                     })
             }
+            #[cfg(feature = "dns")]
             PathRoot::Dns(domain) => {
                 let path_iter = path.iter();
                 dnslink::resolve(self.resolver, domain, path_iter)

src/keystore.rs

@@ -11,8 +11,11 @@ use zeroize::Zeroize;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum KeyType {
+    #[cfg(feature = "ed25519")]
     Ed25519,
+    #[cfg(feature = "ecdsa")]
     Ecdsa,
+    #[cfg(feature = "secp256k1")]
     Secp256k1,
 }
 
@@ -97,18 +100,21 @@ impl Keystore {
 
     /// Generate a Ed25519 Keypair
     /// If `name` is not supplied, the [`crate::PeerId`] will be the used as the name by default
+    #[cfg(feature = "ed25519")]
     pub async fn generate_ed25519(&self, name: Option<&str>) -> Result<PublicKey, Error> {
         self.generate_key(name, KeyType::Ed25519).await
     }
 
     /// Generate a Ecdsa Keypair
     /// If `name` is not supplied, the [`crate::PeerId`] will be the used as the name by default
+    #[cfg(feature = "ecdsa")]
     pub async fn generate_ecdsa(&self, name: Option<&str>) -> Result<PublicKey, Error> {
         self.generate_key(name, KeyType::Ecdsa).await
     }
 
     /// Generate a Secp256k1 Keypair
     /// If `name` is not supplied, the [`crate::PeerId`] will be the used as the name by default
+    #[cfg(feature = "secp256k1")]
     pub async fn generate_secp256k1(&self, name: Option<&str>) -> Result<PublicKey, Error> {
         self.generate_key(name, KeyType::Secp256k1).await
     }
@@ -120,25 +126,39 @@ impl Keystore {
         name: Option<&str>,
         key_type: KeyType,
     ) -> Result<PublicKey, Error> {
-        let keypair = match key_type {
-            KeyType::Ed25519 => Keypair::generate_ed25519(),
-            KeyType::Ecdsa => Keypair::generate_ecdsa(),
-            KeyType::Secp256k1 => Keypair::generate_secp256k1(),
-        };
-        let public_key = keypair.public();
+        #[cfg(not(all(feature = "ed25519", feature = "ecdsa", feature = "secp256k1")))]
+        {
+            let _ = name;
+            let _ = key_type;
+            return Err(anyhow::anyhow!("No key type selected"));
+        }
 
-        let peer_id = public_key.to_peer_id().to_string();
+        #[cfg(any(feature = "ed25519", feature = "ecdsa", feature = "secp256k1"))]
+        {
+            let keypair: Keypair = match key_type {
+                #[cfg(feature = "ed25519")]
+                KeyType::Ed25519 => Keypair::generate_ed25519(),
+                #[cfg(feature = "ecdsa")]
+                KeyType::Ecdsa => Keypair::generate_ecdsa(),
+                #[cfg(feature = "secp256k1")]
+                KeyType::Secp256k1 => Keypair::generate_secp256k1(),
+            };
 
-        let peer_id_str = peer_id.as_str();
+            let public_key = keypair.public();
 
-        // We could probably wrap this in `Zeroizing` instead until `KeyStore` is refactored to accept `Key`
-        let bytes = Key::from(keypair.to_protobuf_encoding()?);
+            let peer_id = public_key.to_peer_id().to_string();
 
-        let name = name.unwrap_or(peer_id_str);
+            let peer_id_str = peer_id.as_str();
 
-        self.storage.set(name, bytes.as_ref()).await?;
+            // We could probably wrap this in `Zeroizing` instead until `KeyStore` is refactored to accept `Key`
+            let bytes = Key::from(keypair.to_protobuf_encoding()?);
 
-        Ok(public_key)
+            let name = name.unwrap_or(peer_id_str);
+
+            self.storage.set(name, bytes.as_ref()).await?;
+
+            Ok(public_key)
+        }
     }
 
     /// Get a [`Keypair`] from the [`Keystore`]
@@ -244,6 +264,7 @@ impl KeyStorage for MemoryKeyStorage {
 mod test {
     use crate::keystore::Keystore;
 
+    #[cfg(feature = "ed25519")]
     #[tokio::test]
     async fn keystore_with_peerid() -> anyhow::Result<()> {
         let keystore = Keystore::in_memory();
@@ -257,6 +278,7 @@ mod test {
         Ok(())
     }
 
+    #[cfg(feature = "ed25519")]
     #[tokio::test]
     async fn keystore_with_name() -> anyhow::Result<()> {
         let keystore = Keystore::in_memory();
@@ -268,6 +290,7 @@ mod test {
         Ok(())
     }
 
+    #[cfg(feature = "ed25519")]
     #[tokio::test]
     async fn keystore_replace_existing() -> anyhow::Result<()> {
         let keystore = Keystore::in_memory();
@@ -277,6 +300,7 @@ mod test {
         Ok(())
     }
 
+    #[cfg(feature = "ed25519")]
     #[tokio::test]
     async fn keystore_multiple_keys() -> anyhow::Result<()> {
         let keystore = Keystore::in_memory();
@@ -293,6 +317,7 @@ mod test {
         Ok(())
     }
 
+    #[cfg(feature = "ed25519")]
     #[tokio::test]
     async fn keystore_rename() -> anyhow::Result<()> {
         let keystore = Keystore::in_memory();