Increase in refunds on Google Play after migrating from react-native-iap to expo-iap

[AdamGerthel]

We've very recently migrated one of our apps from react-native-iap to expo-iap and we've seen about a 1000% increase in IAP refunds since the switch. It doesn't affect all purchases, but something definitely seems to be off. The only thing I can think of that was completely removed in the migration was the flushFailedPurchasesCachedAsPendingAndroid() call since it doesn't exist in expo-iap.

I remember we had a similar issue many years ago, where all IAP purchases on Android were automatically refunded roughly three days after purchase - which is exactly what I'm seeing now too, except it doesn't affect all orders. It affects roughly 5-10% of all orders now. IIRC, the reason back then was that we didn't call finishTransaction() but we are now, so I'm not sure what could be the problem.

Here's the class we use to handle purchases (note: I've removed som unrelated methods from the class to make the snippet smaller):

import type { Stores } from './'
import type { Database } from '../models/database'
import { observable, action, computed } from 'mobx'
import { t } from '../i18n'
import NetInfo from '@react-native-community/netinfo'
import {
  finishTransaction,
  getAvailablePurchases,
  getProducts,
  initConnection,
  type Product,
  type Purchase,
  type PurchaseError,
  type RequestPurchaseProps,
  purchaseErrorListener,
  purchaseUpdatedListener,
  requestPurchase,
  endConnection
} from 'expo-iap'
import { Platform } from 'react-native'
import Order, { type ParsedOrder } from '../models/database/schemas/order'
import { delay } from '../helpers/misc'
import { analytics } from '../helpers/analytics'
import { logger } from '../helpers/logger'

const warningTypes = {
  E_USER_CANCELLED: 'E_USER_CANCELLED',
  '3': '3'
}

type TWarningTypes = keyof typeof warningTypes

const errorTypes = {
  E_IAP_NOT_AVAILABLE: 'E_IAP_NOT_AVAILABLE',
  E_UNKNOWN: 'E_UNKNOWN',
  E_USER_ERROR: 'E_USER_ERROR',
  E_ITEM_UNAVAILABLE: 'E_ITEM_UNAVAILABLE',
  E_REMOTE_ERROR: 'E_REMOTE_ERROR',
  E_NETWORK_ERROR: 'E_NETWORK_ERROR',
  E_SERVICE_ERROR: 'E_SERVICE_ERROR',
  E_RECEIPT_FAILED: 'E_RECEIPT_FAILED',
  E_RECEIPT_FINISHED_FAILED: 'E_RECEIPT_FINISHED_FAILED',
  E_NOT_PREPARED: 'E_NOT_PREPARED',
  E_NOT_ENDED: 'E_NOT_ENDED',
  E_ALREADY_OWNED: 'E_ALREADY_OWNED',
  E_DEVELOPER_ERROR: 'E_DEVELOPER_ERROR',
  E_BILLING_RESPONSE_JSON_PARSE_ERROR: 'E_BILLING_RESPONSE_JSON_PARSE_ERROR',
  E_DEFERRED_PAYMENT: 'E_DEFERRED_PAYMENT'
}

type TErrorTypes = keyof typeof errorTypes

export class PurchaseStore {
  constructor(
    private readonly stores: Pick<Stores, 'ui' | 'settings'>,
    private readonly database: Database
  ) {
    if (!stores.settings.config.productSKUs.basic) {
      this.access = AccessType.premium
      this.trackEntitlement()
    }
  }

  purchaseUpdateSubscription: {
    remove: () => void
  } | null = null

  purchaseErrorSubscription: {
    remove: () => void
  } | null = null

  @observable awaitingResponse = false
  @observable products: EnrichedProduct[] = []
  @observable ownedProducts: (ProductType | null)[] = []
  @observable access = AccessType.demo
  @observable storeIsOpen: boolean = false

  get isConfigured() {
    const { config } = this.stores.settings

    return config.allSkusExist
  }

  @action openStore = async () => {
    this.awaitingResponse = true

    try {
      const netState = await NetInfo.fetch()

      if (!netState.isConnected) return

      await initConnection()
      await this.populateProducts()
      this.initiatePurchaseHandlers()
      this.storeIsOpen = true
    } catch (error) {
      logger.error(error)
    } finally {
      this.awaitingResponse = false
    }
  }

