react-native-iap 15.4.0-rc.3 → 15.4.1

package/android/src/main/java/com/margelo/nitro/iap/HybridRnIap.kt

@@ -18,7 +18,7 @@ import dev.hyo.openiap.ProductRequest
 import dev.hyo.openiap.ProductSubscriptionAndroid
 import dev.hyo.openiap.ProductSubscriptionAndroidOfferDetails
 import dev.hyo.openiap.ProductCommon
-import dev.hyo.openiap.ProductType
+import dev.hyo.openiap.ProductType as OpenIapProductType
 import dev.hyo.openiap.Purchase as OpenIapPurchase
 import dev.hyo.openiap.PurchaseAndroid
 import dev.hyo.openiap.RequestPurchaseAndroidProps
@@ -28,6 +28,7 @@ import dev.hyo.openiap.RequestPurchaseResultPurchase
 import dev.hyo.openiap.RequestPurchaseResultPurchases
 import dev.hyo.openiap.RequestSubscriptionAndroidProps
 import dev.hyo.openiap.RequestSubscriptionPropsByPlatforms
+import dev.hyo.openiap.SubResponseCodeAndroid as OpenIapSubResponseCodeAndroid
 import dev.hyo.openiap.SubscriptionProductReplacementParamsAndroid as OpenIapSubscriptionProductReplacementParams
 import dev.hyo.openiap.SubscriptionReplacementModeAndroid as OpenIapSubscriptionReplacementMode
 import dev.hyo.openiap.VerifyPurchaseGoogleOptions
@@ -37,7 +38,17 @@ import dev.hyo.openiap.InitConnectionConfig as OpenIapInitConnectionConfig
 import dev.hyo.openiap.listener.OpenIapPurchaseErrorListener
 import dev.hyo.openiap.listener.OpenIapPurchaseUpdateListener
 import dev.hyo.openiap.listener.OpenIapUserChoiceBillingListener
+import dev.hyo.openiap.BillingChoiceImageLayoutAndroid as OpenIapBillingChoiceImageLayout
+import dev.hyo.openiap.BillingChoiceScreenTypeAndroid as OpenIapBillingChoiceScreenType
+import dev.hyo.openiap.BillingProgramInformationDialogParamsAndroid as OpenIapBillingProgramInformationDialogParams
 import dev.hyo.openiap.BillingProgramAndroid as OpenIapBillingProgramAndroid
+import dev.hyo.openiap.DeveloperBillingTypeAndroid as OpenIapDeveloperBillingType
+import dev.hyo.openiap.DeveloperBillingLaunchModeAndroid as OpenIapDeveloperBillingLaunchMode
+import dev.hyo.openiap.DeveloperBillingOptionParamsAndroid as OpenIapDeveloperBillingOptionParams
+import dev.hyo.openiap.GetBillingChoiceInfoParamsAndroid as OpenIapGetBillingChoiceInfoParams
+import dev.hyo.openiap.InAppMessageCategoryAndroid as OpenIapInAppMessageCategory
+import dev.hyo.openiap.InAppMessageParamsAndroid as OpenIapInAppMessageParams
+import dev.hyo.openiap.InAppMessageResponseCodeAndroid as OpenIapInAppMessageResponseCode
 import dev.hyo.openiap.LaunchExternalLinkParamsAndroid as OpenIapLaunchExternalLinkParams
 import dev.hyo.openiap.ExternalLinkLaunchModeAndroid as OpenIapExternalLinkLaunchMode
 import dev.hyo.openiap.ExternalLinkTypeAndroid as OpenIapExternalLinkType
@@ -47,7 +58,6 @@ import java.util.Locale
 import kotlin.coroutines.cancellation.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
-import kotlinx.coroutines.CompletableDeferred
 import org.json.JSONArray
 import org.json.JSONObject
 
@@ -55,7 +65,7 @@ import org.json.JSONObject
  * Custom exception for OpenIAP errors that only includes the error JSON without stack traces.
  * This ensures clean error messages are passed to JavaScript without Java/Kotlin stack traces.
  */
