                 
             } else {
                 
-                
+                // fetch descriptors
+                let _ = try discoverDescriptors(for: characteristic, timeout: timeout)
+                
+                // get updated cache
+                if let cache = self.cache.characteristic(for: characteristic.identifier)?.1.descriptors.values.map({ $0.attribute }) {
+                    
+                    descriptors = Array(cache)
+                    
+                } else {
+                    
+                    descriptors = []
+                }
             }
             
             // GATT request
             try async(timeout: timeout) {
                 client.registerNotification(notification,
                                             for: gattCharacteristic.attribute,
-                                            descriptors: gattCharacteristic.descriptors,
+                                            descriptors: descriptors,
                                             completion: $0)
             }
         }

            }
            
            // store in cache
            cache.insert(foundCharacteristics, for: gattService)
            
            return cache.service(for: service.identifier)?.characteristics.map {
                Characteristic(identifier: $0.key,

        }
        
        mutating func insert(_ newValues: [GATTClient.Characteristic],
                             for service: UInt) {
            
            // remove old values
            services[service]?.characteristics.removeAll(keepingCapacity: true)
            
            // insert new values
            newValues.forEach {
                services[service]?.characteristics[UInt($0.handle.declaration)] = CharacteristicCache(attribute: $0, notification: nil, descriptors: [:])
            }
        }
        
        mutating func insert(_ newValues: [GATTClient.Descriptor],
                             for service: UInt,
                             characteristic: UInt) {
            
            var descriptorsCache = [UInt: DescriptorCache]()
            
            descriptorsCache.reserveCapacity(newValues.count)
            newValues.forEach {
                descriptorsCache[UInt($0.handle)] = DescriptorCache(attribute: $0)
            }
            
            services[service]?.characteristics[characteristic]?.descriptors = descriptorsCache
        }
    }
    
