Storekit

import StoreKit
enum ProductID {    static let premium = "com.myapp.premium"    static let gems100 = "com.myapp.gems100"    static let monthlyPlan = "com.myapp.monthly"    static let yearlyPlan = "com.myapp.yearly"    static let all: [String] = [premium, gems100, monthlyPlan, yearlyPlan]}
let products = try await Product.products(for: ProductID.all)for product in products {    print("\(product.displayName): \(product.displayPrice)")}

@Environment(\.purchase) private var purchase
func purchaseProduct(_ product: Product) async throws {    let result = try await purchase(product, options: [        .appAccountToken(userAccountToken)    ])    switch result {    case .success(let verification):        let transaction = try checkVerified(verification)        await deliverContent(for: transaction)        await transaction.finish()    case .userCancelled:        break    case .pending:        // Ask to Buy or deferred approval: show pending UI, no unlock yet.        showPendingApprovalMessage()    @unknown default:        break    }}
func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {    switch result {    case .verified(let value): return value    case .unverified(_, let error): throw error    }}

@mainstruct MyApp: App {    private let transactionListener: Task<Void, Never>
    init() {        transactionListener = Self.listenForTransactions()    }
    var body: some Scene {        WindowGroup { ContentView() }    }
    static func listenForTransactions() -> Task<Void, Never> {        Task(priority: .background) {            for await result in Transaction.updates {                guard case .verified(let transaction) = result else { continue }                await StoreManager.shared.updateEntitlements()                await transaction.finish()            }        }    }}

@Observable@MainActorclass StoreManager {    static let shared = StoreManager()    var purchasedProductIDs: Set<String> = []    var isPremium: Bool { purchasedProductIDs.contains(ProductID.premium) }
    func updateEntitlements() async {        var purchased = Set<String>()        for await result in Transaction.currentEntitlements {            if case .verified(let transaction) = result,               transaction.revocationDate == nil {                if transaction.productType == .nonRenewing,                   transaction.expirationDate.map({ $0 <= .now }) ?? true {                    continue                }                purchased.insert(transaction.productID)            }        }        purchasedProductIDs = purchased    }}

struct PremiumGatedView: View {    @State private var state: EntitlementTaskState<VerificationResult<Transaction>?> = .loading
    var body: some View {        Group {            switch state {            case .loading: ProgressView()            case .failure: PaywallView()            case .success(.some(.verified(let transaction))) where transaction.revocationDate == nil:                PremiumContentView()            case .success:                PaywallView()            }        }        .currentEntitlementTask(for: ProductID.premium) { state in            self.state = state        }    }}

SubscriptionStoreView(groupID: "YOUR_GROUP_ID")    .subscriptionStoreControlStyle(.prominentPicker)    .subscriptionStoreButtonLabel(.multiline)    .storeButton(.visible, for: .restorePurchases)    .storeButton(.visible, for: .redeemCode)    .subscriptionStorePolicyDestination(url: termsURL, for: .termsOfService)    .subscriptionStorePolicyDestination(url: privacyURL, for: .privacyPolicy)    .onInAppPurchaseCompletion { product, result in        if case .success(.success(.verified(let transaction))) = result {            await deliverContent(for: transaction)            await transaction.finish()        }    }

StoreView(ids: [ProductID.gems100, ProductID.premium], prefersPromotionalIcon: true)    .productViewStyle(.large)    .storeButton(.visible, for: .restorePurchases)    .onInAppPurchaseCompletion { product, result in        if case .success(.success(.verified(let transaction))) = result {            await deliverContent(for: transaction)            await transaction.finish()        }    }

ProductView(id: ProductID.premium) { iconPhase in    switch iconPhase {    case .success(let image): image.resizable().scaledToFit()    case .loading: ProgressView()    default: Image(systemName: "star.fill")    }}.productViewStyle(.large)

func checkSubscriptionActive(groupID: String) async throws -> Bool {    let statuses = try await Product.SubscriptionInfo.status(for: groupID)    for status in statuses {        guard case .verified = status.renewalInfo,              case .verified = status.transaction else { continue }        if status.state == .subscribed || status.state == .inGracePeriod {            return true        }    }    return false}

func restorePurchases() async throws {    try await AppStore.sync()    await StoreManager.shared.updateEntitlements()}

func verifyAppPurchase() async {    do {        let result = try await AppTransaction.shared        switch result {        case .verified(let appTransaction):            let originalVersion = appTransaction.originalAppVersion            let purchaseDate = appTransaction.originalPurchaseDate            // Migration logic for users who paid before subscription model        case .unverified:            // Potentially tampered -- restrict features as appropriate            break        }    } catch { /* Could not retrieve app transaction */ }}

// App account token for server-side reconciliationtry await product.purchase(options: [.appAccountToken(UUID())])
// Consumable quantitytry await product.purchase(options: [.quantity(5)])
// Simulate Ask to Buy in sandboxtry await product.purchase(options: [.simulatesAskToBuyInSandbox(true)])

.onInAppPurchaseStart { product in    await analytics.trackPurchaseStarted(product.id)}.onInAppPurchaseCompletion { product, result in    if case .success(.success(.verified(let transaction))) = result {        await deliverContent(for: transaction)        await transaction.finish()    }}.inAppPurchaseOptions { product in    [.appAccountToken(userAccountToken)]}

// WRONG: No listener -- misses renewals, refunds, Ask to Buy approvals@main struct MyApp: App {    var body: some Scene { WindowGroup { ContentView() } }}// CORRECT: Start listener in App init (see Transaction.updates section above)

// WRONG: Never finished -- reappears in unfinished queue foreverlet transaction = try checkVerified(verification)unlockFeature(transaction.productID)
// CORRECT: Deliver durably, then finish. If delivery fails, do not finish yet.let transaction = try checkVerified(verification)try await recordDelivery(transaction)await transaction.finish()

// WRONG: Using unverified transaction -- security risklet transaction = verification.unsafePayloadValue
// CORRECT: Verify before usinglet transaction = try checkVerified(verification)

// AVOID: Original In-App Purchase APIslet request = SKProductsRequest(productIdentifiers: ["com.app.premium"])SKPaymentQueue.default().add(payment)
// PREFERRED: StoreKit 2let products = try await Product.products(for: ["com.app.premium"])let result = try await product.purchase()

// WRONG: Grants access to refunded purchasesif case .verified(let transaction) = result {    purchased.insert(transaction.productID)}
// CORRECT: Skip revoked transactionsif case .verified(let transaction) = result, transaction.revocationDate == nil {    purchased.insert(transaction.productID)}

// WRONG: Wrong for other currencies and regionsText("Buy Premium for $4.99")
// CORRECT: Localized price from ProductText("Buy \(product.displayName) for \(product.displayPrice)")

// WRONG: Silently drops pending Ask to Buydefault: break
// CORRECT: Explain approval is pending; unlock only after Transaction.updatescase .pending:    showPendingApprovalMessage()

// WRONG: Check once, never updatefunc appDidFinish() { Task { await updateEntitlements() } }
// CORRECT: Re-check on Transaction.updates AND on foreground return// Transaction.updates listener handles mid-session changes.// Also use .task { await storeManager.updateEntitlements() } on content views.

// WRONG: No restore option -- App Store rejection riskSubscriptionStoreView(groupID: "group_id")
// CORRECTSubscriptionStoreView(groupID: "group_id")    .storeButton(.visible, for: .restorePurchases)

// WRONG: No terms or privacy policySubscriptionStoreView(groupID: "group_id")
// CORRECTSubscriptionStoreView(groupID: "group_id")    .subscriptionStorePolicyDestination(url: termsURL, for: .termsOfService)    .subscriptionStorePolicyDestination(url: privacyURL, for: .privacyPolicy)