@bota.dev/react-native-app-sdk 2.0.0-beta.0

package/ios/BotaDeviceSDKAppleSecurity.swift

@@ -0,0 +1,586 @@
+import BotaAppSDK
+import Foundation
+
+struct BotaDeviceSDKAppleProvisioningRequest: Equatable, Sendable {
+    let requestID: String
+    let serialNumber: String
+    let nonce: String
+    let devicePublicKey: String
+}
+
+struct BotaDeviceSDKAppleFactoryResetRequest: Equatable, Sendable {
+    let requestID: String
+    let serialNumber: String
+    let nonce: String
+    let commandID: String
+    let bindingGeneration: UInt64
+}
+
+struct BotaDeviceSDKAppleFactoryResetPersistenceRequest: Equatable, Sendable {
+    let requestID: String
+    let localRecordingsDeleted: UInt16
+}
+
+protocol BotaDeviceSDKAppleSecurityClient: Sendable {
+    func isProvisioned(_ device: ConnectedDevice) async throws -> Bool
+    func readPublicKey(from device: ConnectedDevice) async throws -> String?
+    func readAuthNonce(from device: ConnectedDevice) async throws -> String?
+    func setAPIEndpoint(_ environment: DeviceAPIEnvironment, on device: ConnectedDevice) async throws
+    func deliverCertificate(
+        _ certificatePEM: String,
+        privateKeyPEM: String,
+        to device: ConnectedDevice
+    ) async throws
+    func deliverBackendPublicKey(_ publicKey: Data, to device: ConnectedDevice) async throws
+    func writeGrant(_ grantBlob: String, to device: ConnectedDevice) async throws
+    func syncTime(_ device: ConnectedDevice) async throws
+    func requestStartRecording(
+        _ device: ConnectedDevice,
+        grantBlob: String
+    ) async throws -> RecordingControlResult
+    func requestStopRecording(
+        _ device: ConnectedDevice,
+        grantBlob: String
+    ) async throws -> RecordingControlResult
+    func readRecordingState(from device: ConnectedDevice) async throws -> RecordingState
+    func recordingStateUpdates(
+        _ device: ConnectedDevice
+    ) async throws -> AsyncThrowingStream<RecordingState, Error>
+    func provision(
+        _ device: ConnectedDevice,
+        using provider: @escaping ProvisioningMaterialProvider
+    ) async throws
+    func deprovision(
+        _ device: ConnectedDevice,
+        grantBlob: String
+    ) async throws -> DeprovisionResult
+    func readConnectionSettings(from device: ConnectedDevice) async throws -> DeviceConnectionSettings
+    func writeConnectionSettings(
+        _ settings: DeviceConnectionSettings,
+        to device: ConnectedDevice
+    ) async throws
+    func factoryReset(
+        _ device: ConnectedDevice,
+        commandID: String,
+        bindingGeneration: UInt64,
+        persistResult: FactoryResetResultPersister?,
+        using provider: @escaping FactoryResetGrantProvider
+    ) async throws -> FactoryResetCompletion
+    func resumePendingFactoryReset(
+        _ device: ConnectedDevice,
+        currentBindingGeneration: UInt64,
+        persistResult: FactoryResetResultPersister?
+    ) async throws -> FactoryResetCompletion?
+    func resumeUnjournaledFactoryReset(
+        _ device: ConnectedDevice,
+        commandID: String,
+        bindingGeneration: UInt64,
+        persistResult: @escaping FactoryResetResultPersister
+    ) async throws -> FactoryResetCompletion
+    func cancelCurrentOperation() async throws
+    func cancelFactoryReset() async throws
+}
+
+struct BotaDeviceSDKSharedAppleSecurityClient: BotaDeviceSDKAppleSecurityClient {
+    private let controls: DeviceControlManager
+    private let provisioning: ProvisioningManager
+    private let factoryResetManager: FactoryResetManager
+
+    init(client: BotaDeviceClient = .shared) {
+        controls = client.controls
+        provisioning = client.provisioning
+        factoryResetManager = client.factoryReset
+    }
+
+    func isProvisioned(_ device: ConnectedDevice) async throws -> Bool {
+        try await controls.isProvisioned(device)
+    }
+
+    func readPublicKey(from device: ConnectedDevice) async throws -> String? {
+        try await controls.readPublicKey(from: device)
+    }
+
+    func readAuthNonce(from device: ConnectedDevice) async throws -> String? {
+        try await controls.readAuthNonce(from: device)
+    }
+
+    func setAPIEndpoint(_ environment: DeviceAPIEnvironment, on device: ConnectedDevice) async throws {
+        try await controls.setAPIEndpoint(environment, on: device)
+    }
+
+    func deliverCertificate(
+        _ certificatePEM: String,
+        privateKeyPEM: String,
+        to device: ConnectedDevice
+    ) async throws {
+        try await controls.deliverCertificate(
+            certificatePEM,
+            privateKeyPEM: privateKeyPEM,
+            to: device
+        )
+    }
+
+    func deliverBackendPublicKey(_ publicKey: Data, to device: ConnectedDevice) async throws {
+        try await controls.deliverBackendPublicKey(publicKey, to: device)
+    }
+
+    func writeGrant(_ grantBlob: String, to device: ConnectedDevice) async throws {
+        try await controls.writeGrant(grantBlob, to: device)
+    }
+
+    func syncTime(_ device: ConnectedDevice) async throws {
+        try await controls.syncTime(to: device)
+    }
+
+    func requestStartRecording(
+        _ device: ConnectedDevice,
+        grantBlob: String
+    ) async throws -> RecordingControlResult {
+        try await controls.requestStartRecording(device, grantBlob: grantBlob)
+    }
+
+    func requestStopRecording(
+        _ device: ConnectedDevice,
+        grantBlob: String
+    ) async throws -> RecordingControlResult {
+        try await controls.requestStopRecording(device, grantBlob: grantBlob)
+    }
+
+    func readRecordingState(from device: ConnectedDevice) async throws -> RecordingState {
+        try await controls.readRecordingState(from: device)
+    }
+
+    func recordingStateUpdates(
+        _ device: ConnectedDevice
+    ) async throws -> AsyncThrowingStream<RecordingState, Error> {
+        try await controls.recordingStateUpdates(for: device)
+    }
+
+    func provision(
+        _ device: ConnectedDevice,
+        using provider: @escaping ProvisioningMaterialProvider
+    ) async throws {
+        try await provisioning.provision(
+            device,
+            materialID: UUID().uuidString,
+            using: provider
+        )
+    }
+
+    func deprovision(
+        _ device: ConnectedDevice,
+        grantBlob: String
+    ) async throws -> DeprovisionResult {
+        try await provisioning.deprovision(device, grantBlob: grantBlob)
+    }
+
+    func readConnectionSettings(from device: ConnectedDevice) async throws -> DeviceConnectionSettings {
+        try await provisioning.readConnectionSettings(from: device)
+    }
+
+    func writeConnectionSettings(
+        _ settings: DeviceConnectionSettings,
+        to device: ConnectedDevice
+    ) async throws {
+        try await provisioning.writeConnectionSettings(settings, to: device)
+    }
+
+    func factoryReset(
+        _ device: ConnectedDevice,
+        commandID: String,
+        bindingGeneration: UInt64,
+        persistResult: FactoryResetResultPersister?,
+        using provider: @escaping FactoryResetGrantProvider
+    ) async throws -> FactoryResetCompletion {
+        try await factoryResetManager.factoryReset(
+            device,
+            commandID: commandID,
+            grantID: UUID().uuidString,
+            bindingGeneration: bindingGeneration,
+            persistResult: persistResult,
+            using: provider
+        )
+    }
+
+    func resumePendingFactoryReset(
+        _ device: ConnectedDevice,
+        currentBindingGeneration: UInt64,
+        persistResult: FactoryResetResultPersister?
+    ) async throws -> FactoryResetCompletion? {
+        try await factoryResetManager.resumePendingFactoryReset(
+            device,
+            currentBindingGeneration: currentBindingGeneration,
+            persistResult: persistResult
+        )
+    }
+
+    func resumeUnjournaledFactoryReset(
+        _ device: ConnectedDevice,
+        commandID: String,
+        bindingGeneration: UInt64,
+        persistResult: @escaping FactoryResetResultPersister
+    ) async throws -> FactoryResetCompletion {
+        try await factoryResetManager.resumeUnjournaledFactoryReset(
+            device,
+            commandID: commandID,
+            bindingGeneration: bindingGeneration,
+            persistResult: persistResult
+        )
+    }
+
+    func cancelCurrentOperation() async throws {
+        try await provisioning.cancelCurrentOperation()
+    }
+
+    func cancelFactoryReset() async throws {
+        try await factoryResetManager.cancelCurrentOperation()
+    }
+}
+
+actor BotaDeviceSDKAppleSecurity {
+    private enum MaterialError: LocalizedError {
+        case cancelled
+        case invalidFactoryResetGrant
+        case rejected(String)
+        case unknownRequest
+
+        var errorDescription: String? {
+            switch self {
+            case .cancelled: "application material request was cancelled"
+            case .invalidFactoryResetGrant: "factory reset grant is not valid encoded data"
+            case let .rejected(message): message
+            case .unknownRequest: "application material request is no longer pending"
+            }
+        }
+    }
+
+    private let client: any BotaDeviceSDKAppleSecurityClient
+    private var provisioningRequests: [
+        String: CheckedContinuation<ProvisioningMaterial, Error>
+    ] = [:]
+    private var factoryResetRequests: [String: CheckedContinuation<Data, Error>] = [:]
+    private var factoryResetPersistenceRequests: [String: CheckedContinuation<Void, Error>] = [:]
+    private var recordingStateTask: Task<Void, Never>?
+
+    init(client: any BotaDeviceSDKAppleSecurityClient = BotaDeviceSDKSharedAppleSecurityClient()) {
+        self.client = client
+    }
+
+    func provision(
+        _ device: ConnectedDevice,
+        onMaterialRequest: @escaping @Sendable (BotaDeviceSDKAppleProvisioningRequest) -> Void
+    ) async throws {
+        try await client.provision(device) { request in
+            try await self.requestProvisioningMaterial(request, onRequest: onMaterialRequest)
+        }
+    }
+
+    func deprovision(
+        _ device: ConnectedDevice,
+        grantBlob: String
+    ) async throws -> DeprovisionResult {
+        try await client.deprovision(device, grantBlob: grantBlob)
+    }
+
+    func isProvisioned(_ device: ConnectedDevice) async throws -> Bool {
+        try await client.isProvisioned(device)
+    }
+
+    func readPublicKey(from device: ConnectedDevice) async throws -> String? {
+        try await client.readPublicKey(from: device)
+    }
+
+    func readAuthNonce(from device: ConnectedDevice) async throws -> String? {
+        try await client.readAuthNonce(from: device)
+    }
+
+    func setAPIEndpoint(_ environment: DeviceAPIEnvironment, on device: ConnectedDevice) async throws {
+        try await client.setAPIEndpoint(environment, on: device)
+    }
+
+    func deliverCertificate(
+        _ certificatePEM: String,
+        privateKeyPEM: String,
+        to device: ConnectedDevice
+    ) async throws {
+        try await client.deliverCertificate(
+            certificatePEM,
+            privateKeyPEM: privateKeyPEM,
+            to: device
+        )
+    }
+
+    func deliverBackendPublicKey(_ publicKey: Data, to device: ConnectedDevice) async throws {
+        try await client.deliverBackendPublicKey(publicKey, to: device)
+    }
+
+    func writeGrant(_ grantBlob: String, to device: ConnectedDevice) async throws {
+        try await client.writeGrant(grantBlob, to: device)
+    }
+
+    func syncTime(_ device: ConnectedDevice) async throws {
+        try await client.syncTime(device)
+    }
+
+    func requestStartRecording(
+        _ device: ConnectedDevice,
+        grantBlob: String
+    ) async throws -> RecordingControlResult {
+        try await client.requestStartRecording(device, grantBlob: grantBlob)
+    }
+
+    func requestStopRecording(
+        _ device: ConnectedDevice,
+        grantBlob: String
+    ) async throws -> RecordingControlResult {
+        try await client.requestStopRecording(device, grantBlob: grantBlob)
+    }
+
+    func readRecordingState(from device: ConnectedDevice) async throws -> RecordingState {
+        try await client.readRecordingState(from: device)
+    }
+
+    func startRecordingStateUpdates(
+        _ device: ConnectedDevice,
+        onState: @escaping @Sendable (RecordingState) -> Void,
+        onError: @escaping @Sendable (Error) -> Void = { _ in }
+    ) async throws {
+        await stopRecordingStateUpdates()
+        let updates = try await client.recordingStateUpdates(device)
+        let task = Task {
+            do {
+                for try await state in updates { onState(state) }
+            } catch is CancellationError {
+                // Explicit stop is not a recording-state stream failure.
+            } catch {
+                onError(error)
+            }
+        }
+        recordingStateTask = task
+    }
+
+    func stopRecordingStateUpdates() async {
+        guard let task = recordingStateTask else { return }
+        recordingStateTask = nil
+        task.cancel()
+        await task.value
+    }
+
+    func readConnectionSettings(from device: ConnectedDevice) async throws -> DeviceConnectionSettings {
+        try await client.readConnectionSettings(from: device)
+    }
+
+    func writeConnectionSettings(
+        _ settings: DeviceConnectionSettings,
+        to device: ConnectedDevice
+    ) async throws {
+        try await client.writeConnectionSettings(settings, to: device)
+    }
+
+    func factoryReset(
+        _ device: ConnectedDevice,
+        commandID: String,
+        bindingGeneration: UInt64,
+        onGrantRequest: @escaping @Sendable (BotaDeviceSDKAppleFactoryResetRequest) -> Void,
+        onPersistenceRequest: (@Sendable (
+            BotaDeviceSDKAppleFactoryResetPersistenceRequest
+        ) -> Void)?
+    ) async throws -> FactoryResetCompletion {
+        let persister: FactoryResetResultPersister?
+        if let onPersistenceRequest {
+            persister = { result in
+                try await self.requestFactoryResetPersistence(
+                    result,
+                    onRequest: onPersistenceRequest
+                )
+            }
+        } else {
+            persister = nil
+        }
+        return try await client.factoryReset(
+            device,
+            commandID: commandID,
+            bindingGeneration: bindingGeneration,
+            persistResult: persister
+        ) { request in
+            try await self.requestFactoryResetGrant(request, onRequest: onGrantRequest)
+        }
+    }
+
+    func resumePendingFactoryReset(
+        _ device: ConnectedDevice,
+        currentBindingGeneration: UInt64,
+        onPersistenceRequest: (@Sendable (
+            BotaDeviceSDKAppleFactoryResetPersistenceRequest
+        ) -> Void)?
+    ) async throws -> FactoryResetCompletion? {
+        let persister: FactoryResetResultPersister?
+        if let onPersistenceRequest {
+            persister = { result in
+                try await self.requestFactoryResetPersistence(
+                    result,
+                    onRequest: onPersistenceRequest
+                )
+            }
+        } else {
+            persister = nil
+        }
+        let pending = try await client.resumePendingFactoryReset(
+            device,
+            currentBindingGeneration: currentBindingGeneration,
+            persistResult: persister
+        )
+        if let pending { return pending }
+        guard let persister else { return nil }
+        return try await client.resumeUnjournaledFactoryReset(
+            device,
+            commandID: "rn-resume-\(UUID().uuidString)",
+            bindingGeneration: currentBindingGeneration,
+            persistResult: persister
+        )
+    }
+
+    func resolveProvisioningMaterial(
+        requestID: String,
+        apiEndpoint: String,
+        deviceToken: String,
+        mtu: UInt64
+    ) throws {
+        guard let continuation = provisioningRequests.removeValue(forKey: requestID) else {
+            throw MaterialError.unknownRequest
+        }
+        continuation.resume(returning: ProvisioningMaterial(
+            apiEndpoint: Data(apiEndpoint.utf8),
+            deviceToken: Data(deviceToken.utf8),
+            mtu: mtu
+        ))
+    }
+
+    func rejectApplicationMaterial(requestID: String, message: String) throws {
+        if let continuation = provisioningRequests.removeValue(forKey: requestID) {
+            continuation.resume(throwing: MaterialError.rejected(message))
+            return
+        }
+        if let continuation = factoryResetRequests.removeValue(forKey: requestID) {
+            continuation.resume(throwing: MaterialError.rejected(message))
+            return
+        }
+        if let continuation = factoryResetPersistenceRequests.removeValue(forKey: requestID) {
+            continuation.resume(throwing: MaterialError.rejected(message))
+            return
+        }
+        throw MaterialError.unknownRequest
+    }
+
+    func resolveFactoryResetGrant(requestID: String, grantBlob: String) throws {
+        guard let continuation = factoryResetRequests.removeValue(forKey: requestID) else {
+            throw MaterialError.unknownRequest
+        }
+        guard let grant = Data(base64Encoded: grantBlob), !grant.isEmpty else {
+            continuation.resume(throwing: MaterialError.invalidFactoryResetGrant)
+            return
+        }
+        continuation.resume(returning: grant)
+    }
+
+    func resolveFactoryResetResultPersistence(requestID: String) throws {
+        guard let continuation = factoryResetPersistenceRequests.removeValue(forKey: requestID) else {
+            throw MaterialError.unknownRequest
+        }
+        continuation.resume()
+    }
+
+    func cancelAll() async {
+        await stopRecordingStateUpdates()
+        let pending = provisioningRequests.values
+        provisioningRequests.removeAll()
+        pending.forEach { $0.resume(throwing: MaterialError.cancelled) }
+        let pendingResets = factoryResetRequests.values
+        factoryResetRequests.removeAll()
+        pendingResets.forEach { $0.resume(throwing: MaterialError.cancelled) }
+        let pendingPersistence = factoryResetPersistenceRequests.values
+        factoryResetPersistenceRequests.removeAll()
+        pendingPersistence.forEach { $0.resume(throwing: MaterialError.cancelled) }
+        try? await client.cancelCurrentOperation()
+        try? await client.cancelFactoryReset()
+    }
+
+    private func requestProvisioningMaterial(
+        _ request: ProvisioningMaterialRequest,
+        onRequest: @escaping @Sendable (BotaDeviceSDKAppleProvisioningRequest) -> Void
+    ) async throws -> ProvisioningMaterial {
+        let requestID = UUID().uuidString
+        return try await withTaskCancellationHandler {
+            try await withCheckedThrowingContinuation { continuation in
+                provisioningRequests[requestID] = continuation
+                onRequest(.init(
+                    requestID: requestID,
+                    serialNumber: request.serialNumber,
+                    nonce: request.nonce.hexString,
+                    devicePublicKey: request.devicePublicKey.hexString
+                ))
+            }
+        } onCancel: {
+            Task { await self.cancel(requestID: requestID) }
+        }
+    }
+
+    private func cancel(requestID: String) {
+        if let continuation = provisioningRequests.removeValue(forKey: requestID) {
+            continuation.resume(throwing: MaterialError.cancelled)
+        }
+        if let continuation = factoryResetRequests.removeValue(forKey: requestID) {
+            continuation.resume(throwing: MaterialError.cancelled)
+        }
+        if let continuation = factoryResetPersistenceRequests.removeValue(forKey: requestID) {
+            continuation.resume(throwing: MaterialError.cancelled)
+        }
+    }
+
+    private func requestFactoryResetGrant(
+        _ request: FactoryResetGrantRequest,
+        onRequest: @escaping @Sendable (BotaDeviceSDKAppleFactoryResetRequest) -> Void
+    ) async throws -> Data {
+        let requestID = UUID().uuidString
+        return try await withTaskCancellationHandler {
+            try await withCheckedThrowingContinuation { continuation in
+                factoryResetRequests[requestID] = continuation
+                onRequest(.init(
+                    requestID: requestID,
+                    serialNumber: request.serialNumber,
+                    nonce: request.nonce.hexString,
+                    commandID: request.commandID,
+                    bindingGeneration: request.bindingGeneration
+                ))
+            }
+        } onCancel: {
+            Task { await self.cancel(requestID: requestID) }
+        }
+    }
+
+    private func requestFactoryResetPersistence(
+        _ result: FactoryResetPersistenceResult,
+        onRequest: @escaping @Sendable (
+            BotaDeviceSDKAppleFactoryResetPersistenceRequest
+        ) -> Void
+    ) async throws {
+        let requestID = UUID().uuidString
+        try await withTaskCancellationHandler {
+            try await withCheckedThrowingContinuation { continuation in
+                factoryResetPersistenceRequests[requestID] = continuation
+                onRequest(.init(
+                    requestID: requestID,
+                    localRecordingsDeleted: result.localRecordingsDeleted
+                ))
+            }
+        } onCancel: {
+            Task { await self.cancel(requestID: requestID) }
+        }
+    }
+}
+
+private extension Data {
+    var hexString: String {
+        map { String(format: "%02x", $0) }.joined()
+    }
+}

