@bota.dev/react-native-app-sdk 2.0.0-beta.10 → 2.0.0-beta.12

package/android/src/main/java/dev/bota/sdk/reactnative/upload/UploadHttp.kt

@@ -0,0 +1,158 @@
+package dev.bota.sdk.reactnative.upload
+
+import java.io.IOException
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.Response
+import org.json.JSONObject
+
+internal class UploadOperation(val input: UploadInput) {
+  private var cancelled = false
+  private val cancellations = mutableSetOf<() -> Unit>()
+  var registrationId: String? = null
+
+  @Synchronized fun check() { if (cancelled) fail("CANCELLED") }
+  @Synchronized fun <T> active(block: () -> T): T { check(); return block() }
+  @Synchronized fun onCancel(callback: () -> Unit): () -> Unit {
+    check()
+    cancellations.add(callback)
+    return { synchronized(this) { cancellations.remove(callback) }; Unit }
+  }
+  fun cancel() {
+    val callbacks = synchronized(this) {
+      if (cancelled) return
+      cancelled = true
+      cancellations.toList().also { cancellations.clear() }
+    }
+    callbacks.forEach { it() }
+  }
+}
+
+internal class CredentialBroker(private val emit: (String, String) -> Unit) {
+  private data class Pending(val operation: UploadOperation, val result: CompletableDeferred<String>)
+  private val pending = mutableMapOf<String, Pending>()
+
+  suspend fun request(operation: UploadOperation): String {
+    operation.check()
+    val requestId = UUID.randomUUID().toString()
+    val result = CompletableDeferred<String>()
+    val unregister = operation.onCancel { reject(requestId) }
+    try {
+      operation.active {
+        synchronized(this) { pending[requestId] = Pending(operation, result) }
+        emit(requestId, operation.input.operationId)
+      }
+      val token = withTimeoutOrNull(30_000) { result.await() } ?: fail("CREDENTIALS")
+      operation.check()
+      return token
+    } catch (error: Exception) {
+      operation.check()
+      throw error
+    } finally {
+      unregister()
+      synchronized(this) { pending.remove(requestId) }
+    }
+  }
+
+  fun resolve(requestId: String, token: String) {
+    val request = synchronized(this) { pending.remove(requestId) } ?: return
+    try {
+      request.operation.active {
+        demand(token.length in 1..32768 && token.all { it.code in 33..126 }, "CREDENTIALS")
+        request.result.complete(token)
+      }
+    } catch (error: UploadFailure) { request.result.completeExceptionally(error) }
+  }
+
+  fun reject(requestId: String) {
+    val request = synchronized(this) { pending.remove(requestId) } ?: return
+    request.result.completeExceptionally(UploadFailure("BOTA_UPLOAD_CREDENTIALS"))
+  }
+}
+
+internal class UploadRequest(
+  val origin: String, val path: String, val method: String, val headers: Map<String, String>, val body: JSONObject?,
+) {
+  override fun toString(): String = "UploadRequest(<redacted>)"
+}
+
+internal interface UploadHttp {
+  suspend fun execute(request: UploadRequest, operation: UploadOperation, retain: Boolean,
+    beforeDispatch: () -> Unit = {}): JSONObject
+}
+
+/** Dedicated client: no app network recorder, auth interceptor, redirects, or automatic POST retry. */
+internal class BackendUploadHttp(private val client: OkHttpClient = OkHttpClient.Builder()
+  .followRedirects(false).followSslRedirects(false).retryOnConnectionFailure(false)
+  .connectTimeout(20, TimeUnit.SECONDS).readTimeout(30, TimeUnit.SECONDS).callTimeout(45, TimeUnit.SECONDS).build()) : UploadHttp {
+  override suspend fun execute(request: UploadRequest, operation: UploadOperation, retain: Boolean,
+    beforeDispatch: () -> Unit): JSONObject = withContext(if (retain) NonCancellable else kotlin.coroutines.EmptyCoroutineContext) {
+    try {
+      val nativeRequest = Request.Builder().url(request.origin + request.path).apply {
+        request.headers.forEach { (key, value) -> header(key, value) }
+        method(request.method, request.body?.toString()?.toRequestBody("application/json".toMediaType()))
+      }.build()
+      val call = client.newCall(nativeRequest)
+      suspendCancellableCoroutine { continuation ->
+        var unregister: (() -> Unit)? = null
+        continuation.invokeOnCancellation { call.cancel() }
+        try {
+          operation.active {
+            if (!retain) unregister = operation.onCancel { call.cancel() }
+            beforeDispatch()
+            call.enqueue(object : Callback {
+              override fun onFailure(call: Call, e: IOException) {
+                unregister?.invoke()
+                if (continuation.isActive) continuation.resumeWithException(UploadFailure("BOTA_UPLOAD_TRANSPORT"))
+              }
+              override fun onResponse(call: Call, response: Response) {
+                val value = runCatching {
+                  response.use {
+                    if (!response.isSuccessful && response.code != 401 && response.code != 403 && response.code != 409) fail("HTTP_${response.code}")
+                    val body = response.body ?: fail("INVALID_DOCUMENT")
+                    demand(body.contentLength() <= 65536, "INVALID_DOCUMENT")
+                    // Read a bounded body here, before completing the retained request.
+                    val source = body.source()
+                    source.request(65537)
+                    demand(source.buffer.size <= 65536, "INVALID_DOCUMENT")
+                    val text = source.readUtf8()
+                    if (response.code == 409 && runCatching {
+                      JSONObject(text).optJSONObject("error")?.optString("code") == "encrypted_upload_v2_staging_missing"
+                    }.getOrDefault(false)) fail("STAGING_MISSING")
+                    if (!response.isSuccessful) fail("HTTP_${response.code}")
+                    if (text.isEmpty()) JSONObject() else sanitized("INVALID_DOCUMENT") { JSONObject(text) }
+                  }
+                }
+                unregister?.invoke()
+                if (continuation.isActive) value.fold({ continuation.resume(it) }, {
+                  continuation.resumeWithException(if (it is UploadFailure) it else UploadFailure("BOTA_UPLOAD_TRANSPORT"))
+                })
+              }
+            })
+          }
+        } catch (error: Exception) {
+          unregister?.invoke()
+          if (continuation.isActive) continuation.resumeWithException(
+            if (error is UploadFailure) error else UploadFailure("BOTA_UPLOAD_TRANSPORT"))
+        }
+      }
+    } catch (error: Exception) {
+      if (!retain) operation.check()
+      if (error is UploadFailure) throw error
+      fail("TRANSPORT")
+    }
+  }
+}

