diff --git a/Cargo.lock b/Cargo.lock
index 252451a01d..ac86ab4e59 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -856,7 +856,7 @@ dependencies = [
  "serde",
  "serde_derive",
  "sfw-provider-requests",
- "sphinx",
+ "sphinx 0.1.0",
  "tokio 0.2.9",
  "topology",
 ]
@@ -1257,7 +1257,7 @@ dependencies = [
  "pretty_env_logger",
  "rand 0.7.2",
  "rand_distr",
- "sphinx",
+ "sphinx 0.1.0",
  "tokio 0.2.9",
  "topology",
 ]
@@ -1364,7 +1364,7 @@ dependencies = [
  "serde",
  "serde_json",
  "sfw-provider-requests",
- "sphinx",
+ "sphinx 0.1.0",
  "tokio 0.2.9",
  "tokio-tungstenite",
  "topology",
@@ -1385,7 +1385,7 @@ dependencies = [
  "futures 0.3.1",
  "log",
  "pretty_env_logger",
- "sphinx",
+ "sphinx 0.1.0 (git+https://github.com/nymtech/sphinx?rev=1d8cefcb6a0cb8e87d00d89eb1ccf2839e92aa1f)",
  "tokio 0.2.9",
 ]
 
@@ -1410,7 +1410,7 @@ dependencies = [
  "serde_json",
  "sfw-provider-requests",
  "sha2",
- "sphinx",
+ "sphinx 0.1.0 (git+https://github.com/nymtech/sphinx?rev=1d8cefcb6a0cb8e87d00d89eb1ccf2839e92aa1f)",
  "tokio 0.2.9",
 ]
 
@@ -1618,7 +1618,7 @@ dependencies = [
  "log",
  "pretty_env_logger",
  "sfw-provider-requests",
- "sphinx",
+ "sphinx 0.1.0 (git+https://github.com/nymtech/sphinx?rev=1d8cefcb6a0cb8e87d00d89eb1ccf2839e92aa1f)",
  "tokio 0.2.9",
 ]
 
@@ -2025,7 +2025,7 @@ dependencies = [
 name = "sfw-provider-requests"
 version = "0.1.0"
 dependencies = [
- "sphinx",
+ "sphinx 0.1.0 (git+https://github.com/nymtech/sphinx?rev=1d8cefcb6a0cb8e87d00d89eb1ccf2839e92aa1f)",
 ]
 
 [[package]]
@@ -2116,6 +2116,27 @@ dependencies = [
  "sha2",
 ]
 
+[[package]]
+name = "sphinx"
+version = "0.1.0"
+dependencies = [
+ "aes-ctr",
+ "arrayref",
+ "base64 0.11.0",
+ "blake2",
+ "byteorder",
+ "chacha",
+ "curve25519-dalek",
+ "hkdf",
+ "hmac",
+ "lioness",
+ "log",
+ "rand 0.7.2",
+ "rand_distr",
+ "rand_os",
+ "sha2",
+]
+
 [[package]]
 name = "stream-cipher"
 version = "0.3.2"
@@ -2427,7 +2448,7 @@ dependencies = [
  "pretty_env_logger",
  "rand 0.7.2",
  "serde",
- "sphinx",
+ "sphinx 0.1.0",
  "version-checker",
 ]
 
diff --git a/common/clients/directory-client/src/presence.rs b/common/clients/directory-client/src/presence.rs
index 8be3c73b9e..469a1dd026 100644
--- a/common/clients/directory-client/src/presence.rs
+++ b/common/clients/directory-client/src/presence.rs
@@ -5,7 +5,10 @@ use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use std::io;
 use std::net::ToSocketAddrs;
-use topology::{CocoNode, MixNode, MixProviderNode, NymTopology};
+use topology::coco;
+use topology::mix;
+use topology::provider;
+use topology::NymTopology;
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -16,9 +19,9 @@ pub struct CocoPresence {
     pub version: String,
 }
 
-impl Into<topology::CocoNode> for CocoPresence {
-    fn into(self) -> topology::CocoNode {
-        topology::CocoNode {
+impl Into<topology::coco::Node> for CocoPresence {
+    fn into(self) -> topology::coco::Node {
+        topology::coco::Node {
             host: self.host,
             pub_key: self.pub_key,
             last_seen: self.last_seen,
@@ -27,8 +30,8 @@ impl Into<topology::CocoNode> for CocoPresence {
     }
 }
 
-impl From<topology::CocoNode> for CocoPresence {
-    fn from(cn: CocoNode) -> Self {
+impl From<topology::coco::Node> for CocoPresence {
+    fn from(cn: coco::Node) -> Self {
         CocoPresence {
             host: cn.host,
             pub_key: cn.pub_key,
@@ -48,10 +51,10 @@ pub struct MixNodePresence {
     pub version: String,
 }
 
-impl TryInto<topology::MixNode> for MixNodePresence {
+impl TryInto<topology::mix::Node> for MixNodePresence {
     type Error = io::Error;
 
-    fn try_into(self) -> Result<MixNode, Self::Error> {
+    fn try_into(self) -> Result<topology::mix::Node, Self::Error> {
         let resolved_hostname = self.host.to_socket_addrs()?.next();
         if resolved_hostname.is_none() {
             return Err(io::Error::new(
@@ -60,7 +63,7 @@ impl TryInto<topology::MixNode> for MixNodePresence {
             ));
         }
 
-        Ok(topology::MixNode {
+        Ok(topology::mix::Node {
             host: resolved_hostname.unwrap(),
             pub_key: self.pub_key,
             layer: self.layer,
@@ -70,8 +73,8 @@ impl TryInto<topology::MixNode> for MixNodePresence {
     }
 }
 
-impl From<topology::MixNode> for MixNodePresence {
-    fn from(mn: MixNode) -> Self {
+impl From<topology::mix::Node> for MixNodePresence {
+    fn from(mn: mix::Node) -> Self {
         MixNodePresence {
             host: mn.host.to_string(),
             pub_key: mn.pub_key,
@@ -93,9 +96,9 @@ pub struct MixProviderPresence {
     pub version: String,
 }
 
-impl Into<topology::MixProviderNode> for MixProviderPresence {
-    fn into(self) -> topology::MixProviderNode {
-        topology::MixProviderNode {
+impl Into<provider::Node> for MixProviderPresence {
+    fn into(self) -> provider::Node {
+        provider::Node {
             client_listener: self.client_listener.parse().unwrap(),
             mixnet_listener: self.mixnet_listener.parse().unwrap(),
             pub_key: self.pub_key,
@@ -110,8 +113,8 @@ impl Into<topology::MixProviderNode> for MixProviderPresence {
     }
 }
 
-impl From<topology::MixProviderNode> for MixProviderPresence {
-    fn from(mpn: MixProviderNode) -> Self {
+impl From<topology::provider::Node> for MixProviderPresence {
+    fn from(mpn: provider::Node) -> Self {
         MixProviderPresence {
             client_listener: mpn.client_listener.to_string(),
             mixnet_listener: mpn.mixnet_listener.to_string(),
@@ -133,16 +136,16 @@ pub struct MixProviderClient {
     pub pub_key: String,
 }
 
-impl Into<topology::MixProviderClient> for MixProviderClient {
-    fn into(self) -> topology::MixProviderClient {
-        topology::MixProviderClient {
+impl Into<topology::provider::Client> for MixProviderClient {
+    fn into(self) -> topology::provider::Client {
+        topology::provider::Client {
             pub_key: self.pub_key,
         }
     }
 }
 
-impl From<topology::MixProviderClient> for MixProviderClient {
-    fn from(mpc: topology::MixProviderClient) -> Self {
+impl From<topology::provider::Client> for MixProviderClient {
+    fn from(mpc: topology::provider::Client) -> Self {
         MixProviderClient {
             pub_key: mpc.pub_key,
         }
@@ -174,9 +177,9 @@ impl NymTopology for Topology {
     }
 
     fn new_from_nodes(
-        mix_nodes: Vec<MixNode>,
-        mix_provider_nodes: Vec<MixProviderNode>,
-        coco_nodes: Vec<CocoNode>,
+        mix_nodes: Vec<mix::Node>,
+        mix_provider_nodes: Vec<provider::Node>,
+        coco_nodes: Vec<coco::Node>,
     ) -> Self {
         Topology {
             coco_nodes: coco_nodes.into_iter().map(|node| node.into()).collect(),
@@ -188,21 +191,21 @@ impl NymTopology for Topology {
         }
     }
 
-    fn get_mix_nodes(&self) -> Vec<topology::MixNode> {
+    fn mix_nodes(&self) -> Vec<mix::Node> {
         self.mix_nodes
             .iter()
             .filter_map(|x| x.clone().try_into().ok())
             .collect()
     }
 
-    fn get_mix_provider_nodes(&self) -> Vec<topology::MixProviderNode> {
+    fn providers(&self) -> Vec<provider::Node> {
         self.mix_provider_nodes
             .iter()
             .map(|x| x.clone().into())
             .collect()
     }
 
-    fn get_coco_nodes(&self) -> Vec<topology::CocoNode> {
+    fn coco_nodes(&self) -> Vec<topology::coco::Node> {
         self.coco_nodes.iter().map(|x| x.clone().into()).collect()
     }
 }
@@ -223,7 +226,7 @@ mod converting_mixnode_presence_into_topology_mixnode {
             version: "".to_string(),
         };
 
-        let result: Result<topology::MixNode, io::Error> = mix_presence.try_into();
+        let result: Result<mix::Node, io::Error> = mix_presence.try_into();
         assert!(result.is_err())
     }
 
@@ -239,7 +242,7 @@ mod converting_mixnode_presence_into_topology_mixnode {
             version: "".to_string(),
         };
 
-        let result: Result<topology::MixNode, io::Error> = mix_presence.try_into();
+        let result: Result<topology::mix::Node, io::Error> = mix_presence.try_into();
         assert!(result.is_ok())
     }
 }
diff --git a/common/clients/mix-client/Cargo.toml b/common/clients/mix-client/Cargo.toml
index a7ef6e35c8..37722aa238 100644
--- a/common/clients/mix-client/Cargo.toml
+++ b/common/clients/mix-client/Cargo.toml
@@ -18,5 +18,6 @@ addressing = {path = "../../addressing"}
 topology = {path = "../../topology"}
 
 ## will be moved to proper dependencies once released
-sphinx = { git = "https://github.com/nymtech/sphinx", rev="1d8cefcb6a0cb8e87d00d89eb1ccf2839e92aa1f" }
+# sphinx = { git = "https://github.com/nymtech/sphinx", rev="1d8cefcb6a0cb8e87d00d89eb1ccf2839e92aa1f" }
+sphinx = { path = "../../../../sphinx"}
 
diff --git a/common/clients/mix-client/src/packet.rs b/common/clients/mix-client/src/packet.rs
index cc1a027cb6..7999d1e620 100644
--- a/common/clients/mix-client/src/packet.rs
+++ b/common/clients/mix-client/src/packet.rs
@@ -28,7 +28,7 @@ pub fn encapsulate_message<T: NymTopology>(
     topology: &T,
     average_delay: f64,
 ) -> (SocketAddr, SphinxPacket) {
-    let mut providers = topology.get_mix_provider_nodes();
+    let mut providers = topology.providers();
     let provider = providers.pop().unwrap().into();
 
     let route = topology.route_to(provider).unwrap();
diff --git a/common/healthcheck/Cargo.toml b/common/healthcheck/Cargo.toml
index 918efa0df9..22f55f572a 100644
--- a/common/healthcheck/Cargo.toml
+++ b/common/healthcheck/Cargo.toml
@@ -25,6 +25,7 @@ sfw-provider-requests = { path = "../../sfw-provider/sfw-provider-requests" }
 topology = {path = "../topology" }
 
 ## will be moved to proper dependencies once released
-sphinx = { git = "https://github.com/nymtech/sphinx", rev="1d8cefcb6a0cb8e87d00d89eb1ccf2839e92aa1f" }
+# sphinx = { git = "https://github.com/nymtech/sphinx", rev="1d8cefcb6a0cb8e87d00d89eb1ccf2839e92aa1f" }
+sphinx = { path = "../../../sphinx"}
 
 [dev-dependencies]
diff --git a/common/healthcheck/src/path_check.rs b/common/healthcheck/src/path_check.rs
index 62b94a86b1..e5d90eb70a 100644
--- a/common/healthcheck/src/path_check.rs
+++ b/common/healthcheck/src/path_check.rs
@@ -6,7 +6,7 @@ use provider_client::ProviderClient;
 use sphinx::header::delays::Delay;
 use sphinx::route::{Destination, Node as SphinxNode};
 use std::collections::HashMap;
-use topology::MixProviderNode;
+use topology::provider;
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum PathStatus {
@@ -27,7 +27,7 @@ pub(crate) struct PathChecker {
 
 impl PathChecker {
     pub(crate) async fn new(
-        providers: Vec<MixProviderNode>,
+        providers: Vec<provider::Node>,
         ephemeral_keys: DummyMixIdentityKeyPair,
     ) -> Self {
         let mut provider_clients = HashMap::new();
diff --git a/common/healthcheck/src/result.rs b/common/healthcheck/src/result.rs
index 79ec6a291f..b7aae8d33c 100644
--- a/common/healthcheck/src/result.rs
+++ b/common/healthcheck/src/result.rs
@@ -28,8 +28,8 @@ impl HealthCheckResult {
 
     fn zero_score<T: NymTopology>(topology: T) -> Self {
         warn!("The network is unhealthy, could not send any packets - returning zero score!");
-        let mixes = topology.get_mix_nodes();
-        let providers = topology.get_mix_provider_nodes();
+        let mixes = topology.mix_nodes();
+        let providers = topology.providers();
 
         let health = mixes
             .into_iter()
@@ -58,7 +58,7 @@ impl HealthCheckResult {
         score_threshold: f64,
     ) -> T {
         let filtered_mix_nodes = topology
-            .get_mix_nodes()
+            .mix_nodes()
             .into_iter()
             .filter(|node| {
                 match self.node_score(NodeAddressBytes::from_b64_string(node.pub_key.clone())) {
@@ -72,7 +72,7 @@ impl HealthCheckResult {
             .collect();
 
         let filtered_provider_nodes = topology
-            .get_mix_provider_nodes()
+            .providers()
             .into_iter()
             .filter(|node| {
                 match self.node_score(NodeAddressBytes::from_b64_string(node.pub_key.clone())) {
@@ -85,7 +85,7 @@ impl HealthCheckResult {
             })
             .collect();
         // coco nodes remain unchanged as no healthcheck is being run on them or time being
-        let filtered_coco_nodes = topology.get_coco_nodes();
+        let filtered_coco_nodes = topology.coco_nodes();
 
         T::new_from_nodes(
             filtered_mix_nodes,
@@ -110,19 +110,16 @@ impl HealthCheckResult {
 
         // create entries for all nodes
         let mut score_map = HashMap::new();
-        topology.get_mix_nodes().into_iter().for_each(|node| {
+        topology.mix_nodes().into_iter().for_each(|node| {
             score_map.insert(node.get_pub_key_bytes(), NodeScore::from_mixnode(node));
         });
 
-        topology
-            .get_mix_provider_nodes()
-            .into_iter()
-            .for_each(|node| {
-                score_map.insert(node.get_pub_key_bytes(), NodeScore::from_provider(node));
-            });
+        topology.providers().into_iter().for_each(|node| {
+            score_map.insert(node.get_pub_key_bytes(), NodeScore::from_provider(node));
+        });
 
         let ephemeral_keys = DummyMixIdentityKeyPair::new();
-        let providers = topology.get_mix_provider_nodes();
+        let providers = topology.providers();
 
         let mut path_checker = PathChecker::new(providers, ephemeral_keys).await;
         for i in 0..iterations {
diff --git a/common/healthcheck/src/score.rs b/common/healthcheck/src/score.rs
index 8f97cf96a8..4d29e8f5b6 100644
--- a/common/healthcheck/src/score.rs
+++ b/common/healthcheck/src/score.rs
@@ -4,7 +4,8 @@ use std::cmp::Ordering;
 use std::fmt::Error;
 use std::fmt::Formatter;
 use std::net::SocketAddr;
-use topology::{MixNode, MixProviderNode};
+use topology::mix;
+use topology::provider;
 
 // TODO: should 'nodetype' really be part of healthcheck::score
 
@@ -91,7 +92,7 @@ impl PartialEq for NodeScore {
 }
 
 impl NodeScore {
-    pub(crate) fn from_mixnode(node: MixNode) -> Self {
+    pub(crate) fn from_mixnode(node: mix::Node) -> Self {
         NodeScore {
             typ: NodeType::Mix,
             pub_key: NodeAddressBytes::from_b64_string(node.pub_key),
@@ -103,7 +104,7 @@ impl NodeScore {
         }
     }
 
-    pub(crate) fn from_provider(node: MixProviderNode) -> Self {
+    pub(crate) fn from_provider(node: provider::Node) -> Self {
         NodeScore {
             typ: NodeType::MixProvider,
             pub_key: NodeAddressBytes::from_b64_string(node.pub_key),
diff --git a/common/topology/Cargo.toml b/common/topology/Cargo.toml
index e9e8022c91..bc6d39ef7a 100644
--- a/common/topology/Cargo.toml
+++ b/common/topology/Cargo.toml
@@ -20,4 +20,5 @@ addressing = {path = "../addressing"}
 version-checker = {path = "../version-checker" }
 
 ## will be moved to proper dependencies once released
-sphinx = { git = "https://github.com/nymtech/sphinx", rev="1d8cefcb6a0cb8e87d00d89eb1ccf2839e92aa1f" }
+# sphinx = { git = "https://github.com/nymtech/sphinx", rev="1d8cefcb6a0cb8e87d00d89eb1ccf2839e92aa1f" }
+sphinx = { path = "../../../sphinx"}
diff --git a/common/topology/src/coco.rs b/common/topology/src/coco.rs
new file mode 100644
index 0000000000..320064d08e
--- /dev/null
+++ b/common/topology/src/coco.rs
@@ -0,0 +1,13 @@
+#[derive(Debug, Clone)]
+pub struct Node {
+    pub host: String,
+    pub pub_key: String,
+    pub last_seen: u64,
+    pub version: String,
+}
+
+impl super::Versioned for Node {
+    fn get_version(&self) -> String {
+        self.version.clone()
+    }
+}
diff --git a/common/topology/src/lib.rs b/common/topology/src/lib.rs
index 8fadc5c2ab..486a4340bc 100644
--- a/common/topology/src/lib.rs
+++ b/common/topology/src/lib.rs
@@ -1,103 +1,29 @@
-use addressing;
-use curve25519_dalek::montgomery::MontgomeryPoint;
 use itertools::Itertools;
 use rand::seq::IteratorRandom;
-use sphinx::route::{Node as SphinxNode, NodeAddressBytes};
+use sphinx::route::Node as SphinxNode;
 use std::cmp::max;
 use std::collections::HashMap;
-use std::net::SocketAddr;
+use std::marker::PhantomData;
 use version_checker;
 
-#[derive(Debug, Clone)]
-pub struct MixNode {
-    pub host: SocketAddr,
-    pub pub_key: String,
-    pub layer: u64,
-    pub last_seen: u64,
-    pub version: String,
-}
-
-impl Into<SphinxNode> for MixNode {
-    fn into(self) -> SphinxNode {
-        let address_bytes = addressing::encoded_bytes_from_socket_address(self.host);
-        let key_bytes = self.get_pub_key_bytes();
-        let key = MontgomeryPoint(key_bytes);
-
-        SphinxNode::new(NodeAddressBytes::from_bytes(address_bytes), key)
-    }
-}
-
-impl MixNode {
-    pub fn get_pub_key_bytes(&self) -> [u8; 32] {
-        let decoded_key_bytes = base64::decode_config(&self.pub_key, base64::URL_SAFE).unwrap();
-        let mut key_bytes = [0; 32];
-        key_bytes.copy_from_slice(&decoded_key_bytes[..]);
-        key_bytes
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct MixProviderClient {
-    pub pub_key: String,
-}
-
-#[derive(Debug, Clone)]
-pub struct MixProviderNode {
-    pub client_listener: SocketAddr,
-    pub mixnet_listener: SocketAddr,
-    pub pub_key: String,
-    pub registered_clients: Vec<MixProviderClient>,
-    pub last_seen: u64,
-    pub version: String,
-}
-
-impl Into<SphinxNode> for MixProviderNode {
-    fn into(self) -> SphinxNode {
-        let address_bytes = addressing::encoded_bytes_from_socket_address(self.mixnet_listener);
-        let key_bytes = self.get_pub_key_bytes();
-        let key = MontgomeryPoint(key_bytes);
-
-        SphinxNode::new(NodeAddressBytes::from_bytes(address_bytes), key)
-    }
-}
-
-impl MixProviderNode {
-    pub fn get_pub_key_bytes(&self) -> [u8; 32] {
-        let decoded_key_bytes = base64::decode_config(&self.pub_key, base64::URL_SAFE).unwrap();
-        let mut key_bytes = [0; 32];
-        key_bytes.copy_from_slice(&decoded_key_bytes[..]);
-        key_bytes
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct CocoNode {
-    pub host: String,
-    pub pub_key: String,
-    pub last_seen: u64,
-    pub version: String,
-}
-
-#[derive(Debug)]
-pub enum NymTopologyError {
-    InvalidMixLayerError,
-    MissingLayerError(Vec<u64>),
-}
+pub mod coco;
+pub mod mix;
+pub mod provider;
 
 pub trait NymTopology: Sized {
     fn new(directory_server: String) -> Self;
     fn new_from_nodes(
-        mix_nodes: Vec<MixNode>,
-        mix_provider_nodes: Vec<MixProviderNode>,
-        coco_nodes: Vec<CocoNode>,
+        mix_nodes: Vec<mix::Node>,
+        mix_provider_nodes: Vec<provider::Node>,
+        coco_nodes: Vec<coco::Node>,
     ) -> Self;
-    fn get_mix_nodes(&self) -> Vec<MixNode>;
-    fn get_mix_provider_nodes(&self) -> Vec<MixProviderNode>;
-    fn get_coco_nodes(&self) -> Vec<CocoNode>;
-    fn make_layered_topology(&self) -> Result<HashMap<u64, Vec<MixNode>>, NymTopologyError> {
-        let mut layered_topology: HashMap<u64, Vec<MixNode>> = HashMap::new();
+    fn mix_nodes(&self) -> Vec<mix::Node>;
+    fn providers(&self) -> Vec<provider::Node>;
+    fn coco_nodes(&self) -> Vec<coco::Node>;
+    fn make_layered_topology(&self) -> Result<HashMap<u64, Vec<mix::Node>>, NymTopologyError> {
+        let mut layered_topology: HashMap<u64, Vec<mix::Node>> = HashMap::new();
         let mut highest_layer = 0;
-        for mix in self.get_mix_nodes() {
+        for mix in self.mix_nodes() {
             // we need to have extra space for provider
             if mix.layer > sphinx::constants::MAX_PATH_LENGTH as u64 {
                 return Err(NymTopologyError::InvalidMixLayerError);
@@ -125,6 +51,8 @@ pub trait NymTopology: Sized {
 
         Ok(layered_topology)
     }
+
+    // Tries to get a route through the mix network
     fn mix_route(&self) -> Result<Vec<SphinxNode>, NymTopologyError> {
         let mut layered_topology = self.make_layered_topology()?;
         let num_layers = layered_topology.len();
@@ -137,7 +65,7 @@ pub trait NymTopology: Sized {
         Ok(route)
     }
 
-    // sets a route to specific provider
+    // Sets up a route to a specific provider
     fn route_to(&self, provider_node: SphinxNode) -> Result<Vec<SphinxNode>, NymTopologyError> {
         Ok(self
             .mix_route()?
@@ -148,7 +76,7 @@ pub trait NymTopology: Sized {
 
     fn all_paths(&self) -> Result<Vec<Vec<SphinxNode>>, NymTopologyError> {
         let mut layered_topology = self.make_layered_topology()?;
-        let providers = self.get_mix_provider_nodes();
+        let providers = self.providers();
 
         let sorted_layers: Vec<Vec<SphinxNode>> = (1..=layered_topology.len() as u64)
             .map(|layer| layered_topology.remove(&layer).unwrap()) // get all nodes per layer
@@ -172,32 +100,23 @@ pub trait NymTopology: Sized {
         expected_provider_version: &str,
         expected_coco_version: &str,
     ) -> Self {
-        let filtered_mixes = self
-            .get_mix_nodes()
-            .iter()
-            .filter(|mix_node| {
-                version_checker::is_compatible(&mix_node.version, expected_mix_version)
-            })
-            .cloned()
-            .collect();
-        let filtered_providers = self
-            .get_mix_provider_nodes()
-            .iter()
-            .filter(|provider_node| {
-                version_checker::is_compatible(&provider_node.version, expected_provider_version)
-            })
-            .cloned()
-            .collect();
-        let filtered_coco_nodes = self
-            .get_coco_nodes()
-            .iter()
-            .filter(|coco_node| {
-                version_checker::is_compatible(&coco_node.version, expected_coco_version)
-            })
-            .cloned()
-            .collect();
+        let unversioned_mixnodes = self.mix_nodes();
+        // let f = Filter::new(unversioned_mixnodes)
+        // unversioned_mixnodes
 
-        Self::new_from_nodes(filtered_mixes, filtered_providers, filtered_coco_nodes)
+        let mixes = self.filter::<mix::Node>(self.mix_nodes(), expected_mix_version);
+        let providers = self.filter::<provider::Node>(self.providers(), expected_provider_version);
+        let cocos = self.filter::<coco::Node>(self.coco_nodes(), expected_coco_version);
+
+        Self::new_from_nodes(mixes, providers, cocos)
+    }
+
+    fn filter<T: Versioned>(&self, nodes: Vec<T>, expected_version: &str) -> Vec<T> {
+        nodes
+            .iter()
+            .filter(|node| version_checker::is_compatible(&node.get_version(), expected_version))
+            .cloned()
+            .collect()
     }
 
     fn can_construct_path_through(&self) -> bool {
@@ -208,4 +127,46 @@ pub trait NymTopology: Sized {
     }
 }
 
-// TODO: tests...
+pub trait Versioned: Clone + Sized {
+    fn get_version(&self) -> String;
+}
+
+pub struct Filter<T> {
+    _phantom_data: PhantomData<T>,
+}
+
+impl<T: Versioned> Filter<T> {
+    fn new() -> Self {
+        Self {
+            _phantom_data: PhantomData,
+        }
+    }
+
+    fn run(&self, nodes: Vec<T>, expected_version: &str) -> Vec<T> {
+        nodes
+            .iter()
+            .filter(|node| version_checker::is_compatible(&node.get_version(), expected_version))
+            .cloned()
+            .collect()
+    }
+}
+
+// impl<T: Versioned> VersionFilter<T> {
+//     fn new() -> Self {
+//         Self {}
+//     }
+
+//     fn run(&self, nodes: Vec<T>, expected_version: &str) -> Vec<T> {
+//         nodes
+//             .iter()
+//             .filter(|node| version_checker::is_compatible(&node.get_version(), expected_version))
+//             .cloned()
+//             .collect()
+//     }
+// }
+
+#[derive(Debug)]
+pub enum NymTopologyError {
+    InvalidMixLayerError,
+    MissingLayerError(Vec<u64>),
+}
diff --git a/common/topology/src/mix.rs b/common/topology/src/mix.rs
new file mode 100644
index 0000000000..0501a9f314
--- /dev/null
+++ b/common/topology/src/mix.rs
@@ -0,0 +1,37 @@
+use sphinx::route::Node as SphinxNode;
+use sphinx::route::NodeAddressBytes;
+use std::net::SocketAddr;
+
+#[derive(Debug, Clone)]
+pub struct Node {
+    pub host: SocketAddr,
+    pub pub_key: String,
+    pub layer: u64,
+    pub last_seen: u64,
+    pub version: String,
+}
+
+impl Node {
+    pub fn get_pub_key_bytes(&self) -> [u8; 32] {
+        let decoded_key_bytes = base64::decode_config(&self.pub_key, base64::URL_SAFE).unwrap();
+        let mut key_bytes = [0; 32];
+        key_bytes.copy_from_slice(&decoded_key_bytes[..]);
+        key_bytes
+    }
+}
+
+impl super::Versioned for Node {
+    fn get_version(&self) -> String {
+        self.version.clone()
+    }
+}
+
+impl Into<SphinxNode> for Node {
+    fn into(self) -> SphinxNode {
+        let address_bytes = addressing::encoded_bytes_from_socket_address(self.host);
+        let key_bytes = self.get_pub_key_bytes();
+        let key = sphinx::key::new(key_bytes);
+
+        SphinxNode::new(NodeAddressBytes::from_bytes(address_bytes), key)
+    }
+}
diff --git a/common/topology/src/provider.rs b/common/topology/src/provider.rs
new file mode 100644
index 0000000000..f887a6989a
--- /dev/null
+++ b/common/topology/src/provider.rs
@@ -0,0 +1,43 @@
+use sphinx::route::Node as SphinxNode;
+use sphinx::route::NodeAddressBytes;
+use std::net::SocketAddr;
+
+#[derive(Debug, Clone)]
+pub struct Client {
+    pub pub_key: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct Node {
+    pub client_listener: SocketAddr,
+    pub mixnet_listener: SocketAddr,
+    pub pub_key: String,
+    pub registered_clients: Vec<Client>,
+    pub last_seen: u64,
+    pub version: String,
+}
+
+impl Node {
+    pub fn get_pub_key_bytes(&self) -> [u8; 32] {
+        let decoded_key_bytes = base64::decode_config(&self.pub_key, base64::URL_SAFE).unwrap();
+        let mut key_bytes = [0; 32];
+        key_bytes.copy_from_slice(&decoded_key_bytes[..]);
+        key_bytes
+    }
+}
+
+impl super::Versioned for Node {
+    fn get_version(&self) -> String {
+        self.version.clone()
+    }
+}
+
+impl Into<SphinxNode> for Node {
+    fn into(self) -> SphinxNode {
+        let address_bytes = addressing::encoded_bytes_from_socket_address(self.mixnet_listener);
+        let key_bytes = self.get_pub_key_bytes();
+        let key = sphinx::key::new(key_bytes);
+
+        SphinxNode::new(NodeAddressBytes::from_bytes(address_bytes), key)
+    }
+}
diff --git a/nym-client/Cargo.toml b/nym-client/Cargo.toml
index 51730b0dd1..3133e21703 100644
--- a/nym-client/Cargo.toml
+++ b/nym-client/Cargo.toml
@@ -40,7 +40,8 @@ sfw-provider-requests = { path = "../sfw-provider/sfw-provider-requests" }
 topology = {path = "../common/topology" }
 
 ## will be moved to proper dependencies once released
-sphinx = { git = "https://github.com/nymtech/sphinx", rev="1d8cefcb6a0cb8e87d00d89eb1ccf2839e92aa1f" }
+# sphinx = { git = "https://github.com/nymtech/sphinx", rev="1d8cefcb6a0cb8e87d00d89eb1ccf2839e92aa1f" }
+sphinx = { path = "../../sphinx"}
 
 # putting this explicitly below everything and most likely, the next time we look into it, it will already have a proper release
 tokio-tungstenite = { git = "https://github.com/snapview/tokio-tungstenite", rev="308d9680c0e59dd1e8651659a775c05df937934e" }
diff --git a/nym-client/src/client/mod.rs b/nym-client/src/client/mod.rs
index 8359716f71..98e4840be0 100644
--- a/nym-client/src/client/mod.rs
+++ b/nym-client/src/client/mod.rs
@@ -154,7 +154,7 @@ impl NymClient {
 
         // this is temporary and assumes there exists only a single provider.
         let provider_client_listener_address: SocketAddr = initial_topology
-            .get_mix_provider_nodes()
+            .providers()
             .first()
             .expect("Could not get a provider from the supplied network topology, are you using the right directory server?")
             .client_listener;