How to Implement Storefront Gating in 4 Weeks

import StoreKit

/// Returns true only when the user is on the US App Store.
/// Never cache - storefront can change when users travel or use a VPN.
func isUSStorefront() async -> Bool {
    guard let storefront = await Storefront.current else {
        return false
    }
    return storefront.countryCode == "USA"
}

// Usage: call this right before presenting your paywall
Task {
    let showWebCheckout = await isUSStorefront()
    await MainActor.run {
        paywallView.configure(webCheckoutEnabled: showWebCheckout)
    }
}

import { NativeModules, Platform } from 'react-native';
import { useState, useEffect } from 'react';

// Native module bridges StoreKit 2's Storefront.current on iOS
const { StorefrontModule } = NativeModules;

async function getStorefrontCountry(): Promise<string | null> {
  if (Platform.OS !== 'ios') return null;
  try {
    const countryCode = await StorefrontModule.getCountryCode();
    return countryCode ?? null;
  } catch {
    return null;
  }
}

export function useIsUSStorefront() {
  const [isUS, setIsUS] = useState(false);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    getStorefrontCountry().then((code) => {
      setIsUS(code === 'USA');
      setLoading(false);
    });
  }, []);

  return { isUS, loading };
}

import remoteConfig from '@react-native-firebase/remote-config';

async function initRemoteConfig() {
  // Safe defaults - web checkout is OFF until explicitly enabled
  await remoteConfig().setDefaults({
    enable_web_checkout: false,
    web_checkout_url: '',
  });

  await remoteConfig().setConfigSettings({
    minimumFetchIntervalMillis: 3600000, // 1 hour TTL
  });

  await remoteConfig().fetchAndActivate();
}

export function getWebCheckoutConfig() {
  return {
    enabled: remoteConfig().getValue('enable_web_checkout').asBoolean(),
    url: remoteConfig().getValue('web_checkout_url').asString(),
  };
}

import { useEffect, useState } from 'react';
import { useIsUSStorefront } from './useStorefront';
import { getWebCheckoutConfig } from './remoteConfig';

export function PaywallGate() {
  const { isUS, loading } = useIsUSStorefront();
  const [config, setConfig] = useState({ enabled: false, url: '' });

  useEffect(() => {
    setConfig(getWebCheckoutConfig());
  }, []);

  if (loading) return <LoadingSpinner />;

  // Both conditions required: US storefront AND remote kill switch on
  const showWebCheckout = isUS && config.enabled && config.url.length > 0;

  if (showWebCheckout) {
    return <WebCheckoutButton url={config.url} />;
  }

  return <IAPPaywall />;
}

import RevenueCat

// Intercept incoming Universal Links in SceneDelegate
func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
    guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
          let url = userActivity.webpageURL else { return }

    // Only handle RevenueCat redemption URLs
    guard url.absoluteString.contains("revenuecat") else { return }

    Task {
        do {
            let result = try await Purchases.shared.redeemWebPurchase(url)
            await MainActor.run {
                // Notify the rest of the app that entitlements changed
                NotificationCenter.default.post(
                    name: .purchaseRedeemed,
                    object: result.customerInfo
                )
            }
        } catch {
            await MainActor.run {
                // Surface this - do NOT silently swallow the error
                showRedemptionError(error)
            }
        }
    }
}

import { Linking } from 'react-native';
import Purchases from 'react-native-purchases';
import { useEffect } from 'react';

async function handleRedemptionUrl(url: string) {
  if (!url.includes('revenuecat')) return;
  try {
    const { customerInfo } = await Purchases.redeemWebPurchase(url);
    // customerInfo now has updated entitlements - refresh your UI
    console.log('Active entitlements:', customerInfo.activeSubscriptions);
  } catch (err) {
    console.error('Redemption failed:', err);
    // Surface this - don't let it fail silently
  }
}

export function useRedemptionLink() {
  useEffect(() => {
    // Case 1: app is open when link is tapped
    const sub = Linking.addEventListener('url', ({ url }) => {
      handleRedemptionUrl(url);
    });

    // Case 2: cold start - app was killed when link was tapped
    Linking.getInitialURL().then((url) => {
      if (url) handleRedemptionUrl(url);
    });

    return () => sub.remove();
  }, []);
}