package/android/src/main/java/dev/bota/sdk/reactnative/upload/UploadJournal.kt

@@ -0,0 +1,112 @@
+package dev.bota.sdk.reactnative.upload
+
+import java.io.File
+import java.io.FileOutputStream
+import java.nio.channels.FileChannel
+import java.nio.file.Files
+import java.nio.file.LinkOption.NOFOLLOW_LINKS
+import java.nio.file.StandardCopyOption.ATOMIC_MOVE
+import java.nio.file.StandardCopyOption.REPLACE_EXISTING
+import java.nio.file.StandardOpenOption.READ
+import java.util.UUID
+import org.json.JSONObject
+
+internal data class JournalEntry(val identitySha256: String, val pointer: UploadPointer?, val phase: String = "ready",
+  val importedPriorSha256: String? = null, val authorizationNonceSha256: String? = null,
+  val recoveryNonceBase64: String? = null) {
+  fun json(): JSONObject = (pointer?.json() ?: JSONObject()).put("version", 2)
+    .put("identitySha256", identitySha256).put("phase", phase).apply {
+      if (importedPriorSha256 != null) put("importedPriorSha256", importedPriorSha256)
+      if (authorizationNonceSha256 != null) put("authorizationNonceSha256", authorizationNonceSha256)
+      if (recoveryNonceBase64 != null) put("recoveryNonceBase64", recoveryNonceBase64)
+    }
+}
+
+internal interface JournalDurability {
+  fun syncFile(stream: FileOutputStream) { stream.fd.sync() }
+  fun replace(source: File, target: File) { Files.move(source.toPath(), target.toPath(), ATOMIC_MOVE, REPLACE_EXISTING) }
+  fun syncDirectory(directory: File) { FileChannel.open(directory.toPath(), READ).use { it.force(true) } }
+}
+
+internal class UploadJournal(private val root: File, private val durability: JournalDurability = object : JournalDurability {}) {
+  private fun directory() {
+    val path = root.toPath()
+    if (!Files.exists(path, NOFOLLOW_LINKS)) {
+      demand(root.mkdir(), "JOURNAL")
+      durability.syncDirectory(root.parentFile!!)
+    }
+    demand(Files.isDirectory(path, NOFOLLOW_LINKS) && !Files.isSymbolicLink(path), "JOURNAL")
+  }
+  private fun file(key: String): File = File(root, "${hashString(key)}.json")
+
+  @Synchronized fun load(input: UploadInput): JournalEntry? = sanitized("JOURNAL") {
+    directory()
+    val file = file(input.journalKey)
+    if (!Files.exists(file.toPath(), NOFOLLOW_LINKS)) return@sanitized null
+    demand(Files.isRegularFile(file.toPath(), NOFOLLOW_LINKS) && file.length() <= 4096, "JOURNAL")
+    val json = JSONObject(file.readText(Charsets.UTF_8))
+    val allowed = setOf("version", "identitySha256", "phase", "recordingId", "sessionId", "ownerRevision", "importedPriorSha256", "authorizationNonceSha256", "recoveryNonceBase64")
+    demand(json.keys().asSequence().all { it in allowed }, "JOURNAL")
+    val version = json.integer("version", 1, 2)
+    val identity = hashString(json.string("identitySha256"))
+    demand(identity == (if (version == 1L) input.legacyIdentitySha256 else input.identitySha256), "IDENTITY_CONFLICT")
+    val phase = json.string("phase")
+    demand(phase in setOf("ready", "recording_create_unknown", "session_create_unknown"), "JOURNAL")
+    val pointer = if (json.has("recordingId")) UploadPointer.parse(json) else null
+    val imported = if (json.has("importedPriorSha256")) hashString(json.string("importedPriorSha256")) else null
+    val nonceHash = if (json.has("authorizationNonceSha256")) hashString(json.string("authorizationNonceSha256")) else null
+    demand(nonceHash == null || pointer?.sessionId != null, "JOURNAL")
+    val recoveryNonce = if (json.has("recoveryNonceBase64")) json.string("recoveryNonceBase64").also { opaque(it, 16) } else null
+    demand(recoveryNonce == null || (phase == "ready" && pointer?.sessionId != null), "JOURNAL")
+    demand(if (phase == "recording_create_unknown") pointer == null else pointer != null, "JOURNAL")
+    demand(phase != "session_create_unknown" || pointer?.sessionId == null, "JOURNAL")
+    if (input.prior != null && pointer != null) {
+      demand(input.prior.recordingId == pointer.recordingId &&
+        (input.prior.sessionId == null || input.prior.fingerprint() == imported ||
+          (input.prior.sessionId == pointer.sessionId && input.prior.ownerRevision == pointer.ownerRevision)),
+        "IDENTITY_CONFLICT")
+    }
+    JournalEntry(input.identitySha256, pointer, phase, imported, nonceHash, recoveryNonce).also {
+      if (version == 1L) save(input, it)
+    }
+  }
+
+  @Synchronized fun save(input: UploadInput, entry: JournalEntry) = sanitized("JOURNAL") {
+    directory()
+    demand(entry.identitySha256 == input.identitySha256, "IDENTITY_CONFLICT")
+    val target = file(input.journalKey)
+    demand(!Files.isSymbolicLink(target.toPath()), "JOURNAL")
+    val temporary = File(root, ".${input.journalKey}.${UUID.randomUUID()}.tmp")
+    try {
+      demand(temporary.createNewFile(), "JOURNAL")
+      FileOutputStream(temporary).use { stream ->
+        stream.write(entry.json().toString().toByteArray(Charsets.UTF_8))
+        durability.syncFile(stream)
+      }
+      durability.replace(temporary, target)
+      durability.syncDirectory(root)
+    } finally { if (temporary.exists()) temporary.delete() }
+  }
+
+  @Synchronized fun remove(input: UploadInput, expected: UploadPointer) = sanitized("JOURNAL") {
+    val current = load(input) ?: fail("IDENTITY_CONFLICT")
+    demand(current.phase == "ready" && current.pointer == expected, "IDENTITY_CONFLICT")
+    Files.delete(file(input.journalKey).toPath())
+    durability.syncDirectory(root)
+  }
+
+  @Synchronized fun rollbackRejectedCreate(input: UploadInput, marker: JournalEntry, previous: JournalEntry?) = sanitized("JOURNAL") {
+    demand(load(input) == marker, "IDENTITY_CONFLICT")
+    when (marker.phase) {
+      "recording_create_unknown" -> demand(previous == null && marker.pointer == null, "IDENTITY_CONFLICT")
+      "session_create_unknown" -> demand(previous?.phase == "ready" && previous.copy(phase = marker.phase) == marker, "IDENTITY_CONFLICT")
+      else -> fail("IDENTITY_CONFLICT")
+    }
+    if (previous == null) {
+      Files.delete(file(input.journalKey).toPath())
+      durability.syncDirectory(root)
+    } else {
+      save(input, previous)
+    }
+  }
+}

