@tinkerlandai/longplay-react-native 0.10.11 → 0.10.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinkerlandai/longplay-react-native",
-  "version": "0.10.11",
+  "version": "0.10.13",
   "description": "Longplay React Native Customer SDK with growth, analytics, commerce, Funnel, content and native store integrations.",
   "license": "UNLICENSED",
   "repository": {

package/native-sdk/android/java/ai/tinkerland/indiana/NativePendingKeystore.kt

@@ -1,81 +0,0 @@
-package ai.tinkerland.indiana
-
-import android.content.Context
-import android.security.keystore.KeyGenParameterSpec
-import android.security.keystore.KeyProperties
-import android.util.AtomicFile
-import android.util.Base64
-import org.json.JSONObject
-import java.io.File
-import java.security.KeyStore
-import java.security.MessageDigest
-import java.util.UUID
-import javax.crypto.Cipher
-import javax.crypto.KeyGenerator
-import javax.crypto.SecretKey
-import javax.crypto.spec.GCMParameterSpec
-
-internal data class IndianaNativePendingOrder(val runId: UUID, val orderId: UUID, val receiptId: UUID, val productId: String, val accountId: String, val profileId: String, val basePlanId: String?, val offerId: String?) {
-    fun json(): JSONObject = JSONObject().put("runId", runId.toString()).put("orderId", orderId.toString()).put("receiptId", receiptId.toString()).put("productId", productId).put("obfuscatedAccountId", accountId).put("obfuscatedProfileId", profileId).put("basePlanId", basePlanId ?: JSONObject.NULL).put("offerId", offerId ?: JSONObject.NULL)
-    companion object {
-        fun parse(value: JSONObject, runId: UUID = UUID.fromString(value.getString("runId"))): IndianaNativePendingOrder {
-            val result = IndianaNativePendingOrder(runId, UUID.fromString(value.getString("orderId")), UUID.fromString(value.getString("receiptId")), value.getString("productId"), value.getString("obfuscatedAccountId"), value.getString("obfuscatedProfileId"), value.optString("basePlanId").takeIf { value.has("basePlanId") && !value.isNull("basePlanId") }, value.optString("offerId").takeIf { value.has("offerId") && !value.isNull("offerId") })
-            if (result.productId.length !in 1..255 || result.accountId.length !in 1..64 || result.profileId.length !in 1..64) throw IndianaClientException("invalid_response")
-            return result
-        }
-    }
-}
-/** Current order metadata only. No token/JWS/customer credential or legacy storage is read. */
-internal interface IndianaNativePendingStorage {
-    fun read(order: UUID): IndianaNativePendingOrder?
-    fun orders(): List<IndianaNativePendingOrder>
-    fun remove(order: UUID)
-}
-internal class IndianaNativePendingKeystore(context: Context, scope: IndianaScope): IndianaNativePendingStorage {
-    private val namespace = "${context.packageName}:${scope.projectId}:${scope.environment.value}"
-    private val hash = MessageDigest.getInstance("SHA-256").digest(namespace.toByteArray()).joinToString("") { "%02x".format(it) }
-    private val directory = File(context.noBackupFilesDir, "grow-funnel-orders-$hash")
-    private val alias = "grow.funnel.orders.v1.$hash"
-    companion object { private val lock = Any() }
-    private fun file(order: UUID) = AtomicFile(File(directory, "$order.json"))
-    private fun aad(order: UUID) = "grow_funnel_order_v1\u0000$namespace\u0000$order".toByteArray()
-    private fun key(create: Boolean): SecretKey {
-        val store = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
-        (store.getKey(alias, null) as? SecretKey)?.let { return it }
-        if (!create || directory.listFiles()?.any { it.isFile } == true) throw IndianaClientException("protected_storage_unavailable")
-        val spec = KeyGenParameterSpec.Builder(alias, KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT).setKeySize(256).setBlockModes(KeyProperties.BLOCK_MODE_GCM).setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE).setRandomizedEncryptionRequired(true).build()
-        return KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore").apply { init(spec) }.generateKey()
-    }
-    override fun read(order: UUID): IndianaNativePendingOrder? = synchronized(lock) {
-        try {
-            if (!file(order).baseFile.exists()) return@synchronized null
-            val bytes = file(order).openRead().use { input -> val output = java.io.ByteArrayOutputStream(); val buffer = ByteArray(1024); while (true) { val count = input.read(buffer); if (count < 0) break; if (output.size() + count > 8192) throw IndianaClientException("protected_storage_unavailable"); output.write(buffer, 0, count) }; output.toByteArray() }
-            val value = JSONObject(bytes.toString(Charsets.UTF_8)); if (value.keys().asSequence().toSet() != setOf("format", "nonce", "ciphertext") || value.getString("format") != "grow_funnel_order_v1") throw IndianaClientException("protected_storage_unavailable")
-            val nonce = Base64.decode(value.getString("nonce"), Base64.NO_WRAP); if (nonce.size != 12) throw IndianaClientException("protected_storage_unavailable")
-            val cipher = Cipher.getInstance("AES/GCM/NoPadding"); cipher.init(Cipher.DECRYPT_MODE, key(false), GCMParameterSpec(128, nonce)); cipher.updateAAD(aad(order))
-            val plaintext = cipher.doFinal(Base64.decode(value.getString("ciphertext"), Base64.NO_WRAP))
-            try { IndianaNativePendingOrder.parse(JSONObject(plaintext.toString(Charsets.UTF_8))).also { if (it.orderId != order) throw IndianaClientException("protected_storage_unavailable") } } finally { plaintext.fill(0) }
-        } catch (_: Exception) { throw IndianaClientException("protected_storage_unavailable") }
-    }
-    override fun orders(): List<IndianaNativePendingOrder> = synchronized(lock) {
-        val files = directory.listFiles()?.filter { it.name.endsWith(".json") } ?: emptyList()
-        if (files.size > 100) throw IndianaClientException("protected_storage_unavailable")
-        files.mapNotNull { read(UUID.fromString(it.name.removeSuffix(".json"))) }
-    }
-    fun orders(runId: UUID): List<IndianaNativePendingOrder> = orders().filter { it.runId == runId }
-    fun contains(record: IndianaNativePendingOrder): Boolean { val previous = read(record.orderId) ?: return false; if (previous != record) throw IndianaClientException("protected_storage_unavailable"); return true }
-    fun put(record: IndianaNativePendingOrder) = synchronized(lock) {
-        if (contains(record)) return@synchronized
-        if ((directory.listFiles()?.count { it.name.endsWith(".json") } ?: 0) >= 100) throw IndianaClientException("protected_storage_unavailable")
-        val currentKey = key(true)
-        if (!directory.exists() && !directory.mkdirs()) throw IndianaClientException("protected_storage_unavailable")
-        val plaintext = record.json().toString().toByteArray()
-        try {
-            val cipher = Cipher.getInstance("AES/GCM/NoPadding"); cipher.init(Cipher.ENCRYPT_MODE, currentKey); cipher.updateAAD(aad(record.orderId))
-            val bytes = JSONObject().put("format", "grow_funnel_order_v1").put("nonce", Base64.encodeToString(cipher.iv, Base64.NO_WRAP)).put("ciphertext", Base64.encodeToString(cipher.doFinal(plaintext), Base64.NO_WRAP)).toString().toByteArray()
-            val atomic = file(record.orderId); val stream = atomic.startWrite()
-            try { stream.write(bytes); atomic.finishWrite(stream) } catch (error: Exception) { atomic.failWrite(stream); throw error }
-        } finally { plaintext.fill(0) }
-    }
-    override fun remove(order: UUID) = synchronized(lock) { file(order).delete() }
-}