-class OpenIapException(private val errorJson: String) : Exception() {
+class OpenIapException(private val errorJson: String, cause: Throwable? = null) : Exception(cause) {
     override val message: String
         get() = errorJson
 
@@ -67,6 +77,15 @@ class OpenIapException(private val errorJson: String) : Exception() {
     }
 }
 
+internal suspend fun endRnConnectionWithCleanup(
+    endConnection: suspend () -> Boolean,
+    cleanup: () -> Unit,
+): Boolean = try {
+    endConnection()
+} finally {
+    cleanup()
+}
+
 class HybridRnIap : HybridRnIapSpec() {
     private data class PurchaseUpdatedListenerRegistration(
         val token: Double,
@@ -92,14 +111,24 @@ class HybridRnIap : HybridRnIapSpec() {
     private val subscriptionBillingIssueListeners = mutableListOf<(NitroPurchase) -> Unit>()
     private var listenersAttached = false
     private var isInitialized = false
-    private var initDeferred: CompletableDeferred<Boolean>? = null
-    private val initLock = Any()
+    private val connectionLifecycleQueue = ConnectionLifecycleQueue()
     
     // Connection methods
     // Variant wrapper helpers for nitrogen 0.35.0 compatibility
     private fun String?.wrapVariant(): Variant_NullType_String? = this?.let { Variant_NullType_String.Second(it) }
     private fun Double?.wrapVariant(): Variant_NullType_Double? = this?.let { Variant_NullType_Double.Second(it) }
     private fun Boolean?.wrapVariant(): Variant_NullType_Boolean? = this?.let { Variant_NullType_Boolean.Second(it) }
+    private fun List<String>?.wrapVariant(): Variant_NullType_Array_String_? =
+        this?.let { Variant_NullType_Array_String_.Second(it.toTypedArray()) }
+    private fun dev.hyo.openiap.PendingPurchaseUpdateAndroid?.wrapVariant(): Variant_NullType_PendingPurchaseUpdateAndroid? =
+        this?.let {
+            Variant_NullType_PendingPurchaseUpdateAndroid.Second(
+                PendingPurchaseUpdateAndroid(
+                    products = it.products.toTypedArray(),
+                    purchaseToken = it.purchaseToken
+                )
+            )
+        }
     private fun Variant_NullType_String?.unwrapString(): String? = (this as? Variant_NullType_String.Second)?.value
     private fun Variant_NullType_Double?.unwrapDouble(): Double? = (this as? Variant_NullType_Double.Second)?.value
     private fun Variant_NullType_Boolean?.unwrapBool(): Boolean? = (this as? Variant_NullType_Boolean.Second)?.value
@@ -109,14 +138,10 @@ class HybridRnIap : HybridRnIapSpec() {
     }
 
     override fun initConnection(config: Variant_NullType_InitConnectionConfig?): Promise<Boolean> {
-        return Promise.async {
-            val configValue = (config as? Variant_NullType_InitConnectionConfig.Second)?.value
+        val configValue = (config as? Variant_NullType_InitConnectionConfig.Second)?.value
+        val performInit: suspend () -> Boolean = initOperation@{
             RnIapLog.payload("initConnection", configValue)
-            // Fast-path: if already initialized, return immediately
-            if (isInitialized) {
-                RnIapLog.result("initConnection", true)
-                return@async true
-            }
+            if (isInitialized) return@initOperation true
 
             // CRITICAL: Set Activity BEFORE calling initConnection
             // Horizon SDK needs Activity to initialize OVRPlatform with proper returnComponent
@@ -151,28 +176,14 @@ class HybridRnIap : HybridRnIapSpec() {
                 )
             }
 
-            // Single-flight: capture or create the shared Deferred atomically
-            val wasExisting = synchronized(initLock) {
-                if (initDeferred == null) {
-                    initDeferred = CompletableDeferred()
-                    false
-                } else true
-            }
-            if (wasExisting) {
-                val result = initDeferred!!.await()
-                RnIapLog.result("initConnection.await", result)
-                return@async result
-            }
-
             try {
                 if (!listenersAttached) {
-                    listenersAttached = true
                     RnIapLog.payload("listeners.attach", null)
                     openIap.addPurchaseUpdateListener(OpenIapPurchaseUpdateListener { p ->
                         runCatching {
                             RnIapLog.result(
                                 "purchaseUpdatedListener",
-                                mapOf("id" to p.id, "sku" to p.productId)
+                                mapOf("productId" to p.productId)
                             )
                             sendPurchaseUpdate(convertToNitroPurchase(p))
                         }.onFailure { RnIapLog.failure("purchaseUpdatedListener", it) }
@@ -194,26 +205,61 @@ class HybridRnIap : HybridRnIapSpec() {
                                 "userChoiceBillingListener",
                                 mapOf("products" to details.products, "token" to details.externalTransactionToken)
                             )
+                            val originalTransactionId = runCatching {
+                                details.javaClass
+                                    .getMethod("getOriginalExternalTransactionId")
+                                    .invoke(details) as? String
+                            }.getOrNull()
+                            val productDetails = runCatching {
+                                (details.javaClass.getMethod("getProductDetailsAndroid").invoke(details) as? List<*>)
+                                    ?.mapNotNull { it as? dev.hyo.openiap.DeveloperProvidedBillingProductAndroid }
+                            }.getOrNull()
                             val nitroDetails = UserChoiceBillingDetails(
                                 externalTransactionToken = details.externalTransactionToken,
+                                originalExternalTransactionId = originalTransactionId.wrapVariant(),
+                                productDetailsAndroid = productDetails?.map { product ->
+                                    DeveloperProvidedBillingProductAndroid(
+                                        id = product.id,
+                                        offerToken = product.offerToken.wrapVariant(),
+                                        type = when (product.type) {
+                                            OpenIapProductType.InApp -> ProductType.IN_APP
+                                            OpenIapProductType.Subs -> ProductType.SUBS
+                                        }
+                                    )
+                                }?.toTypedArray()?.let {
+                                    Variant_NullType_Array_DeveloperProvidedBillingProductAndroid_.Second(it)
+                                },
                                 products = details.products.toTypedArray()
                             )
                             sendUserChoiceBilling(nitroDetails)
                         }.onFailure { RnIapLog.failure("userChoiceBillingListener", it) }
                     })
-                    // Developer Provided Billing listener (External Payments - 8.3.0+)
+                    // Developer Provided Billing listener (External Payments 8.3.0+, Billing Choice 9.1.0+)
                     openIap.addDeveloperProvidedBillingListener(OpenIapDeveloperProvidedBillingListener { details ->
                         runCatching {
                             RnIapLog.result(
                                 "developerProvidedBillingListener",
-                                mapOf("token" to details.externalTransactionToken)
+                                mapOf("productCount" to details.products.size)
                             )
                             val nitroDetails = DeveloperProvidedBillingDetailsAndroid(
-                                externalTransactionToken = details.externalTransactionToken
+                                externalTransactionToken = details.externalTransactionToken.wrapVariant(),
+                                linkUri = details.linkUri.wrapVariant(),
+                                originalExternalTransactionId = details.originalExternalTransactionId.wrapVariant(),
+                                products = details.products.map { product ->
+                                    DeveloperProvidedBillingProductAndroid(
+                                        id = product.id,
+                                        offerToken = product.offerToken.wrapVariant(),
+                                        type = when (product.type) {
+                                            OpenIapProductType.InApp -> ProductType.IN_APP
+                                            OpenIapProductType.Subs -> ProductType.SUBS
+                                        }
+                                    )
+                                }.toTypedArray()
                             )
                             sendDeveloperProvidedBilling(nitroDetails)
                         }.onFailure { RnIapLog.failure("developerProvidedBillingListener", it) }
                     })
+                    listenersAttached = true
                     RnIapLog.result("listeners.attach", "attached")
                 }
             } catch (err: CancellationException) {
@@ -230,18 +276,10 @@ class HybridRnIap : HybridRnIapSpec() {
                         messageOverride = "Failed to register billing listeners: $errorMessage"
                     )
                 )
-                synchronized(initLock) {
-                    initDeferred?.let { deferred ->
-                        if (!deferred.isCompleted) deferred.completeExceptionally(wrapped)
-                    }
-                    initDeferred = null
-                }
                 isInitialized = false
                 throw wrapped
             }
 
-            // We created it above; reuse the shared instance
-            val deferred = initDeferred!!
             try {
                 // Convert Nitro config to OpenIAP config
                 // Note: enableBillingProgramAndroid is passed to OpenIapInitConnectionConfig
@@ -255,6 +293,9 @@ class HybridRnIap : HybridRnIapSpec() {
                         },
                         enableBillingProgramAndroid = configValue.enableBillingProgramAndroid?.let { program ->
                             mapBillingProgram(program)
+                        },
+                        billingChoiceScreenTypeAndroid = configValue.billingChoiceScreenTypeAndroid?.let { type ->
+                            mapBillingChoiceScreenTypeToOpenIap(type)
                         }
                     )
                 }
@@ -263,6 +304,8 @@ class HybridRnIap : HybridRnIapSpec() {
                     withContext(Dispatchers.Main) {
                         openIap.initConnection(openIapConfig)
                     }
+                } catch (err: CancellationException) {
+                    throw err
                 } catch (err: Throwable) {
                     val error = OpenIapError.InitConnection
                     RnIapLog.failure("initConnection.native", err)
@@ -284,42 +327,57 @@ class HybridRnIap : HybridRnIapSpec() {
                         )
                     )
                 }
-                isInitialized = true
-                deferred.complete(true)
-                RnIapLog.result("initConnection", true)
                 true
             } catch (e: Exception) {
-                // Complete exceptionally so all concurrent awaiters receive the same failure
-                if (!deferred.isCompleted) deferred.completeExceptionally(e)
-                isInitialized = false
                 RnIapLog.failure("initConnection", e)
                 throw e
-            } finally {
-                initDeferred = null
             }
         }
