react-native-iap 14.3.6 → 14.3.8

package/lib/module/index.js

@@ -8,73 +8,29 @@ import { NitroModules } from 'react-native-nitro-modules';
 
 // Internal modules
 
-import { convertNitroProductToProduct, convertNitroPurchaseToPurchase, validateNitroProduct, validateNitroPurchase, convertNitroSubscriptionStatusToSubscriptionStatusIOS } from "./utils/type-bridge.js";
+import { convertNitroProductToProduct, convertNitroPurchaseToPurchase, convertProductToProductSubscription, validateNitroProduct, validateNitroPurchase, convertNitroSubscriptionStatusToSubscriptionStatusIOS } from "./utils/type-bridge.js";
 import { parseErrorStringToJsonObj } from "./utils/error.js";
 import { normalizeErrorCodeFromNative } from "./utils/errorMapping.js";
+import { getSuccessFromPurchaseVariant } from "./utils/purchase.js";
+import { parseAppTransactionPayload } from "./utils.js";
 
 // Export all types
 
 export * from "./types.js";
 export * from "./utils/error.js";
 const LEGACY_INAPP_WARNING = "[react-native-iap] `type: 'inapp'` is deprecated and will be removed in v14.4.0. Use 'in-app' instead.";
-function toNitroProductType(type) {
-  if (type === 'subs') {
-    return 'subs';
-  }
-  if (type === 'inapp') {
-    console.warn(LEGACY_INAPP_WARNING);
-    return 'inapp';
-  }
-  if (type === 'all') {
-    return 'inapp';
-  }
-  return 'inapp';
-}
-function isSubscriptionQuery(type) {
-  return type === 'subs';
-}
-function normalizeProductQueryType(type) {
-  if (type === 'all' || type === 'subs' || type === 'in-app') {
-    return type;
+const toErrorMessage = error => {
+  if (typeof error === 'object' && error !== null && 'message' in error && error.message != null) {
+    return String(error.message);
   }
-  if (typeof type === 'string') {
-    const normalized = type.trim().toLowerCase().replace(/_/g, '-');
-    if (normalized === 'all') {
-      return 'all';
-    }
-    if (normalized === 'subs') {
-      return 'subs';
-    }
-    if (normalized === 'inapp') {
-      console.warn(LEGACY_INAPP_WARNING);
-      return 'in-app';
-    }
-    if (normalized === 'in-app') {
-      return 'in-app';
-    }
-  }
-  return 'in-app';
-}
+  return String(error ?? '');
+};
 // ActiveSubscription and PurchaseError types are already exported via 'export * from ./types'
 
 // Export hooks
 export { useIAP } from "./hooks/useIAP.js";
 
-// iOS promoted product aliases for API parity
-export const getPromotedProductIOS = async () => requestPromotedProductIOS();
-export const requestPurchaseOnPromotedProductIOS = async () => buyPromotedProductIOS();
-
 // Restore completed transactions (cross-platform)
-export const restorePurchases = async (options = {
-  alsoPublishToEventListenerIOS: false,
-  onlyIncludeActiveItemsIOS: true
-}) => {
-  if (Platform.OS === 'ios') {
-    await syncIOS();
-  }
-  return getAvailablePurchases(options);
-};
-
 // Development utilities removed - use type bridge functions directly if needed
 
 // Create the RnIap HybridObject instance lazily to avoid early JSI crashes
@@ -87,7 +43,7 @@ const IAP = {
     try {
       iapRef = NitroModules.createHybridObject('RnIap');
     } catch (e) {
-      const msg = String(e?.message ?? e ?? '');
+      const msg = toErrorMessage(e);
       if (msg.includes('Nitro') || msg.includes('JSI') || msg.includes('dispatcher') || msg.includes('HybridObject')) {
         throw new Error('Nitro runtime not installed yet. Ensure react-native-nitro-modules is initialized before calling IAP.');
       }
@@ -97,6 +53,430 @@ const IAP = {
   }
 };
 
+// ============================================================================
+// EVENT LISTENERS
+// ============================================================================
+
+const purchaseUpdatedListenerMap = new WeakMap();
+const purchaseErrorListenerMap = new WeakMap();
+const promotedProductListenerMap = new WeakMap();
+export const purchaseUpdatedListener = listener => {
+  const wrappedListener = nitroPurchase => {
+    if (validateNitroPurchase(nitroPurchase)) {
+      const convertedPurchase = convertNitroPurchaseToPurchase(nitroPurchase);
+      listener(convertedPurchase);
+    } else {
+      console.error('Invalid purchase data received from native:', nitroPurchase);
+    }
+  };
+  purchaseUpdatedListenerMap.set(listener, wrappedListener);
+  let attached = false;
+  try {
+    IAP.instance.addPurchaseUpdatedListener(wrappedListener);
+    attached = true;
+  } catch (e) {
+    const msg = toErrorMessage(e);
+    if (msg.includes('Nitro runtime not installed')) {
+      console.warn('[purchaseUpdatedListener] Nitro not ready yet; listener inert until initConnection()');
+    } else {
+      throw e;
+    }
+  }
+  return {
+    remove: () => {
+      const wrapped = purchaseUpdatedListenerMap.get(listener);
+      if (wrapped) {
+        if (attached) {
+          try {
+            IAP.instance.removePurchaseUpdatedListener(wrapped);
+          } catch {}
+        }
+        purchaseUpdatedListenerMap.delete(listener);
+      }
+    }
+  };
+};
+export const purchaseErrorListener = listener => {
+  const wrapped = error => {
+    listener({
+      code: normalizeErrorCodeFromNative(error.code),
+      message: error.message,
+      productId: undefined
+    });
+  };
+  purchaseErrorListenerMap.set(listener, wrapped);
+  let attached = false;
+  try {
+    IAP.instance.addPurchaseErrorListener(wrapped);
+    attached = true;
+  } catch (e) {
+    const msg = toErrorMessage(e);
+    if (msg.includes('Nitro runtime not installed')) {
+      console.warn('[purchaseErrorListener] Nitro not ready yet; listener inert until initConnection()');
+    } else {
+      throw e;
+    }
+  }
+  return {
+    remove: () => {
+      const stored = purchaseErrorListenerMap.get(listener);
+      if (stored) {
+        if (attached) {
+          try {
+            IAP.instance.removePurchaseErrorListener(stored);
+          } catch {}
+        }
+        purchaseErrorListenerMap.delete(listener);
+      }
+    }
+  };
+};
+export const promotedProductListenerIOS = listener => {
+  if (Platform.OS !== 'ios') {
+    console.warn('promotedProductListenerIOS: This listener is only available on iOS');
+    return {
+      remove: () => {}
+    };
+  }
+  const wrappedListener = nitroProduct => {
+    if (validateNitroProduct(nitroProduct)) {
+      const convertedProduct = convertNitroProductToProduct(nitroProduct);
+      listener(convertedProduct);
+    } else {
+      console.error('Invalid promoted product data received from native:', nitroProduct);
+    }
+  };
+  promotedProductListenerMap.set(listener, wrappedListener);
+  let attached = false;
+  try {
+    IAP.instance.addPromotedProductListenerIOS(wrappedListener);
+    attached = true;
+  } catch (e) {
+    const msg = toErrorMessage(e);
+    if (msg.includes('Nitro runtime not installed')) {
+      console.warn('[promotedProductListenerIOS] Nitro not ready yet; listener inert until initConnection()');
+    } else {
+      throw e;
+    }
+  }
+  return {
+    remove: () => {
+      const wrapped = promotedProductListenerMap.get(listener);
+      if (wrapped) {
+        if (attached) {
+          try {
+            IAP.instance.removePromotedProductListenerIOS(wrapped);
+          } catch {}
+        }
+        promotedProductListenerMap.delete(listener);
+      }
+    }
+  };
+};
+
+// ------------------------------
+// Query API
+// ------------------------------
+
+/**
+ * Fetch products from the store
+ * @param params - Product request configuration
+ * @param params.skus - Array of product SKUs to fetch
+ * @param params.type - Optional filter: 'in-app' (default) for products, 'subs' for subscriptions, or 'all' for both.
+ * @returns Promise<Product[]> - Array of products from the store
+ *
+ * @example
+ * ```typescript
+ * // Regular products
+ * const products = await fetchProducts({ skus: ['product1', 'product2'] });
+ *
+ * // Subscriptions
+ * const subscriptions = await fetchProducts({ skus: ['sub1', 'sub2'], type: 'subs' });
+ * ```
+ */
+export const fetchProducts = async request => {
+  const {
+    skus,
+    type
+  } = request;
+  try {
+    if (!skus?.length) {
+      throw new Error('No SKUs provided');
+    }
+    const normalizedType = normalizeProductQueryType(type);
+    const fetchAndConvert = async nitroType => {
+      const nitroProducts = await IAP.instance.fetchProducts(skus, nitroType);
+      const validProducts = nitroProducts.filter(validateNitroProduct);
+      if (validProducts.length !== nitroProducts.length) {
+        console.warn(`[fetchProducts] Some products failed validation: ${nitroProducts.length - validProducts.length} invalid`);
+      }
+      return validProducts.map(convertNitroProductToProduct);
+    };
+    if (normalizedType === 'all') {
+      const converted = await fetchAndConvert('all');
+      const productItems = converted.filter(item => item.type === 'in-app');
+      const subscriptionItems = converted.filter(item => item.type === 'subs').map(convertProductToProductSubscription);
+      return [...productItems, ...subscriptionItems];
+    }
+    const convertedProducts = await fetchAndConvert(toNitroProductType(normalizedType));
+    if (normalizedType === 'subs') {
+      return convertedProducts.map(convertProductToProductSubscription);
+    }
+    return convertedProducts;
+  } catch (error) {
+    console.error('[fetchProducts] Failed:', error);
+    throw error;
+  }
+};
+
+/**
+ * Get available purchases (purchased items not yet consumed/finished)
+ * @param params - Options for getting available purchases
+ * @param params.alsoPublishToEventListener - Whether to also publish to event listener
+ * @param params.onlyIncludeActiveItems - Whether to only include active items
+ *
+ * @example
+ * ```typescript
+ * const purchases = await getAvailablePurchases({
+ *   onlyIncludeActiveItemsIOS: true
+ * });
+ * ```
+ */
+export const getAvailablePurchases = async options => {
+  const alsoPublishToEventListenerIOS = Boolean(options?.alsoPublishToEventListenerIOS ?? false);
+  const onlyIncludeActiveItemsIOS = Boolean(options?.onlyIncludeActiveItemsIOS ?? true);
+  try {
+    if (Platform.OS === 'ios') {
+      const nitroOptions = {
+        ios: {
+          alsoPublishToEventListenerIOS,
+          onlyIncludeActiveItemsIOS,
+          alsoPublishToEventListener: alsoPublishToEventListenerIOS,
+          onlyIncludeActiveItems: onlyIncludeActiveItemsIOS
+        }
+      };
+      const nitroPurchases = await IAP.instance.getAvailablePurchases(nitroOptions);
+      const validPurchases = nitroPurchases.filter(validateNitroPurchase);
+      if (validPurchases.length !== nitroPurchases.length) {
+        console.warn(`[getAvailablePurchases] Some purchases failed validation: ${nitroPurchases.length - validPurchases.length} invalid`);
+      }
+      return validPurchases.map(convertNitroPurchaseToPurchase);
+    } else if (Platform.OS === 'android') {
+      // For Android, we need to call twice for inapp and subs
+      const inappNitroPurchases = await IAP.instance.getAvailablePurchases({
+        android: {
+          type: 'inapp'
+        }
+      });
+      const subsNitroPurchases = await IAP.instance.getAvailablePurchases({
+        android: {
+          type: 'subs'
+        }
+      });
+
+      // Validate and convert both sets of purchases
+      const allNitroPurchases = [...inappNitroPurchases, ...subsNitroPurchases];
+      const validPurchases = allNitroPurchases.filter(validateNitroPurchase);
+      if (validPurchases.length !== allNitroPurchases.length) {
+        console.warn(`[getAvailablePurchases] Some Android purchases failed validation: ${allNitroPurchases.length - validPurchases.length} invalid`);
+      }
+      return validPurchases.map(convertNitroPurchaseToPurchase);
+    } else {
+      throw new Error('Unsupported platform');
+    }
+  } catch (error) {
+    console.error('Failed to get available purchases:', error);
+    throw error;
+  }
+};
+
+/**
+ * Request the promoted product from the App Store (iOS only)
+ * @returns Promise<Product | null> - The promoted product or null if none available
+ * @platform iOS
+ */
+export const getPromotedProductIOS = async () => {
+  if (Platform.OS !== 'ios') {
+    return null;
+  }
+  try {
+    const nitroProduct = await IAP.instance.requestPromotedProductIOS();
+    if (!nitroProduct) {
+      return null;
+    }
+    const converted = convertNitroProductToProduct(nitroProduct);
+    return converted.platform === 'ios' ? converted : null;
+  } catch (error) {
+    console.error('[getPromotedProductIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
+  }
+};
+export const requestPromotedProductIOS = getPromotedProductIOS;
+export const getStorefrontIOS = async () => {
+  if (Platform.OS !== 'ios') {
+    throw new Error('getStorefrontIOS is only available on iOS');
+  }
+  try {
+    const storefront = await IAP.instance.getStorefrontIOS();
+    return storefront;
+  } catch (error) {
+    console.error('Failed to get storefront:', error);
+    throw error;
+  }
+};
+export const getAppTransactionIOS = async () => {
+  if (Platform.OS !== 'ios') {
+    throw new Error('getAppTransactionIOS is only available on iOS');
+  }
+  try {
+    const appTransaction = await IAP.instance.getAppTransactionIOS();
+    if (appTransaction == null) {
+      return null;
+    }
+    if (typeof appTransaction === 'string') {
+      const parsed = parseAppTransactionPayload(appTransaction);
+      if (parsed) {
+        return parsed;
+      }
+      throw new Error('Unable to parse app transaction payload');
+    }
+    if (typeof appTransaction === 'object' && appTransaction !== null) {
+      return appTransaction;
+    }
+    return null;
+  } catch (error) {
+    console.error('Failed to get app transaction:', error);
+    throw error;
+  }
+};
+export const subscriptionStatusIOS = async sku => {
+  if (Platform.OS !== 'ios') {
+    throw new Error('subscriptionStatusIOS is only available on iOS');
+  }
+  try {
+    const statuses = await IAP.instance.subscriptionStatusIOS(sku);
+    if (!Array.isArray(statuses)) return [];
+    return statuses.filter(status => status != null).map(convertNitroSubscriptionStatusToSubscriptionStatusIOS);
+  } catch (error) {
+    console.error('[subscriptionStatusIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
+  }
+};
+export const currentEntitlementIOS = async sku => {
+  if (Platform.OS !== 'ios') {
+    return null;
+  }
+  try {
+    const nitroPurchase = await IAP.instance.currentEntitlementIOS(sku);
+    if (nitroPurchase) {
+      const converted = convertNitroPurchaseToPurchase(nitroPurchase);
+      return converted.platform === 'ios' ? converted : null;
+    }
+    return null;
+  } catch (error) {
+    console.error('[currentEntitlementIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
+  }
+};
+export const latestTransactionIOS = async sku => {
+  if (Platform.OS !== 'ios') {
+    return null;
+  }
+  try {
+    const nitroPurchase = await IAP.instance.latestTransactionIOS(sku);
+    if (nitroPurchase) {
+      const converted = convertNitroPurchaseToPurchase(nitroPurchase);
+      return converted.platform === 'ios' ? converted : null;
+    }
+    return null;
+  } catch (error) {
+    console.error('[latestTransactionIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
+  }
+};
+export const getPendingTransactionsIOS = async () => {
+  if (Platform.OS !== 'ios') {
+    return [];
+  }
+  try {
+    const nitroPurchases = await IAP.instance.getPendingTransactionsIOS();
+    return nitroPurchases.map(convertNitroPurchaseToPurchase).filter(purchase => purchase.platform === 'ios');
+  } catch (error) {
+    console.error('[getPendingTransactionsIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
+  }
+};
+export const showManageSubscriptionsIOS = async () => {
+  if (Platform.OS !== 'ios') {
+    return [];
+  }
+  try {
+    const nitroPurchases = await IAP.instance.showManageSubscriptionsIOS();
+    return nitroPurchases.map(convertNitroPurchaseToPurchase).filter(purchase => purchase.platform === 'ios');
+  } catch (error) {
+    console.error('[showManageSubscriptionsIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
+  }
+};
+export const isEligibleForIntroOfferIOS = async groupID => {
+  if (Platform.OS !== 'ios') {
+    return false;
+  }
+  try {
+    return await IAP.instance.isEligibleForIntroOfferIOS(groupID);
+  } catch (error) {
+    console.error('[isEligibleForIntroOfferIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
+  }
+};
+export const getReceiptDataIOS = async () => {
+  if (Platform.OS !== 'ios') {
+    throw new Error('getReceiptDataIOS is only available on iOS');
+  }
+  try {
+    return await IAP.instance.getReceiptDataIOS();
+  } catch (error) {
+    console.error('[getReceiptDataIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
+  }
+};
+export const isTransactionVerifiedIOS = async sku => {
+  if (Platform.OS !== 'ios') {
+    return false;
+  }
+  try {
+    return await IAP.instance.isTransactionVerifiedIOS(sku);
+  } catch (error) {
+    console.error('[isTransactionVerifiedIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
+  }
+};
+export const getTransactionJwsIOS = async sku => {
+  if (Platform.OS !== 'ios') {
+    return null;
+  }
+  try {
+    return await IAP.instance.getTransactionJwsIOS(sku);
+  } catch (error) {
+    console.error('[getTransactionJwsIOS] Failed:', error);
+    const errorJson = parseErrorStringToJsonObj(error);
+    throw new Error(errorJson.message);
+  }
+};
+
+// ------------------------------
+// Mutation API
+// ------------------------------
+
 /**
  * Initialize connection to the store
  */
@@ -114,7 +494,6 @@ export const initConnection = async () => {
  */
 export const endConnection = async () => {
   try {
-    // If never initialized, treat as ended
     if (!iapRef) return true;
     return await IAP.instance.endConnection();
   } catch (error) {
@@ -122,215 +501,106 @@ export const endConnection = async () => {
     throw error;
   }
 };
-
-/**
- * Fetch products from the store
- * @param params - Product request configuration
- * @param params.skus - Array of product SKUs to fetch
- * @param params.type - Optional filter: 'in-app' (default) for products, 'subs' for subscriptions, or 'all' for both.
- * @returns Promise<Product[]> - Array of products from the store
- *
- * @example
- * ```typescript
- * // Regular products
- * const products = await fetchProducts({ skus: ['product1', 'product2'] });
- *
- * // Subscriptions
- * const subscriptions = await fetchProducts({ skus: ['sub1', 'sub2'], type: 'subs' });
- * ```
- */
-export const fetchProducts = async ({
-  skus,
-  type = 'in-app'
-}) => {
+export const restorePurchases = async () => {
   try {
-    if (!skus || skus.length === 0) {
-      throw new Error('No SKUs provided');
-    }
-    const normalizedType = normalizeProductQueryType(type);
-    if (normalizedType === 'all') {
-      const [inappNitro, subsNitro] = await Promise.all([IAP.instance.fetchProducts(skus, 'inapp'), IAP.instance.fetchProducts(skus, 'subs')]);
-      const allNitro = [...inappNitro, ...subsNitro];
-      const validAll = allNitro.filter(validateNitroProduct);
-      if (validAll.length !== allNitro.length) {
-        console.warn(`[fetchProducts] Some products failed validation: ${allNitro.length - validAll.length} invalid`);
-      }
-      return validAll.map(convertNitroProductToProduct);
-    }
-    const nitroProducts = await IAP.instance.fetchProducts(skus, toNitroProductType(normalizedType));
-
-    // Validate and convert NitroProducts to TypeScript Products
-    const validProducts = nitroProducts.filter(validateNitroProduct);
-    if (validProducts.length !== nitroProducts.length) {
-      console.warn(`[fetchProducts] Some products failed validation: ${nitroProducts.length - validProducts.length} invalid`);
+    if (Platform.OS === 'ios') {
+      await syncIOS();
     }
-    const typedProducts = validProducts.map(convertNitroProductToProduct);
-    return typedProducts;
+    await getAvailablePurchases({
+      alsoPublishToEventListenerIOS: false,
+      onlyIncludeActiveItemsIOS: true
+    });
   } catch (error) {
-    console.error('[fetchProducts] Failed:', error);
+    console.error('Failed to restore purchases:', error);
     throw error;
   }
 };
 
-/**
- * Request a purchase for products or subscriptions
- * @param params - Purchase request configuration
- * @param params.request - Platform-specific purchase parameters
- * @param params.type - Type of purchase: 'in-app' for products (default) or 'subs' for subscriptions
- *
- * @example
- * ```typescript
- * // Product purchase
- * await requestPurchase({
- *   request: {
- *     ios: { sku: productId },
- *     android: { skus: [productId] }
- *   },
- *   type: 'in-app'
- * });
- *
- * // Subscription purchase
- * await requestPurchase({
- *   request: {
- *     ios: { sku: subscriptionId },
- *     android: {
- *       skus: [subscriptionId],
- *       subscriptionOffers: [{ sku: subscriptionId, offerToken: 'token' }]
- *     }
- *   },
- *   type: 'subs'
- * });
- * ```
- */
 /**
  * Request a purchase for products or subscriptions
  * ⚠️ Important: This is an event-based operation, not promise-based.
  * Listen for events through purchaseUpdatedListener or purchaseErrorListener.
- * @param params - Purchase request configuration
- * @param params.request - Platform-specific request parameters
- * @param params.type - Type of purchase (defaults to in-app)
  */
-export const requestPurchase = async params => {
+export const requestPurchase = async request => {
   try {
-    const normalizedType = normalizeProductQueryType(params.type);
+    const {
+      request: platformRequest,
+      type
+    } = request;
+    const normalizedType = normalizeProductQueryType(type ?? 'in-app');
     const isSubs = isSubscriptionQuery(normalizedType);
-    const request = params.request;
-    if (!request) {
+    const perPlatformRequest = platformRequest;
+    if (!perPlatformRequest) {
       throw new Error('Missing purchase request configuration');
     }
-
-    // Validate platform-specific requests
     if (Platform.OS === 'ios') {
-      const iosRequest = request.ios;
+      const iosRequest = perPlatformRequest.ios;
       if (!iosRequest?.sku) {
         throw new Error('Invalid request for iOS. The `sku` property is required.');
       }
     } else if (Platform.OS === 'android') {
-      const androidRequest = request.android;
+      const androidRequest = perPlatformRequest.android;
       if (!androidRequest?.skus?.length) {
         throw new Error('Invalid request for Android. The `skus` property is required and must be a non-empty array.');
       }
     } else {
       throw new Error('Unsupported platform');
     }
-
-    // Transform the request for the unified interface
     const unifiedRequest = {};
-    if (Platform.OS === 'ios' && request.ios) {
-      if (isSubs) {
-        const iosReq = request.ios;
-        const autoFinishSubs = iosReq.andDangerouslyFinishTransactionAutomatically == null;
-        unifiedRequest.ios = {
-          ...iosReq,
-          ...(autoFinishSubs ? {
-            andDangerouslyFinishTransactionAutomatically: true
-          } : {})
-        };
-      } else {
-        unifiedRequest.ios = request.ios;
+    if (Platform.OS === 'ios' && perPlatformRequest.ios) {
+      const iosRequest = isSubs ? perPlatformRequest.ios : perPlatformRequest.ios;
+      const iosPayload = {
+        sku: iosRequest.sku
+      };
+      const explicitAutoFinish = iosRequest.andDangerouslyFinishTransactionAutomatically ?? undefined;
+      const autoFinish = explicitAutoFinish !== undefined ? explicitAutoFinish : isSubs ? true : undefined;
+      if (autoFinish !== undefined) {
+        iosPayload.andDangerouslyFinishTransactionAutomatically = autoFinish;
       }
-    }
-    if (Platform.OS === 'android' && request.android) {
-      if (isSubs) {
-        const subsRequest = request.android;
-        unifiedRequest.android = {
-          ...subsRequest,
-          subscriptionOffers: subsRequest.subscriptionOffers || []
-        };
-      } else {
-        unifiedRequest.android = request.android;
+      if (iosRequest.appAccountToken) {
+        iosPayload.appAccountToken = iosRequest.appAccountToken;
       }
+      if (typeof iosRequest.quantity === 'number') {
+        iosPayload.quantity = iosRequest.quantity;
+      }
+      const offerRecord = toDiscountOfferRecordIOS(iosRequest.withOffer);
+      if (offerRecord) {
+        iosPayload.withOffer = offerRecord;
+      }
+      unifiedRequest.ios = iosPayload;
     }
-
-    // Call unified method - returns void, listen for events instead
-    return await IAP.instance.requestPurchase(unifiedRequest);
-  } catch (error) {
-    console.error('Failed to request purchase:', error);
-    throw error;
-  }
-};
-
-/**
- * Get available purchases (purchased items not yet consumed/finished)
- * @param params - Options for getting available purchases
- * @param params.alsoPublishToEventListener - Whether to also publish to event listener
- * @param params.onlyIncludeActiveItems - Whether to only include active items
- *
- * @example
- * ```typescript
- * const purchases = await getAvailablePurchases({
- *   onlyIncludeActiveItemsIOS: true
- * });
- * ```
- */
-export const getAvailablePurchases = async ({
-  alsoPublishToEventListenerIOS = false,
-  onlyIncludeActiveItemsIOS = true
-} = {}) => {
-  try {
-    // Create unified options
-    const options = {};
-    if (Platform.OS === 'ios') {
-      // Provide both new and deprecated keys for compatibility
-      options.ios = {
-        alsoPublishToEventListenerIOS,
-        onlyIncludeActiveItemsIOS,
-        alsoPublishToEventListener: alsoPublishToEventListenerIOS,
-        onlyIncludeActiveItems: onlyIncludeActiveItemsIOS
+    if (Platform.OS === 'android' && perPlatformRequest.android) {
+      const androidRequest = isSubs ? perPlatformRequest.android : perPlatformRequest.android;
+      const androidPayload = {
+        skus: androidRequest.skus
       };
-    } else if (Platform.OS === 'android') {
-      // For Android, we need to call twice for inapp and subs
-      const inappNitroPurchases = await IAP.instance.getAvailablePurchases({
-        android: {
-          type: 'inapp'
+      if (androidRequest.obfuscatedAccountIdAndroid) {
+        androidPayload.obfuscatedAccountIdAndroid = androidRequest.obfuscatedAccountIdAndroid;
+      }
+      if (androidRequest.obfuscatedProfileIdAndroid) {
+        androidPayload.obfuscatedProfileIdAndroid = androidRequest.obfuscatedProfileIdAndroid;
+      }
+      if (androidRequest.isOfferPersonalized != null) {
+        androidPayload.isOfferPersonalized = androidRequest.isOfferPersonalized;
+      }
+      if (isSubs) {
+        const subsRequest = androidRequest;
+        if (subsRequest.purchaseTokenAndroid) {
+          androidPayload.purchaseTokenAndroid = subsRequest.purchaseTokenAndroid;
         }
-      });
-      const subsNitroPurchases = await IAP.instance.getAvailablePurchases({
-        android: {
-          type: 'subs'
+        if (subsRequest.replacementModeAndroid != null) {
+          androidPayload.replacementModeAndroid = subsRequest.replacementModeAndroid;
         }
-      });
-
-      // Validate and convert both sets of purchases
-      const allNitroPurchases = [...inappNitroPurchases, ...subsNitroPurchases];
-      const validPurchases = allNitroPurchases.filter(validateNitroPurchase);
-      if (validPurchases.length !== allNitroPurchases.length) {
-        console.warn(`[getAvailablePurchases] Some Android purchases failed validation: ${allNitroPurchases.length - validPurchases.length} invalid`);
+        androidPayload.subscriptionOffers = (subsRequest.subscriptionOffers ?? []).filter(offer => offer != null).map(offer => ({
+          sku: offer.sku,
+          offerToken: offer.offerToken
+        }));
       }
-      return validPurchases.map(convertNitroPurchaseToPurchase);
-    } else {
-      throw new Error('Unsupported platform');
+      unifiedRequest.android = androidPayload;
     }
-    const nitroPurchases = await IAP.instance.getAvailablePurchases(options);
-
-    // Validate and convert NitroPurchases to TypeScript Purchases
-    const validPurchases = nitroPurchases.filter(validateNitroPurchase);
-    if (validPurchases.length !== nitroPurchases.length) {
-      console.warn(`[getAvailablePurchases] Some purchases failed validation: ${nitroPurchases.length - validPurchases.length} invalid`);
-    }
-    return validPurchases.map(convertNitroPurchaseToPurchase);
+    return await IAP.instance.requestPurchase(unifiedRequest);
   } catch (error) {
-    console.error('Failed to get available purchases:', error);
+    console.error('Failed to request purchase:', error);
     throw error;
   }
 };
@@ -340,6 +610,7 @@ export const getAvailablePurchases = async ({
  * @param params - Transaction finish parameters
  * @param params.purchase - The purchase to finish
  * @param params.isConsumable - Whether this is a consumable product (Android only)
+ * @returns Promise<void> - Resolves when the transaction is successfully finished
  *
  * @example
  * ```typescript
@@ -349,41 +620,42 @@ export const getAvailablePurchases = async ({
  * });
  * ```
  */
-export const finishTransaction = async ({
-  purchase,
-  isConsumable = false
-}) => {
+export const finishTransaction = async args => {
+  const {
+    purchase,
+    isConsumable
+  } = args;
   try {
-    // Create unified params
-    const params = {};
+    let params;
     if (Platform.OS === 'ios') {
       if (!purchase.id) {
         throw new Error('purchase.id required to finish iOS transaction');
       }
-      params.ios = {
-        transactionId: purchase.id
+      params = {
+        ios: {
+          transactionId: purchase.id
+        }
       };
     } else if (Platform.OS === 'android') {
-      const androidPurchase = purchase;
-      const token = androidPurchase.purchaseToken;
+      const token = purchase.purchaseToken ?? undefined;
       if (!token) {
         throw new Error('purchaseToken required to finish Android transaction');
       }
-      params.android = {
-        purchaseToken: token,
-        isConsumable
+      params = {
+        android: {
+          purchaseToken: token,
+          isConsumable: isConsumable ?? false
+        }
       };
     } else {
       throw new Error('Unsupported platform');
     }
     const result = await IAP.instance.finishTransaction(params);
-
-    // Handle variant return type
-    if (typeof result === 'boolean') {
-      return result;
+    const success = getSuccessFromPurchaseVariant(result, 'finishTransaction');
+    if (!success) {
+      throw new Error('Failed to finish transaction');
     }
-    // It's a PurchaseResult
-    return result;
+    return;
   } catch (error) {
     // If iOS transaction has already been auto-finished natively, treat as success
     if (Platform.OS === 'ios') {
@@ -392,7 +664,7 @@ export const finishTransaction = async ({
       const code = (err?.code || '').toString();
       if (msg.includes('Transaction not found') || code === 'E_ITEM_UNAVAILABLE') {
         // Consider already finished
-        return true;
+        return;
       }
     }
     console.error('Failed to finish transaction:', error);
@@ -403,6 +675,7 @@ export const finishTransaction = async ({
 /**
  * Acknowledge a purchase (Android only)
  * @param purchaseToken - The purchase token to acknowledge
+ * @returns Promise<boolean> - Indicates whether the acknowledgement succeeded
  *
  * @example
  * ```typescript
@@ -420,18 +693,7 @@ export const acknowledgePurchaseAndroid = async purchaseToken => {
         isConsumable: false
       }
     });
-
-    // Result is a variant, extract PurchaseResult
-    if (typeof result === 'boolean') {
-      // This shouldn't happen for Android, but handle it
-      return {
-        responseCode: 0,
-        code: '0',
-        message: 'Success',
-        purchaseToken
-      };
-    }
-    return result;
+    return getSuccessFromPurchaseVariant(result, 'acknowledgePurchaseAndroid');
   } catch (error) {
     console.error('Failed to acknowledge purchase Android:', error);
     throw error;
@@ -441,236 +703,29 @@ export const acknowledgePurchaseAndroid = async purchaseToken => {
 /**
  * Consume a purchase (Android only)
  * @param purchaseToken - The purchase token to consume
+ * @returns Promise<boolean> - Indicates whether the consumption succeeded
  *
  * @example
  * ```typescript
  * await consumePurchaseAndroid('purchase_token_here');
  * ```
  */
-export const consumePurchaseAndroid = async purchaseToken => {
-  try {
-    if (Platform.OS !== 'android') {
-      throw new Error('consumePurchaseAndroid is only available on Android');
-    }
-    const result = await IAP.instance.finishTransaction({
-      android: {
-        purchaseToken,
-        isConsumable: true
-      }
-    });
-
-    // Result is a variant, extract PurchaseResult
-    if (typeof result === 'boolean') {
-      // This shouldn't happen for Android, but handle it
-      return {
-        responseCode: 0,
-        code: '0',
-        message: 'Success',
-        purchaseToken
-      };
-    }
-    return result;
-  } catch (error) {
-    console.error('Failed to consume purchase Android:', error);
-    throw error;
-  }
-};
-
-// ============================================================================
-// EVENT LISTENERS
-// ============================================================================
-
-// Store wrapped listeners for proper removal
-const listenerMap = new WeakMap();
-
-/**
- * Purchase updated event listener
- * Fired when a purchase is successful or when a pending purchase is completed.
- *
- * @param listener - Function to call when a purchase is updated
- * @returns EventSubscription object with remove method
- *
- * @example
- * ```typescript
- * const subscription = purchaseUpdatedListener((purchase) => {
- *   console.log('Purchase successful:', purchase);
- *   // 1. Validate receipt with backend
- *   // 2. Deliver content to user
- *   // 3. Call finishTransaction to acknowledge
- * });
- *
- * // Later, clean up
- * subscription.remove();
- * ```
- */
-export const purchaseUpdatedListener = listener => {
-  // Wrap the listener to convert NitroPurchase to Purchase
-  const wrappedListener = nitroPurchase => {
-    if (validateNitroPurchase(nitroPurchase)) {
-      const convertedPurchase = convertNitroPurchaseToPurchase(nitroPurchase);
-      listener(convertedPurchase);
-    } else {
-      console.error('Invalid purchase data received from native:', nitroPurchase);
-    }
-  };
-
-  // Store the wrapped listener for removal
-  listenerMap.set(listener, wrappedListener);
-  let attached = false;
-  try {
-    IAP.instance.addPurchaseUpdatedListener(wrappedListener);
-    attached = true;
-  } catch (e) {
-    const msg = String(e ?? '');
-    if (msg.includes('Nitro runtime not installed')) {
-      console.warn('[purchaseUpdatedListener] Nitro not ready yet; listener inert until initConnection()');
-    } else {
-      throw e;
-    }
-  }
-  return {
-    remove: () => {
-      const wrapped = listenerMap.get(listener);
-      if (wrapped) {
-        if (attached) {
-          try {
-            IAP.instance.removePurchaseUpdatedListener(wrapped);
-          } catch {}
-        }
-        listenerMap.delete(listener);
-      }
-    }
-  };
-};
-
-/**
- * Purchase error event listener
- * Fired when a purchase fails or is cancelled by the user.
- *
- * @param listener - Function to call when a purchase error occurs
- * @returns EventSubscription object with remove method
- *
- * @example
- * ```typescript
- * const subscription = purchaseErrorListener((error) => {
- *   switch (error.code) {
- *     case 'E_USER_CANCELLED':
- *       // User cancelled - no action needed
- *       break;
- *     case 'E_ITEM_UNAVAILABLE':
- *       // Product not available
- *       break;
- *     case 'E_NETWORK_ERROR':
- *       // Retry with backoff
- *       break;
- *   }
- * });
- *
- * // Later, clean up
- * subscription.remove();
- * ```
- */
-export const purchaseErrorListener = listener => {
-  const wrapped = error => {
-    listener({
-      code: normalizeErrorCodeFromNative(error.code),
-      message: error.message,
-      productId: undefined
-    });
-  };
-  listenerMap.set(listener, wrapped);
-  let attached = false;
-  try {
-    IAP.instance.addPurchaseErrorListener(wrapped);
-    attached = true;
-  } catch (e) {
-    const msg = String(e ?? '');
-    if (msg.includes('Nitro runtime not installed')) {
-      console.warn('[purchaseErrorListener] Nitro not ready yet; listener inert until initConnection()');
-    } else {
-      throw e;
-    }
-  }
-  return {
-    remove: () => {
-      const stored = listenerMap.get(listener);
-      if (stored) {
-        if (attached) {
-          try {
-            IAP.instance.removePurchaseErrorListener(stored);
-          } catch {}
-        }
-        listenerMap.delete(listener);
-      }
-    }
-  };
-};
-
-/**
- * iOS-only listener for App Store promoted product events.
- * Fired when a user clicks on a promoted in-app purchase in the App Store.
- *
- * @param listener - Callback function that receives the promoted product
- * @returns EventSubscription object with remove method
- *
- * @example
- * ```typescript
- * const subscription = promotedProductListenerIOS((product) => {
- *   console.log('Promoted product:', product);
- *   // Trigger purchase flow for the promoted product
- * });
- *
- * // Later, clean up
- * subscription.remove();
- * ```
- *
- * @platform iOS
- */
-export const promotedProductListenerIOS = listener => {
-  if (Platform.OS !== 'ios') {
-    console.warn('promotedProductListenerIOS: This listener is only available on iOS');
-    return {
-      remove: () => {}
-    };
-  }
-
-  // Wrap the listener to convert NitroProduct to Product
-  const wrappedListener = nitroProduct => {
-    if (validateNitroProduct(nitroProduct)) {
-      const convertedProduct = convertNitroProductToProduct(nitroProduct);
-      listener(convertedProduct);
-    } else {
-      console.error('Invalid promoted product data received from native:', nitroProduct);
-    }
-  };
-
-  // Store the wrapped listener for removal
-  listenerMap.set(listener, wrappedListener);
-  let attached = false;
+export const consumePurchaseAndroid = async purchaseToken => {
   try {
-    IAP.instance.addPromotedProductListenerIOS(wrappedListener);
-    attached = true;
-  } catch (e) {
-    const msg = String(e ?? '');
-    if (msg.includes('Nitro runtime not installed')) {
-      console.warn('[promotedProductListenerIOS] Nitro not ready yet; listener inert until initConnection()');
-    } else {
-      throw e;
+    if (Platform.OS !== 'android') {
+      throw new Error('consumePurchaseAndroid is only available on Android');
     }
-  }
-  return {
-    remove: () => {
-      const wrapped = listenerMap.get(listener);
-      if (wrapped) {
-        if (attached) {
-          try {
-            IAP.instance.removePromotedProductListenerIOS(wrapped);
-          } catch {}
-        }
-        listenerMap.delete(listener);
+    const result = await IAP.instance.finishTransaction({
+      android: {
+        purchaseToken,
+        isConsumable: true
       }
-    }
-  };
+    });
+    return getSuccessFromPurchaseVariant(result, 'consumePurchaseAndroid');
+  } catch (error) {
+    console.error('Failed to consume purchase Android:', error);
+    throw error;
+  }
 };
 
 // ============================================================================
@@ -683,11 +738,19 @@ export const promotedProductListenerIOS = listener => {
  * @param androidOptions - Android-specific validation options (required for Android)
  * @returns Promise<ReceiptValidationResultIOS | ReceiptValidationResultAndroid> - Platform-specific receipt validation result
  */
-export const validateReceipt = async (sku, androidOptions) => {
+export const validateReceipt = async options => {
+  const {
+    sku,
+    androidOptions
+  } = options;
   try {
+    const normalizedAndroidOptions = androidOptions != null ? {
+      ...androidOptions,
+      isSub: androidOptions.isSub == null ? undefined : Boolean(androidOptions.isSub)
+    } : undefined;
     const params = {
       sku,
-      androidOptions
+      androidOptions: normalizedAndroidOptions
     };
     const nitroResult = await IAP.instance.validateReceipt(params);
 
@@ -743,7 +806,8 @@ export const syncIOS = async () => {
     throw new Error('syncIOS is only available on iOS');
   }
   try {
-    return await IAP.instance.syncIOS();
+    const result = await IAP.instance.syncIOS();
+    return Boolean(result);
   } catch (error) {
     console.error('[syncIOS] Failed:', error);
     const errorJson = parseErrorStringToJsonObj(error);
@@ -751,31 +815,9 @@ export const syncIOS = async () => {
   }
 };
 
-/**
- * Request the promoted product from the App Store (iOS only)
- * @returns Promise<Product | null> - The promoted product or null if none available
- * @platform iOS
- */
-export const requestPromotedProductIOS = async () => {
-  if (Platform.OS !== 'ios') {
-    return null;
-  }
-  try {
-    const nitroProduct = await IAP.instance.requestPromotedProductIOS();
-    if (nitroProduct) {
-      return convertNitroProductToProduct(nitroProduct);
-    }
-    return null;
-  } catch (error) {
-    console.error('[getPromotedProductIOS] Failed:', error);
-    const errorJson = parseErrorStringToJsonObj(error);
-    throw new Error(errorJson.message);
-  }
-};
-
 /**
  * Present the code redemption sheet for offer codes (iOS only)
- * @returns Promise<boolean> - True if the sheet was presented successfully
+ * @returns Promise<boolean> - Indicates whether the redemption sheet was presented
  * @platform iOS
  */
 export const presentCodeRedemptionSheetIOS = async () => {
@@ -783,7 +825,8 @@ export const presentCodeRedemptionSheetIOS = async () => {
     return false;
   }
   try {
-    return await IAP.instance.presentCodeRedemptionSheetIOS();
+    const result = await IAP.instance.presentCodeRedemptionSheetIOS();
+    return Boolean(result);
   } catch (error) {
     console.error('[presentCodeRedemptionSheetIOS] Failed:', error);
     const errorJson = parseErrorStringToJsonObj(error);
@@ -793,33 +836,43 @@ export const presentCodeRedemptionSheetIOS = async () => {
 
 /**
  * Buy promoted product on iOS
- * @returns Promise<void>
+ * @returns Promise<boolean> - true when the request triggers successfully
  * @platform iOS
  */
-export const buyPromotedProductIOS = async () => {
+export const requestPurchaseOnPromotedProductIOS = async () => {
   if (Platform.OS !== 'ios') {
-    throw new Error('buyPromotedProductIOS is only available on iOS');
+    throw new Error('requestPurchaseOnPromotedProductIOS is only available on iOS');
   }
   try {
     await IAP.instance.buyPromotedProductIOS();
+    const pending = await IAP.instance.getPendingTransactionsIOS();
+    const latest = pending.find(purchase => purchase != null);
+    if (!latest) {
+      throw new Error('No promoted purchase available after request');
+    }
+    const converted = convertNitroPurchaseToPurchase(latest);
+    if (converted.platform !== 'ios') {
+      throw new Error('Promoted purchase result not available for iOS');
+    }
+    return true;
   } catch (error) {
-    console.error('[buyPromotedProductIOS] Failed:', error);
-    const errorJson = parseErrorStringToJsonObj(error);
-    throw new Error(errorJson.message);
+    console.error('[requestPurchaseOnPromotedProductIOS] Failed:', error);
+    throw error;
   }
 };
 
 /**
  * Clear unfinished transactions on iOS
- * @returns Promise<void>
+ * @returns Promise<boolean>
  * @platform iOS
  */
 export const clearTransactionIOS = async () => {
   if (Platform.OS !== 'ios') {
-    return;
+    return false;
   }
   try {
     await IAP.instance.clearTransactionIOS();
+    return true;
   } catch (error) {
     console.error('[clearTransactionIOS] Failed:', error);
     const errorJson = parseErrorStringToJsonObj(error);
@@ -835,10 +888,11 @@ export const clearTransactionIOS = async () => {
  */
 export const beginRefundRequestIOS = async sku => {
   if (Platform.OS !== 'ios') {
-    return null;
+    throw new Error('beginRefundRequestIOS is only available on iOS');
   }
   try {
-    return await IAP.instance.beginRefundRequestIOS(sku);
+    const status = await IAP.instance.beginRefundRequestIOS(sku);
+    return status ?? null;
   } catch (error) {
     console.error('[beginRefundRequestIOS] Failed:', error);
     const errorJson = parseErrorStringToJsonObj(error);
@@ -853,180 +907,51 @@ export const beginRefundRequestIOS = async sku => {
  * @throws Error when called on non-iOS platforms or when IAP is not initialized
  * @platform iOS
  */
-export const subscriptionStatusIOS = async sku => {
-  if (Platform.OS !== 'ios') {
-    throw new Error('subscriptionStatusIOS is only available on iOS');
-  }
-  try {
-    const statuses = await IAP.instance.subscriptionStatusIOS(sku);
-    if (!statuses || !Array.isArray(statuses)) return [];
-    return statuses.map(s => convertNitroSubscriptionStatusToSubscriptionStatusIOS(s));
-  } catch (error) {
-    console.error('[subscriptionStatusIOS] Failed:', error);
-    const errorJson = parseErrorStringToJsonObj(error);
-    throw new Error(errorJson.message);
-  }
-};
-
 /**
  * Get current entitlement for a product (iOS only)
  * @param sku - The product SKU
  * @returns Promise<Purchase | null> - Current entitlement or null
  * @platform iOS
  */
-export const currentEntitlementIOS = async sku => {
-  if (Platform.OS !== 'ios') {
-    return null;
-  }
-  try {
-    const nitroPurchase = await IAP.instance.currentEntitlementIOS(sku);
-    if (nitroPurchase) {
-      return convertNitroPurchaseToPurchase(nitroPurchase);
-    }
-    return null;
-  } catch (error) {
-    console.error('[currentEntitlementIOS] Failed:', error);
-    const errorJson = parseErrorStringToJsonObj(error);
-    throw new Error(errorJson.message);
-  }
-};
-
 /**
  * Get latest transaction for a product (iOS only)
  * @param sku - The product SKU
  * @returns Promise<Purchase | null> - Latest transaction or null
  * @platform iOS
  */
-export const latestTransactionIOS = async sku => {
-  if (Platform.OS !== 'ios') {
-    return null;
-  }
-  try {
-    const nitroPurchase = await IAP.instance.latestTransactionIOS(sku);
-    if (nitroPurchase) {
-      return convertNitroPurchaseToPurchase(nitroPurchase);
-    }
-    return null;
-  } catch (error) {
-    console.error('[latestTransactionIOS] Failed:', error);
-    const errorJson = parseErrorStringToJsonObj(error);
-    throw new Error(errorJson.message);
-  }
-};
-
 /**
  * Get pending transactions (iOS only)
  * @returns Promise<Purchase[]> - Array of pending transactions
  * @platform iOS
  */
-export const getPendingTransactionsIOS = async () => {
-  if (Platform.OS !== 'ios') {
-    return [];
-  }
-  try {
-    const nitroPurchases = await IAP.instance.getPendingTransactionsIOS();
-    return nitroPurchases.map(convertNitroPurchaseToPurchase);
-  } catch (error) {
-    console.error('[getPendingTransactionsIOS] Failed:', error);
-    const errorJson = parseErrorStringToJsonObj(error);
-    throw new Error(errorJson.message);
-  }
-};
-
 /**
  * Show manage subscriptions screen (iOS only)
  * @returns Promise<Purchase[]> - Subscriptions where auto-renewal status changed
  * @platform iOS
  */
-export const showManageSubscriptionsIOS = async () => {
-  if (Platform.OS !== 'ios') {
-    return [];
-  }
-  try {
-    const nitroPurchases = await IAP.instance.showManageSubscriptionsIOS();
-    return nitroPurchases.map(convertNitroPurchaseToPurchase);
-  } catch (error) {
-    console.error('[showManageSubscriptionsIOS] Failed:', error);
-    const errorJson = parseErrorStringToJsonObj(error);
-    throw new Error(errorJson.message);
-  }
-};
-
 /**
  * Check if user is eligible for intro offer (iOS only)
  * @param groupID - The subscription group ID
  * @returns Promise<boolean> - Eligibility status
  * @platform iOS
  */
-export const isEligibleForIntroOfferIOS = async groupID => {
-  if (Platform.OS !== 'ios') {
-    return false;
-  }
-  try {
-    return await IAP.instance.isEligibleForIntroOfferIOS(groupID);
-  } catch (error) {
-    console.error('[isEligibleForIntroOfferIOS] Failed:', error);
-    const errorJson = parseErrorStringToJsonObj(error);
-    throw new Error(errorJson.message);
-  }
-};
-
 /**
  * Get receipt data (iOS only)
  * @returns Promise<string> - Base64 encoded receipt data
  * @platform iOS
  */
-export const getReceiptDataIOS = async () => {
-  if (Platform.OS !== 'ios') {
-    throw new Error('getReceiptDataIOS is only available on iOS');
-  }
-  try {
-    return await IAP.instance.getReceiptDataIOS();
-  } catch (error) {
-    console.error('[getReceiptDataIOS] Failed:', error);
-    const errorJson = parseErrorStringToJsonObj(error);
-    throw new Error(errorJson.message);
-  }
-};
-
 /**
  * Check if transaction is verified (iOS only)
  * @param sku - The product SKU
  * @returns Promise<boolean> - Verification status
  * @platform iOS
  */
-export const isTransactionVerifiedIOS = async sku => {
-  if (Platform.OS !== 'ios') {
-    return false;
-  }
-  try {
-    return await IAP.instance.isTransactionVerifiedIOS(sku);
-  } catch (error) {
-    console.error('[isTransactionVerifiedIOS] Failed:', error);
-    const errorJson = parseErrorStringToJsonObj(error);
-    throw new Error(errorJson.message);
-  }
-};
-
 /**
  * Get transaction JWS representation (iOS only)
  * @param sku - The product SKU
  * @returns Promise<string | null> - JWS representation or null
  * @platform iOS
  */
-export const getTransactionJwsIOS = async sku => {
-  if (Platform.OS !== 'ios') {
-    return null;
-  }
-  try {
-    return await IAP.instance.getTransactionJwsIOS(sku);
-  } catch (error) {
-    console.error('[getTransactionJwsIOS] Failed:', error);
-    const errorJson = parseErrorStringToJsonObj(error);
-    throw new Error(errorJson.message);
-  }
-};
-
 /**
  * Get the storefront identifier for the user's App Store account (iOS only)
  * @returns Promise<string> - The storefront identifier (e.g., 'USA' for United States)
@@ -1038,61 +963,26 @@ export const getTransactionJwsIOS = async sku => {
  * console.log('User storefront:', storefront); // e.g., 'USA', 'GBR', 'KOR'
  * ```
  */
-export const getStorefrontIOS = async () => {
-  if (Platform.OS !== 'ios') {
-    throw new Error('getStorefrontIOS is only available on iOS');
-  }
-  try {
-    // Call the native method to get storefront
-    const storefront = await IAP.instance.getStorefrontIOS();
-    return storefront;
-  } catch (error) {
-    console.error('Failed to get storefront:', error);
-    throw error;
-  }
-};
-
-/**
- * Gets the storefront country code from the underlying native store.
- * Returns a two-letter country code such as 'US', 'KR', or empty string on failure.
- *
- * Cross-platform alias aligning with expo-iap.
- */
-export const getStorefront = async () => {
-  if (Platform.OS === 'android') {
-    try {
-      // Optional since older builds may not have the method
-      const result = await IAP.instance.getStorefrontAndroid?.();
-      return result ?? '';
-    } catch {
-      return '';
-    }
-  }
-  return getStorefrontIOS();
-};
-
 /**
  * Deeplinks to native interface that allows users to manage their subscriptions
  * Cross-platform alias aligning with expo-iap
  */
-export const deepLinkToSubscriptions = async (options = {}) => {
+export const deepLinkToSubscriptions = async options => {
+  const resolvedOptions = options ?? undefined;
   if (Platform.OS === 'android') {
     await IAP.instance.deepLinkToSubscriptionsAndroid?.({
-      skuAndroid: options.skuAndroid,
-      packageNameAndroid: options.packageNameAndroid
+      skuAndroid: resolvedOptions?.skuAndroid ?? undefined,
+      packageNameAndroid: resolvedOptions?.packageNameAndroid ?? undefined
     });
     return;
   }
-  // iOS: Use manage subscriptions sheet (ignore returned purchases for deeplink parity)
   if (Platform.OS === 'ios') {
     try {
       await IAP.instance.showManageSubscriptionsIOS();
-    } catch {
-      // no-op
+    } catch (error) {
+      console.warn('[deepLinkToSubscriptions] Failed on iOS:', error);
     }
-    return;
   }
-  return;
 };
 
 /**
@@ -1114,20 +1004,6 @@ export const deepLinkToSubscriptions = async (options = {}) => {
  * }
  * ```
  */
-export const getAppTransactionIOS = async () => {
-  if (Platform.OS !== 'ios') {
-    throw new Error('getAppTransactionIOS is only available on iOS');
-  }
-  try {
-    // Call the native method to get app transaction
-    const appTransaction = await IAP.instance.getAppTransactionIOS();
-    return appTransaction;
-  } catch (error) {
-    console.error('Failed to get app transaction:', error);
-    throw error;
-  }
-};
-
 // Export subscription helpers
 export { getActiveSubscriptions, hasActiveSubscriptions } from "./helpers/subscription.js";
 
@@ -1144,4 +1020,57 @@ export const acknowledgePurchase = acknowledgePurchaseAndroid;
  * @deprecated Use consumePurchaseAndroid instead
  */
 export const consumePurchase = consumePurchaseAndroid;
+
+// ============================================================================
+// Internal Helpers
+// ============================================================================
+
+const toDiscountOfferRecordIOS = offer => {
+  if (!offer) {
+    return undefined;
+  }
+  return {
+    identifier: offer.identifier,
+    keyIdentifier: offer.keyIdentifier,
+    nonce: offer.nonce,
+    signature: offer.signature,
+    timestamp: String(offer.timestamp)
+  };
+};
+const toNitroProductType = type => {
+  if (type === 'subs') {
+    return 'subs';
+  }
+  if (type === 'all') {
+    return 'all';
+  }
+  if (type === 'inapp') {
+    console.warn(LEGACY_INAPP_WARNING);
+    return 'inapp';
+  }
+  return 'inapp';
+};
+const isSubscriptionQuery = type => type === 'subs';
+const normalizeProductQueryType = type => {
+  if (type === 'all' || type === 'subs' || type === 'in-app') {
+    return type;
+  }
+  if (typeof type === 'string') {
+    const normalized = type.trim().toLowerCase().replace(/_/g, '-');
+    if (normalized === 'all') {
+      return 'all';
+    }
+    if (normalized === 'subs') {
+      return 'subs';
+    }
+    if (normalized === 'inapp') {
+      console.warn(LEGACY_INAPP_WARNING);
+      return 'in-app';
+    }
+    if (normalized === 'in-app') {
+      return 'in-app';
+    }
+  }
+  return 'in-app';
+};
 //# sourceMappingURL=index.js.map