diff --git a/src/main.rs b/src/main.rs
index 189ecd2..4317e65 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -142,7 +142,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // Creating a new Router instance
     let router = match router::Router::new(
         tun_tx,
-        node_addr,
+        Subnet::new(node_addr.into(), 64).expect("64 is a valid IPv6 prefix size; qed"),
         vec![StaticRoute::new(
             Subnet::new(node_addr.into(), 64).expect("64 is a valid IPv6 prefix size; qed"),
         )],
diff --git a/src/peer_manager.rs b/src/peer_manager.rs
index da94c79..cc3fc2a 100644
--- a/src/peer_manager.rs
+++ b/src/peer_manager.rs
@@ -48,6 +48,11 @@ impl PeerManager {
 
     async fn get_peers_from_config(self) {
         if let Ok(file_content) = std::fs::read_to_string(NODE_CONFIG_FILE_PATH) {
+            let node_tun_addr = if let IpAddr::V6(ip) = self.router.node_tun_subnet().address() {
+                ip
+            } else {
+                panic!("Non IPv6 node tun not support currently")
+            };
             let config: PeersConfig = toml::from_str(&file_content).unwrap();
 
             for peer_addr in config.peers {
@@ -70,7 +75,7 @@ impl PeerManager {
                     let mut buf = [0u8; 17];
                     // only using IPv6
                     buf[0] = 1;
-                    buf[1..].copy_from_slice(&self.router.node_tun_addr().octets()[..]);
+                    buf[1..].copy_from_slice(&node_tun_addr.octets()[..]);
 
                     peer_stream.write_all(&buf).await.unwrap();
 
@@ -92,6 +97,11 @@ impl PeerManager {
     }
 
     async fn get_peers_from_cli(self, socket_addresses: Vec<SocketAddr>) {
+        let node_tun_addr = if let IpAddr::V6(ip) = self.router.node_tun_subnet().address() {
+            ip
+        } else {
+            panic!("Non IPv6 node tun not support currently")
+        };
         for peer_addr in socket_addresses {
             if let Ok(mut peer_stream) = TcpStream::connect(peer_addr).await {
                 let mut buffer = [0u8; 17];
@@ -112,7 +122,7 @@ impl PeerManager {
                 let mut buf = [0u8; 17];
                 // only using IPv6
                 buf[0] = 1;
-                buf[1..].copy_from_slice(&self.router.node_tun_addr().octets()[..]);
+                buf[1..].copy_from_slice(&node_tun_addr.octets()[..]);
 
                 peer_stream.write_all(&buf).await.unwrap();
 
@@ -132,6 +142,11 @@ impl PeerManager {
 
     // this is used to reconnect to the provided static peers in case the connection is lost
     async fn reconnect_to_initial_peers(self) {
+        let node_tun_addr = if let IpAddr::V6(ip) = self.router.node_tun_subnet().address() {
+            ip
+        } else {
+            panic!("Non IPv6 node tun not support currently")
+        };
         loop {
             tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
 
@@ -157,7 +172,7 @@ impl PeerManager {
                         let mut buf = [0u8; 17];
                         // only using IPv6
                         buf[0] = 1;
-                        buf[1..].copy_from_slice(&self.router.node_tun_addr().octets()[..]);
+                        buf[1..].copy_from_slice(&node_tun_addr.octets()[..]);
 
                         peer_stream.write_all(&buf).await.unwrap();
 
@@ -178,7 +193,11 @@ impl PeerManager {
     }
 
     async fn start_listener(self, port: u16) {
-        let node_tun_addr = self.router.node_tun_addr();
+        let node_tun_addr = if let IpAddr::V6(ip) = self.router.node_tun_subnet().address() {
+            ip
+        } else {
+            panic!("Non IPv6 node tun not support currently")
+        };
         let router_data_tx = self.router.router_data_tx();
         let router_control_tx = self.router.router_control_tx();
 
diff --git a/src/router.rs b/src/router.rs
index 571fcfa..e53b694 100644
--- a/src/router.rs
+++ b/src/router.rs
@@ -46,14 +46,14 @@ pub struct Router {
     router_data_tx: Sender<DataPacket>,
     router_control_tx: UnboundedSender<(ControlPacket, Peer)>,
     node_tun: UnboundedSender<Vec<u8>>,
-    node_tun_addr: Ipv6Addr,
+    node_tun_subnet: Subnet,
     update_filters: Arc<Vec<Box<dyn RouteUpdateFilter + Send + Sync>>>,
 }
 
 impl Router {
     pub fn new(
         node_tun: UnboundedSender<Vec<u8>>,
-        node_tun_addr: Ipv6Addr,
+        node_tun_subnet: Subnet,
         static_routes: Vec<StaticRoute>,
         node_keypair: (SecretKey, PublicKey),
         update_filters: Vec<Box<dyn RouteUpdateFilter + Send + Sync>>,
@@ -76,7 +76,7 @@ impl Router {
             router_data_tx,
             router_control_tx,
             node_tun,
-            node_tun_addr,
+            node_tun_subnet,
             update_filters: Arc::new(update_filters),
         };
 
@@ -108,8 +108,8 @@ impl Router {
         self.router_data_tx.clone()
     }
 
-    pub fn node_tun_addr(&self) -> Ipv6Addr {
-        self.node_tun_addr
+    pub fn node_tun_subnet(&self) -> Subnet {
+        self.node_tun_subnet
     }
 
     pub fn node_tun(&self) -> UnboundedSender<Vec<u8>> {
@@ -527,15 +527,15 @@ impl Router {
     }
 
     pub fn route_packet(&self, data_packet: DataPacket) -> Result<(), ()> {
-        let node_tun_addr = self.node_tun_addr();
+        let node_tun_subnet = self.node_tun_subnet();
 
         trace!(
             "Incoming data packet, with dest_ip: {} (side node, this node's tun addr is: {})",
             data_packet.dest_ip,
-            node_tun_addr
+            node_tun_subnet
         );
 
-        if data_packet.dest_ip == node_tun_addr {
+        if node_tun_subnet.contains_ip(data_packet.dest_ip.into()) {
             // decrypt & send to TUN interface
             let pubkey_sender = data_packet.pubkey;
             let shared_secret = match self.get_shared_secret_by_pubkey(&pubkey_sender) {