How to Implement In-App Purchase in SwiftUI

import SwiftUI
import StoreKit

// MARK: - Errors
enum StoreError: LocalizedError {
    case failedVerification
    var errorDescription: String? { "Purchase verification failed." }
}

// MARK: - Store Manager
@Observable
final class StoreManager {
    var products: [Product] = []
    var purchasedIDs: Set<String> = []
    var isLoading = false

    private let productIDs: [String]
    private var transactionListener: Task<Void, Error>?

    init(productIDs: [String]) {
        self.productIDs = productIDs
        transactionListener = listenForTransactions()
        Task { await refresh() }
    }

    deinit { transactionListener?.cancel() }

    // Load products from App Store Connect (or .storekit config in debug)
    func refresh() async {
        isLoading = true
        defer { isLoading = false }
        products = (try? await Product.products(for: productIDs)) ?? []
        await updateEntitlements()
    }

    // Initiate a purchase and finish the transaction on success
    func purchase(_ product: Product) async throws {
        let result = try await product.purchase()
        switch result {
        case .success(let verification):
            let transaction = try checkVerified(verification)
            await updateEntitlements()
            await transaction.finish()
        case .userCancelled:
            break         // user tapped cancel — not an error
        case .pending:
            break         // Ask to Buy / deferred — handle via updates listener
        @unknown default:
            break
        }
    }

    // Restore: iterate current entitlements (no network call needed in SK2)
    func restorePurchases() async {
        await updateEntitlements()
    }

    func isPurchased(_ productID: String) -> Bool {
        purchasedIDs.contains(productID)
    }

    // MARK: Private helpers

    private func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
        switch result {
        case .unverified: throw StoreError.failedVerification
        case .verified(let value): return value
        }
    }

    @MainActor
    private func updateEntitlements() async {
        var ids: Set<String> = []
        for await result in Transaction.currentEntitlements {
            guard let transaction = try? result.payloadValue,
                  transaction.revocationDate == nil else { continue }
            ids.insert(transaction.productID)
        }
        purchasedIDs = ids
    }

    private func listenForTransactions() -> Task<Void, Error> {
        Task.detached(priority: .background) {
            for await result in Transaction.updates {
                if let transaction = try? result.payloadValue {
                    await self.updateEntitlements()
                    await transaction.finish()
                }
            }
        }
    }
}

// MARK: - Custom Paywall View
struct PaywallView: View {
    @State private var store = StoreManager(productIDs: [
        "com.yourapp.premium_lifetime",
        "com.yourapp.pro_monthly"
    ])
    @State private var error: StoreError?
    @State private var showError = false

    var body: some View {
        NavigationStack {
            ScrollView {
                VStack(spacing: 24) {
                    // Header
                    VStack(spacing: 8) {
                        Image(systemName: "star.circle.fill")
                            .font(.system(size: 64))
                            .foregroundStyle(.yellow)
                            .accessibilityHidden(true)
                        Text("Unlock Premium")
                            .font(.largeTitle.bold())
                        Text("Everything you need to ship faster.")
                            .foregroundStyle(.secondary)
                    }
                    .padding(.top, 32)

                    // Product list
                    if store.isLoading {
                        ProgressView()
                    } else {
                        VStack(spacing: 12) {
                            ForEach(store.products) { product in
                                ProductRowView(
                                    product: product,
                                    isPurchased: store.isPurchased(product.id)
                                ) {
                                    await buy(product)
                                }
                            }
                        }
                        .padding(.horizontal)
                    }

                    // Restore link
                    Button("Restore Purchases") {
                        Task { await store.restorePurchases() }
                    }
                    .font(.footnote)
                    .foregroundStyle(.secondary)
                }
            }
            .navigationTitle("Upgrade")
            .navigationBarTitleDisplayMode(.inline)
            .alert("Purchase failed", isPresented: $showError) {
                Button("OK", role: .cancel) {}
            } message: {
                Text(error?.localizedDescription ?? "Unknown error.")
            }
        }
        .task { await store.refresh() }
    }

    private func buy(_ product: Product) async {
        do {
            try await store.purchase(product)
        } catch let e as StoreError {
            error = e; showError = true
        } catch {}
    }
}

// MARK: - Product Row
struct ProductRowView: View {
    let product: Product
    let isPurchased: Bool
    let action: () async -> Void

    var body: some View {
        HStack {
            VStack(alignment: .leading, spacing: 4) {
                Text(product.displayName)
                    .font(.headline)
                Text(product.description)
                    .font(.caption)
                    .foregroundStyle(.secondary)
            }
            Spacer()
            if isPurchased {
                Image(systemName: "checkmark.seal.fill")
                    .foregroundStyle(.green)
                    .accessibilityLabel("Purchased")
            } else {
                Button {
                    Task { await action() }
                } label: {
                    Text(product.displayPrice)
                        .font(.subheadline.bold())
                        .padding(.horizontal, 14)
                        .padding(.vertical, 8)
                        .background(.blue)
                        .foregroundStyle(.white)
                        .clipShape(Capsule())
                }
                .accessibilityLabel("Buy \(product.displayName) for \(product.displayPrice)")
            }
        }
        .padding()
        .background(.regularMaterial, in: RoundedRectangle(cornerRadius: 14))
    }
}

#Preview {
    PaywallView()
}