+        val invocation = connectionLifecycleQueue.enqueueInit(
+            operation = performInit,
+            onCommitted = { value ->
+                isInitialized = value
+                RnIapLog.result("initConnection", value)
+            },
+            onFailed = { isInitialized = false }
+        )
+        return Promise.async {
+            invocation.await()
+        }
     }
     
     override fun endConnection(): Promise<Boolean> {
-        return Promise.async {
+        val pendingInitError = OpenIapException(
+            toErrorJson(
+                error = OpenIapError.ServiceDisconnected(
+                    "Connection ended while initialization was in progress"
+                )
+            )
+        )
+        val invocation = connectionLifecycleQueue.enqueueEnd(pendingInitError) {
             RnIapLog.payload("endConnection", null)
-            runCatching { openIap.endConnection() }
-            productTypeBySku.clear()
-            isInitialized = false
-            listenersAttached = false
-            synchronized(purchaseUpdatedListeners) {
-                purchaseUpdatedListeners.clear()
-                nextPurchaseUpdatedListenerToken = 1.0
-            }
-            synchronized(purchaseErrorListeners) { purchaseErrorListeners.clear() }
-            promotedProductListenersIOS.clear()
-            synchronized(userChoiceBillingListenersAndroid) { userChoiceBillingListenersAndroid.clear() }
-            synchronized(developerProvidedBillingListenersAndroid) { developerProvidedBillingListenersAndroid.clear() }
-            synchronized(subscriptionBillingIssueListeners) { subscriptionBillingIssueListeners.clear() }
-            detachSubscriptionBillingIssueIfNeeded()
-            initDeferred = null
-            RnIapLog.result("endConnection", true)
-            true
+            val result = endRnConnectionWithCleanup(
+                endConnection = { openIap.endConnection() },
+                cleanup = {
+                    productTypeBySku.clear()
+                    isInitialized = false
+                    // Native listener sets persist; clear only bridge callbacks.
+                    synchronized(purchaseUpdatedListeners) {
+                        purchaseUpdatedListeners.clear()
+                        nextPurchaseUpdatedListenerToken = 1.0
+                    }
+                    synchronized(purchaseErrorListeners) { purchaseErrorListeners.clear() }
+                    promotedProductListenersIOS.clear()
+                    synchronized(userChoiceBillingListenersAndroid) { userChoiceBillingListenersAndroid.clear() }
+                    synchronized(developerProvidedBillingListenersAndroid) { developerProvidedBillingListenersAndroid.clear() }
+                    clearSubscriptionBillingIssueListeners()
+                },
+            )
+            RnIapLog.result("endConnection", result)
+            result
+        }
+        return Promise.async {
+            invocation.await()
         }
     }
     
@@ -478,6 +536,11 @@ class HybridRnIap : HybridRnIapSpec() {
                     }
                     ?: emptyList()
                 val normalizedOffers = subscriptionOffers.takeIf { it.isNotEmpty() }
+                val developerBillingOption =
+                    (androidRequest.developerBillingOption as?
+                        Variant_NullType_DeveloperBillingOptionParamsAndroid.Second)
+                        ?.value
+                        ?.let(::mapDeveloperBillingOption)
 
                 val requestProps = when (queryType) {
                     ProductQueryType.Subs -> {
@@ -495,6 +558,8 @@ class HybridRnIap : HybridRnIapSpec() {
                             isOfferPersonalized = androidRequest.isOfferPersonalized.unwrapBool(),
                             obfuscatedAccountId = androidRequest.obfuscatedAccountId.unwrapString(),
                             obfuscatedProfileId = androidRequest.obfuscatedProfileId.unwrapString(),
+                            developerBillingOption = developerBillingOption,
+                            originalExternalTransactionId = androidRequest.originalExternalTransactionId.unwrapString(),
                             purchaseToken = androidRequest.purchaseToken.unwrapString(),
                             replacementMode = replacementMode,
                             skus = androidRequest.skus.toList(),
@@ -503,7 +568,7 @@ class HybridRnIap : HybridRnIapSpec() {
                         )
                         RequestPurchaseProps(
                             request = RequestPurchaseProps.Request.Subscription(
-                                RequestSubscriptionPropsByPlatforms(android = androidProps)
+                                RequestSubscriptionPropsByPlatforms(google = androidProps)
                             ),
                             type = ProductQueryType.Subs
                         )
@@ -513,12 +578,13 @@ class HybridRnIap : HybridRnIapSpec() {
                             isOfferPersonalized = androidRequest.isOfferPersonalized.unwrapBool(),
                             obfuscatedAccountId = androidRequest.obfuscatedAccountId.unwrapString(),
                             obfuscatedProfileId = androidRequest.obfuscatedProfileId.unwrapString(),
+                            developerBillingOption = developerBillingOption,
                             offerToken = androidRequest.offerToken.unwrapString(),
                             skus = androidRequest.skus.toList()
                         )
                         RequestPurchaseProps(
                             request = RequestPurchaseProps.Request.Purchase(
-                                RequestPurchasePropsByPlatforms(android = androidProps)
+                                RequestPurchasePropsByPlatforms(google = androidProps)
                             ),
                             type = ProductQueryType.InApp
                         )
@@ -538,14 +604,13 @@ class HybridRnIap : HybridRnIapSpec() {
                     openIap.requestPurchase(requestProps)
                 }
                 val purchases = result.purchasesOrEmpty()
-                purchases.forEach { p ->
-                    runCatching {
-                        RnIapLog.result(
-                            "requestPurchase.native",
-                            mapOf("id" to p.id, "sku" to p.productId)
-                        )
-                    }.onFailure { RnIapLog.failure("requestPurchase.native", it) }
-                }
+                RnIapLog.result(
+                    "requestPurchase.native",
+                    mapOf(
+                        "purchaseCount" to purchases.size,
+                        "productIds" to purchases.map { it.productId }
+                    )
+                )
 
                 defaultResult
             } catch (e: Exception) {
@@ -605,7 +670,10 @@ class HybridRnIap : HybridRnIapSpec() {
             }
             RnIapLog.result(
                 "getAvailablePurchases",
-                result.map { mapOf("id" to it.id, "sku" to it.productId) }
+                mapOf(
+                    "purchaseCount" to result.size,
+                    "productIds" to result.map { it.productId }
+                )
             )
             result.map { convertToNitroPurchase(it) }.toTypedArray()
         }
@@ -718,7 +786,12 @@ class HybridRnIap : HybridRnIapSpec() {
                         debugMessage = "Missing purchaseToken",
                         code = OpenIapError.toCode(OpenIapError.DeveloperError()),
                         message = "Missing purchaseToken",
-                        purchaseToken = null
+                        purchaseToken = null,
+                        productId = null,
+                        productIds = null,
+                        productType = null,
+                        isEmptyProductList = null,
+                        subResponseCodeAndroid = null
                     )
                 )
             }
@@ -734,7 +807,12 @@ class HybridRnIap : HybridRnIapSpec() {
                         debugMessage = e.message,
                         code = OpenIapError.toCode(err),
                         message = e.message?.takeIf { it.isNotBlank() } ?: err.message,
-                        purchaseToken = purchaseToken
+                        purchaseToken = purchaseToken,
+                        productId = null,
+                        productIds = null,
+                        productType = null,
+                        isEmptyProductList = null,
+                        subResponseCodeAndroid = null
                     )
                 )
             }
@@ -751,7 +829,12 @@ class HybridRnIap : HybridRnIapSpec() {
                         debugMessage = null,
                         code = "0",
                         message = "OK",
-                        purchaseToken = purchaseToken
+                        purchaseToken = purchaseToken,
+                        productId = null,
+                        productIds = null,
+                        productType = null,
+                        isEmptyProductList = null,
+                        subResponseCodeAndroid = null
                     )
                 )
                 RnIapLog.result("finishTransaction", mapOf("success" to true))