package/android/src/main/java/dev/bota/sdk/reactnative/upload/UploadModels.kt

@@ -0,0 +1,171 @@
+package dev.bota.sdk.reactnative.upload
+
+import java.net.URI
+import java.security.MessageDigest
+import java.time.Instant
+import java.util.Base64
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal class UploadFailure(val code: String) : Exception(code)
+internal fun fail(code: String): Nothing = throw UploadFailure("BOTA_UPLOAD_$code")
+internal fun demand(value: Boolean, code: String = "INVALID_INPUT") { if (!value) fail(code) }
+internal inline fun <T> sanitized(code: String, block: () -> T): T = try { block() }
+  catch (error: UploadFailure) { throw error }
+  catch (_: Exception) { fail(code) }
+internal fun digest(value: ByteArray): String = MessageDigest.getInstance("SHA-256").digest(value)
+  .joinToString("") { "%02x".format(it.toInt() and 255) }
+internal fun hex(value: String): ByteArray {
+  demand(value.length % 2 == 0 && value.matches(Regex("[0-9a-fA-F]*")))
+  return value.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
+}
+internal fun encoded(value: ByteArray): String = Base64.getEncoder().encodeToString(value)
+internal fun opaque(value: String, length: Int, hash: String? = null): ByteArray = sanitized("INVALID_DOCUMENT") {
+  val bytes = Base64.getDecoder().decode(value)
+  demand(bytes.size == length && encoded(bytes) == value && (hash == null || digest(bytes) == hash), "INVALID_DOCUMENT")
+  bytes
+}
+internal fun JSONObject.string(key: String): String = (opt(key) as? String)?.also {
+  demand(it.isNotEmpty() && it.length <= 8192)
+} ?: fail("INVALID_INPUT")
+internal fun JSONObject.integer(key: String, minimum: Long = 0, maximum: Long = 9007199254740991L): Long {
+  val raw = opt(key) as? Number ?: fail("INVALID_INPUT")
+  val text = raw.toString()
+  demand(text.matches(Regex("0|[1-9][0-9]*")))
+  val number = text.toLongOrNull() ?: fail("INVALID_INPUT")
+  demand(number in minimum..maximum)
+  return number
+}
+internal fun JSONObject.decimal(key: String, minimum: Long = 0): Long {
+  val value = string(key)
+  demand(value.matches(Regex("0|[1-9][0-9]*")))
+  return (value.toLongOrNull() ?: fail("INVALID_INPUT")).also { demand(it in minimum..9007199254740991L) }
+}
+internal fun uuid(value: String): String = value.also {
+  demand(it.matches(Regex("[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}")))
+}
+internal fun hashString(value: String): String = value.also { demand(it.matches(Regex("[0-9a-f]{64}"))) }
+internal fun JSONObject.optionalObject(key: String): JSONObject? {
+  if (!has(key) || isNull(key)) return null
+  return opt(key) as? JSONObject ?: fail("INVALID_INPUT")
+}
+internal fun timestamp(value: String): Long = sanitized("INVALID_DOCUMENT") { Instant.parse(value).toEpochMilli() }
+
+internal data class UploadScope(
+  val apiOrigin: String, val accountId: String, val projectId: String, val organizationId: String,
+  val environment: String, val endUserId: String, val deviceId: String,
+  val bindingGeneration: Long, val serialNumber: String, val nativeDeviceId: String, val scopeKey: String,
+  val apiBasePath: String = "/v1",
+) {
+  fun identity(includeTransport: Boolean = false): List<Any> = listOf(apiOrigin, accountId, projectId, organizationId, environment, endUserId,
+    deviceId, bindingGeneration, serialNumber, if (includeTransport) nativeDeviceId else "", scopeKey, apiBasePath)
+
+  companion object {
+    fun parse(json: JSONObject): UploadScope {
+      val origin = json.string("apiOrigin")
+      val url = URI(origin)
+      demand(url.scheme == "https" && !url.host.isNullOrEmpty() && url.rawUserInfo == null &&
+        url.rawQuery == null && url.rawFragment == null && (url.rawPath.isNullOrEmpty() || url.rawPath == "/"))
+      fun identifier(key: String) = json.string(key).also { demand(it.matches(Regex("[A-Za-z0-9_-]{1,256}"))) }
+      return UploadScope(origin.trimEnd('/'), identifier("accountId"), identifier("projectId"), json.optString("organizationId", "").also { demand(it.isEmpty() || it.matches(Regex("[A-Za-z0-9_-]{1,256}"))) },
+        identifier("environment"), identifier("endUserId"), identifier("deviceId"), json.integer("bindingGeneration"),
+        json.string("serialNumber"), json.string("nativeDeviceId"), json.string("scopeKey"),
+        json.optString("apiBasePath", "/v1").also { demand(it.matches(Regex("(/[A-Za-z0-9_-]+)+"))) })
+    }
+  }
+}
+
+internal data class UploadRecording(
+  val uuid: String, val generation: Long, val ciphertextLength: Long, val ciphertextSha256: String,
+  val startedAtMs: Long, val durationMs: Long, val plaintextLength: Long, val storageFormat: Long,
+) {
+  fun identity(): List<Any> = listOf(uuid, generation, ciphertextLength.toString(), ciphertextSha256,
+    startedAtMs.toString(), durationMs.toString(), plaintextLength.toString(), storageFormat)
+
+  companion object {
+    fun parse(json: JSONObject): UploadRecording = UploadRecording(uuid(json.string("uuid")),
+      json.integer("generation", 1, 4294967295), json.decimal("ciphertextLength", 1),
+      hashString(json.string("ciphertextSha256")), json.decimal("startedAtMs"), json.decimal("durationMs"),
+      json.decimal("plaintextLength"), json.integer("storageFormat", 3, 3)).also {
+      demand(it.startedAtMs + it.durationMs <= 8640000000000000L)
+    }
+  }
+}
+
+internal data class UploadPointer(val recordingId: String, val sessionId: String? = null, val ownerRevision: Long? = null) {
+  fun fingerprint(): String = digest(JSONArray(listOf(recordingId, sessionId ?: JSONObject.NULL,
+    ownerRevision ?: JSONObject.NULL)).toString().toByteArray(Charsets.UTF_8))
+  fun json(): JSONObject = JSONObject().put("recordingId", recordingId).apply {
+    if (sessionId != null) put("sessionId", sessionId).put("ownerRevision", ownerRevision)
+  }
+  companion object {
+    fun parse(json: JSONObject): UploadPointer {
+      val id = json.string("recordingId")
+      demand(id.matches(Regex("rec_[A-Za-z0-9_-]+")))
+      val hasSession = json.has("sessionId") && !json.isNull("sessionId")
+      val hasRevision = json.has("ownerRevision") && !json.isNull("ownerRevision")
+      demand(hasSession == hasRevision)
+      return UploadPointer(id, if (hasSession) uuid(json.string("sessionId")) else null,
+        if (hasRevision) json.integer("ownerRevision", 1, Int.MAX_VALUE.toLong()) else null)
+    }
+  }
+}
+
+internal data class UploadInput(
+  val operationId: String, val scope: UploadScope, val recording: UploadRecording,
+  val capability: ByteArray, val flags: Long, val journalKey: String, val identitySha256: String,
+  val prior: UploadPointer?, val checkpoint: JSONObject?,
+) {
+  val legacyIdentitySha256: String get() = digest(JSONArray(scope.identity(includeTransport = true) +
+    recording.identity()).toString().toByteArray(Charsets.UTF_8))
+
+  fun validateCheckpoint(pointer: UploadPointer?) {
+    val cp = checkpoint ?: return
+    sanitized("IDENTITY_CONFLICT") {
+      demand(pointer?.sessionId != null && pointer.ownerRevision != null, "IDENTITY_CONFLICT")
+      val session = uuid(cp.string("uploadSessionId"))
+      cp.integer("version", 1, 1)
+      val revision = cp.integer("ownerRevision", 1, Int.MAX_VALUE.toLong())
+      demand(revision <= pointer!!.ownerRevision!! &&
+        ((revision == pointer.ownerRevision) == (session == pointer.sessionId)), "IDENTITY_CONFLICT")
+      demand(cp.decimal("nextCiphertextOffset") <= recording.ciphertextLength, "IDENTITY_CONFLICT")
+      hashString(cp.string("prefixSha256"))
+      cp.integer("revision", 1, 4294967295)
+      val transport = cp.string("transportSessionId")
+      demand(transport.matches(Regex("[1-9][0-9]*")) && transport.toULongOrNull() != null)
+      cp.string("sinkRegistrationId")
+      cp.integer("windowPackets", 1, 65535)
+      cp.integer("dataPayloadBytes", 1, 65535)
+      if (cp.has("highestContiguousSequence") && !cp.isNull("highestContiguousSequence"))
+        cp.integer("highestContiguousSequence", 0, 4294967295)
+      // Legacy identity fields, if supplied during migration, cannot contradict this recording.
+      if (cp.has("recordingUuid")) demand(cp.string("recordingUuid") == recording.uuid, "IDENTITY_CONFLICT")
+      if (cp.has("recordingGeneration")) demand(cp.integer("recordingGeneration") == recording.generation, "IDENTITY_CONFLICT")
+      if (cp.has("ciphertextLength")) demand(cp.decimal("ciphertextLength") == recording.ciphertextLength, "IDENTITY_CONFLICT")
+      if (cp.has("ciphertextSha256")) demand(cp.string("ciphertextSha256") == recording.ciphertextSha256, "IDENTITY_CONFLICT")
+    }
+  }
+
+  companion object {
+    fun parse(text: String): UploadInput = sanitized("INVALID_INPUT") {
+      demand(text.length <= 32768)
+      val json = JSONObject(text)
+      val operation = json.string("operationId").also { demand(it.length <= 256) }
+      val scope = UploadScope.parse(json.getJSONObject("scope"))
+      val recording = UploadRecording.parse(json.getJSONObject("recording"))
+      val capability = json.getJSONObject("capability")
+      val bytes = hex(capability.string("rawValueHex"))
+      demand(bytes.size == 24)
+
+      val keyFields = listOf(scope.scopeKey, scope.deviceId, scope.bindingGeneration, recording.uuid,
+        recording.generation, recording.ciphertextLength.toString(), recording.ciphertextSha256)
+      // Android org.json escapes slashes; the existing JS journal key uses JSON.stringify.
+      val keyJson = JSONArray(keyFields).toString().replace("\\/", "/")
+      val key = digest(keyJson.toByteArray(Charsets.UTF_8))
+      if (json.has("journalKey")) demand(hashString(json.string("journalKey")) == key, "IDENTITY_CONFLICT")
+      val identity = digest(JSONArray(scope.identity() + recording.identity()).toString().toByteArray(Charsets.UTF_8))
+      UploadInput(operation, scope, recording, bytes, capability.integer("flags", 0, 4294967295), key, identity,
+        json.optionalObject("priorJournalEntry")?.let(UploadPointer::parse), json.optionalObject("checkpoint"))
+    }
+  }
+}

