expo-iap 3.1.1 → 3.1.3

package/android/src/main/java/expo/modules/iap/ExpoIapHelper.kt

@@ -0,0 +1,171 @@
+package expo.modules.iap
+
+import android.util.Log
+import dev.hyo.openiap.AndroidSubscriptionOfferInput
+import dev.hyo.openiap.OpenIapModule
+import dev.hyo.openiap.ProductQueryType
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.modules.Module
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import java.util.Locale
+import java.util.concurrent.ConcurrentLinkedQueue
+
+object ExpoIapHelper {
+    private const val TAG = "ExpoIapHelper"
+    private const val MAX_BUFFERED_EVENTS = 200
+
+    fun emitOrQueue(
+        module: Module,
+        scope: CoroutineScope,
+        connectionReady: java.util.concurrent.atomic.AtomicBoolean,
+        pendingEvents: ConcurrentLinkedQueue<Pair<String, Map<String, Any?>>>,
+        name: String,
+        payload: Map<String, Any?>,
+    ) {
+        if (connectionReady.get()) {
+            // Ensure event emission occurs on the main dispatcher
+            scope.launch { module.sendEvent(name, payload) }
+            return
+        }
+        // Bound the buffer to prevent unbounded growth if init stalls
+        if (pendingEvents.size >= MAX_BUFFERED_EVENTS) {
+            pendingEvents.poll()
+            ExpoIapLog.warning("pendingEvents overflow; dropping oldest")
+        }
+        pendingEvents.add(name to payload)
+    }
+
+    fun parseProductQueryType(rawType: String?): ProductQueryType {
+        val normalized =
+            rawType
+                ?.trim()
+                ?.lowercase(Locale.US)
+                ?.replace("-", "")
+                ?.replace("_", "")
+
+        return when (normalized) {
+            "subs" -> ProductQueryType.Subs
+            "all" -> ProductQueryType.All
+            else -> ProductQueryType.InApp
+        }
+    }
+
+    fun parseRequestPurchaseParams(params: Map<String, Any?>): RequestPurchaseParams {
+        val type = params["type"] as? String
+        val skus: List<String> =
+            (params["skus"] as? List<*>)?.filterIsInstance<String>()
+                ?: (params["skuArr"] as? List<*>)?.filterIsInstance<String>()
+                ?: emptyList()
+        val obfuscatedAccountId =
+            (params["obfuscatedAccountIdAndroid"] ?: params["obfuscatedAccountId"]) as? String
+        val obfuscatedProfileId =
+            (params["obfuscatedProfileIdAndroid"] ?: params["obfuscatedProfileId"]) as? String
+        val isOfferPersonalized = params["isOfferPersonalized"] as? Boolean ?: false
+        val offerTokenArr =
+            (params["offerTokenArr"] as? List<*>)?.filterIsInstance<String>() ?: emptyList()
+        val explicitSubscriptionOffers =
+            (params["subscriptionOffers"] as? List<*>)?.mapNotNull { rawOffer ->
+                val offerMap = rawOffer as? Map<*, *> ?: return@mapNotNull null
+                val sku = offerMap["sku"] as? String
+                val offerToken = offerMap["offerToken"] as? String
+                if (sku.isNullOrEmpty() || offerToken.isNullOrEmpty()) {
+                    null
+                } else {
+                    AndroidSubscriptionOfferInput(offerToken = offerToken, sku = sku)
+                }
+            } ?: emptyList()
+        val purchaseToken =
+            (params["purchaseTokenAndroid"] ?: params["purchaseToken"]) as? String
+        val replacementMode =
+            (params["replacementModeAndroid"] ?: params["replacementMode"]) as? Number
+
+        return RequestPurchaseParams(
+            type = type,
+            skus = skus,
+            obfuscatedAccountId = obfuscatedAccountId,
+            obfuscatedProfileId = obfuscatedProfileId,
+            isOfferPersonalized = isOfferPersonalized,
+            offerTokenArr = offerTokenArr,
+            explicitSubscriptionOffers = explicitSubscriptionOffers,
+            purchaseToken = purchaseToken,
+            replacementMode = replacementMode,
+        )
+    }
+
+    data class RequestPurchaseParams(
+        val type: String?,
+        val skus: List<String>,
+        val obfuscatedAccountId: String?,
+        val obfuscatedProfileId: String?,
+        val isOfferPersonalized: Boolean,
+        val offerTokenArr: List<String>,
+        val explicitSubscriptionOffers: List<AndroidSubscriptionOfferInput>,
+        val purchaseToken: String?,
+        val replacementMode: Number?,
+    )
+
+    fun addPurchasePromise(promise: Promise) {
+        PromiseUtils.addPromiseForKey(PromiseUtils.PROMISE_BUY_ITEM, promise)
+    }
+
+    fun resolvePurchasePromises(purchases: List<Map<String, Any?>>) {
+        PromiseUtils.resolvePromisesForKey(
+            PromiseUtils.PROMISE_BUY_ITEM,
+            purchases,
+        )
+    }
+
+    fun rejectPurchasePromises(
+        code: String,
+        message: String?,
+        error: Exception?,
+    ) {
+        PromiseUtils.rejectPromisesForKey(
+            PromiseUtils.PROMISE_BUY_ITEM,
+            code,
+            message,
+            error,
+        )
+    }
+
+    fun setupListeners(
+        openIap: OpenIapModule,
+        module: Module,
+        scope: CoroutineScope,
+        connectionReady: java.util.concurrent.atomic.AtomicBoolean,
+        pendingEvents: ConcurrentLinkedQueue<Pair<String, Map<String, Any?>>>,
+        eventPurchaseUpdated: String,
+        eventPurchaseError: String,
+    ) {
+        openIap.addPurchaseUpdateListener { p ->
+            runCatching {
+                emitOrQueue(
+                    module,
+                    scope,
+                    connectionReady,
+                    pendingEvents,
+                    eventPurchaseUpdated,
+                    p.toJson(),
+                )
+            }.onFailure { android.util.Log.e(TAG, "Failed to buffer/send PURCHASE_UPDATED", it) }
+        }
+        openIap.addPurchaseErrorListener { e ->
+            runCatching {
+                emitOrQueue(
+                    module,
+                    scope,
+                    connectionReady,
+                    pendingEvents,
+                    eventPurchaseError,
+                    e.toJSON(),
+                )
+            }.onFailure { android.util.Log.e(TAG, "Failed to buffer/send PURCHASE_ERROR", it) }
+        }
+    }
+
+    fun cleanupListeners(openIap: OpenIapModule) {
+        // Android doesn't have explicit listeners to clean up
+        // This function is kept for API compatibility with iOS
+    }
+}

