Only save auto-renewing status for changed tokens on post success

Fixes a bug where saveAutoRenewingStatus was called eagerly before
posting, so if the post failed, the cache already reflected the new
value and the change would never be retried.

Now: unchanged tokens' auto-renewing status is saved eagerly (safe
since they're not being reposted). Changed tokens' status is saved
per-transaction only on successful post via updateAutoRenewingStatus.
If the post fails, the old cached value is preserved and the change
will be detected again on the next sync cycle.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: facumenzella

purchases/src/main/kotlin/com/revenuecat/purchases/PostPendingTransactionsHelper.kt

@@ -6,6 +6,7 @@ import com.revenuecat.purchases.common.Dispatcher
 import com.revenuecat.purchases.common.LogIntent
 import com.revenuecat.purchases.common.caching.DeviceCache
 import com.revenuecat.purchases.common.log
+import com.revenuecat.purchases.common.sha1
 import com.revenuecat.purchases.identity.IdentityManager
 import com.revenuecat.purchases.models.PurchaseState
 import com.revenuecat.purchases.models.StoreTransaction
@@ -57,7 +58,13 @@ internal class PostPendingTransactionsHelper(
                     val autoRenewingChanged = deviceCache.getPurchasesWithAutoRenewingChange(
                         purchasesByHashedToken,
                     )
-                    deviceCache.saveAutoRenewingStatus(purchasesByHashedToken)
+                    // Save auto-renewing status only for tokens NOT being re-synced due to a
+                    // change. Changed tokens' status is saved per-transaction on post success,
+                    // so a failed post preserves the old cached value for retry on next sync.
+                    val changedTokenHashes = autoRenewingChanged.map { it.purchaseToken.sha1() }
+                        .toSet()
+                    val unchangedTokens = purchasesByHashedToken.minus(changedTokenHashes)
+                    deviceCache.saveAutoRenewingStatus(unchangedTokens)
                     val transactionsToSync = (newPurchases + autoRenewingChanged).distinctBy {
                         it.purchaseToken
                     }
@@ -149,7 +156,11 @@ internal class PostPendingTransactionsHelper(
                 appUserID,
                 PostReceiptInitiationSource.UNSYNCED_ACTIVE_PURCHASES,
                 sdkOriginated = false,
-                transactionPostSuccess = { _, customerInfo ->
+                transactionPostSuccess = { transaction, customerInfo ->
+                    deviceCache.updateAutoRenewingStatus(
+                        transaction.purchaseToken,
+                        transaction.isAutoRenewing,
+                    )
                     results.add(Result.Success(customerInfo))
                     callCompletionFromResults(transactionsToSync, results, onError, onSuccess)
                 },

purchases/src/main/kotlin/com/revenuecat/purchases/common/caching/DeviceCache.kt

@@ -531,6 +531,20 @@ internal open class DeviceCache(
         saveTokenMap(current)
     }
 
+    /**
+     * Updates the cached auto-renewing status for a single token. Used to persist the status
+     * after a successful post, so we don't eagerly save before knowing the post succeeded.
+     */
+    @Synchronized
+    fun updateAutoRenewingStatus(token: String, isAutoRenewing: Boolean?) {
+        val hashedToken = token.sha1()
+        val current = getTokenMap().toMutableMap()
+        if (hashedToken in current) {
+            current[hashedToken] = isAutoRenewing
+            saveTokenMap(current)
+        }
+    }
+
     // endregion
 
     // region offerings response

purchases/src/test/java/com/revenuecat/purchases/PostPendingTransactionsHelperTest.kt

@@ -66,6 +66,8 @@ class PostPendingTransactionsHelperTest {
             lambda<() -> Unit>().captured.invoke()
         }
 
+        every { deviceCache.updateAutoRenewingStatus(any(), any()) } just Runs
+
         changeBillingConnected()
         changeAutoSyncEnabled(true)
 
@@ -368,7 +370,10 @@ class PostPendingTransactionsHelperTest {
                     lambda<SuccessfulPurchaseCallback>().captured.invoke(transaction, customerInfo!!)
                 }
             } ?: run {
-                lambda<SuccessfulPurchaseCallback>().captured.invoke(mockk(), customerInfo!!)
+                lambda<SuccessfulPurchaseCallback>().captured.invoke(
+                    mockk(relaxed = true),
+                    customerInfo!!,
+                )
             }
         }
     }
