React Native Billing

import { AppDNA } from '@appdna-ai/react-native-sdk';

await AppDNA.configure('adn_live_xxx', 'production', { billingProvider: 'storeKit2' });

import Purchases from 'react-native-purchases';

AppDNA.paywall.setDelegate({
  async onPaywallPurchaseFailed(paywallId, error, errorType, productId) {
    if (errorType !== 'providerNotAvailable' || !productId) return;
    const offerings = await Purchases.getOfferings();
    const pkg = offerings.current?.availablePackages.find((p: { product: { identifier: string } }) => p.product.identifier === productId);
    if (pkg) await Purchases.purchasePackage(pkg); // RevenueCat buys, finishes and reports via its webhook
    // then dismiss the paywall in your UI
  },
});

const billing = AppDNA.billing;

const products = await AppDNA.billing.getProducts(['premium_monthly']);

for (const product of products) {
  console.log(`${product.name}: ${product.displayPrice}`);
}

import type { AppDNAPurchaseErrorCode } from '@appdna-ai/react-native-sdk';

declare function showAwaitingApproval(): void;
declare function showRetry(): void;
declare function showPurchaseFailed(): void;

try {
  const transaction = await AppDNA.billing.purchase('premium_monthly', 'offer-xxx');
  // Resolved means PURCHASED. There is no status to check.
  console.log(`Purchased ${transaction.productId} (${transaction.transactionId})`);
} catch (error) {
  // A user cancellation, a pending (deferred / ask-to-buy) purchase, and a store failure all REJECT.
  // Branch on the CODE — never on the message, which is localized.
  const code = (error as { code?: AppDNAPurchaseErrorCode }).code;
  switch (code) {
    case 'userCancelled':
      break;                                   // the user tapped Cancel. Say nothing.
    case 'pending':
      showAwaitingApproval();                  // ask-to-buy / SCA. Entitlements arrive later, if approved.
      break;
    case 'networkError':
    case 'serverError':
      showRetry();
      break;
    default:
      showPurchaseFailed();
  }
}

const delegate: Pick<AppDNABillingDelegate, 'onPurchaseCompleted'> = {
  onPurchaseCompleted(productId, transaction) {
    const txnId = transaction.transactionId as string;
    const purchasedAt = new Date(Number(transaction.purchaseDate)); // epoch millis as a decimal string
    console.log(productId, txnId, purchasedAt);
  },
};

const restoredProductIds = await AppDNA.billing.restorePurchases();

for (const productId of restoredProductIds) {
  console.log(`Restored: ${productId}`);
}

// For the entitlement objects themselves (status, expiry, trial):
const entitlements = await AppDNA.billing.getEntitlements();

try {
  await AppDNA.billing.restorePurchases();
} catch (e) {
  const code = (e as { code?: string }).code;
  if (code === 'providerNotAvailable') {
    // restore with your billing provider instead
  } else {
    // show a retry
  }
}

const active = await AppDNA.billing.hasActiveSubscription();

if (active) {
  // Unlock premium features
}

const ents = await AppDNA.billing.getEntitlements();

for (const ent of ents) {
  console.log(`${ent.productId}: ${ent.status}, trial: ${ent.isTrial}`);
}

const unsubscribe = AppDNA.billing.onEntitlementsChanged((entitlements) => {
  console.log(`Entitlements changed: ${entitlements.length} active`);
  // Update UI to reflect new entitlement state
});

// Later, when you no longer need updates:
unsubscribe();

interface AppDNABillingDelegate {
  onPurchaseCompleted(productId: string, transaction: Record<string, unknown>): void;
  /** `error` is a message STRING, not an `Error` object. */
  onPurchaseFailed(productId: string, error: unknown): void;
  /** Each entry is an Entitlement map — not a product-ID string. */
  onEntitlementsChanged(entitlements: Record<string, unknown>[]): void;
  onRestoreCompleted(restoredProductIds: string[]): void;
  /** Android only — Play Billing is permanently unavailable on this device. */
  onBillingUnavailable(): void;
}

const billingHandler: AppDNABillingDelegate = {
  onPurchaseCompleted(productId, transaction) {
    console.log(`Purchased: ${productId}`);
    // Unlock premium features
  },

  onPurchaseFailed(productId, error) {
    // `error` is a message string delivered as `unknown` — there is no `.message`.
    console.log(`Purchase failed: ${productId} -- ${String(error)}`);
    // Show error message to user
  },

  onEntitlementsChanged(entitlements) {
    // Each entry is an entitlement MAP, not a product-ID string.
    console.log(`Entitlements: ${entitlements.map((e) => e.productId).join(', ')}`);
  },

  onBillingUnavailable() {
    // Android only: Play Services is missing/broken. Hide the purchase UI.
  },

  onRestoreCompleted(restoredProductIds) {
    console.log(`Restored ${restoredProductIds.length} products`);
  },
};

AppDNA.billing.setDelegate(billingHandler);

import React, { useEffect, useState } from 'react';
import { View, Text, FlatList, Pressable, Button, Alert } from 'react-native';
import { AppDNA, ProductInfo } from '@appdna-ai/react-native-sdk';

export function SubscriptionPage() {
  const [products, setProducts] = useState<ProductInfo[]>([]);
  const [isSubscribed, setIsSubscribed] = useState(false);

  useEffect(() => {
    loadProducts();
    checkSubscription();

    const unsubscribe = AppDNA.billing.onEntitlementsChanged((entitlements) => {
      setIsSubscribed(entitlements.some((e) => e.status === 'active'));
    });

    return unsubscribe;
  }, []);

  async function loadProducts() {
    const result = await AppDNA.billing.getProducts(['premium_monthly', 'premium_yearly']);
    setProducts(result);
  }

  async function checkSubscription() {
    const active = await AppDNA.billing.hasActiveSubscription();
    setIsSubscribed(active);
  }

  async function purchase(product: ProductInfo) {
    try {
      await AppDNA.billing.purchase(product.id, product.offerToken);
      // Resolved means purchased; a cancellation or store error rejects.
      Alert.alert('Purchase successful!');
    } catch {
      // User cancelled, or the store failed. Nothing to unlock.
    }
  }

  async function restore() {
    const restored = await AppDNA.billing.restorePurchases();
    Alert.alert(`Restored ${restored.length} purchases`);
  }

  return (
    <View style={{ flex: 1 }}>
      <View style={{ padding: 16, flexDirection: 'row', justifyContent: 'flex-end' }}>
        <Button title="Restore" onPress={restore} />
      </View>
      <FlatList
        data={products}
        keyExtractor={(item) => item.id}
        renderItem={({ item }) => (
          <Pressable
            onPress={() => purchase(item)}
            style={{ padding: 16, borderBottomWidth: 1, borderColor: '#eee' }}
          >
            <Text style={{ fontWeight: 'bold' }}>{item.name}</Text>
            <Text>{item.description}</Text>
            <Text>{item.displayPrice}</Text>
          </Pressable>
        )}
      />
    </View>
  );
}

await AppDNA.reportPayingUser('pro_monthly', 999, 'USD');