StoreKit 2: что это такое и как он повлияет на Apphud?

func loadProducts() async {  
  do {  
    let ids = [ "com.apphud.weekly", "com.apphud.weekly2", "com.apphud.monthly"]  
    self.products = try await Product.request(with: Set(ids))  
  } catch {  
    print("error while loading products: \(error.localizedDescription)")  
  }  
}

public static var consumable: Product.ProductType  
public static var nonConsumable: Product.ProductType  
public static var nonRenewable: Product.ProductType  
public static var autoRenewable: Product.ProductType

/// A localized string representation of `price`.  
public let displayPrice: String

/// Whether the user is eligible to have an introductory offer applied to their purchase.  
public var isEligibleForIntroOffer: Bool { get async }  
public static func isEligibleForIntroOffer(for groupID: String) async -> Bool

/// A UUID that associates the purchase with an account in your system.  
public static func appAccountToken(_ token: UUID) -> Product.PurchaseOption

let result = try await product.purchase()

public enum PurchaseResult {  
  /// The purchase succeeded with a `Transaction`.  
  case success(VerificationResult<Transaction>)  
​  
  /// The user cancelled the purchase.  
  case userCancelled  
​  
  /// The purchase is pending some user action.  
  ///  
  /// These purchases may succeed in the future, and the resulting `Transaction` will be  
  /// delivered via `Transaction.listener`  
  case pending  
}

func purchase(_ product: Product) async throws -> Transaction? {  
        //Begin a purchase.  
        let result = try await product.purchase()  
​  
        switch result {  
        case .success(let verification):  
            let transaction = try checkVerified(verification)  
​  
            //Deliver content to the user.  
            await updatePurchasedIdentifiers(transaction)  
​  
            //Always finish a transaction.  
            await transaction.finish()  
​  
            return transaction  
        case .userCancelled, .pending:  
            return nil  
        default:  
            return nil  
        }  
    }  
​  
func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {  
        //Check if the transaction passes StoreKit verification.  
        switch result {  
        case .unverified:  
            //StoreKit has parsed the JWS but failed verification. Don't deliver content to the user.  
            throw StoreError.failedVerification  
        case .verified(let safe):  
            //If the transaction is verified, unwrap and return it.  
            return safe  
        }  
}

override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {  
  let product = products[indexPath.row]  
    async {  
      await self.purchaseAsync(product: product)  
    }  
}

// Start a transaction listener as close to app launch as possible so you don't miss any transactions.  
​  
taskHandle = listenForTransactions()  
​  
func listenForTransactions() -> Task.Handle<Void, Error> {  
        return detach {  
            //Iterate through any transactions which didn't come from a direct call to `purchase()`.  
            for await result in Transaction.listener {  
                do {  
                    let transaction = try self.checkVerified(result)  
​  
                    //Deliver content to the user.  
                    await self.updatePurchasedIdentifiers(transaction)  
​  
                    //Always finish a transaction.  
                    await transaction.finish()  
                } catch {  
                    //StoreKit has a receipt it can read but it failed verification. Don't deliver content to the user.  
                    print("Transaction failed verification")  
                }  
            }  
        }  
    }

/// A sequence of every transaction for this user and app.  
public static var all: Transaction.TransactionSequence { get }  
​  
/// Returns all transactions for products the user is currently entitled to  
///  
/// i.e. all currently-subscribed transactions, and all purchased (and not refunded) non-consumables  
public static var currentEntitlements: Transaction.TransactionSequence { get }  
​  
/// Get the transaction that entitles the user to a product.  
/// - Parameter productID: Identifies the product to check entitlements for.  
/// - Returns: A transaction if the user is entitled to the product, or `nil` if they are not.  
public static func currentEntitlement(for productID: String) async -> VerificationResult<Transaction>?  
​  
/// The user's latest transaction for a product.  
/// - Parameter productID: Identifies the product to check entitlements for.  
/// - Returns: A verified transaction, or `nil` if the user has never purchased this product.  
public static func latest(for productID: String) async -> VerificationResult<Transaction>?