@@ -398,7 +403,7 @@ class PostPendingTransactionsHelperTest {
             deviceCache.getPurchasesWithAutoRenewingChange(purchasesByHashedToken)
         } returns autoRenewingChanged
         every {
-            deviceCache.saveAutoRenewingStatus(purchasesByHashedToken)
+            deviceCache.saveAutoRenewingStatus(any())
         } just Runs
 
         every {
@@ -849,7 +854,7 @@ class PostPendingTransactionsHelperTest {
     }
 
     @Test
-    fun `auto-renewing status is saved after detecting changes`() {
+    fun `auto-renewing status is saved for unchanged tokens`() {
         val purchase = stubGooglePurchase(
             purchaseToken = "token",
             productIds = listOf("product"),
@@ -871,5 +876,79 @@ class PostPendingTransactionsHelperTest {
         }
     }
 
+    @Test
+    fun `auto-renewing status is not eagerly saved for changed tokens`() {
+        val purchase = stubGooglePurchase(
+            purchaseToken = "token",
+            productIds = listOf("product"),
+            purchaseState = Purchase.PurchaseState.PURCHASED,
+        )
+        val transaction = purchase.toStoreTransaction(ProductType.SUBS)
+        val purchasesByHash = mapOf(purchase.purchaseToken.sha1() to transaction)
+
+        mockSuccessfulQueryPurchases(
+            purchasesByHashedToken = purchasesByHash,
+            notInCache = emptyList(),
+            autoRenewingChanged = listOf(transaction),
+        )
+
+        val customerInfoMock = mockk<CustomerInfo>()
+        mockPostTransactionsSuccessful(customerInfoMock, listOf(transaction))
+
+        postPendingTransactionsHelper.syncPendingPurchaseQueue(allowSharingPlayStoreAccount)
+
+        // Changed tokens are excluded from the eager save
+        verify(exactly = 1) {
+            deviceCache.saveAutoRenewingStatus(emptyMap())
+        }
+        // Instead, auto-renewing is saved per-transaction on post success
+        verify(exactly = 1) {
+            deviceCache.updateAutoRenewingStatus(transaction.purchaseToken, transaction.isAutoRenewing)
+        }
+    }
+
+    @Test
+    fun `failed post of changed auto-renewing does not update cache`() {
+        val purchase = stubGooglePurchase(
+            purchaseToken = "token",
+            productIds = listOf("product"),
+            purchaseState = Purchase.PurchaseState.PURCHASED,
+        )
+        val transaction = purchase.toStoreTransaction(ProductType.SUBS)
+        val purchasesByHash = mapOf(purchase.purchaseToken.sha1() to transaction)
+
+        mockSuccessfulQueryPurchases(
+            purchasesByHashedToken = purchasesByHash,
+            notInCache = emptyList(),
+            autoRenewingChanged = listOf(transaction),
+        )
+
+        val error = PurchasesError(PurchasesErrorCode.NetworkError)
+        every {
+            postTransactionWithProductDetailsHelper.postTransactions(
+                transactions = any(),
+                allowSharingPlayStoreAccount = allowSharingPlayStoreAccount,
+                appUserID = appUserId,
+                initiationSource = initiationSource,
+                sdkOriginated = false,
+                transactionPostSuccess = any(),
+                transactionPostError = captureLambda(),
+            )
+        } answers {
+            lambda<ErrorPurchaseCallback>().captured.invoke(transaction, error)
+        }
+
+        postPendingTransactionsHelper.syncPendingPurchaseQueue(allowSharingPlayStoreAccount)
+
+        // Changed token excluded from eager save
+        verify(exactly = 1) {
+            deviceCache.saveAutoRenewingStatus(emptyMap())
+        }
+        // updateAutoRenewingStatus NOT called since the post failed
+        verify(exactly = 0) {
+            deviceCache.updateAutoRenewingStatus(any(), any())
+        }
+    }
+
     // endregion
 }

purchases/src/test/java/com/revenuecat/purchases/common/DeviceCacheTest.kt

@@ -1055,6 +1055,30 @@ class DeviceCacheTest {
         }
     }
 
+    @Test
+    fun `updateAutoRenewingStatus updates single token`() {
+        val sha1 = "token1".sha1()
+        mockTokenMap("""{"$sha1":null}""")
+        every { mockEditor.apply() } just runs
+
+        cache.updateAutoRenewingStatus("token1", false)
+        verify {
+            mockEditor.putString(cache.tokensCacheKey, match { json ->
+                val obj = JSONObject(json)
+                obj.length() == 1 && obj.getBoolean(sha1) == false
+            })
+        }
+    }
+
+    @Test
+    fun `updateAutoRenewingStatus does nothing for unknown token`() {
+        mockTokenMap("""{"hash1":true}""")
+        cache.updateAutoRenewingStatus("unknown", false)
+        verify(exactly = 0) {
+            mockEditor.putString(cache.tokensCacheKey, any())
+        }
+    }
+
     // endregion legacy token migration
 
     private fun mockTokenMap(json: String) {