     
     // MARK: - PRIVATE METHODS
     
-    fileprivate func connect(peerWithId peerId: UUID) {
+    fileprivate func connect(peerWithId peerId: String) {
         Clink.Configuration.dispatchQueue.async {
             if
-                let i = self.activePeripherals.index(where: { $0.identifier == peerId }),
+                let uuid = UUID(uuidString: peerId),
+                let i = self.activePeripherals.index(where: { $0.identifier == uuid }),
                 self.activePeripherals[i].state == .connected
             {
                 return
             }
             
-            let peerManager = Clink.Configuration.peerManager ?? self
-            let peripherals = self.centralManager.retrievePeripherals(withIdentifiers: [peerId])
-            
             guard
-                let peer = peerManager.getSavedPeer(withId: peerId),
-                let peripheral = peripherals.first
-            else {
-                guard peripherals.count > 0 else { return }
-                
-                peerManager.save(peer: Peer(id: peerId))
-                
-                return self.connect(peerWithId: peerId)
-            }
+                let peripheralId = UUID(uuidString: peerId),
+                let peripheral = self.centralManager.retrievePeripherals(withIdentifiers: [peripheralId]).first
+            else { return }
             
             peripheral.delegate = self
-            //            peer.peripheral = peripheral
-            
-            if let i = self.activePeripherals.index(where: { $0.identifier == peerId }) {
+            
+            if let i = self.activePeripherals.index(where: { $0.identifier.uuidString == peerId }) {
                 self.activePeripherals[i] = peripheral
             } else {
                 self.activePeripherals.append(peripheral)

    {
        if error != nil { self.publish(notification: .error(.unknownError)) }
        
        if let peer = (Clink.Configuration.peerManager ?? self).getSavedPeer(withId: peripheral.identifier) {
            self.publish(notification: .disconnected(peer))
        }
        
        self.connect(peerWithId: peripheral.identifier)
    }
    
    public final func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {

        var connectedPeers: [ClinkPeer] = []
        
        for peripheral in activePeripherals where peripheral.state == .connected {
            if let peer = peerManager?.getSavedPeer(withId: peripheral.identifier.uuidString) {
                connectedPeers.append(peer)
            }
        }