@@ -765,7 +848,12 @@ class HybridRnIap : HybridRnIapSpec() {
                         debugMessage = e.message,
                         code = OpenIapError.toCode(err),
                         message = e.message?.takeIf { it.isNotBlank() } ?: err.message,
-                        purchaseToken = null
+                        purchaseToken = null,
+                        productId = null,
+                        productIds = null,
+                        productType = null,
+                        isEmptyProductList = null,
+                        subResponseCodeAndroid = null
                     )
                 )
             }
@@ -778,11 +866,30 @@ class HybridRnIap : HybridRnIapSpec() {
                 ensureConnection()
                 RnIapLog.payload("getStorefront", null)
                 val value = openIap.getStorefront()
+                if (value.isBlank()) {
+                    throw OpenIapError.ServiceUnavailable(
+                        "Storefront lookup returned no country code"
+                    )
+                }
                 RnIapLog.result("getStorefront", value)
                 value
+            } catch (e: OpenIapException) {
+                RnIapLog.failure("getStorefront", e)
+                throw e
+            } catch (e: OpenIapError) {
+                RnIapLog.failure("getStorefront", e)
+                throw OpenIapException(toErrorJson(e))
             } catch (e: Exception) {
                 RnIapLog.failure("getStorefront", e)
-                ""
+                val error = OpenIapError.ServiceUnavailable(e.message)
+                throw OpenIapException(
+                    toErrorJson(
+                        error = error,
+                        debugMessage = e.message,
+                        messageOverride = "Failed to get storefront"
+                    ),
+                    e
+                )
             }
         }
     }
@@ -879,7 +986,12 @@ class HybridRnIap : HybridRnIapSpec() {
             debugMessage = debugMessage,
             code = errorCode,
             message = message,
-            purchaseToken = null
+            purchaseToken = null,
+            productId = sku,
+            productIds = null,
+            productType = null,
+            isEmptyProductList = null,
+            subResponseCodeAndroid = null
         )
     }
 
