A free trial that survives reinstalling: Keychain and StoreKit 2

import Foundation
import Security

enum Keychain {
    static var service: String { Bundle.main.bundleIdentifier ?? "app" }

    static func data(_ key: String) -> Data? {
        var query = base(key)
        query[kSecReturnData as String] = true
        query[kSecMatchLimit as String] = kSecMatchLimitOne
        var out: AnyObject?
        return SecItemCopyMatching(query as CFDictionary, &out) == errSecSuccess ? out as? Data : nil
    }

    static func set(_ data: Data?, for key: String) {
        let query = base(key)
        SecItemDelete(query as CFDictionary)
        guard let data else { return }
        var add = query
        add[kSecValueData as String] = data
        add[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlock
        SecItemAdd(add as CFDictionary, nil)
    }

    static func int(_ key: String) -> Int {
        data(key).flatMap { Int(String(decoding: $0, as: UTF8.self)) } ?? 0
    }

    static func set(_ value: Int, for key: String) {
        set(Data(String(value).utf8), for: key)
    }

    private static func base(_ key: String) -> [String: Any] {
        [kSecClass as String: kSecClassGenericPassword,
         kSecAttrService as String: service,
         kSecAttrAccount as String: key]
    }
}

import Observation

@MainActor
@Observable
final class FreeQuota {
    let key: String
    let free: Int
    private(set) var used: Int

    init(_ name: String, free: Int) {
        key = "quota.\(name)"
        self.free = free
        used = Keychain.int("quota.\(name)")
    }

    var remaining: Int { max(0, free - used) }
    var isAvailable: Bool { remaining > 0 }

    func use(_ count: Int = 1) {
        used += count
        Keychain.set(used, for: key)
    }

    #if DEBUG
    func reset() { used = 0; Keychain.set(nil, for: key) }
    #endif
}

import StoreKit
import Observation

@MainActor
@Observable
final class Unlock {
    let productID: String
    private(set) var product: Product?
    private(set) var isUnlocked: Bool
    private(set) var isPurchasing = false
    var price: String? { product?.displayPrice }

    @ObservationIgnored private var updates: Task<Void, Never>?
    private var cacheKey: String { "unlock.\(productID)" }

    init(_ productID: String) {
        self.productID = productID
        // Last known state first, so the UI doesn't flash a paywall at launch.
        isUnlocked = UserDefaults.standard.bool(forKey: "unlock.\(productID)")
        updates = Task { [weak self] in
            for await result in Transaction.updates {
                if case .verified(let t) = result { await t.finish() }
                await self?.refresh()
            }
        }
        Task { await load() }
    }

    func load() async {
        product = try? await Product.products(for: [productID]).first
        await refresh()
    }

    /// Re-reads entitlements: catches refunds, Family Sharing and Ask to Buy approvals.
    func refresh() async {
        var owned = false
        for await result in Transaction.currentEntitlements {
            if case .verified(let t) = result, t.productID == productID, t.revocationDate == nil {
                owned = true
            }
        }
        set(owned)
    }

    @discardableResult
    func buy() async throws -> Bool {
        if product == nil { await load() }
        guard let product else { throw StoreError.productNotFound }
        isPurchasing = true
        defer { isPurchasing = false }
        switch try await product.purchase() {
        case .success(.verified(let t)):
            await t.finish()
            set(true)
            return true
        case .success(.unverified):
            throw StoreError.unverified
        default:
            return false          // .pending (Ask to Buy) or .userCancelled
        }
    }

    func restore() async throws {
        try await AppStore.sync()
        await refresh()
        if !isUnlocked { throw StoreError.nothingToRestore }
    }

    private func set(_ owned: Bool) {
        isUnlocked = owned
        UserDefaults.standard.set(owned, forKey: cacheKey)
    }
}

enum StoreError: LocalizedError {
    case productNotFound, unverified, nothingToRestore
    var errorDescription: String? {
        switch self {
        case .productNotFound: "The App Store can't be reached right now."
        case .unverified: "The purchase couldn't be verified."
        case .nothingToRestore: "No purchase was found for this Apple Account."
        }
    }
}

import SwiftUI

struct LetterView: View {
    @State private var quota = FreeQuota("letters", free: 2)
    @State private var unlock = Unlock("com.example.app.unlimited")
    @State private var showPaywall = false
    let text: String

    var body: some View {
        VStack(spacing: 16) {
            Button("Read this letter") { Task { await analyze() } }
            if !unlock.isUnlocked {
                Text("\(quota.remaining) free letters left").font(.footnote)
            }
        }
        .sheet(isPresented: $showPaywall) {
            VStack(spacing: 12) {
                Button("Unlock for \(unlock.price ?? "…")") {
                    Task { if (try? await unlock.buy()) == true { showPaywall = false } }
                }
                .disabled(unlock.isPurchasing)
                Button("Restore purchase") {
                    Task { try? await unlock.restore(); if unlock.isUnlocked { showPaywall = false } }
                }
            }
            .padding()
        }
    }

    private func analyze() async {
        guard unlock.isUnlocked || quota.isAvailable else { showPaywall = true; return }
        do {
            try await runModel(on: text)     // your feature
            if !unlock.isUnlocked { quota.use() }
        } catch {
            // failed work does not count against the trial
        }
    }

    private func runModel(on text: String) async throws { /* ... */ }
}