Implementation Notes: Adding StoreKit 2 In-App Purchases to a Rork iOS App

// PurchaseManager.swift
import StoreKit
import SwiftUI
 
@MainActor
final class PurchaseManager: ObservableObject {
    @Published private(set) var products: [Product] = []
    @Published private(set) var purchasedProductIDs: Set<String> = []
    
    private var updates: Task<Void, Never>? = nil
    
    static let productIDs = [
        "com.dolice.wallpaper.nonconsumable.premium",
        "com.dolice.wallpaper.consumable.pack_50",
    ]
    
    init() {
        // Listen for Transaction updates in background
        updates = observeTransactionUpdates()
    }
    
    deinit {
        updates?.cancel()
    }
    
    // Fetch product info from App Store
    func loadProducts() async throws {
        products = try await Product.products(for: Self.productIDs)
    }
    
    // Execute purchase
    func purchase(_ product: Product) async throws -> Bool {
        let result = try await product.purchase()
        switch result {
        case .success(let verification):
            let transaction = try checkVerified(verification)
            await transaction.finish()
            await updatePurchasedProducts()
            return true
        case .userCancelled:
            return false
        case .pending:
            return false
        @unknown default:
            return false
        }
    }
    
    // JWS-based verification handled by StoreKit 2
    func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
        switch result {
        case .verified(let safe):
            return safe
        case .unverified:
            throw PurchaseError.verificationFailed
        }
    }
    
    // Refresh current entitlements
    func updatePurchasedProducts() async {
        var purchased: Set<String> = []
        for await result in Transaction.currentEntitlements {
            guard case .verified(let transaction) = result else { continue }
            if transaction.revocationDate == nil {
                purchased.insert(transaction.productID)
            }
        }
        purchasedProductIDs = purchased
    }
    
    // Continuous Transaction observation
    private func observeTransactionUpdates() -> Task<Void, Never> {
        Task { [weak self] in
            for await result in Transaction.updates {
                guard let self else { return }
                guard case .verified(let transaction) = result else { continue }
                await transaction.finish()
                await self.updatePurchasedProducts()
            }
        }
    }
    
    enum PurchaseError: Error {
        case verificationFailed
    }
}

// Rork placeholder
struct PremiumGateView: View {
    var body: some View {
        VStack {
            Text("Unlock Premium features")
            Button("Purchase") {
                // TODO: implement purchase
            }
        }
    }
}

// PremiumGateView.swift (implemented)
struct PremiumGateView: View {
    @EnvironmentObject var purchaseManager: PurchaseManager
    @State private var isProcessing = false
    @State private var errorMessage: String?
    
    var body: some View {
        VStack(spacing: 24) {
            Image(systemName: "crown.fill")
                .font(.system(size: 60))
                .foregroundStyle(.yellow)
            
            Text("Unlock Premium")
                .font(.title2.bold())
            
            VStack(alignment: .leading, spacing: 8) {
                Label("All wallpapers unlocked", systemImage: "checkmark.circle.fill")
                Label("No ads", systemImage: "checkmark.circle.fill")
                Label("Early access to weekly drops", systemImage: "checkmark.circle.fill")
            }
            .foregroundStyle(.secondary)
            
            if let product = purchaseManager.products.first(where: {
                $0.id == "com.dolice.wallpaper.nonconsumable.premium"
            }) {
                Button {
                    Task { await buy(product) }
                } label: {
                    Text("Purchase for \(product.displayPrice)")
                        .frame(maxWidth: .infinity)
                        .padding()
                }
                .buttonStyle(.borderedProminent)
                .disabled(isProcessing)
            } else {
                ProgressView("Loading products...")
            }
            
            Button("Restore purchases") {
                Task { await restore() }
            }
            .font(.footnote)
            
            if let errorMessage {
                Text(errorMessage).foregroundStyle(.red).font(.footnote)
            }
        }
        .padding()
        .task {
            try? await purchaseManager.loadProducts()
            await purchaseManager.updatePurchasedProducts()
        }
    }
    
    func buy(_ product: Product) async {
        isProcessing = true
        defer { isProcessing = false }
        do {
            _ = try await purchaseManager.purchase(product)
        } catch {
            errorMessage = "Purchase failed: \(error.localizedDescription)"
        }
    }
    
    func restore() async {
        do {
            try await AppStore.sync()
            await purchaseManager.updatePurchasedProducts()
        } catch {
            errorMessage = "Restore failed: \(error.localizedDescription)"
        }
    }
}

// MyAppApp.swift
@main
struct MyAppApp: App {
    @StateObject private var purchaseManager = PurchaseManager()
    
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(purchaseManager)
        }
    }
}

// WallpaperDetailView.swift
struct WallpaperDetailView: View {
    let wallpaper: WallpaperItem
    @EnvironmentObject var purchaseManager: PurchaseManager
    @State private var showPaywall = false
    
    var isPremiumUnlocked: Bool {
        purchaseManager.purchasedProductIDs.contains(
            "com.dolice.wallpaper.nonconsumable.premium"
        )
    }
    
    var body: some View {
        VStack {
            if wallpaper.isPremium && !isPremiumUnlocked {
                // blur preview + paywall button
                Image(wallpaper.imageName)
                    .resizable()
                    .blur(radius: 20)
                Button("Unlock with Premium") {
                    showPaywall = true
                }
                .buttonStyle(.borderedProminent)
            } else {
                Image(wallpaper.imageName)
                    .resizable()
                Button("Save wallpaper") {
                    saveWallpaper()
                }
            }
        }
        .sheet(isPresented: $showPaywall) {
            PremiumGateView()
        }
    }
}