func purchase(_ product: Product) async throws -> Transaction? {
...
}

 do {
    if try await store.purchase(product) != nil {
      ...
    }
 } catch {
    print("Error :\(error)")
 }

@MainActor
    func requestProducts() async {
        do {
            let storeProducts = try await Product.products(for: productInfo.keys)
            
            var newDrinks: [Product] = []
            var newVip: [Product] = []
            
            for product in storeProducts {
                switch product.type {
                case .consumable:
                    newDrinks.append(product)
                case .nonConsumable:
                    newVip.append(product)
                default:
                    //Ignore this product.
                    print("Unknown product")
                }
            }
            
            drinks = sortByPrice(newDrinks)
            vipTicket = sortByPrice(newVip)
            
        } catch {
            print("Failed product request: \(error)")
        }
    }

func purchase(_ product: Product) async throws -> Transaction? {
        
        let result = try await product.purchase()
        
        switch result {
        case .success(let verification):
            let transaction = try checkVerified(verification)
            
            await updatePurchasedIDs(transaction)
            
            // 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
        }
    }

func listenForTransactions() -> Task<Void, Error> {
        return Task.detached {
            
            for await result in Transaction.updates {
                do {
                    let transcation = try self.checkVerified(result)
                    
                    await self.updatePurchasedIDs(transcation)
                    
                    await transcation.finish()
                } catch {
                    print("Transcation failed verification")
                }
            }
            
        }
    }

.onAppear {
    Task {
       isPurchased = (try? await store.isPurchased(drink.id)) ?? false
    }
}

func isPurchased(_ productId: String) async throws -> Bool {
        
    guard let result = await Transaction.latest(for: productId) else {
        return false
    }
        
    let transcation = try checkVerified(result)
        
    return transcation.revocationDate == nil && !transcation.isUpgraded
}

private(set) var products: [SKProduct] = []
private var productRequest: SKProductsRequest!
    
// MARK: - get production
func getProductInfo() {
    let productIdentifiers = Set(["Item01", "Item02", "Item03"])

    productRequest = SKProductsRequest(productIdentifiers: productIdentifiers)
    productRequest.delegate = self

    productRequest.start()
}

----------

extension IAPManager: SKProductsRequestDelegate {
    func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse) {
        if !response.products.isEmpty {
            self.products = response.products
        }
    
        if response.invalidProductIdentifiers.count > 0 {
            print("invalidProductionIdentifiers: \(response.invalidProductIdentifiers)")
        }
    }
}

func buyProduct(product: SKProduct) {
    let payment = SKPayment(product: product)
    SKPaymentQueue.default().add(payment)
}

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
  ...
  SKPaymentQueue.default().add(IAPManager.shared)
  ...
  return true
}

extension IAPManager: SKPaymentTransactionObserver {
    func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
        for transaction in transactions {
            switch transaction.transactionState {
            
            case .purchasing:
                print("[IAPurchase] purchasing")
            case .purchased:
                print("[IAPurchase] purchased")
                SKPaymentQueue.default().finishTransaction(transaction)
            case .failed:
                print("[IAPurchase] failed error \(String(describing: transaction.error?.localizedDescription))")
                SKPaymentQueue.default().finishTransaction(transaction)
            case .restored:
                print("[IAPurchase] restored")
                SKPaymentQueue.default().finishTransaction(transaction)
            case .deferred:
                print("[IAPurchase] deferred")
            @unknown default:
                print("[IAPurchase] Unexpected transaction state \(transaction.transactionState)")
            }
        }
    }
}

func fetchReceipt() -> String {
        if let appStoreReceiptURL = Bundle.main.appStoreReceiptURL,
           FileManager.default.fileExists(atPath: appStoreReceiptURL.path) {
            do {
                let receiptData = try Data(contentsOf: appStoreReceiptURL, options: .alwaysMapped)
                let receiptString = receiptData.base64EncodedString(options: [])
                
                return receiptString
            } catch {
                print("[IAPurchase] Couldn't read receipt data with error: " + error.localizedDescription)
                return ""
            }
        }
        return ""
}