What's the connection between Zip and StoreKit? about zip HOT 5 OPEN

import Foundation
import StoreKit

public typealias bookId = String
public typealias BooksRequestCompleteHandler = (_ success: Bool, _ books:[SKProduct]?) -> ()

open class IAPHelper: NSObject {

    static let IAPHelperPurchaseNotification = "IAPHelperPurchaseNotification"

    var books: Set<bookId>
    fileprivate var purchasedBookIds:Set<bookId> = Set()
    var aRequest:SKProductsRequest?
    var booksRequestFinishedHandler: BooksRequestCompleteHandler?

    init(bookIds: Set<bookId>) {
        books = bookIds
        for id in bookIds {
            let purchased = UserDefaults.standard.bool(forKey: id)
            if purchased {
                purchasedBookIds.insert(id)
            } else {
            }
        }
        super.init()
        SKPaymentQueue.default().add(self)
    }
}

// MARK: StoreKit API
extension IAPHelper {

    public func requestProducts(_ completionHandler: @escaping BooksRequestCompleteHandler) {
        aRequest?.cancel()
        booksRequestFinishedHandler = completionHandler
        aRequest = SKProductsRequest(productIdentifiers: books)
        aRequest!.delegate = self
        aRequest!.start()
    }

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

    public func isProductPurchased(_ productIdentifier: bookId) -> Bool {
        return purchasedBookIds.contains(productIdentifier)
    }

    public class func canMakePayments() -> Bool {
        return SKPaymentQueue.canMakePayments()
    }

    public func restorePurchases() {
        SKPaymentQueue.default().restoreCompletedTransactions()
    }
}

// MARK: SKProductsRequestDelegate
extension IAPHelper: SKProductsRequestDelegate {
    public func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse) {
        let booksGet = response.products
        booksRequestFinishedHandler?(true, booksGet)
        clearRequestANdHandler()

    public func request(_ request: SKRequest, didFailWithError error: Error) {
        booksRequestFinishedHandler?(false, nil)
        clearRequestANdHandler()
    }

    public func clearRequestANdHandler() {
        aRequest = nil
        booksRequestFinishedHandler = nil
    }
}

// MARK: SKPaymentTransactionObserver
extension IAPHelper: SKPaymentTransactionObserver {

    public func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
        for transaction in transactions {
            switch (transaction.transactionState) {
            case .purchased:
                completeTransaction(transaction)
                break
            case .failed:
                failedTransaction(transaction)
                break
            case .restored:
                restoreTransaction(transaction)
                break
            case .deferred:
                break
            case .purchasing:
                break
            }
        }
    }

    fileprivate func completeTransaction(_ transaction: SKPaymentTransaction) {
        UserDefaults.standard.set(true, forKey: transaction.payment.productIdentifier)
        deliverPurchaseNotificatioForIdentifier(transaction.payment.productIdentifier)
        SKPaymentQueue.default().finishTransaction(transaction)
    }

    fileprivate func restoreTransaction(_ transaction: SKPaymentTransaction) {
        guard let productIdentifier = transaction.original?.payment.productIdentifier else { return }
        deliverPurchaseNotificatioForIdentifier(productIdentifier)
        SKPaymentQueue.default().finishTransaction(transaction)
    }

    fileprivate func failedTransaction(_ transaction: SKPaymentTransaction) {
        if transaction.error!._code != SKError.paymentCancelled.rawValue {
            print("Transaction Error: \(transaction.error?.localizedDescription)")
        }

        SKPaymentQueue.default().finishTransaction(transaction)
    }

    fileprivate func deliverPurchaseNotificatioForIdentifier(_ identifier: String?) {
        guard let identifier = identifier else { return }
        purchasedBookIds.insert(identifier)
        UserDefaults.standard.set(true, forKey: identifier)
        UserDefaults.standard.synchronize()
        NotificationCenter.default.post(name: Notification.Name(rawValue: IAPHelper.IAPHelperPurchaseNotification), object: identifier)
    }
}

/// get productIdentifiers
class PurchaseBooks {
    var bookListArray:[String] {
        didSet {
            self.bookIds = Set(bookListArray)
            self.store = IAPHelper(bookIds: self.bookIds)
        }
    }

    var bookIds:Set<bookId> = []
    var store:IAPHelper?
    init() {
        bookListArray = bookListData?.allKeys as! [String]
        bookListArray = []
        bookIds = Set(bookListArray)
        store = IAPHelper(bookIds: self.bookIds)
    }
}
var bookPurchase = PurchaseBooks()

func resetDefaultBookOffline() {
        let defaultZip = Bundle.main.path(forResource: "defaultResource", ofType: "zip")
        let booklistFile = "\(documentPath)/BookList.plist"
        let fileMgr = FileManager.default
        if fileMgr.fileExists(atPath: booklistFile) == false {
            do {
                try _ = Zip.unzipFile(URL(string: defaultZip!)!, destination: URL(string:documentPath)!, overwrite: false, password: nil, progress: {
                    (progress: Double) -> () in
                    // print("Unzip progress: \(progress)\n")
                })
                try? fileMgr.removeItem(atPath: documentPath + "/__MACOSX")
                try? fileMgr.removeItem(atPath: documentPath + "/default.zip")

                print("Unzip complete, path：\(documentPath)")

            } catch let error {
                print("Unzip error：\(error.localizedDescription)")
            }
        }
    }