@bota.dev/react-native-app-sdk 2.0.0-beta.1 → 2.0.0-beta.11

package/ios/BotaDeviceSDKAppleRecordingUploads.swift

@@ -1,4 +1,5 @@
 import Foundation
+import Darwin
 
 struct BotaDeviceSDKAppleRecordingUploadRequest: Sendable {
     let taskID: String
@@ -11,6 +12,7 @@ struct BotaDeviceSDKAppleRecordingUploadRequest: Sendable {
     let contentSHA256: String?
     let relayURL: String?
     let relayBearerToken: String?
+    var fileSizeBytes: Int64? = nil
 }
 
 struct BotaDeviceSDKAppleRecordingUploadProgress: Equatable, Sendable {
@@ -25,6 +27,9 @@ actor BotaDeviceSDKAppleRecordingUploads {
         case invalidResponse
         case missingFile(String)
         case requestFailed(Int)
+        case invalidJournal
+        case notCompleted
+        case fileSizeChanged
 
         var errorDescription: String? {
             switch self {
@@ -36,24 +41,42 @@ actor BotaDeviceSDKAppleRecordingUploads {
                 "recording file does not exist: \(path)"
             case let .requestFailed(statusCode):
                 "recording upload failed with HTTP \(statusCode)"
+            case .invalidJournal:
+                "invalid upload recovery journal"
+            case .notCompleted:
+                "recording release requires exact durable completion"
+            case .fileSizeChanged:
+                "stored recording length changed"
             }
         }
     }
 
     private var queueFile: URL
+    private var recordingDirectory: URL
     private let session: URLSession
+    private let syncDirectory: @Sendable (URL) throws -> Void
+    private var journalWriteUncertain = false
     private var operations: [String: Task<Void, Error>] = [:]
+    private var cancelledAttempts = Set<String>()
 
     init(
         queueFile: URL = BotaDeviceSDKAppleRecordingUploads.defaultQueueFile(),
-        session: URLSession = .shared
+        session: URLSession = .shared,
+        syncDirectory: @escaping @Sendable (URL) throws -> Void = BotaDeviceSDKAppleRecordingUploads.synchronizeDirectory
     ) {
         self.queueFile = queueFile
+        recordingDirectory = queueFile.deletingLastPathComponent().appendingPathComponent("Recordings", isDirectory: true)
         self.session = session
+        self.syncDirectory = syncDirectory
     }
 
     func configure(applicationSupportDirectory: URL?) {
-        guard let applicationSupportDirectory else { return }
+        guard let applicationSupportDirectory else {
+            queueFile = Self.defaultQueueFile()
+            recordingDirectory = queueFile.deletingLastPathComponent().appendingPathComponent("Recordings", isDirectory: true)
+            return
+        }
+        recordingDirectory = applicationSupportDirectory.appendingPathComponent("Recordings", isDirectory: true)
         queueFile = applicationSupportDirectory
             .appendingPathComponent("BotaDeviceSDK", isDirectory: true)
             .appendingPathComponent("compat-upload-queue.json")
@@ -63,6 +86,8 @@ actor BotaDeviceSDKAppleRecordingUploads {
         _ upload: BotaDeviceSDKAppleRecordingUploadRequest,
         onProgress: @escaping @Sendable (BotaDeviceSDKAppleRecordingUploadProgress) -> Void
     ) async throws {
+        guard !cancelledAttempts.contains(upload.taskID) else { throw CancellationError() }
+        try requireOwnedFile(upload.localPath)
         guard operations[upload.taskID] == nil else {
             throw UploadError.alreadyActive(upload.taskID)
         }
@@ -72,16 +97,21 @@ actor BotaDeviceSDKAppleRecordingUploads {
         }
         operations[upload.taskID] = operation
         defer { operations.removeValue(forKey: upload.taskID) }
-        try await operation.value
+        try await withTaskCancellationHandler {
+            try await operation.value
+        } onCancel: {
+            operation.cancel()
+        }
     }
 
     func cancel(taskID: String) {
-        operations.removeValue(forKey: taskID)?.cancel()
+        cancelledAttempts.insert(taskID)
+        operations[taskID]?.cancel()
     }
 
     func cancelAll() {
+        cancelledAttempts.formUnion(operations.keys)
         operations.values.forEach { $0.cancel() }
-        operations.removeAll()
     }
 
     func loadQueue() throws -> String {
@@ -90,11 +120,103 @@ actor BotaDeviceSDKAppleRecordingUploads {
     }
 
     func saveQueue(_ serializedTasks: String) throws {
+        try writeQueue(Self.serialize(Self.metadata(serializedTasks)))
+    }
+
+    func release(taskID: String, localPath: String) async throws {
+        guard !journalWriteUncertain else { throw UploadError.notCompleted }
+        let tasks = try Self.metadata(String(contentsOf: queueFile, encoding: .utf8))
+        guard tasks.contains(where: {
+            $0["id"] as? String == taskID && $0["localPath"] as? String == localPath &&
+                $0["status"] as? String == "completed"
+        }) else { throw UploadError.notCompleted }
+        try removeCompletedFile(localPath)
+    }
+
+    private func removeCompletedFile(_ path: String) throws {
+        try requireOwnedFile(path)
+        if FileManager.default.fileExists(atPath: path) {
+            let attributes = try FileManager.default.attributesOfItem(atPath: path)
+            guard attributes[.type] as? FileAttributeType == .typeRegular else { throw UploadError.notCompleted }
+            try FileManager.default.removeItem(atPath: path)
+        }
+        // A missing file may be an earlier unlink whose directory sync failed.
+        try syncDirectory(URL(fileURLWithPath: path).deletingLastPathComponent())
+    }
+
+    private func requireOwnedFile(_ path: String) throws {
+        let file = URL(fileURLWithPath: path)
+        guard path.hasPrefix("/"), file.pathExtension == "recording",
+              UUID(uuidString: file.deletingPathExtension().lastPathComponent) != nil,
+              file.resolvingSymlinksInPath().deletingLastPathComponent().standardizedFileURL == recordingDirectory.resolvingSymlinksInPath().standardizedFileURL
+        else { throw UploadError.notCompleted }
+        if FileManager.default.fileExists(atPath: path) {
+            let attributes = try FileManager.default.attributesOfItem(atPath: path)
+            guard attributes[.type] as? FileAttributeType == .typeRegular else { throw UploadError.notCompleted }
+        }
+    }
+
+    private func writeQueue(_ serializedTasks: String) throws {
+        journalWriteUncertain = true
         try FileManager.default.createDirectory(
             at: queueFile.deletingLastPathComponent(),
             withIntermediateDirectories: true
         )
+        try syncDirectory(queueFile.deletingLastPathComponent().deletingLastPathComponent())
         try Data(serializedTasks.utf8).write(to: queueFile, options: .atomic)
+        let handle = try FileHandle(forWritingTo: queueFile)
+        defer { try? handle.close() }
+        try handle.synchronize()
+        try syncDirectory(queueFile.deletingLastPathComponent())
+        journalWriteUncertain = false
+    }
+
+    private static func serialize(_ tasks: [[String: Any]]) throws -> String {
+        String(decoding: try JSONSerialization.data(withJSONObject: tasks, options: [.sortedKeys]), as: UTF8.self)
+    }
+
+    private static func metadata(_ serialized: String) throws -> [[String: Any]] {
+        guard let tasks = try JSONSerialization.jsonObject(with: Data(serialized.utf8)) as? [[String: Any]] else {
+            throw UploadError.invalidJournal
+        }
+        let fields: Set<String> = ["id", "recordingId", "deviceId", "recordingUuid", "localPath", "status", "retryCount", "createdAt", "updatedAt", "recoveryScope", "fileSizeBytes", "nextAttemptAt", "contentType", "contentSha256", "relayUpload"]
+        var ids = Set<String>()
+        return try tasks.map { task in
+            guard let id = task["id"] as? String, !id.isEmpty, ids.insert(id).inserted,
+                  let recordingID = task["recordingId"] as? String, !recordingID.isEmpty,
+                  let deviceID = task["deviceId"] as? String, !deviceID.isEmpty,
+                  task["localPath"] is String, task["createdAt"] is String, task["updatedAt"] is String,
+                  let status = task["status"] as? String, ["pending", "uploading", "completed", "failed"].contains(status),
+                  validInteger(task["retryCount"])
+            else { throw UploadError.invalidJournal }
+            for key in ["recordingUuid", "recoveryScope", "contentType", "contentSha256"] where task[key] != nil {
+                guard task[key] is String else { throw UploadError.invalidJournal }
+            }
+            for key in ["fileSizeBytes", "nextAttemptAt"] where task[key] != nil {
+                guard validInteger(task[key]) else { throw UploadError.invalidJournal }
+            }
+            if let relay = task["relayUpload"] {
+                guard let number = relay as? NSNumber, CFGetTypeID(number) == CFBooleanGetTypeID() else { throw UploadError.invalidJournal }
+            }
+            let dates = ISO8601DateFormatter()
+            let fractionalDates = ISO8601DateFormatter()
+            fractionalDates.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+            for key in ["createdAt", "updatedAt"] {
+                guard let value = task[key] as? String,
+                      dates.date(from: value) != nil || fractionalDates.date(from: value) != nil
+                else { throw UploadError.invalidJournal }
+            }
+            var clean = task.filter { fields.contains($0.key) }
+            guard clean.values.allSatisfy({ $0 is String || $0 is NSNumber }) else { throw UploadError.invalidJournal }
+            clean["relayUpload"] = task["relayUpload"] as? Bool ?? (task["relay"] is [String: Any])
+            return clean
+        }
+    }
+
+    private static func validInteger(_ value: Any?) -> Bool {
+        guard let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() else { return false }
+        let value = number.doubleValue
+        return value.isFinite && value >= 0 && value <= 9_007_199_254_740_991 && value.rounded() == value
     }
 
     private static func performUpload(
@@ -108,6 +230,8 @@ actor BotaDeviceSDKAppleRecordingUploads {
         }
         let attributes = try FileManager.default.attributesOfItem(atPath: fileURL.path)
         let totalBytes = (attributes[.size] as? NSNumber)?.int64Value ?? 0
+        if let expected = upload.fileSizeBytes, expected != totalBytes { throw UploadError.fileSizeChanged }
+        try Task.checkCancellation()
         onProgress(.init(taskID: upload.taskID, completedBytes: 0, totalBytes: totalBytes))
 
         let relay = upload.relayURL != nil
@@ -123,6 +247,7 @@ actor BotaDeviceSDKAppleRecordingUploads {
         }
         let (_, response) = try await session.upload(for: request, fromFile: fileURL)
         try Self.requireSuccess(response)
+        try Task.checkCancellation()
 
         if !relay,
            let completeURL = upload.completeURL,
@@ -144,12 +269,12 @@ actor BotaDeviceSDKAppleRecordingUploads {
             try requireSuccess(completeResponse)
         }
 
+        try Task.checkCancellation()
         onProgress(.init(
             taskID: upload.taskID,
             completedBytes: totalBytes,
             totalBytes: totalBytes
         ))
-        try FileManager.default.removeItem(at: fileURL)
     }
 
     private static func requiredURL(_ value: String) throws -> URL {
@@ -175,4 +300,11 @@ actor BotaDeviceSDKAppleRecordingUploads {
             .appendingPathComponent("BotaDeviceSDK", isDirectory: true)
             .appendingPathComponent("compat-upload-queue.json")
     }
+
+    private static func synchronizeDirectory(_ directory: URL) throws {
+        let descriptor = Darwin.open(directory.path, O_RDONLY)
+        guard descriptor >= 0 else { throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO) }
+        defer { Darwin.close(descriptor) }
+        guard Darwin.fsync(descriptor) == 0 else { throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO) }
+    }
 }

package/ios/BotaDeviceSDKAppleRecordings.swift

@@ -5,10 +5,12 @@ struct BotaDeviceSDKAppleRecordingFile: Equatable, Sendable {
     let localPath: String
     let isE2EEncrypted: Bool
     let contentSHA256Hex: String?
+    let fileSizeBytes: UInt64
 }
 
 protocol BotaDeviceSDKAppleRecordingClient: Sendable {
     func listRecordings(_ device: ConnectedDevice) async throws -> [DeviceRecording]
+    func listPendingRecordings(_ device: ConnectedDevice) async throws -> [PendingRecording]
     func syncRecording(
         _ device: ConnectedDevice,
         recording: DeviceRecording,
@@ -18,8 +20,10 @@ protocol BotaDeviceSDKAppleRecordingClient: Sendable {
     func syncEncryptedRecordingV2(
         _ device: ConnectedDevice,
         recording: EncryptedUploadV2Recording,
+        operationID: UUID,
         provider: @escaping EncryptedUploadV2ProfileProvider
     ) async throws
+    func cancelEncryptedUploadV2Operation(_ operationID: UUID) async throws
     func confirmRecording(_ device: ConnectedDevice, recordingUUID: String) async throws
     func observeUploadOwnership(
         _ device: ConnectedDevice,
@@ -50,6 +54,10 @@ struct BotaDeviceSDKSharedAppleRecordingClient: BotaDeviceSDKAppleRecordingClien
         try await recordings.listRecordings(device)
     }
 
+    func listPendingRecordings(_ device: ConnectedDevice) async throws -> [PendingRecording] {
+        try await recordings.listPendingRecordings(device)
+    }
+
     func syncRecording(
         _ device: ConnectedDevice,
         recording: DeviceRecording,
@@ -70,15 +78,21 @@ struct BotaDeviceSDKSharedAppleRecordingClient: BotaDeviceSDKAppleRecordingClien
     func syncEncryptedRecordingV2(
         _ device: ConnectedDevice,
         recording: EncryptedUploadV2Recording,
+        operationID: UUID,
         provider: @escaping EncryptedUploadV2ProfileProvider
     ) async throws {
         try await recordings.syncEncryptedRecordingV2(
             device,
             recording: recording,
+            operationID: operationID,
             provider: provider
         )
     }
 
+    func cancelEncryptedUploadV2Operation(_ operationID: UUID) async throws {
+        try await recordings.cancelEncryptedUploadV2Operation(operationID)
+    }
+
     func confirmRecording(_ device: ConnectedDevice, recordingUUID: String) async throws {
         try await recordings.confirmRecording(device, recordingUUID: recordingUUID)
     }
@@ -153,11 +167,16 @@ actor BotaDeviceSDKAppleRecordings {
     }
 
     private let client: any BotaDeviceSDKAppleRecordingClient
+    private let fileSize: @Sendable (String) throws -> UInt64
     private struct EncryptedUploadV2Request {
+        let operationID: String
         let recording: EncryptedUploadV2Recording
         let continuation: CheckedContinuation<EncryptedUploadV2Material, Error>
     }
     private var encryptedUploadV2Requests: [String: EncryptedUploadV2Request] = [:]
+    private var encryptedUploadV2Operations: [String: UUID] = [:]
+    private var encryptedUploadV2Tasks: [String: Task<Void, Error>] = [:]
+    private var cancelledEncryptedUploadV2Operations: Set<String> = []
     private var destinationRequests: [
         String: CheckedContinuation<StreamingUploadDestination, Error>
     ] = [:]
@@ -166,15 +185,28 @@ actor BotaDeviceSDKAppleRecordings {
 
     init(
         client: any BotaDeviceSDKAppleRecordingClient =
-            BotaDeviceSDKSharedAppleRecordingClient()
+            BotaDeviceSDKSharedAppleRecordingClient(),
+        fileSize: @escaping @Sendable (String) throws -> UInt64 = { path in
+            let attributes = try FileManager.default.attributesOfItem(atPath: path)
+            guard attributes[.type] as? FileAttributeType == .typeRegular,
+                  let size = attributes[.size] as? NSNumber else {
+                throw CocoaError(.fileReadCorruptFile)
+            }
+            return size.uint64Value
+        }
     ) {
         self.client = client
+        self.fileSize = fileSize
     }
 
     func listRecordings(_ device: ConnectedDevice) async throws -> [DeviceRecording] {
         try await client.listRecordings(device)
     }
 
+    func listPendingRecordings(_ device: ConnectedDevice) async throws -> [PendingRecording] {
+        try await client.listPendingRecordings(device)
+    }
+
     func syncRecording(
         _ device: ConnectedDevice,
         recording: DeviceRecording,
@@ -200,7 +232,8 @@ actor BotaDeviceSDKAppleRecordings {
         return BotaDeviceSDKAppleRecordingFile(
             localPath: path,
             isE2EEncrypted: metadata?.isE2EEncrypted ?? false,
-            contentSHA256Hex: metadata?.contentSHA256Hex
+            contentSHA256Hex: metadata?.contentSHA256Hex,
+            fileSizeBytes: try fileSize(path)
         )
     }
 
@@ -210,11 +243,51 @@ actor BotaDeviceSDKAppleRecordings {
         operationID: String,
         onProfileRequest: @escaping @Sendable ([String: Any]) -> Void,
         onProgress: @escaping @Sendable ([String: Any]) -> Void
+    ) async throws {
+        guard encryptedUploadV2Operations[operationID] == nil else {
+            throw RecordingError.invalidEncryptedUploadV2Selection
+        }
+        guard !cancelledEncryptedUploadV2Operations.contains(operationID) else { throw CancellationError() }
+        let nativeID = UUID()
+        let task = Task {
+            try Task.checkCancellation()
+            try await self.runEncryptedRecordingV2(
+                device,
+                recording: recording,
+                operationID: operationID,
+                nativeID: nativeID,
+                onProfileRequest: onProfileRequest,
+                onProgress: onProgress
+            )
+        }
+        encryptedUploadV2Operations[operationID] = nativeID
+        encryptedUploadV2Tasks[operationID] = task
+        defer {
+            encryptedUploadV2Operations.removeValue(forKey: operationID)
+            encryptedUploadV2Tasks.removeValue(forKey: operationID)
+            BotaDeviceSDKEncryptedUploadV2Materials.removeContext(operationID)
+        }
+        try await withTaskCancellationHandler {
+            try await task.value
+        } onCancel: {
+            task.cancel()
+            Task { try? await self.cancelEncryptedRecordingV2(operationID) }
+        }
+    }
+
+    private func runEncryptedRecordingV2(
+        _ device: ConnectedDevice,
+        recording: EncryptedUploadV2Recording,
+        operationID: String,
+        nativeID: UUID,
+        onProfileRequest: @escaping @Sendable ([String: Any]) -> Void,
+        onProgress: @escaping @Sendable ([String: Any]) -> Void
     ) async throws {
         do {
             try await client.syncEncryptedRecordingV2(
                 device,
-                recording: recording
+                recording: recording,
+                operationID: nativeID
             ) { context in
                 let completedBytes = String(context.checkpoint?.nextCiphertextOffset ?? 0)
                 let checkpointRevision = context.checkpoint?.revision
@@ -264,6 +337,25 @@ actor BotaDeviceSDKAppleRecordings {
         }
     }
 
+    func cancelEncryptedRecordingV2(_ operationID: String) async throws {
+        cancelledEncryptedUploadV2Operations.insert(operationID)
+        let task = encryptedUploadV2Tasks[operationID]
+        task?.cancel()
+        let pending = encryptedUploadV2Requests.filter { $0.value.operationID == operationID }
+        for (id, request) in pending {
+            encryptedUploadV2Requests.removeValue(forKey: id)
+            request.continuation.resume(throwing: CancellationError())
+        }
+        BotaDeviceSDKEncryptedUploadV2Materials.removeContext(operationID)
+        var cancellationError: Error?
+        if let nativeID = encryptedUploadV2Operations[operationID] {
+            do { try await client.cancelEncryptedUploadV2Operation(nativeID) }
+            catch { cancellationError = error }
+        }
+        _ = await task?.result
+        if let cancellationError { throw cancellationError }
+    }
+
     func resolveEncryptedUploadV2Profile(
         requestID: String,
         profile: String,
@@ -275,6 +367,7 @@ actor BotaDeviceSDKAppleRecordings {
         guard let request = encryptedUploadV2Requests.removeValue(forKey: requestID) else {
             throw RecordingError.missingEncryptedUploadV2Request
         }
+        BotaDeviceSDKEncryptedUploadV2Materials.removeContext(request.operationID)
         do {
             guard profile == "encrypted_upload_v2",
                   let sessionID = UUID(uuidString: uploadSessionID)
@@ -299,6 +392,7 @@ actor BotaDeviceSDKAppleRecordings {
         guard let request = encryptedUploadV2Requests.removeValue(forKey: requestID) else {
             throw RecordingError.missingEncryptedUploadV2Request
         }
+        BotaDeviceSDKEncryptedUploadV2Materials.removeContext(request.operationID)
         guard errorCode == "application_material_rejected" else {
             request.continuation.resume(throwing: RecordingError.invalidEncryptedUploadV2Selection)
             throw RecordingError.invalidEncryptedUploadV2Selection
@@ -453,6 +547,9 @@ actor BotaDeviceSDKAppleRecordings {
     }
 
     func cancelAll() async {
+        let operationIDs = Array(encryptedUploadV2Tasks.keys)
+        for id in operationIDs { encryptedUploadV2Tasks[id]?.cancel() }
+        for id in operationIDs { try? await cancelEncryptedRecordingV2(id) }
         rejectPendingRequests(message: "recording operations were cancelled")
         try? await client.cancelCurrentOperation()
     }
@@ -462,9 +559,13 @@ actor BotaDeviceSDKAppleRecordings {
         context: EncryptedUploadV2ProviderContext,
         onRequest: @escaping @Sendable ([String: Any]) -> Void
     ) async throws -> EncryptedUploadV2Material {
+        guard encryptedUploadV2Operations[operationID] != nil,
+              !cancelledEncryptedUploadV2Operations.contains(operationID) else { throw CancellationError() }
         let requestID = UUID().uuidString.lowercased()
+        try BotaDeviceSDKEncryptedUploadV2Materials.registerContext(operationID, context: context)
         return try await withCheckedThrowingContinuation { continuation in
             encryptedUploadV2Requests[requestID] = .init(
+                operationID: operationID,
                 recording: context.recording,
                 continuation: continuation
             )
@@ -525,12 +626,15 @@ actor BotaDeviceSDKAppleRecordings {
         destinationRequests.removeAll()
         finalizeRequests.removeAll()
         encryptedUploadV2Requests.removeAll()
-        encryptedUploadV2.forEach { $0.continuation.resume(throwing: error) }
+        encryptedUploadV2.forEach {
+            BotaDeviceSDKEncryptedUploadV2Materials.removeContext($0.operationID)
+            $0.continuation.resume(throwing: error)
+        }
         destinations.forEach { $0.resume(throwing: error) }
         finalizations.forEach { $0.resume(throwing: error) }
     }
 
-    private static func encryptedUploadV2Recording(
+    static func encryptedUploadV2Recording(
         _ recording: EncryptedUploadV2Recording
     ) -> [String: Any] {
         [
@@ -538,6 +642,10 @@ actor BotaDeviceSDKAppleRecordings {
             "generation": recording.generation,
             "ciphertextLength": String(recording.ciphertextLength),
             "ciphertextSha256": recording.ciphertextSHA256.hexString,
+            "startedAtMs": String(recording.startedAtMs),
+            "durationMs": String(recording.durationMs),
+            "plaintextLength": String(recording.plaintextLength),
+            "storageFormat": Int(recording.storageFormat),
         ]
     }
 

package/ios/BotaDeviceSDKEncryptedUploadV2Materials.swift

@@ -15,6 +15,25 @@ public enum BotaDeviceSDKEncryptedUploadV2Materials {
         storage.remove(registrationID)
     }
 
+    public static func readAuthNonce(_ operationID: String) async throws -> Data {
+        let entry = try storage.context(operationID)
+        let nonce = try await entry.value.readAuthNonce()
+        guard try storage.context(operationID).lease == entry.lease else {
+            throw CancellationError()
+        }
+        return nonce
+    }
+
+    public static func release(_ registrationID: String) async {
+        if let material = storage.remove(registrationID) { await material.cancelPreparation() }
+    }
+
+    static func registerContext(_ operationID: String, context: EncryptedUploadV2ProviderContext) throws {
+        try storage.registerContext(operationID, value: context)
+    }
+
+    static func removeContext(_ operationID: String) { storage.removeContext(operationID) }
+
     static func consume(
         _ registrationID: String,
         recording: EncryptedUploadV2Recording,
@@ -33,6 +52,10 @@ public enum BotaDeviceSDKEncryptedUploadV2Materials {
 }
 
 private final class BotaDeviceSDKEncryptedUploadV2MaterialStorage: @unchecked Sendable {
+    struct Context: Sendable {
+        let lease: UUID
+        let value: EncryptedUploadV2ProviderContext
+    }
     private enum RegistrationError: LocalizedError {
         case invalidSelection
         case unknownRegistration
@@ -49,6 +72,23 @@ private final class BotaDeviceSDKEncryptedUploadV2MaterialStorage: @unchecked Se
 
     private let lock = NSLock()
     private var materials: [String: EncryptedUploadV2Material] = [:]
+    private var contexts: [String: Context] = [:]
+
+    func registerContext(_ operationID: String, value: EncryptedUploadV2ProviderContext) throws {
+        try lock.withLock {
+            guard contexts[operationID] == nil else { throw RegistrationError.invalidSelection }
+            contexts[operationID] = Context(lease: UUID(), value: value)
+        }
+    }
+
+    func context(_ operationID: String) throws -> Context {
+        try lock.withLock {
+            guard let context = contexts[operationID] else { throw RegistrationError.unknownRegistration }
+            return context
+        }
+    }
+
+    func removeContext(_ operationID: String) { _ = lock.withLock { contexts.removeValue(forKey: operationID) } }
 
     func register(_ material: EncryptedUploadV2Material) -> String {
         let registrationID = UUID().uuidString.lowercased()

package/ios/BotaUploadV2Backend.mm

@@ -0,0 +1,49 @@
+#import <BotaDeviceSDKSpec/BotaDeviceSDKSpec.h>
+#if __has_include(<BotaDeviceSDK/BotaDeviceSDK-Swift.h>)
+#import <BotaDeviceSDK/BotaDeviceSDK-Swift.h>
+#else
+#import "BotaDeviceSDK-Swift.h"
+#endif
+
+@interface BotaUploadV2Backend : NativeBotaUploadV2BackendSpecBase <NativeBotaUploadV2BackendSpec>
+@property(nonatomic, strong) BotaUploadV2BackendBridge *backend;
+@end
+
+@implementation BotaUploadV2Backend
+RCT_EXPORT_MODULE(BotaUploadV2Backend)
++ (BOOL)requiresMainQueueSetup { return NO; }
+- (instancetype)init {
+  if ((self = [super init])) { _backend = [BotaUploadV2BackendBridge new]; }
+  return self;
+}
+- (void)prepare:(NSString *)inputJSON resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  __weak BotaUploadV2Backend *weakSelf = self;
+  [_backend prepare:inputJSON credentialsRequested:^(NSString *requestId, NSString *operationId) {
+    [weakSelf emitOnCredentialsRequested:@{@"requestId": requestId, @"operationId": operationId}];
+  } completion:^(NSString *result, NSError *error) {
+    if (error) { reject(@"encrypted_upload_v2_backend_failed", error.localizedDescription, nil); }
+    else { resolve(result); }
+  }];
+}
+- (void)cancel:(NSString *)operationId resolve:(RCTPromiseResolveBlock)resolve reject:(__unused RCTPromiseRejectBlock)reject {
+  [_backend cancel:operationId completion:^{ resolve(nil); }];
+}
+- (void)complete:(NSString *)operationId resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  [_backend complete:operationId completion:^(NSError *error) {
+    if (error) { reject(@"encrypted_upload_v2_backend_failed", error.localizedDescription, nil); }
+    else { resolve(nil); }
+  }];
+}
+- (void)resolveCredentials:(NSString *)requestId token:(NSString *)token resolve:(RCTPromiseResolveBlock)resolve reject:(__unused RCTPromiseRejectBlock)reject {
+  [_backend resolveCredentials:requestId token:token completion:^{ resolve(nil); }];
+}
+- (void)rejectCredentials:(NSString *)requestId resolve:(RCTPromiseResolveBlock)resolve reject:(__unused RCTPromiseRejectBlock)reject {
+  [_backend rejectCredentials:requestId completion:^{ resolve(nil); }];
+}
+- (void)invalidate { [_backend invalidate]; }
+#if RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeBotaUploadV2BackendSpecJSI>(params);
+}
+#endif
+@end