package/ios/BotaDeviceSDKAppleWiFi.swift

@@ -0,0 +1,128 @@
+import BotaAppSDK
+import Foundation
+
+protocol BotaDeviceSDKAppleWiFiClient: Sendable {
+    func configure(
+        _ device: ConnectedDevice,
+        ssid: String,
+        password: String,
+        grantBlob: String
+    ) async throws -> WiFiConfigResult
+    func disconnect(_ device: ConnectedDevice) async throws -> WiFiConfigResult
+    func readStatus(_ device: ConnectedDevice) async throws -> WiFiStatusInfo
+    func statusUpdates(
+        _ device: ConnectedDevice
+    ) async throws -> AsyncThrowingStream<WiFiStatusInfo, Error>
+    func scanNetworks(_ device: ConnectedDevice) async throws -> DeviceWiFiScanResult
+    func cancelCurrentOperation() async
+}
+
+struct BotaDeviceSDKSharedAppleWiFiClient: BotaDeviceSDKAppleWiFiClient {
+    private let wifi: WiFiManager
+
+    init(client: BotaDeviceClient = .shared) {
+        wifi = client.wifi
+    }
+
+    func configure(
+        _ device: ConnectedDevice,
+        ssid: String,
+        password: String,
+        grantBlob: String
+    ) async throws -> WiFiConfigResult {
+        try await wifi.configure(
+            device,
+            ssid: ssid,
+            password: password,
+            grantBlob: grantBlob
+        )
+    }
+
+    func disconnect(_ device: ConnectedDevice) async throws -> WiFiConfigResult {
+        try await wifi.disconnect(device)
+    }
+
+    func readStatus(_ device: ConnectedDevice) async throws -> WiFiStatusInfo {
+        try await wifi.readStatus(device)
+    }
+
+    func statusUpdates(
+        _ device: ConnectedDevice
+    ) async throws -> AsyncThrowingStream<WiFiStatusInfo, Error> {
+        try await wifi.statusUpdates(device)
+    }
+
+    func scanNetworks(_ device: ConnectedDevice) async throws -> DeviceWiFiScanResult {
+        try await wifi.scanNetworks(device)
+    }
+
+    func cancelCurrentOperation() async {
+        await wifi.cancelCurrentOperation()
+    }
+}
+
+actor BotaDeviceSDKAppleWiFi {
+    private let client: any BotaDeviceSDKAppleWiFiClient
+    private var statusTask: Task<Void, Never>?
+
+    init(client: any BotaDeviceSDKAppleWiFiClient = BotaDeviceSDKSharedAppleWiFiClient()) {
+        self.client = client
+    }
+
+    func configure(
+        _ device: ConnectedDevice,
+        ssid: String,
+        password: String,
+        grantBlob: String
+    ) async throws -> WiFiConfigResult {
+        try await client.configure(
+            device,
+            ssid: ssid,
+            password: password,
+            grantBlob: grantBlob
+        )
+    }
+
+    func disconnect(_ device: ConnectedDevice) async throws -> WiFiConfigResult {
+        try await client.disconnect(device)
+    }
+
+    func readStatus(_ device: ConnectedDevice) async throws -> WiFiStatusInfo {
+        try await client.readStatus(device)
+    }
+
+    func scanNetworks(_ device: ConnectedDevice) async throws -> DeviceWiFiScanResult {
+        try await client.scanNetworks(device)
+    }
+
+    func startStatusUpdates(
+        _ device: ConnectedDevice,
+        onStatus: @escaping @Sendable (WiFiStatusInfo) -> Void,
+        onError: @escaping @Sendable (Error) -> Void = { _ in }
+    ) async throws {
+        await stopStatusUpdates()
+        let updates = try await client.statusUpdates(device)
+        let task = Task {
+            do {
+                for try await status in updates { onStatus(status) }
+            } catch is CancellationError {
+                // Explicit stop is not a status-stream failure.
+            } catch {
+                onError(error)
+            }
+        }
+        statusTask = task
+    }
+
+    func stopStatusUpdates() async {
+        guard let task = statusTask else { return }
+        statusTask = nil
+        task.cancel()
+        await task.value
+    }
+
+    func cancelAll() async {
+        await stopStatusUpdates()
+        await client.cancelCurrentOperation()
+    }
+}