package/native-sdk/ios/NativePendingKeychain.swift

@@ -1,52 +0,0 @@
-import Foundation
-import Security
-
-struct IndianaNativePendingOrder: Codable, Sendable, Equatable {
-    let runId: UUID; let orderId: UUID; let receiptId: UUID; let productId: String; let accountToken: UUID
-}
-/// Stores only current order bindings; never a run token, customer token or JWS.
-protocol IndianaNativePendingStorage: Sendable {
-    func read(_ order: UUID) async throws -> IndianaNativePendingOrder?
-    func orders() async throws -> [IndianaNativePendingOrder]
-    func orders(runId: UUID) async throws -> [IndianaNativePendingOrder]
-    func contains(_ record: IndianaNativePendingOrder) async throws -> Bool
-    func put(_ record: IndianaNativePendingOrder) async throws
-    func remove(_ order: UUID) async throws
-}
-actor IndianaNativePendingKeychain: IndianaNativePendingStorage {
-    private let service: String
-    init(scope: IndianaScope) { service = "\(Bundle.main.bundleIdentifier ?? "Indiana").grow.funnel.orders.v1.\(scope.projectId.uuidString.lowercased()).\(scope.environment.rawValue)" }
-    private func query(_ order: UUID) -> [String: Any] { [kSecClass as String:kSecClassGenericPassword,kSecAttrService as String:service,kSecAttrAccount as String:order.uuidString.lowercased()] }
-    func read(_ order: UUID) throws -> IndianaNativePendingOrder? {
-        var result: CFTypeRef?
-        let status = SecItemCopyMatching(query(order).merging([kSecReturnData as String:true]) { _, new in new } as CFDictionary, &result)
-        if status == errSecItemNotFound { return nil }
-        guard status == errSecSuccess, let data = result as? Data, data.count <= 4096, let original = try? JSONDecoder().decode(IndianaNativePendingOrder.self, from: data), original.orderId == order else { throw IndianaClientError.protectedStorageUnavailable }
-        return original
-    }
-    private func allOrders() throws -> [IndianaNativePendingOrder] {
-        let query: [String: Any] = [kSecClass as String:kSecClassGenericPassword,kSecAttrService as String:service,kSecReturnData as String:true,kSecMatchLimit as String:kSecMatchLimitAll]
-        var result: CFTypeRef?
-        let status = SecItemCopyMatching(query as CFDictionary, &result)
-        if status == errSecItemNotFound { return [] }
-        guard status == errSecSuccess, let bytes = result as? [Data], bytes.count <= 100 else { throw IndianaClientError.protectedStorageUnavailable }
-        return try bytes.map { data in
-            guard data.count <= 4096 else { throw IndianaClientError.protectedStorageUnavailable }
-            return try JSONDecoder().decode(IndianaNativePendingOrder.self, from: data)
-        }
-    }
-    func orders() throws -> [IndianaNativePendingOrder] { try allOrders() }
-    func orders(runId: UUID) throws -> [IndianaNativePendingOrder] { try allOrders().filter { $0.runId == runId } }
-    func contains(_ record: IndianaNativePendingOrder) throws -> Bool {
-        guard let original = try read(record.orderId) else { return false }; guard original == record else { throw IndianaClientError.protectedStorageUnavailable }; return true
-    }
-    func put(_ record: IndianaNativePendingOrder) throws {
-        if try contains(record) { return }
-        guard try allOrders().count < 100 else { throw IndianaClientError.protectedStorageUnavailable }
-        let bytes = try JSONEncoder().encode(record)
-        let status = SecItemAdd(query(record.orderId).merging([kSecValueData as String:bytes,kSecAttrAccessible as String:kSecAttrAccessibleWhenUnlockedThisDeviceOnly]) { _, new in new } as CFDictionary, nil)
-        if status == errSecDuplicateItem { guard try contains(record) else { throw IndianaClientError.protectedStorageUnavailable }; return }
-        guard status == errSecSuccess else { throw IndianaClientError.protectedStorageUnavailable }
-    }
-    func remove(_ order: UUID) throws { let status = SecItemDelete(query(order) as CFDictionary); guard status == errSecSuccess || status == errSecItemNotFound else { throw IndianaClientError.protectedStorageUnavailable } }
-}