@@ -924,111 +1036,21 @@ class HybridRnIap : HybridRnIapSpec() {
     }
 
     private fun serializeSubscriptionOffers(offers: List<ProductSubscriptionAndroidOfferDetails>): String {
-        val array = JSONArray()
-        offers.forEach { offer ->
-            val offerJson = JSONObject()
-            offerJson.put("basePlanId", offer.basePlanId)
-            offerJson.put("offerId", offer.offerId)
-            offerJson.put("offerTags", JSONArray(offer.offerTags))
-            offerJson.put("offerToken", offer.offerToken)
-
-            val phasesArray = JSONArray()
-            offer.pricingPhases.pricingPhaseList.forEach { phase ->
-                val phaseJson = JSONObject()
-                phaseJson.put("billingCycleCount", phase.billingCycleCount)
-                phaseJson.put("billingPeriod", phase.billingPeriod)
-                phaseJson.put("formattedPrice", phase.formattedPrice)
-                phaseJson.put("priceAmountMicros", phase.priceAmountMicros)
-                phaseJson.put("priceCurrencyCode", phase.priceCurrencyCode)
-                phaseJson.put("recurrenceMode", phase.recurrenceMode)
-                phasesArray.put(phaseJson)
-            }
-
-            val pricingPhasesJson = JSONObject()
-            pricingPhasesJson.put("pricingPhaseList", phasesArray)
-            offerJson.put("pricingPhases", pricingPhasesJson)
-
-            array.put(offerJson)
-        }
-        return array.toString()
+        return JSONArray(legacySubscriptionOfferMaps(offers)).toString()
     }
 
     /**
      * Serialize standardized SubscriptionOffer list to JSON string (OpenIAP 1.3.10+)
      */
     private fun serializeStandardizedSubscriptionOffers(offers: List<dev.hyo.openiap.SubscriptionOffer>): String {
-        val array = JSONArray()
-        offers.forEach { offer ->
-            val offerJson = JSONObject()
-            offerJson.put("id", offer.id)
-            offerJson.put("displayPrice", offer.displayPrice)
-            offerJson.put("price", offer.price)
-            offerJson.put("type", offer.type.rawValue)
-            offer.currency?.let { offerJson.put("currency", it) }
-            offer.basePlanIdAndroid?.let { offerJson.put("basePlanIdAndroid", it) }
-            offer.offerTokenAndroid?.let { offerJson.put("offerTokenAndroid", it) }
-            offer.offerTagsAndroid?.let { offerJson.put("offerTagsAndroid", JSONArray(it)) }
-            offer.paymentMode?.let { offerJson.put("paymentMode", it.rawValue) }
-            offer.periodCount?.let { offerJson.put("periodCount", it) }
-            offer.numberOfPeriodsIOS?.let { offerJson.put("numberOfPeriodsIOS", it) }
-            offer.period?.let { period ->
-                val periodJson = JSONObject()
-                periodJson.put("unit", period.unit.rawValue)
-                periodJson.put("value", period.value)
-                offerJson.put("period", periodJson)
-            }
-            offer.pricingPhasesAndroid?.let { phases ->
-                val phasesJson = JSONObject()
-                val phaseList = JSONArray()
-                phases.pricingPhaseList.forEach { phase ->
-                    val phaseJson = JSONObject()
-                    phaseJson.put("billingCycleCount", phase.billingCycleCount)
-                    phaseJson.put("billingPeriod", phase.billingPeriod)
-                    phaseJson.put("formattedPrice", phase.formattedPrice)
-                    phaseJson.put("priceAmountMicros", phase.priceAmountMicros)
-                    phaseJson.put("priceCurrencyCode", phase.priceCurrencyCode)
-                    phaseJson.put("recurrenceMode", phase.recurrenceMode)
-                    phaseList.put(phaseJson)
-                }
-                phasesJson.put("pricingPhaseList", phaseList)
-                offerJson.put("pricingPhasesAndroid", phasesJson)
-            }
-            array.put(offerJson)
-        }
-        return array.toString()
+        return JSONArray(subscriptionOfferMaps(offers)).toString()
     }
 
     /**
      * Serialize standardized DiscountOffer list to JSON string (OpenIAP 1.3.10+)
      */
     private fun serializeStandardizedDiscountOffers(offers: List<dev.hyo.openiap.DiscountOffer>): String {
-        val array = JSONArray()
-        offers.forEach { offer ->
-            val offerJson = JSONObject()
-            offerJson.put("currency", offer.currency)
-            offerJson.put("displayPrice", offer.displayPrice)
-            offerJson.put("price", offer.price)
-            offer.id?.let { offerJson.put("id", it) }
-            offer.offerTagsAndroid?.let { offerJson.put("offerTagsAndroid", JSONArray(it)) }
-            offer.offerTokenAndroid?.let { offerJson.put("offerTokenAndroid", it) }
-            offer.discountAmountMicrosAndroid?.let { offerJson.put("discountAmountMicrosAndroid", it) }
-            offer.formattedDiscountAmountAndroid?.let { offerJson.put("formattedDiscountAmountAndroid", it) }
-            offer.fullPriceMicrosAndroid?.let { offerJson.put("fullPriceMicrosAndroid", it) }
-            offer.limitedQuantityInfoAndroid?.let { info ->
-                val infoJson = JSONObject()
-                infoJson.put("maximumQuantity", info.maximumQuantity)
-                infoJson.put("remainingQuantity", info.remainingQuantity)
-                offerJson.put("limitedQuantityInfoAndroid", infoJson)
-            }
-            offer.validTimeWindowAndroid?.let { window ->
-                val windowJson = JSONObject()
-                windowJson.put("startTimeMillis", window.startTimeMillis)
-                windowJson.put("endTimeMillis", window.endTimeMillis)
-                offerJson.put("validTimeWindowAndroid", windowJson)
-            }
-            array.put(offerJson)
-        }
-        return array.toString()
+        return JSONArray(discountOfferMaps(offers)).toString()
     }
 
     private fun convertToNitroProduct(product: ProductCommon): NitroProduct {
@@ -1044,64 +1066,9 @@ class HybridRnIap : HybridRnIapSpec() {
         }
 
         val subscriptionOffersJson = subscriptionOffers.takeIf { it.isNotEmpty() }?.let { serializeSubscriptionOffers(it) }
-        val oneTimeOffersNitro = oneTimeOffers?.map { otp ->
-            NitroOneTimePurchaseOfferDetail(
-                formattedPrice = otp.formattedPrice,
-                priceAmountMicros = otp.priceAmountMicros,
-                priceCurrencyCode = otp.priceCurrencyCode,
-                offerId = otp.offerId.wrapVariant(),
-                offerToken = otp.offerToken,
-                offerTags = otp.offerTags.toTypedArray(),
-                fullPriceMicros = otp.fullPriceMicros.wrapVariant(),
-                discountDisplayInfo = otp.discountDisplayInfo?.let { discount ->
-                    Variant_NullType_NitroDiscountDisplayInfoAndroid.Second(
-                        NitroDiscountDisplayInfoAndroid(
-                            percentageDiscount = discount.percentageDiscount?.toDouble().wrapVariant(),
-                            discountAmount = discount.discountAmount?.let { amount ->
-                                Variant_NullType_NitroDiscountAmountAndroid.Second(
-                                    NitroDiscountAmountAndroid(
-                                        discountAmountMicros = amount.discountAmountMicros,
-                                        formattedDiscountAmount = amount.formattedDiscountAmount
-                                    )
-                                )
-                            }
-                        )
-                    )
-                },
-                validTimeWindow = otp.validTimeWindow?.let { window ->
-                    Variant_NullType_NitroValidTimeWindowAndroid.Second(
-                        NitroValidTimeWindowAndroid(
-                            startTimeMillis = window.startTimeMillis,
-                            endTimeMillis = window.endTimeMillis
-                        )
-                    )
-                },
-                limitedQuantityInfo = otp.limitedQuantityInfo?.let { info ->
-                    Variant_NullType_NitroLimitedQuantityInfoAndroid.Second(
-                        NitroLimitedQuantityInfoAndroid(
-                            maximumQuantity = info.maximumQuantity.toDouble(),
-                            remainingQuantity = info.remainingQuantity.toDouble()
-                        )
-                    )
-                },
-                preorderDetailsAndroid = otp.preorderDetailsAndroid?.let { preorder ->
-                    Variant_NullType_NitroPreorderDetailsAndroid.Second(
-                        NitroPreorderDetailsAndroid(
-                            preorderPresaleEndTimeMillis = preorder.preorderPresaleEndTimeMillis,
-                            preorderReleaseTimeMillis = preorder.preorderReleaseTimeMillis
-                        )
-                    )
-                },
-                rentalDetailsAndroid = otp.rentalDetailsAndroid?.let { rental ->
-                    Variant_NullType_NitroRentalDetailsAndroid.Second(
-                        NitroRentalDetailsAndroid(
-                            rentalExpirationPeriod = rental.rentalExpirationPeriod?.let { Variant_NullType_String.Second(it) },
-                            rentalPeriod = rental.rentalPeriod
-                        )
-                    )
-                }
-            )
-        }?.toTypedArray()
+        val oneTimeOffersNitro = oneTimeOffers
+            ?.map { it.toNitroOneTimePurchaseOfferDetail() }
+            ?.toTypedArray()
 
         var originalPriceAndroid: String? = null
         var originalPriceAmountMicrosAndroid: Double? = null
@@ -1111,7 +1078,7 @@ class HybridRnIap : HybridRnIapSpec() {
         var subscriptionPeriodAndroid: String? = null
         var freeTrialPeriodAndroid: String? = null
 
-        if (product.type == ProductType.InApp) {
+        if (product.type == OpenIapProductType.InApp) {
             oneTimeOffers?.firstOrNull()?.let { otp ->
                 originalPriceAndroid = otp.formattedPrice
                 originalPriceAmountMicrosAndroid = otp.priceAmountMicros.toDoubleOrNull()
@@ -1177,6 +1144,7 @@ class HybridRnIap : HybridRnIapSpec() {
             id = product.id,
             title = product.title,
             description = product.description,
+            debugDescription = product.nitroDebugDescription(),
             type = product.type.rawValue,
             displayName = product.displayName.wrapVariant(),
             displayPrice = product.displayPrice,
@@ -1186,6 +1154,8 @@ class HybridRnIap : HybridRnIapSpec() {
             typeIOS = null,
             isFamilyShareableIOS = null,
             jsonRepresentationIOS = null,
+            pricingTermsIOS = null,
+            subscriptionInfoIOS = null,
             discountsIOS = null,
             subscriptionPeriodUnitIOS = null,
             subscriptionPeriodNumberIOS = null,
@@ -1225,11 +1195,16 @@ class HybridRnIap : HybridRnIapSpec() {
             productId = purchase.productId,
             transactionDate = purchase.transactionDate,
             purchaseToken = purchase.purchaseToken.wrapVariant(),
+            currentPlanId = purchase.currentPlanId.wrapVariant(),
+            ids = purchase.ids.wrapVariant(),
             platform = IapPlatform.ANDROID,
             store = mapIapStore(purchase.store),
             quantity = purchase.quantity.toDouble(),
             purchaseState = mapPurchaseState(purchase.purchaseState),
             isAutoRenewing = purchase.isAutoRenewing,
+            advancedCommerceInfoIOS = null,
+            billingPlanTypeIOS = null,
+            commitmentInfoIOS = null,
             quantityIOS = null,
             originalTransactionDateIOS = null,
             originalTransactionIdentifierIOS = null,
@@ -1262,7 +1237,8 @@ class HybridRnIap : HybridRnIapSpec() {
             obfuscatedAccountIdAndroid = androidPurchase?.obfuscatedAccountIdAndroid.wrapVariant(),
             obfuscatedProfileIdAndroid = androidPurchase?.obfuscatedProfileIdAndroid.wrapVariant(),
             developerPayloadAndroid = androidPurchase?.developerPayloadAndroid.wrapVariant(),
-            isSuspendedAndroid = androidPurchase?.isSuspendedAndroid.wrapVariant()
+            isSuspendedAndroid = androidPurchase?.isSuspendedAndroid.wrapVariant(),
+            pendingPurchaseUpdateAndroid = androidPurchase?.pendingPurchaseUpdateAndroid.wrapVariant()
         )
     }
 
@@ -1333,10 +1309,10 @@ class HybridRnIap : HybridRnIapSpec() {
         }
     }
 
-    override fun buyPromotedProductIOS(): Promise<Unit> {
+    override fun buyPromotedProductIOS(): Promise<Boolean> {
         return Promise.async {
             // Android doesn't have promoted products like iOS App Store
-            // This is an iOS-only feature, so we do nothing on Android
+            false
         }
     }
 
@@ -1418,11 +1394,17 @@ class HybridRnIap : HybridRnIapSpec() {
 
                 // Call OpenIAP's verifyPurchase - this makes the actual Google Play API call
                 val verifyResult = openIap.verifyPurchase(props)
-                RnIapLog.result("validateReceipt", verifyResult.toString())
 
                 // Cast to Android result type (on Android, verifyPurchase returns VerifyPurchaseResultAndroid)
                 val androidResult = verifyResult as? VerifyPurchaseResultAndroid
                     ?: throw OpenIapException(toErrorJson(OpenIapError.InvalidPurchaseVerification, debugMessage = "Unexpected result type from verifyPurchase"))
+                RnIapLog.result(
+                    "validateReceipt",
+                    mapOf(
+                        "productId" to androidResult.productId,
+                        "testTransaction" to androidResult.testTransaction
+                    )
+                )
 
                 // Convert OpenIAP result to Nitro result
                 val result = NitroReceiptValidationResultAndroid(
@@ -1631,7 +1613,7 @@ class HybridRnIap : HybridRnIapSpec() {
             } catch (err: Throwable) {
                 RnIapLog.failure("checkAlternativeBillingAvailabilityAndroid", err)
                 val errorType = parseOpenIapError(err)
-                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message))
+                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message), err)
             }
         }
     }
@@ -1653,7 +1635,7 @@ class HybridRnIap : HybridRnIapSpec() {
             } catch (err: Throwable) {
                 RnIapLog.failure("showAlternativeBillingDialogAndroid", err)
                 val errorType = parseOpenIapError(err)
-                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message))
+                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message), err)
             }
         }
     }