  closeStore = async () => {
    this.removePurchaseHandlers()
    await endConnection()
    this.storeIsOpen = false
  }

  initiatePurchaseHandlers = () => {
    if (this.purchaseUpdateSubscription || this.purchaseErrorSubscription) {
      this.removePurchaseHandlers()
    }

    this.purchaseUpdateSubscription = purchaseUpdatedListener(this.purchaseUpdateHandler)
    this.purchaseErrorSubscription = purchaseErrorListener(this.purchaseErrorHandler)
  }

  removePurchaseHandlers = () => {
    if (this.purchaseUpdateSubscription) {
      this.purchaseUpdateSubscription.remove()
      this.purchaseUpdateSubscription = null
    }
    if (this.purchaseErrorSubscription) {
      this.purchaseErrorSubscription.remove()
      this.purchaseErrorSubscription = null
    }
  }

  initiatePurchase = async (sku: string, options?: { fake: boolean }) => {
    this.awaitingResponse = true

    if (options?.fake) {
      await delay(2000)
      this.access = this.getAccessFromProductId(sku)
      this.ownedProducts.push(this.getProductType(sku))
      this.awaitingResponse = false
      return
    }

    if (!sku) {
      throw new Error(`No SKU supplied. Aborting purchase.`)
    }

    try {
      const netState = await NetInfo.fetch()

      if (!netState.isConnected) {
        return this.stores.ui.alert(
          t('PURCHASE-CONNECTION_FAILURE-TITLE'),
          t('PURCHASE-CONNECTION_FAILURE-MESSAGE')
        )
      }

      // Attempt to re-fetch products if there aren't any. This was
      // added because iOS sometimes returned "invalid" sku error.
      // By doing this, we'll at least make sure that paywall has
      // a fresh product setup in case requestPurchase fails..
      if (!this.products.length) {
        await this.populateProducts()
      }

      const purchaseRequest: RequestPurchaseProps | undefined = Platform.select({
        ios: { sku },
        android: { skus: [sku] }
      })

      if (purchaseRequest) {
        await requestPurchase({
          request: purchaseRequest
        })
      }
    } catch (error) {
      if (typeof error === 'object' && error !== null && 'code' in error) {
        if (!warningTypes[error.code as TWarningTypes]) {
          logger.error(error)
        }
      } else {
        logger.error(error)
      }
    } finally {
      this.awaitingResponse = false
    }
  }

  purchaseUpdateHandler = async (purchase: Purchase) => {
    try {
      if (purchase.transactionReceipt) {
        await this.saveOrderInLocalStorage(new Order(purchase))
        await this.setAccessFromOrderHistory()
        await finishTransaction({ purchase, isConsumable: false })
        analytics.event(PurchaseAnalyticsEvents.PURCHASED_PRODUCT, {
          productSku: purchase.id
        })
      }
    } catch (error) {
      logger.error(error)
    } finally {
      this.awaitingResponse = false
    }
  }

  purchaseErrorHandler = (error: PurchaseError) => {
    const { alert } = this.stores.ui

    if (error.code && !warningTypes[error.code as TWarningTypes]) {
      const message =
        errorTypes[error.code as TErrorTypes] && error.message
          ? error.message
          : t('PURCHASE-UNKNOWN_FAILURE-MESSAGE')

      alert(t('PURCHASE-UNKNOWN_FAILURE-TITLE'), message)
      logger.error(error)
    }

    this.awaitingResponse = false
  }

  deletePurchases = async () => {
    this.awaitingResponse = true

    try {
      await this.database.deleteAll(Order.schema.name)
      await this.setAccessFromOrderHistory()
    } catch (error) {
      logger.error(error)
    } finally {
      this.awaitingResponse = false
    }
  }

  restorePurchases = async () => {
    const netState = await NetInfo.fetch()

    if (!netState.isConnected) {
      throw new Error(t('PURCHASE-CONNECTION_FAILURE-MESSAGE'))
    }

    if (!this.storeIsOpen) {
      await this.openStore()
    }

    const transactions = await getAvailablePurchases()

    await this.removeOrdersFromLocalStorage()

    for (let i = 0; i < transactions.length; i++) {
      await this.saveOrderInLocalStorage(new Order(transactions[i]))
    }

    await this.setAccessFromOrderHistory()
  }
}

export default PurchaseStore