         // The Attribute Type is set to the UUID for «Characteristic» and the Starting Handle and Ending Handle
         // parameters shall be set to the service handle range.
         
-        discoverCharacteristics(uuid: uuid, service: service, completion: completion)
+        discoverCharacteristics(uuid: uuid, service: service) { [unowned self] (response) in
+            
+            // update cache
+            switch response {
+            case .error:
+                break
+            case let .value(value):
+                self.cache.services[service.uuid]?.update(value, isCompleteSet: false)
+            }
+            
+            // call completion
+            completion(response)
+        }
     }
     
     /**

        guard let end = cache.endHandle(for: characteristic)
            else { fatalError("Could not retrieve handles") }
        
        let operation = DescriptorDiscoveryOperation(start: start, end: end, completion: completion)
        
        discoverDescriptors(operation: operation)
    }

            
            return nil
        }
        
        @discardableResult
        mutating func update(_ newValue: [GATTClient.Descriptor], for characteristic: GATTClient.Characteristic) -> Bool {
            
            for (serviceUUID, service) in self.services {
                
                for (characteristicUUID, characteristicCache) in service.characteristics {
                    
                    guard characteristicCache.characteristic.handle == characteristic.handle,
                        characteristicCache.characteristic.uuid == characteristic.uuid
                        else { continue }
                    
                    // update cache
                    self.services[serviceUUID]?.characteristics[characteristicUUID]?.update(newValue)
                }
            }
            
            return false
        }
    }
}