@@ -1669,12 +1651,15 @@ class HybridRnIap : HybridRnIapSpec() {
                 val token = withContext(Dispatchers.Main) {
                     openIap.createAlternativeBillingReportingToken()
                 }
-                RnIapLog.result("createAlternativeBillingTokenAndroid", token)
+                RnIapLog.result(
+                    "createAlternativeBillingTokenAndroid",
+                    if (token.isNullOrBlank()) "<empty>" else "<token>"
+                )
                 token?.let { Variant_NullType_String.Second(it) } ?: Variant_NullType_String.First(NullType.NULL)
             } catch (err: Throwable) {
                 RnIapLog.failure("createAlternativeBillingTokenAndroid", err)
                 val errorType = parseOpenIapError(err)
-                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message))
+                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message), err)
             }
         }
     }
@@ -1726,15 +1711,19 @@ class HybridRnIap : HybridRnIapSpec() {
     private var subscriptionBillingIssueNativeListener: dev.hyo.openiap.listener.OpenIapSubscriptionBillingIssueListener? = null
 
     override fun addSubscriptionBillingIssueListener(listener: (purchase: NitroPurchase) -> Unit) {
-        synchronized(subscriptionBillingIssueListeners) {
-            subscriptionBillingIssueListeners.add(listener)
+        synchronized(subscriptionBillingIssueAttachLock) {
+            synchronized(subscriptionBillingIssueListeners) {
+                subscriptionBillingIssueListeners.add(listener)
+            }
+            attachSubscriptionBillingIssueIfNeeded()
         }
-        attachSubscriptionBillingIssueIfNeeded()
     }
 
     override fun removeSubscriptionBillingIssueListener(listener: (purchase: NitroPurchase) -> Unit) {
-        synchronized(subscriptionBillingIssueListeners) {
-            subscriptionBillingIssueListeners.remove(listener)
+        synchronized(subscriptionBillingIssueAttachLock) {
+            synchronized(subscriptionBillingIssueListeners) {
+                subscriptionBillingIssueListeners.remove(listener)
+            }
         }
     }
 
@@ -1766,6 +1755,15 @@ class HybridRnIap : HybridRnIapSpec() {
         }
     }
 
+    private fun clearSubscriptionBillingIssueListeners() {
+        synchronized(subscriptionBillingIssueAttachLock) {
+            synchronized(subscriptionBillingIssueListeners) {
+                subscriptionBillingIssueListeners.clear()
+            }
+            detachSubscriptionBillingIssueIfNeeded()
+        }
+    }
+
     // -------------------------------------------------------------------------
     // Billing Programs API (Android 8.2.0+)
     // -------------------------------------------------------------------------
@@ -1794,25 +1792,66 @@ class HybridRnIap : HybridRnIapSpec() {
                 val result = openIapStore.isBillingProgramAvailable(openIapProgram)
                 val nitroResult = NitroBillingProgramAvailabilityResultAndroid(
                     billingProgram = program,
-                    isAvailable = result.isAvailable
+                    choiceScreenType = result.choiceScreenType?.let { mapBillingChoiceScreenType(it) },
+                    isAvailable = result.isAvailable,
+                    isExternalLinkAvailable = result.isExternalLinkAvailable.wrapVariant()
                 )
                 RnIapLog.result("isBillingProgramAvailableAndroid", mapOf("isAvailable" to result.isAvailable))
                 nitroResult
             } catch (err: Throwable) {
                 RnIapLog.failure("isBillingProgramAvailableAndroid", err)
                 val errorType = parseOpenIapError(err)
-                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message))
+                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message), err)
             }
         }
     }
 