package/android/src/main/java/expo/modules/iap/ExpoIapLog.kt

@@ -28,6 +28,10 @@ internal object ExpoIapLog {
         Log.e(TAG, "$name failed: ${error.localizedMessage}", error)
     }
 
+    fun warning(message: String) {
+        Log.w(TAG, message)
+    }
+
     fun debug(message: String) {
         Log.d(TAG, message)
     }

package/android/src/main/java/expo/modules/iap/ExpoIapModule.kt

@@ -28,7 +28,6 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import java.util.Locale
 import java.util.concurrent.ConcurrentLinkedQueue
 import java.util.concurrent.atomic.AtomicBoolean
 
@@ -53,38 +52,6 @@ class ExpoIapModule : Module() {
     private val connectionReady = AtomicBoolean(false)
     private val connectionMutex = Mutex()
 
-    private fun emitOrQueue(
-        name: String,
-        payload: Map<String, Any?>,
-    ) {
-        if (connectionReady.get()) {
-            // Ensure event emission occurs on the main dispatcher
-            scope.launch { sendEvent(name, payload) }
-            return
-        }
-        // Bound the buffer to prevent unbounded growth if init stalls
-        if (pendingEvents.size >= MAX_BUFFERED_EVENTS) {
-            pendingEvents.poll()
-            Log.w(TAG, "pendingEvents overflow; dropping oldest")
-        }
-        pendingEvents.add(name to payload)
-    }
-
-    private fun parseProductQueryType(rawType: String?): ProductQueryType {
-        val normalized =
-            rawType
-                ?.trim()
-                ?.lowercase(Locale.US)
-                ?.replace("-", "")
-                ?.replace("_", "")
-
-        return when (normalized) {
-            "subs" -> ProductQueryType.Subs
-            "all" -> ProductQueryType.All
-            else -> ProductQueryType.InApp
-        }
-    }
-
     override fun definition() =
         ModuleDefinition {
             Name("ExpoIap")
@@ -101,7 +68,6 @@ class ExpoIapModule : Module() {
                     connectionMutex.withLock {
                         try {
                             // Activity may be unavailable in headless/background scenarios.
-                            // Attempt to set it, but do not fail init if missing.
                             runCatching { openIap.setActivity(currentActivity) }
                                 .onFailure { Log.w(TAG, "initConnection: Activity missing; proceeding headless", it) }
 
@@ -115,15 +81,15 @@ class ExpoIapModule : Module() {
                             // Attach listeners early to avoid races during init
                             if (!listenersAttached) {
                                 listenersAttached = true
-                                openIap.addPurchaseUpdateListener { p ->
-                                    runCatching {
-                                        emitOrQueue(EVENT_PURCHASE_UPDATED, p.toJson())
-                                    }.onFailure { Log.e(TAG, "Failed to buffer/send PURCHASE_UPDATED", it) }
-                                }
-                                openIap.addPurchaseErrorListener { e ->
-                                    runCatching { emitOrQueue(EVENT_PURCHASE_ERROR, e.toJSON()) }
-                                        .onFailure { Log.e(TAG, "Failed to buffer/send PURCHASE_ERROR", it) }
-                                }
+                                ExpoIapHelper.setupListeners(
+                                    openIap,
+                                    this@ExpoIapModule,
+                                    scope,
+                                    connectionReady,
+                                    pendingEvents,
+                                    EVENT_PURCHASE_UPDATED,
+                                    EVENT_PURCHASE_ERROR,
+                                )
                             }
 
                             val ok = openIap.initConnection()
@@ -131,10 +97,7 @@ class ExpoIapModule : Module() {
                             if (!ok) {
                                 // Clear any buffered events from a failed init
                                 pendingEvents.clear()
-                                ExpoIapLog.failure(
-                                    "initConnection",
-                                    IllegalStateException("Failed to initialize connection"),
-                                )
+                                ExpoIapLog.failure("initConnection", IllegalStateException("Failed to initialize connection"))
                                 promise.reject(OpenIapError.InitConnection.CODE, "Failed to initialize connection", null)
                                 return@withLock
                             }
@@ -163,9 +126,11 @@ class ExpoIapModule : Module() {
                 scope.launch {
                     connectionMutex.withLock {
                         runCatching { openIap.endConnection() }
+                        ExpoIapHelper.cleanupListeners(openIap)
                         // Reset connection state and clear any buffered events
                         connectionReady.set(false)
                         pendingEvents.clear()
+                        listenersAttached = false
                         ExpoIapLog.result("endConnection", true)
                         promise.resolve(true)
                     }
@@ -179,7 +144,7 @@ class ExpoIapModule : Module() {
                 )
                 scope.launch {
                     try {
-                        val queryType = parseProductQueryType(type)
+                        val queryType = ExpoIapHelper.parseProductQueryType(type)
                         val request = ProductRequest(skuArr.toList(), queryType)
                         val result = openIap.fetchProducts(request)
                         val payload =
@@ -216,18 +181,10 @@ class ExpoIapModule : Module() {
             AsyncFunction("deepLinkToSubscriptionsAndroid") { params: Map<String, Any?>, promise: Promise ->
                 val sku = (params["sku"] ?: params["skuAndroid"]) as? String
                 val packageName = (params["packageName"] ?: params["packageNameAndroid"]) as? String
-                ExpoIapLog.payload(
-                    "deepLinkToSubscriptionsAndroid",
-                    mapOf("sku" to sku, "packageName" to packageName),
-                )
+                ExpoIapLog.payload("deepLinkToSubscriptionsAndroid", mapOf("sku" to sku, "packageName" to packageName))
                 scope.launch {
                     try {
-                        openIap.deepLinkToSubscriptions(
-                            DeepLinkOptions(
-                                packageNameAndroid = packageName,
-                                skuAndroid = sku,
-                            ),
-                        )
+                        openIap.deepLinkToSubscriptions(DeepLinkOptions(packageNameAndroid = packageName, skuAndroid = sku))
                         ExpoIapLog.result("deepLinkToSubscriptionsAndroid", true)
                         promise.resolve(null)
                     } catch (e: Exception) {
@@ -254,43 +211,17 @@ class ExpoIapModule : Module() {
 
             AsyncFunction("requestPurchase") { params: Map<String, Any?>, promise: Promise ->
                 ExpoIapLog.payload("requestPurchaseAndroid", params)
-                val type = params["type"] as? String
-                val skus: List<String> =
-                    (params["skus"] as? List<*>)?.filterIsInstance<String>()
-                        ?: (params["skuArr"] as? List<*>)?.filterIsInstance<String>()
-                        ?: emptyList()
-                val obfuscatedAccountId =
-                    (params["obfuscatedAccountIdAndroid"] ?: params["obfuscatedAccountId"]) as? String
-                val obfuscatedProfileId =
-                    (params["obfuscatedProfileIdAndroid"] ?: params["obfuscatedProfileId"]) as? String
-                val isOfferPersonalized = params["isOfferPersonalized"] as? Boolean ?: false
-                val offerTokenArr =
-                    (params["offerTokenArr"] as? List<*>)?.filterIsInstance<String>() ?: emptyList()
-                val explicitSubscriptionOffers =
-                    (params["subscriptionOffers"] as? List<*>)?.mapNotNull { rawOffer ->
-                        val offerMap = rawOffer as? Map<*, *> ?: return@mapNotNull null
-                        val sku = offerMap["sku"] as? String
-                        val offerToken = offerMap["offerToken"] as? String
-                        if (sku.isNullOrEmpty() || offerToken.isNullOrEmpty()) {
-                            null
-                        } else {
-                            AndroidSubscriptionOfferInput(offerToken = offerToken, sku = sku)
-                        }
-                    } ?: emptyList()
-                val purchaseToken =
-                    (params["purchaseTokenAndroid"] ?: params["purchaseToken"]) as? String
-                val replacementMode =
-                    (params["replacementModeAndroid"] ?: params["replacementMode"]) as? Number
+                val parsedParams = ExpoIapHelper.parseRequestPurchaseParams(params)
 
                 val productType =
-                    when (parseProductQueryType(type)) {
+                    when (ExpoIapHelper.parseProductQueryType(parsedParams.type)) {
                         ProductQueryType.Subs -> ProductQueryType.Subs
                         else -> ProductQueryType.InApp
                     }
 
                 val fallbackOffers =
-                    if (explicitSubscriptionOffers.isEmpty() && offerTokenArr.isNotEmpty()) {
-                        skus.zip(offerTokenArr).mapNotNull { (sku, token) ->
+                    if (parsedParams.explicitSubscriptionOffers.isEmpty() && parsedParams.offerTokenArr.isNotEmpty()) {
+                        parsedParams.skus.zip(parsedParams.offerTokenArr).mapNotNull { (sku, token) ->
                             if (token.isNotEmpty()) {
                                 AndroidSubscriptionOfferInput(offerToken = token, sku = sku)
                             } else {
@@ -302,7 +233,7 @@ class ExpoIapModule : Module() {
                     }
 
                 val subscriptionOffers =
-                    (explicitSubscriptionOffers.ifEmpty { fallbackOffers })
+                    (parsedParams.explicitSubscriptionOffers.ifEmpty { fallbackOffers })
                         .takeIf { it.isNotEmpty() }
 
                 val requestProps =
@@ -310,12 +241,12 @@ class ExpoIapModule : Module() {
                         ProductQueryType.Subs -> {
                             val android =
                                 RequestSubscriptionAndroidProps(
-                                    isOfferPersonalized = isOfferPersonalized,
-                                    obfuscatedAccountIdAndroid = obfuscatedAccountId,
-                                    obfuscatedProfileIdAndroid = obfuscatedProfileId,
-                                    purchaseTokenAndroid = purchaseToken,
-                                    replacementModeAndroid = replacementMode?.toInt(),
-                                    skus = skus,
+                                    isOfferPersonalized = parsedParams.isOfferPersonalized,
+                                    obfuscatedAccountIdAndroid = parsedParams.obfuscatedAccountId,
+                                    obfuscatedProfileIdAndroid = parsedParams.obfuscatedProfileId,
+                                    purchaseTokenAndroid = parsedParams.purchaseToken,
+                                    replacementModeAndroid = parsedParams.replacementMode?.toInt(),
+                                    skus = parsedParams.skus,
                                     subscriptionOffers = subscriptionOffers,
                                 )
                             RequestPurchaseProps(
@@ -330,10 +261,10 @@ class ExpoIapModule : Module() {
                         else -> {
                             val android =
                                 RequestPurchaseAndroidProps(
-                                    isOfferPersonalized = isOfferPersonalized,
-                                    obfuscatedAccountIdAndroid = obfuscatedAccountId,
-                                    obfuscatedProfileIdAndroid = obfuscatedProfileId,
-                                    skus = skus,
+                                    isOfferPersonalized = parsedParams.isOfferPersonalized,
+                                    obfuscatedAccountIdAndroid = parsedParams.obfuscatedAccountId,
+                                    obfuscatedProfileIdAndroid = parsedParams.obfuscatedProfileId,
+                                    skus = parsedParams.skus,
                                 )
                             RequestPurchaseProps(
                                 request =
@@ -345,7 +276,7 @@ class ExpoIapModule : Module() {
                         }
                     }
 
-                PromiseUtils.addPromiseForKey(PromiseUtils.PROMISE_BUY_ITEM, promise)
+                ExpoIapHelper.addPurchasePromise(promise)
                 scope.launch {
                     try {
                         openIap.setActivity(currentActivity)
@@ -360,10 +291,7 @@ class ExpoIapModule : Module() {
                             "requestPurchaseAndroid",
                             purchases.map { it.toJson() },
                         )
-                        PromiseUtils.resolvePromisesForKey(
-                            PromiseUtils.PROMISE_BUY_ITEM,
-                            purchases.map { it.toJson() },
-                        )
+                        ExpoIapHelper.resolvePurchasePromises(purchases.map { it.toJson() })
                     } catch (e: Exception) {
                         ExpoIapLog.failure("requestPurchaseAndroid", e)
                         val errorMap =
@@ -372,16 +300,23 @@ class ExpoIapModule : Module() {
                                 "message" to (e.message ?: "Purchase failed"),
                                 "platform" to "android",
                             )
-                        runCatching { emitOrQueue(EVENT_PURCHASE_ERROR, errorMap) }
-                            .onFailure { ex ->
-                                Log.e(
-                                    TAG,
-                                    "Failed to send PURCHASE_ERROR event (requestPurchase)",
-                                    ex,
-                                )
-                            }
-                        PromiseUtils.rejectPromisesForKey(
-                            PromiseUtils.PROMISE_BUY_ITEM,
+                        runCatching {
+                            ExpoIapHelper.emitOrQueue(
+                                this@ExpoIapModule,
+                                scope,
+                                connectionReady,
+                                pendingEvents,
+                                EVENT_PURCHASE_ERROR,
+                                errorMap,
+                            )
+                        }.onFailure { ex ->
+                            Log.e(
+                                TAG,
+                                "Failed to send PURCHASE_ERROR event (requestPurchase)",
+                                ex,
+                            )
+                        }
+                        ExpoIapHelper.rejectPurchasePromises(
                             OpenIapError.PurchaseFailed.CODE,
                             e.message,
                             null,
@@ -422,6 +357,7 @@ class ExpoIapModule : Module() {
             }
 
             OnDestroy {
+                ExpoIapHelper.cleanupListeners(openIap)
                 job.cancel()
             }
         }

package/build/types.d.ts

@@ -77,40 +77,40 @@ export interface EntitlementIOS {
     transactionId: string;
 }
 export declare enum ErrorCode {
-    ActivityUnavailable = "ACTIVITY_UNAVAILABLE",
-    AlreadyOwned = "ALREADY_OWNED",
-    AlreadyPrepared = "ALREADY_PREPARED",
-    BillingResponseJsonParseError = "BILLING_RESPONSE_JSON_PARSE_ERROR",
-    BillingUnavailable = "BILLING_UNAVAILABLE",
-    ConnectionClosed = "CONNECTION_CLOSED",
-    DeferredPayment = "DEFERRED_PAYMENT",
-    DeveloperError = "DEVELOPER_ERROR",
-    EmptySkuList = "EMPTY_SKU_LIST",
-    FeatureNotSupported = "FEATURE_NOT_SUPPORTED",
-    IapNotAvailable = "IAP_NOT_AVAILABLE",
-    InitConnection = "INIT_CONNECTION",
-    Interrupted = "INTERRUPTED",
-    ItemNotOwned = "ITEM_NOT_OWNED",
-    ItemUnavailable = "ITEM_UNAVAILABLE",
-    NetworkError = "NETWORK_ERROR",
-    NotEnded = "NOT_ENDED",
-    NotPrepared = "NOT_PREPARED",
-    Pending = "PENDING",
-    PurchaseError = "PURCHASE_ERROR",
-    QueryProduct = "QUERY_PRODUCT",
-    ReceiptFailed = "RECEIPT_FAILED",
-    ReceiptFinished = "RECEIPT_FINISHED",
-    ReceiptFinishedFailed = "RECEIPT_FINISHED_FAILED",
-    RemoteError = "REMOTE_ERROR",
-    ServiceDisconnected = "SERVICE_DISCONNECTED",
-    ServiceError = "SERVICE_ERROR",
-    SkuNotFound = "SKU_NOT_FOUND",
-    SkuOfferMismatch = "SKU_OFFER_MISMATCH",
-    SyncError = "SYNC_ERROR",
-    TransactionValidationFailed = "TRANSACTION_VALIDATION_FAILED",
-    Unknown = "UNKNOWN",
-    UserCancelled = "USER_CANCELLED",
-    UserError = "USER_ERROR"
+    ActivityUnavailable = "activity-unavailable",
+    AlreadyOwned = "already-owned",
+    AlreadyPrepared = "already-prepared",
+    BillingResponseJsonParseError = "billing-response-json-parse-error",
+    BillingUnavailable = "billing-unavailable",
+    ConnectionClosed = "connection-closed",
+    DeferredPayment = "deferred-payment",
+    DeveloperError = "developer-error",
+    EmptySkuList = "empty-sku-list",
+    FeatureNotSupported = "feature-not-supported",
+    IapNotAvailable = "iap-not-available",
+    InitConnection = "init-connection",
+    Interrupted = "interrupted",
+    ItemNotOwned = "item-not-owned",
+    ItemUnavailable = "item-unavailable",
+    NetworkError = "network-error",
+    NotEnded = "not-ended",
+    NotPrepared = "not-prepared",
+    Pending = "pending",
+    PurchaseError = "purchase-error",
+    QueryProduct = "query-product",
+    ReceiptFailed = "receipt-failed",
+    ReceiptFinished = "receipt-finished",
+    ReceiptFinishedFailed = "receipt-finished-failed",
+    RemoteError = "remote-error",
+    ServiceDisconnected = "service-disconnected",
+    ServiceError = "service-error",
+    SkuNotFound = "sku-not-found",
+    SkuOfferMismatch = "sku-offer-mismatch",
+    SyncError = "sync-error",
+    TransactionValidationFailed = "transaction-validation-failed",
+    Unknown = "unknown",
+    UserCancelled = "user-cancelled",
+    UserError = "user-error"
 }
 export type FetchProductsResult = Product[] | ProductSubscription[] | null;
 export type IapEvent = 'purchase-updated' | 'purchase-error' | 'promoted-product-ios';

package/build/types.js

@@ -4,40 +4,40 @@
 // ============================================================================
 export var ErrorCode;
 (function (ErrorCode) {
-    ErrorCode["ActivityUnavailable"] = "ACTIVITY_UNAVAILABLE";
-    ErrorCode["AlreadyOwned"] = "ALREADY_OWNED";
-    ErrorCode["AlreadyPrepared"] = "ALREADY_PREPARED";
-    ErrorCode["BillingResponseJsonParseError"] = "BILLING_RESPONSE_JSON_PARSE_ERROR";
-    ErrorCode["BillingUnavailable"] = "BILLING_UNAVAILABLE";
-    ErrorCode["ConnectionClosed"] = "CONNECTION_CLOSED";
-    ErrorCode["DeferredPayment"] = "DEFERRED_PAYMENT";
-    ErrorCode["DeveloperError"] = "DEVELOPER_ERROR";
-    ErrorCode["EmptySkuList"] = "EMPTY_SKU_LIST";
-    ErrorCode["FeatureNotSupported"] = "FEATURE_NOT_SUPPORTED";
-    ErrorCode["IapNotAvailable"] = "IAP_NOT_AVAILABLE";
-    ErrorCode["InitConnection"] = "INIT_CONNECTION";
-    ErrorCode["Interrupted"] = "INTERRUPTED";
-    ErrorCode["ItemNotOwned"] = "ITEM_NOT_OWNED";
-    ErrorCode["ItemUnavailable"] = "ITEM_UNAVAILABLE";
-    ErrorCode["NetworkError"] = "NETWORK_ERROR";
-    ErrorCode["NotEnded"] = "NOT_ENDED";
-    ErrorCode["NotPrepared"] = "NOT_PREPARED";
-    ErrorCode["Pending"] = "PENDING";
-    ErrorCode["PurchaseError"] = "PURCHASE_ERROR";
-    ErrorCode["QueryProduct"] = "QUERY_PRODUCT";
-    ErrorCode["ReceiptFailed"] = "RECEIPT_FAILED";
-    ErrorCode["ReceiptFinished"] = "RECEIPT_FINISHED";
-    ErrorCode["ReceiptFinishedFailed"] = "RECEIPT_FINISHED_FAILED";
-    ErrorCode["RemoteError"] = "REMOTE_ERROR";
-    ErrorCode["ServiceDisconnected"] = "SERVICE_DISCONNECTED";
-    ErrorCode["ServiceError"] = "SERVICE_ERROR";
-    ErrorCode["SkuNotFound"] = "SKU_NOT_FOUND";
-    ErrorCode["SkuOfferMismatch"] = "SKU_OFFER_MISMATCH";
-    ErrorCode["SyncError"] = "SYNC_ERROR";
-    ErrorCode["TransactionValidationFailed"] = "TRANSACTION_VALIDATION_FAILED";
-    ErrorCode["Unknown"] = "UNKNOWN";
-    ErrorCode["UserCancelled"] = "USER_CANCELLED";
-    ErrorCode["UserError"] = "USER_ERROR";
+    ErrorCode["ActivityUnavailable"] = "activity-unavailable";
+    ErrorCode["AlreadyOwned"] = "already-owned";
+    ErrorCode["AlreadyPrepared"] = "already-prepared";
+    ErrorCode["BillingResponseJsonParseError"] = "billing-response-json-parse-error";
+    ErrorCode["BillingUnavailable"] = "billing-unavailable";
+    ErrorCode["ConnectionClosed"] = "connection-closed";
+    ErrorCode["DeferredPayment"] = "deferred-payment";
+    ErrorCode["DeveloperError"] = "developer-error";
+    ErrorCode["EmptySkuList"] = "empty-sku-list";
+    ErrorCode["FeatureNotSupported"] = "feature-not-supported";
+    ErrorCode["IapNotAvailable"] = "iap-not-available";
+    ErrorCode["InitConnection"] = "init-connection";
+    ErrorCode["Interrupted"] = "interrupted";
+    ErrorCode["ItemNotOwned"] = "item-not-owned";
+    ErrorCode["ItemUnavailable"] = "item-unavailable";
+    ErrorCode["NetworkError"] = "network-error";
+    ErrorCode["NotEnded"] = "not-ended";
+    ErrorCode["NotPrepared"] = "not-prepared";
+    ErrorCode["Pending"] = "pending";
+    ErrorCode["PurchaseError"] = "purchase-error";
+    ErrorCode["QueryProduct"] = "query-product";
+    ErrorCode["ReceiptFailed"] = "receipt-failed";
+    ErrorCode["ReceiptFinished"] = "receipt-finished";
+    ErrorCode["ReceiptFinishedFailed"] = "receipt-finished-failed";
+    ErrorCode["RemoteError"] = "remote-error";
+    ErrorCode["ServiceDisconnected"] = "service-disconnected";
+    ErrorCode["ServiceError"] = "service-error";
+    ErrorCode["SkuNotFound"] = "sku-not-found";
+    ErrorCode["SkuOfferMismatch"] = "sku-offer-mismatch";
+    ErrorCode["SyncError"] = "sync-error";
+    ErrorCode["TransactionValidationFailed"] = "transaction-validation-failed";
+    ErrorCode["Unknown"] = "unknown";
+    ErrorCode["UserCancelled"] = "user-cancelled";
+    ErrorCode["UserError"] = "user-error";
 })(ErrorCode || (ErrorCode = {}));
 // -- End subscription helper types
 //# sourceMappingURL=types.js.map