Don't depend on the meta crate for dev-dependencies

Cargo.toml

@@ -126,8 +126,8 @@ libp2p-gossipsub = { version = "0.42.1", path = "protocols/gossipsub", optional
 [dev-dependencies]
 async-std = { version = "1.6.2", features = ["attributes"] }
 async-trait = "0.1"
-env_logger = "0.9.0"
 clap = { version = "4.0.13", features = ["derive"] }
+env_logger = "0.9.0"
 tokio = { version = "1.15", features = ["io-util", "io-std", "macros", "rt", "rt-multi-thread"] }
 
 [workspace]
@@ -168,36 +168,36 @@ members = [
 
 [[example]]
 name = "chat"
-required-features = ["full"]
+required-features = []
 
 [[example]]
 name = "chat-tokio"
-required-features = ["full"]
+required-features = []
 
 [[example]]
 name = "file-sharing"
-required-features = ["full"]
+required-features = []
 
 [[example]]
 name = "gossipsub-chat"
-required-features = ["full"]
+required-features = []
 
 [[example]]
 name = "ipfs-private"
-required-features = ["full"]
+required-features = []
 
 [[example]]
 name = "ipfs-kad"
-required-features = ["full"]
+required-features = []
 
 [[example]]
 name = "ping"
-required-features = ["full"]
+required-features = []
 
 [[example]]
 name = "mdns-passive-discovery"
-required-features = ["full"]
+required-features = []
 
 [[example]]
 name = "distributed-key-value-store"
-required-features = ["full"]
+required-features = []

core/Cargo.toml

@@ -46,7 +46,8 @@ ring = { version = "0.16.9", features = ["alloc", "std"], default-features = fal
 async-std = { version = "1.6.2", features = ["attributes"] }
 base64 = "0.13.0"
 criterion = "0.4"
-libp2p = { path = "..", features = ["full"] }
+libp2p-mplex = { path = "../muxers/mplex" }
+libp2p-noise = { path = "../transports/noise" }
 multihash = { version = "0.16", default-features = false, features = ["arb"] }
 quickcheck = { package = "quickcheck-ext", path = "../misc/quickcheck-ext" }
 rmp-serde = "1.0"

core/tests/transport_upgrade.rs

@@ -19,11 +19,11 @@
 // DEALINGS IN THE SOFTWARE.
 
 use futures::prelude::*;
-use libp2p::core::identity;
-use libp2p::core::transport::{MemoryTransport, Transport};
-use libp2p::core::upgrade::{self, InboundUpgrade, OutboundUpgrade, UpgradeInfo};
-use libp2p::mplex::MplexConfig;
-use libp2p::noise;
+use libp2p_core::identity;
+use libp2p_core::transport::{MemoryTransport, Transport};
+use libp2p_core::upgrade::{self, InboundUpgrade, OutboundUpgrade, UpgradeInfo};
+use libp2p_mplex::MplexConfig;
+use libp2p_noise as noise;
 use multiaddr::{Multiaddr, Protocol};
 use rand::random;
 use std::{io, pin::Pin};

misc/metrics/Cargo.toml

@@ -32,9 +32,8 @@ prometheus-client = "0.18.0"
 libp2p-gossipsub =  { version = "0.42.0", path = "../../protocols/gossipsub", optional = true }
 
 [dev-dependencies]
-log = "0.4.0"
 env_logger = "0.9.0"
 futures = "0.3.1"
-libp2p = { path = "../..", features = ["full"] }
 hyper = { version="0.14", features = ["server", "tcp", "http1"] }
+log = "0.4.0"
 tokio = { version = "1", features = ["rt-multi-thread"] }

misc/metrics/examples/metrics/main.rs

@@ -51,11 +51,14 @@
 use env_logger::Env;
 use futures::executor::block_on;
 use futures::stream::StreamExt;
-use libp2p::core::Multiaddr;
-use libp2p::metrics::{Metrics, Recorder};
-use libp2p::swarm::{NetworkBehaviour, SwarmEvent};
-use libp2p::{identity, ping, PeerId, Swarm};
+use libp2p_core::Multiaddr;
+use libp2p_core::{identity, PeerId};
+use libp2p_metrics::{Metrics, Recorder};
+use libp2p_ping as ping;
 use libp2p_swarm::keep_alive;
+use libp2p_swarm::NetworkBehaviour;
+use libp2p_swarm::Swarm;
+use libp2p_swarm::SwarmEvent;
 use log::info;
 use prometheus_client::registry::Registry;
 use std::error::Error;
@@ -110,6 +113,7 @@ fn main() -> Result<(), Box<dyn Error>> {
 /// For illustrative purposes, this includes the [`keep_alive::Behaviour`]) behaviour so the ping actually happen
 /// and can be observed via the metrics.
 #[derive(NetworkBehaviour, Default)]
+#[behaviour(prelude = "libp2p_swarm::derive_prelude")]
 struct Behaviour {
     keep_alive: keep_alive::Behaviour,
     ping: ping::Behaviour,

misc/multistream-select/Cargo.toml

@@ -21,7 +21,10 @@ unsigned-varint = "0.7"
 [dev-dependencies]
 async-std = "1.6.2"
 env_logger = "0.9"
-libp2p = { path = "../..", features = ["full"] }
+libp2p-core = { path = "../../core" }
+libp2p-mplex = { path = "../../muxers/mplex" }
+libp2p-plaintext = { path = "../../transports/plaintext" }
+libp2p-swarm = { path = "../../swarm" }
 quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
 rand = "0.8"
 rw-stream-sink = { version = "0.3.0", path = "../../misc/rw-stream-sink" }

misc/multistream-select/tests/transport.rs

@@ -19,16 +19,16 @@
 // DEALINGS IN THE SOFTWARE.
 
 use futures::{channel::oneshot, prelude::*, ready};
-use libp2p::core::{
+use libp2p_core::{
     identity,
     multiaddr::Protocol,
     muxing::StreamMuxerBox,
     transport::{self, MemoryTransport},
     upgrade, Multiaddr, PeerId, Transport,
 };
-use libp2p::mplex::MplexConfig;
-use libp2p::plaintext::PlainText2Config;
-use libp2p::swarm::{dummy, Swarm, SwarmEvent};
+use libp2p_mplex::MplexConfig;
+use libp2p_plaintext::PlainText2Config;
+use libp2p_swarm::{dummy, Swarm, SwarmEvent};
 use rand::random;
 use std::task::Poll;
 

muxers/mplex/Cargo.toml

@@ -27,8 +27,9 @@ async-std = { version = "1.7.0", features = ["attributes"] }
 criterion = "0.4"
 env_logger = "0.9"
 futures = "0.3"
-libp2p = { path = "../..", features = ["full"] }
 libp2p-muxer-test-harness = { path = "../test-harness" }
+libp2p-plaintext = { path = "../../transports/plaintext" }
+libp2p-tcp = { path = "../../transports/tcp" }
 quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
 
 [[bench]]

muxers/mplex/benches/split_send_size.rs

@@ -26,13 +26,13 @@ use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughpu
 use futures::future::poll_fn;
 use futures::prelude::*;
 use futures::{channel::oneshot, future::join};
-use libp2p::core::muxing::StreamMuxerExt;
-use libp2p::core::{
+use libp2p_core::muxing::StreamMuxerExt;
+use libp2p_core::{
     identity, multiaddr::multiaddr, muxing, transport, upgrade, Multiaddr, PeerId, Transport,
 };
-use libp2p::mplex;
-use libp2p::plaintext::PlainText2Config;
-use libp2p::tcp::GenTcpConfig;
+use libp2p_mplex as mplex;
+use libp2p_plaintext::PlainText2Config;
+use libp2p_tcp::GenTcpConfig;
 use std::pin::Pin;
 use std::time::Duration;
 
@@ -170,7 +170,7 @@ fn tcp_transport(split_send_size: usize) -> BenchTransport {
     let mut mplex = mplex::MplexConfig::default();
     mplex.set_split_send_size(split_send_size);
 
-    libp2p::tcp::TcpTransport::new(GenTcpConfig::default().nodelay(true))
+    libp2p_tcp::TcpTransport::new(GenTcpConfig::default().nodelay(true))
         .upgrade(upgrade::Version::V1)
         .authenticate(PlainText2Config { local_public_key })
         .multiplex(mplex)

protocols/autonat/Cargo.toml

@@ -27,6 +27,6 @@ prost = "0.11"
 
 [dev-dependencies]
 async-std = { version = "1.10", features = ["attributes"] }
-env_logger = "0.9"
 clap = { version = "4.0.13", features = ["derive"] }
-libp2p = { path = "../..", features = ["full"] }
+env_logger = "0.9"
+libp2p-identify = { path = "../identify" }

protocols/autonat/examples/autonat_client.rs

@@ -31,11 +31,11 @@
 
 use clap::Parser;
 use futures::prelude::*;
-use libp2p::autonat;
-use libp2p::identify;
-use libp2p::multiaddr::Protocol;
-use libp2p::swarm::{NetworkBehaviour, Swarm, SwarmEvent};
-use libp2p::{identity, Multiaddr, PeerId};
+use libp2p_autonat as autonat;
+use libp2p_core::multiaddr::Protocol;
+use libp2p_core::{identity, Multiaddr, PeerId};
+use libp2p_identify as identify;
+use libp2p_swarm::{NetworkBehaviour, Swarm, SwarmEvent};
 use std::error::Error;
 use std::net::Ipv4Addr;
 use std::time::Duration;
@@ -89,7 +89,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 }
 
 #[derive(NetworkBehaviour)]
-#[behaviour(out_event = "Event")]
+#[behaviour(out_event = "Event", prelude = "libp2p_swarm::derive_prelude")]
 struct Behaviour {
     identify: identify::Behaviour,
     auto_nat: autonat::Behaviour,

protocols/autonat/examples/autonat_server.rs

@@ -28,11 +28,11 @@
 
 use clap::Parser;
 use futures::prelude::*;
-use libp2p::autonat;
-use libp2p::identify;
-use libp2p::multiaddr::Protocol;
-use libp2p::swarm::{NetworkBehaviour, Swarm, SwarmEvent};
-use libp2p::{identity, Multiaddr, PeerId};
+use libp2p_autonat as autonat;
+use libp2p_core::multiaddr::Protocol;
+use libp2p_core::{identity, Multiaddr, PeerId};
+use libp2p_identify as identify;
+use libp2p_swarm::{NetworkBehaviour, Swarm, SwarmEvent};
 use std::error::Error;
 use std::net::Ipv4Addr;
 
@@ -74,7 +74,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 }
 
 #[derive(NetworkBehaviour)]
-#[behaviour(out_event = "Event")]
+#[behaviour(out_event = "Event", prelude = "libp2p_swarm::derive_prelude")]
 struct Behaviour {
     identify: identify::Behaviour,
     auto_nat: autonat::Behaviour,

protocols/autonat/tests/test_client.rs

@@ -20,15 +20,11 @@
 
 use futures::{channel::oneshot, Future, FutureExt, StreamExt};
 use futures_timer::Delay;
-use libp2p::{
-    development_transport,
-    identity::Keypair,
-    swarm::{AddressScore, Swarm, SwarmEvent},
-    Multiaddr, PeerId,
-};
 use libp2p_autonat::{
     Behaviour, Config, Event, NatStatus, OutboundProbeError, OutboundProbeEvent, ResponseError,
 };
+use libp2p_core::{identity::Keypair, Multiaddr, PeerId};
+use libp2p_swarm::{AddressScore, Swarm, SwarmEvent};
 use std::time::Duration;
 
 const MAX_CONFIDENCE: usize = 3;
@@ -38,7 +34,7 @@ const TEST_REFRESH_INTERVAL: Duration = Duration::from_secs(2);
 async fn init_swarm(config: Config) -> Swarm<Behaviour> {
     let keypair = Keypair::generate_ed25519();
     let local_id = PeerId::from_public_key(&keypair.public());
-    let transport = development_transport(keypair).await.unwrap();
+    let transport = libp2p::development_transport(keypair).await.unwrap();
     let behaviour = Behaviour::new(local_id, config);
     Swarm::new(transport, behaviour, local_id)
 }

protocols/autonat/tests/test_server.rs

@@ -20,24 +20,19 @@
 
 use futures::{channel::oneshot, Future, FutureExt, StreamExt};
 use futures_timer::Delay;
-use libp2p::core::{ConnectedPoint, Endpoint};
-use libp2p::swarm::DialError;
-use libp2p::{
-    development_transport,
-    identity::Keypair,
-    multiaddr::Protocol,
-    swarm::{AddressScore, Swarm, SwarmEvent},
-    Multiaddr, PeerId,
-};
 use libp2p_autonat::{
     Behaviour, Config, Event, InboundProbeError, InboundProbeEvent, ResponseError,
 };
+use libp2p_core::{identity::Keypair, multiaddr::Protocol, Multiaddr, PeerId};
+use libp2p_core::{ConnectedPoint, Endpoint};
+use libp2p_swarm::DialError;
+use libp2p_swarm::{AddressScore, Swarm, SwarmEvent};
 use std::{num::NonZeroU32, time::Duration};
 
 async fn init_swarm(config: Config) -> Swarm<Behaviour> {
     let keypair = Keypair::generate_ed25519();
     let local_id = PeerId::from_public_key(&keypair.public());
-    let transport = development_transport(keypair).await.unwrap();
+    let transport = libp2p::development_transport(keypair).await.unwrap();
     let behaviour = Behaviour::new(local_id, config);
     Swarm::new(transport, behaviour, local_id)
 }

protocols/dcutr/Cargo.toml

@@ -29,7 +29,13 @@ void = "1"
 prost-build = "0.11"
 
 [dev-dependencies]
+clap = { version = "4.0.13", features = ["derive"] }
 env_logger = "0.9.0"
-libp2p = { path = "../..", features = ["full"] }
+libp2p-dns = { path = "../../transports/dns" }
+libp2p-noise = { path = "../../transports/noise" }
+libp2p-identify = { path = "../../protocols/identify" }
+libp2p-plaintext = { path = "../../transports/plaintext" }
+libp2p-relay = { path = "../relay" }
+libp2p-tcp = { path = "../../transports/tcp" }
+libp2p-yamux = { path = "../../muxers/yamux" }
 rand = "0.8"
-clap = { version = "4.0.13", features = ["derive"] }

protocols/dcutr/examples/dcutr.rs

@@ -22,18 +22,19 @@ use clap::Parser;
 use futures::executor::block_on;
 use futures::future::FutureExt;
 use futures::stream::StreamExt;
-use libp2p::core::multiaddr::{Multiaddr, Protocol};
-use libp2p::core::transport::OrTransport;
-use libp2p::core::upgrade;
-use libp2p::dns::DnsConfig;
-use libp2p::identify;
-use libp2p::noise;
-use libp2p::relay::v2::client::{self, Client};
-use libp2p::swarm::{NetworkBehaviour, SwarmBuilder, SwarmEvent};
-use libp2p::tcp::{GenTcpConfig, TcpTransport};
-use libp2p::Transport;
-use libp2p::{dcutr, ping};
-use libp2p::{identity, PeerId};
+use libp2p_core::multiaddr::{Multiaddr, Protocol};
+use libp2p_core::transport::OrTransport;
+use libp2p_core::upgrade;
+use libp2p_core::Transport;
+use libp2p_core::{identity, PeerId};
+use libp2p_dcutr as dctur;
+use libp2p_dns::DnsConfig;
+use libp2p_identify as identify;
+use libp2p_noise as noise;
+use libp2p_ping as ping;
+use libp2p_relay::v2::client::{self, Client};
+use libp2p_swarm::{NetworkBehaviour, SwarmBuilder, SwarmEvent};
+use libp2p_tcp::{GenTcpConfig, TcpTransport};
 use log::info;
 use std::convert::TryInto;
 use std::error::Error;
@@ -100,7 +101,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         noise::NoiseAuthenticated::xx(&local_key)
             .expect("Signing libp2p-noise static DH keypair failed."),
     )
-    .multiplex(libp2p::yamux::YamuxConfig::default())
+    .multiplex(libp2p_yamux::YamuxConfig::default())
     .boxed();
 
     #[derive(NetworkBehaviour)]