-    override fun createBillingProgramReportingDetailsAndroid(program: BillingProgramAndroid): Promise<NitroBillingProgramReportingDetailsAndroid> {
+    override fun getBillingChoiceInfoAndroid(params: NitroGetBillingChoiceInfoParamsAndroid): Promise<NitroBillingChoiceInfoAndroid> {
         return Promise.async {
-            RnIapLog.payload("createBillingProgramReportingDetailsAndroid", mapOf("program" to program.name))
+            RnIapLog.payload("getBillingChoiceInfoAndroid", mapOf(
+                "billingProgram" to params.billingProgram.name,
+                "playBillingChoiceImageLayout" to params.playBillingChoiceImageLayout.name,
+                "userLocale" to params.userLocale.unwrapString()
+            ))
+            try {
+                ensureConnection()
+                val result = openIapStore.getBillingChoiceInfo(
+                    OpenIapGetBillingChoiceInfoParams(
+                        billingProgram = mapBillingProgram(params.billingProgram),
+                        playBillingChoiceImageLayout = mapBillingChoiceImageLayout(params.playBillingChoiceImageLayout),
+                        userLocale = params.userLocale.unwrapString()
+                    )
+                )
+                val nitroResult = NitroBillingChoiceInfoAndroid(
+                    playBillingChoiceImageUrl = result.playBillingChoiceImageUrl,
+                    playBillingLoyaltyInfo = result.playBillingLoyaltyInfo.wrapVariant()
+                )
+                RnIapLog.result("getBillingChoiceInfoAndroid", mapOf("hasImageUrl" to result.playBillingChoiceImageUrl.isNotBlank()))
+                nitroResult
+            } catch (err: Throwable) {
+                RnIapLog.failure("getBillingChoiceInfoAndroid", err)
+                val errorType = parseOpenIapError(err)
+                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message), err)
+            }
+        }
+    }
+
+    override fun createBillingProgramReportingDetailsAndroid(
+        program: BillingProgramAndroid,
+        developerBillingType: DeveloperBillingTypeAndroid?
+    ): Promise<NitroBillingProgramReportingDetailsAndroid> {
+        return Promise.async {
+            RnIapLog.payload(
+                "createBillingProgramReportingDetailsAndroid",
+                mapOf("program" to program.name, "developerBillingType" to developerBillingType?.name)
+            )
             try {
                 ensureConnection()
                 val openIapProgram = mapBillingProgram(program)
-                val result = openIapStore.createBillingProgramReportingDetails(openIapProgram)
+                val result = openIapStore.createBillingProgramReportingDetails(
+                    openIapProgram,
+                    mapDeveloperBillingType(developerBillingType)
+                )
                 val nitroResult = NitroBillingProgramReportingDetailsAndroid(
                     billingProgram = program,
                     externalTransactionToken = result.externalTransactionToken
@@ -1822,7 +1861,75 @@ class HybridRnIap : HybridRnIapSpec() {
             } catch (err: Throwable) {
                 RnIapLog.failure("createBillingProgramReportingDetailsAndroid", err)
                 val errorType = parseOpenIapError(err)
-                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message))
+                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message), err)
+            }
+        }
+    }
+
+    override fun showBillingProgramInformationDialogAndroid(
+        params: NitroBillingProgramInformationDialogParamsAndroid
+    ): Promise<NitroBillingResultAndroid> {
+        return Promise.async {
+            RnIapLog.payload("showBillingProgramInformationDialogAndroid", mapOf("program" to params.billingProgram.name))
+            try {
+                ensureConnection()
+                val activity = withContext(Dispatchers.Main) {
+                    runCatching { context.currentActivity }.getOrNull()
+                } ?: throw OpenIapException(toErrorJson(OpenIapError.DeveloperError(), debugMessage = "Activity not available"))
+                val result = withContext(Dispatchers.Main) {
+                    openIapStore.showBillingProgramInformationDialog(
+                        activity,
+                        OpenIapBillingProgramInformationDialogParams(
+                            billingProgram = mapBillingProgram(params.billingProgram),
+                            externalTransactionToken = params.externalTransactionToken
+                        )
+                    )
+                }
+                RnIapLog.result("showBillingProgramInformationDialogAndroid", mapOf("responseCode" to result.responseCode))
+                NitroBillingResultAndroid(
+                    responseCode = result.responseCode.toDouble(),
+                    debugMessage = result.debugMessage.wrapVariant(),
+                    subResponseCode = mapSubResponseCode(result.subResponseCode)
+                )
+            } catch (err: Throwable) {
+                RnIapLog.failure("showBillingProgramInformationDialogAndroid", err)
+                val errorType = parseOpenIapError(err)
+                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message), err)
+            }
+        }
+    }
+
+    override fun showInAppMessagesAndroid(
+        params: Variant_NullType_NitroInAppMessageParamsAndroid?
+    ): Promise<NitroInAppMessageResultAndroid> {
+        return Promise.async {
+            val messageParams = params?.asSecondOrNull()
+            val categories = messageParams?.categories?.asSecondOrNull()
+            RnIapLog.payload("showInAppMessagesAndroid", mapOf("categories" to categories?.map { it.name }))
+            try {
+                ensureConnection()
+                val activity = withContext(Dispatchers.Main) {
+                    runCatching { context.currentActivity }.getOrNull()
+                } ?: throw OpenIapException(toErrorJson(OpenIapError.DeveloperError(), debugMessage = "Activity not available"))
+                val result = withContext(Dispatchers.Main) {
+                    openIapStore.showInAppMessages(
+                        activity,
+                        messageParams?.let {
+                            OpenIapInAppMessageParams(
+                                categories = categories?.map { category -> mapInAppMessageCategory(category) }
+                            )
+                        }
+                    )
+                }
+                RnIapLog.result("showInAppMessagesAndroid", mapOf("responseCode" to result.responseCode.name))
+                NitroInAppMessageResultAndroid(
+                    responseCode = mapInAppMessageResponseCode(result.responseCode),
+                    purchaseToken = result.purchaseToken.wrapVariant()
+                )
+            } catch (err: Throwable) {
+                RnIapLog.failure("showInAppMessagesAndroid", err)
+                val errorType = parseOpenIapError(err)
+                throw OpenIapException(toErrorJson(errorType, debugMessage = err.message), err)
             }
         }
     }