package/generated/codegen-contract.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "package": "@bota.dev/react-native-app-sdk",
-  "packageVersion": "2.0.0-beta.10",
+  "packageVersion": "2.0.0-beta.12",
   "reactNativeVersion": "0.86.3",
   "codegenLibrary": "BotaDeviceSDKSpec",
   "nativeModule": "BotaDeviceSDK",
@@ -4108,6 +4108,161 @@
           ]
         },
         "moduleName": "BotaDeviceSDK"
+      },
+      "NativeBotaUploadV2Backend": {
+        "type": "NativeModule",
+        "aliasMap": {},
+        "enumMap": {},
+        "spec": {
+          "eventEmitters": [
+            {
+              "name": "onCredentialsRequested",
+              "optional": false,
+              "typeAnnotation": {
+                "type": "EventEmitterTypeAnnotation",
+                "typeAnnotation": {
+                  "type": "ObjectTypeAnnotation",
+                  "properties": [
+                    {
+                      "name": "requestId",
+                      "optional": false,
+                      "typeAnnotation": {
+                        "type": "StringTypeAnnotation"
+                      }
+                    },
+                    {
+                      "name": "operationId",
+                      "optional": false,
+                      "typeAnnotation": {
+                        "type": "StringTypeAnnotation"
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          ],
+          "methods": [
+            {
+              "name": "prepare",
+              "optional": false,
+              "typeAnnotation": {
+                "type": "FunctionTypeAnnotation",
+                "returnTypeAnnotation": {
+                  "type": "PromiseTypeAnnotation",
+                  "elementType": {
+                    "type": "StringTypeAnnotation"
+                  }
+                },
+                "params": [
+                  {
+                    "name": "inputJSON",
+                    "optional": false,
+                    "typeAnnotation": {
+                      "type": "StringTypeAnnotation"
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "name": "cancel",
+              "optional": false,
+              "typeAnnotation": {
+                "type": "FunctionTypeAnnotation",
+                "returnTypeAnnotation": {
+                  "type": "PromiseTypeAnnotation",
+                  "elementType": {
+                    "type": "VoidTypeAnnotation"
+                  }
+                },
+                "params": [
+                  {
+                    "name": "operationId",
+                    "optional": false,
+                    "typeAnnotation": {
+                      "type": "StringTypeAnnotation"
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "name": "complete",
+              "optional": false,
+              "typeAnnotation": {
+                "type": "FunctionTypeAnnotation",
+                "returnTypeAnnotation": {
+                  "type": "PromiseTypeAnnotation",
+                  "elementType": {
+                    "type": "VoidTypeAnnotation"
+                  }
+                },
+                "params": [
+                  {
+                    "name": "operationId",
+                    "optional": false,
+                    "typeAnnotation": {
+                      "type": "StringTypeAnnotation"
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "name": "resolveCredentials",
+              "optional": false,
+              "typeAnnotation": {
+                "type": "FunctionTypeAnnotation",
+                "returnTypeAnnotation": {
+                  "type": "PromiseTypeAnnotation",
+                  "elementType": {
+                    "type": "VoidTypeAnnotation"
+                  }
+                },
+                "params": [
+                  {
+                    "name": "requestId",
+                    "optional": false,
+                    "typeAnnotation": {
+                      "type": "StringTypeAnnotation"
+                    }
+                  },
+                  {
+                    "name": "token",
+                    "optional": false,
+                    "typeAnnotation": {
+                      "type": "StringTypeAnnotation"
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              "name": "rejectCredentials",
+              "optional": false,
+              "typeAnnotation": {
+                "type": "FunctionTypeAnnotation",
+                "returnTypeAnnotation": {
+                  "type": "PromiseTypeAnnotation",
+                  "elementType": {
+                    "type": "VoidTypeAnnotation"
+                  }
+                },
+                "params": [
+                  {
+                    "name": "requestId",
+                    "optional": false,
+                    "typeAnnotation": {
+                      "type": "StringTypeAnnotation"
+                    }
+                  }
+                ]
+              }
+            }
+          ]
+        },
+        "moduleName": "BotaUploadV2Backend"
       }
     }
   },
@@ -4117,13 +4272,17 @@
         "path": "java/dev/bota/sdk/reactnative/NativeBotaDeviceSDKSpec.java",
         "sha256": "3f1acef6907956745c7db721b5ec768a7d099da4a8e85bc50ae960451c261e2d"
       },
+      {
+        "path": "java/dev/bota/sdk/reactnative/NativeBotaUploadV2BackendSpec.java",
+        "sha256": "50844eb0e1ed98848de2819d2a88f00ccc4a550d4bcfdc5db21039a1eb17127f"
+      },
       {
         "path": "jni/BotaDeviceSDKSpec-generated.cpp",
-        "sha256": "544e060e90cf43640d48192c784a354c26c96ea47950a58967a70bbbfd010e38"
+        "sha256": "f1a82f3cf03616e6f08655204af85317087cd2b0f633c052f2939eb49448c6b8"
       },
       {
         "path": "jni/BotaDeviceSDKSpec.h",
-        "sha256": "e82597a93c10fd0b8cded44c655abc919235f347879dae756545616925ab2c00"
+        "sha256": "a4809b54c65c499c2ad727df1461d2044cfcb6de1eb3bbb05582e160426effce"
       },
       {
         "path": "jni/CMakeLists.txt",
@@ -4131,23 +4290,23 @@
       },
       {
         "path": "jni/react/renderer/components/BotaDeviceSDKSpec/BotaDeviceSDKSpecJSI.h",
-        "sha256": "23446d334170a7dab1df1d655e942e052b857ba286a7d18e1729301182ed27f3"
+        "sha256": "6c5309bc7b6b6b4b2e62e5bed85a7fab8a9da8c43af9e3904692e50756de9e0f"
       }
     ],
     "ios": [
       {
         "path": "BotaDeviceSDKSpec/BotaDeviceSDKSpec-generated.mm",
-        "sha256": "26fe0dc191f982056702506a2159a7ee813241333434f0c90e7306b9a9c70a00"
+        "sha256": "8bee25e75f2e73f0b989b65e1c083fb851ba77ca3d4384aecaabb1bcb252fe7a"
       },
       {
         "path": "BotaDeviceSDKSpec/BotaDeviceSDKSpec.h",
-        "sha256": "5a680da391ab9fabbe0422bf692be4023ea26575c86231657a17518d22ef3260"
+        "sha256": "6bef81e2a87bb83ddbc3021e69ddbd280dac23a5049af675b738925454b1c22c"
       },
       {
         "path": "BotaDeviceSDKSpecJSI.h",
-        "sha256": "23446d334170a7dab1df1d655e942e052b857ba286a7d18e1729301182ed27f3"
+        "sha256": "6c5309bc7b6b6b4b2e62e5bed85a7fab8a9da8c43af9e3904692e50756de9e0f"
       }
     ]
   },
-  "contractDigest": "058deff0ead08281d386027a52b699bca6b42bd9549d55c1e7a659eccefa8aab"
+  "contractDigest": "0378337ad43dd8f3d04c6df7713d4c7805779f15befb830951437c6f60d057fe"
 }