             guard let self = self else { return }
             self.async {
                 // get peripheral
-                guard let peripheralObject = self.cache.peripherals[peripheral] else {
-                    continuation.resume(throwing: CentralError.unknownPeripheral)
+                guard let peripheralObject = self.validatePeripheral(peripheral, for: continuation) else {
                     return
                 }
                 // yield value
-                continuation.resume(returning: peripheralObject.canSendWriteWithoutResponse)
+                let value = peripheralObject.canSendWriteWithoutResponse
+                continuation.resume(returning: value)
             }
         }
     }

                // notify
                self.continuation.stopNotification[characteristic] = continuation
                peripheralObject.setNotifyValue(false, for: characteristicObject)
            }
        }
    }

        peripheralObject.readValue(for: characteristicObject)
    }
    
    func execute(_ operation: Operation.WriteCharacteristic) -> Bool {
        // check power on
        guard validateState(.poweredOn, for: operation.continuation) else {
            return false
        }
        // get peripheral
        guard let peripheralObject = validatePeripheral(operation.characteristic.peripheral, for: operation.continuation) else {
            return false
        }
        // check connected
        guard validateConnected(peripheralObject, for: operation.continuation) else {
            return false
        }
        // get characteristic
        guard let characteristicObject = validateCharacteristic(operation.characteristic, for: operation.continuation) else {
            return false
        }
        assert(operation.withResponse || peripheralObject.canSendWriteWithoutResponse, "Cannot write without response")
        // calls `peripheral:didWriteValueForCharacteristic:error:` only
        // if you specified the write type as `.withResponse`.
        let writeType: CBCharacteristicWriteType = operation.withResponse ? .withResponse : .withoutResponse
        peripheralObject.writeValue(operation.data, for: characteristicObject, type: writeType)
        return operation.withResponse
    }
    
    func execute(_ operation: Operation.DiscoverDescriptors) {