@@ -1844,6 +1951,7 @@ class HybridRnIap : HybridRnIapSpec() {
 
                 val openIapParams = OpenIapLaunchExternalLinkParams(
                     billingProgram = mapBillingProgram(params.billingProgram),
+                    externalTransactionToken = params.externalTransactionToken.unwrapString(),
                     launchMode = mapExternalLinkLaunchMode(params.launchMode),
                     linkType = mapExternalLinkType(params.linkType),
                     linkUri = params.linkUri
@@ -1870,6 +1978,86 @@ class HybridRnIap : HybridRnIapSpec() {
             BillingProgramAndroid.EXTERNAL_OFFER -> OpenIapBillingProgramAndroid.ExternalOffer
             BillingProgramAndroid.EXTERNAL_PAYMENTS -> OpenIapBillingProgramAndroid.ExternalPayments
             BillingProgramAndroid.USER_CHOICE_BILLING -> OpenIapBillingProgramAndroid.UserChoiceBilling
+            BillingProgramAndroid.BILLING_CHOICE -> OpenIapBillingProgramAndroid.BillingChoice
+        }
+    }
+
+    private fun mapBillingChoiceImageLayout(layout: BillingChoiceImageLayoutAndroid): OpenIapBillingChoiceImageLayout {
+        return when (layout) {
+            BillingChoiceImageLayoutAndroid.RECTANGULAR_FOUR_BY_ONE -> OpenIapBillingChoiceImageLayout.RectangularFourByOne
+            BillingChoiceImageLayoutAndroid.RECTANGULAR_THREE_BY_ONE -> OpenIapBillingChoiceImageLayout.RectangularThreeByOne
+            BillingChoiceImageLayoutAndroid.RECTANGULAR_TWO_BY_TWO -> OpenIapBillingChoiceImageLayout.RectangularTwoByTwo
+        }
+    }
+
+    private fun mapBillingChoiceScreenType(type: OpenIapBillingChoiceScreenType): BillingChoiceScreenTypeAndroid {
+        return when (type) {
+            OpenIapBillingChoiceScreenType.Unspecified -> BillingChoiceScreenTypeAndroid.UNSPECIFIED
+            OpenIapBillingChoiceScreenType.DeveloperRendered -> BillingChoiceScreenTypeAndroid.DEVELOPER_RENDERED
+            OpenIapBillingChoiceScreenType.GoogleRendered -> BillingChoiceScreenTypeAndroid.GOOGLE_RENDERED
+        }
+    }
+
+    private fun mapBillingChoiceScreenTypeToOpenIap(
+        type: BillingChoiceScreenTypeAndroid
+    ): OpenIapBillingChoiceScreenType {
+        return when (type) {
+            BillingChoiceScreenTypeAndroid.UNSPECIFIED -> OpenIapBillingChoiceScreenType.Unspecified
+            BillingChoiceScreenTypeAndroid.DEVELOPER_RENDERED -> OpenIapBillingChoiceScreenType.DeveloperRendered
+            BillingChoiceScreenTypeAndroid.GOOGLE_RENDERED -> OpenIapBillingChoiceScreenType.GoogleRendered
+        }
+    }
+
+    private fun mapDeveloperBillingType(type: DeveloperBillingTypeAndroid?): OpenIapDeveloperBillingType? {
+        return when (type) {
+            null, DeveloperBillingTypeAndroid.DEVELOPER_BILLING_TYPE_UNSPECIFIED -> null
+            DeveloperBillingTypeAndroid.IN_APP -> OpenIapDeveloperBillingType.InApp
+            DeveloperBillingTypeAndroid.EXTERNAL_LINK -> OpenIapDeveloperBillingType.ExternalLink
+        }
+    }
+
+    private fun mapSubResponseCode(
+        code: OpenIapSubResponseCodeAndroid?
+    ): SubResponseCodeAndroid? = when (code) {
+        null -> null
+        OpenIapSubResponseCodeAndroid.NoApplicableSubResponseCode ->
+            SubResponseCodeAndroid.NO_APPLICABLE_SUB_RESPONSE_CODE
+        OpenIapSubResponseCodeAndroid.PaymentDeclinedDueToInsufficientFunds ->
+            SubResponseCodeAndroid.PAYMENT_DECLINED_DUE_TO_INSUFFICIENT_FUNDS
+        OpenIapSubResponseCodeAndroid.UserIneligible ->
+            SubResponseCodeAndroid.USER_INELIGIBLE
+    }
+
+    private fun mapDeveloperBillingOption(
+        option: DeveloperBillingOptionParamsAndroid
+    ): OpenIapDeveloperBillingOptionParams {
+        val launchMode = when (option.launchMode) {
+            null -> null
+            DeveloperBillingLaunchModeAndroid.UNSPECIFIED -> OpenIapDeveloperBillingLaunchMode.Unspecified
+            DeveloperBillingLaunchModeAndroid.LAUNCH_IN_EXTERNAL_BROWSER_OR_APP ->
+                OpenIapDeveloperBillingLaunchMode.LaunchInExternalBrowserOrApp
+            DeveloperBillingLaunchModeAndroid.CALLER_WILL_LAUNCH_LINK ->
+                OpenIapDeveloperBillingLaunchMode.CallerWillLaunchLink
+        }
+        return OpenIapDeveloperBillingOptionParams(
+            billingProgram = mapBillingProgram(option.billingProgram),
+            externalTransactionToken = option.externalTransactionToken.unwrapString(),
+            launchMode = launchMode,
+            linkUri = option.linkUri.unwrapString()
+        )
+    }
+
+    private fun mapInAppMessageCategory(category: InAppMessageCategoryAndroid): OpenIapInAppMessageCategory {
+        return when (category) {
+            InAppMessageCategoryAndroid.UNKNOWN_IN_APP_MESSAGE_CATEGORY_ID -> OpenIapInAppMessageCategory.UnknownInAppMessageCategoryId
+            InAppMessageCategoryAndroid.TRANSACTIONAL -> OpenIapInAppMessageCategory.Transactional
+        }
+    }
+
+    private fun mapInAppMessageResponseCode(code: OpenIapInAppMessageResponseCode): InAppMessageResponseCodeAndroid {
+        return when (code) {
+            OpenIapInAppMessageResponseCode.NoActionNeeded -> InAppMessageResponseCodeAndroid.NO_ACTION_NEEDED
+            OpenIapInAppMessageResponseCode.SubscriptionStatusUpdated -> InAppMessageResponseCodeAndroid.SUBSCRIPTION_STATUS_UPDATED
         }
     }
 
@@ -1966,6 +2154,13 @@ class HybridRnIap : HybridRnIapSpec() {
             ?: OpenIapError.Companion.defaultMessage(code)
         val diagnostics = error.toJSON()
         val responseCode = (diagnostics["responseCode"] as? Number)?.toInt()
+        val diagnosticProductId = productId
+            ?: diagnostics["productId"] as? String
+            ?: when (error) {
+                is OpenIapError.ProductNotFound -> error.productId
+                is OpenIapError.SkuNotFound -> error.sku
+                else -> null
+            }
         val productIds = diagnostics["productIds"] as? List<*>
         val productType = diagnostics["productType"] as? String
         val isEmptyProductList = diagnostics["isEmptyProductList"] as? Boolean
@@ -1975,15 +2170,18 @@ class HybridRnIap : HybridRnIapSpec() {
             "message" to message
         )
 
-        errorMap["responseCode"] = responseCode ?: -1
+        responseCode?.let { errorMap["responseCode"] = it }
         debugMessage
             ?.let { errorMap["debugMessage"] = it }
             ?: (diagnostics["debugMessage"] as? String)?.let { errorMap["debugMessage"] = it }
             ?: error.message?.let { errorMap["debugMessage"] = it }
-        productId?.let { errorMap["productId"] = it }
+        diagnosticProductId?.let { errorMap["productId"] = it }
         if (!productIds.isNullOrEmpty()) errorMap["productIds"] = productIds
         productType?.let { errorMap["productType"] = it }
         isEmptyProductList?.let { errorMap["isEmptyProductList"] = it }
+        (diagnostics["subResponseCodeAndroid"] as? String)?.let {
+            errorMap["subResponseCodeAndroid"] = it
+        }
 
         return try {
             JSONObject(errorMap).toString()
@@ -2053,12 +2251,30 @@ class HybridRnIap : HybridRnIapSpec() {
         val diagnostics = error.toJSON()
         val responseCode = (diagnostics["responseCode"] as? Number)?.toDouble()
         val diagnosticMessage = diagnostics["debugMessage"] as? String
+        val diagnosticProductId = productId
+            ?: diagnostics["productId"] as? String
+            ?: when (error) {
+                is OpenIapError.ProductNotFound -> error.productId
+                is OpenIapError.SkuNotFound -> error.sku
+                else -> null
+            }
+        val productIds = (diagnostics["productIds"] as? Iterable<*>)
+            ?.filterIsInstance<String>()
+            ?.toTypedArray()
+        val subResponseCode = (diagnostics["subResponseCodeAndroid"] as? String)?.let {
+            runCatching { OpenIapSubResponseCodeAndroid.fromJson(it) }.getOrNull()
+        }
         return NitroPurchaseResult(
             responseCode = responseCode ?: -1.0,
             debugMessage = debugMessage ?: diagnosticMessage ?: error.message,
             code = code,
             message = message,
-            purchaseToken = null
+            purchaseToken = null,
+            productId = diagnosticProductId,
+            productIds = productIds,
+            productType = diagnostics["productType"] as? String,
+            isEmptyProductList = diagnostics["isEmptyProductList"] as? Boolean,
+            subResponseCodeAndroid = mapSubResponseCode(subResponseCode)
         )
     }
 }