GitHub - holla-world/SwiftyStoreKit: Lightweight In App Purchases Swift framework for iOS 8.0+, tvOS 9.0+ and macOS 10.10+ ⛺

SwiftyStoreKit is a lightweight In App Purchases framework for iOS, tvOS, watchOS, macOS, and Mac Catalyst.

Contributions Wanted

SwiftyStoreKit makes it easy for an incredible number of developers to seemlessly integrate in-App Purchases. This project, however, is now community-led. We need help building out features and writing tests (see issue #550).

Maintainers Wanted

The author is no longer maintaining this project actively. If you'd like to become a maintainer, join the Slack workspace and enter the #maintainers channel.
Going forward, SwiftyStoreKit should be made for the community, by the community.

More info here:

The Future of SwiftyStoreKit: Maintainers Wanted

Join on Slack

SwiftyStoreKit is on Slack. Join here.

Content

Requirements
Installation
Features
Contributing
App startup
- Complete Transactions
Purchases
Receipt verification
Verifying purchases and subscriptions
Notes
Change Log
Sample Code
Essential Reading
- Troubleshooting
Video Tutorials
Payment flows: implementation details
Credits
Apps using SwiftyStoreKit
License

Requirements

If you've shipped an app in the last five years, you're probably good to go. Some features (like discounts) are only available on new OS versions, but most features are available as far back as:

iOS	watchOS	tvOS	macOS	Mac Catalyst
8.0	6.2	9.0	10.10	13.0

Installation

There are a number of ways to install SwiftyStoreKit for your project. Swift Package Manager and Carthage integrations are the preferred and recommended approaches. Unfortunately, CocoaPods is currently not supported / outdated (see below for details).

Regardless, make sure to import the project wherever you may use it:

import SwiftyStoreKit

Swift Package Manager

The Swift Package Manager is a tool for automating the distribution of Swift code and is integrated into Xcode and the Swift compiler. This is the recommended installation method. Updates to SwiftyStoreKit will always be available immediately to projects with SPM. SPM is also integrated directly with Xcode.

If you are using Xcode 11 or later:

Click File
Swift Packages
Add Package Dependency...
Specify the git URL for SwiftyStoreKit.

https://github.com/bizz84/SwiftyStoreKit.git

Carthage

To integrate SwiftyStoreKit into your Xcode project using Carthage, specify it in your Cartfile:

github "bizz84/SwiftyStoreKit"

NOTE: Please ensure that you have the latest Carthage installed.

CocoaPods

SwiftyStoreKit can be installed as a CocoaPod and builds as a Swift framework. To install, include this in your Podfile.

use_frameworks!

pod 'SwiftyStoreKit'

Features

Super easy-to-use block-based API
Support for consumable and non-consumable in-app purchases
Support for free, auto-renewable and non-renewing subscriptions
Support for in-app purchases started in the App Store (iOS 11)
Support for subscription discounts and offers
Remote receipt verification
Verify purchases, subscriptions, subscription groups
Downloading content hosted with Apple
iOS, tvOS, watchOS, macOS, and Catalyst compatible

Contributing

Got issues / pull requests / want to contribute? Read here.

App startup

Complete Transactions

Apple recommends to register a transaction observer as soon as the app starts:

Adding your app's observer at launch ensures that it will persist during all launches of your app, thus allowing your app to receive all the payment queue notifications.

SwiftyStoreKit supports this by calling completeTransactions() when the app starts:

func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
	// see notes below for the meaning of Atomic / Non-Atomic
	SwiftyStoreKit.completeTransactions(atomically: true) { purchases in
	    for purchase in purchases {
	        switch purchase.transaction.transactionState {
	        case .purchased, .restored:
	            if purchase.needsFinishTransaction {
	                // Deliver content from server, then:
	                SwiftyStoreKit.finishTransaction(purchase.transaction)
	            }
	            // Unlock content
	        case .failed, .purchasing, .deferred:
	            break // do nothing
	        }
	    }
	}
    return true
}

If there are any pending transactions at this point, these will be reported by the completion block so that the app state and UI can be updated.

If there are no pending transactions, the completion block will not be called.

Note that completeTransactions() should only be called once in your code, in application(:didFinishLaunchingWithOptions:).

Purchases

Retrieve products info

SwiftyStoreKit.retrieveProductsInfo(["com.musevisions.SwiftyStoreKit.Purchase1"]) { result in
    if let product = result.retrievedProducts.first {
        let priceString = product.localizedPrice!
        print("Product: \(product.localizedDescription), price: \(priceString)")
    }
    else if let invalidProductId = result.invalidProductIDs.first {
        print("Invalid product identifier: \(invalidProductId)")
    }
    else {
        print("Error: \(result.error)")
    }
}

Purchase a product (given a product id)

Atomic: to be used when the content is delivered immediately.

SwiftyStoreKit.purchaseProduct("com.musevisions.SwiftyStoreKit.Purchase1", quantity: 1, atomically: true) { result in
    switch result {
    case .success(let purchase):
        print("Purchase Success: \(purchase.productId)")
    case .error(let error):
        switch error.code {
        case .unknown: print("Unknown error. Please contact support")
        case .clientInvalid: print("Not allowed to make the payment")
        case .paymentCancelled: break
        case .paymentInvalid: print("The purchase identifier was invalid")
        case .paymentNotAllowed: print("The device is not allowed to make the payment")
        case .storeProductNotAvailable: print("The product is not available in the current storefront")
        case .cloudServicePermissionDenied: print("Access to cloud service information is not allowed")
        case .cloudServiceNetworkConnectionFailed: print("Could not connect to the network")
        case .cloudServiceRevoked: print("User has revoked permission to use this cloud service")
        default: print((error as NSError).localizedDescription)
        }
    }
}

Non-Atomic: to be used when the content is delivered by the server.

SwiftyStoreKit.purchaseProduct("com.musevisions.SwiftyStoreKit.Purchase1", quantity: 1, atomically: false) { result in
    switch result {
    case .success(let product):
        // fetch content from your server, then:
        if product.needsFinishTransaction {
            SwiftyStoreKit.finishTransaction(product.transaction)
        }
        print("Purchase Success: \(product.productId)")
    case .error(let error):
        switch error.code {
        case .unknown: print("Unknown error. Please contact support")
        case .clientInvalid: print("Not allowed to make the payment")
        case .paymentCancelled: break
        case .paymentInvalid: print("The purchase identifier was invalid")
        case .paymentNotAllowed: print("The device is not allowed to make the payment")
        case .storeProductNotAvailable: print("The product is not available in the current storefront")
        case .cloudServicePermissionDenied: print("Access to cloud service information is not allowed")
        case .cloudServiceNetworkConnectionFailed: print("Could not connect to the network")
        case .cloudServiceRevoked: print("User has revoked permission to use this cloud service")
        default: print((error as NSError).localizedDescription)
        }
    }
}

Purchase a product (given a SKProduct)

This is a variant of the method above that can be used to purchase a product when the corresponding SKProduct has already been retrieved with retrieveProductsInfo:

SwiftyStoreKit.retrieveProductsInfo(["com.musevisions.SwiftyStoreKit.Purchase1"]) { result in
    if let product = result.retrievedProducts.first {
        SwiftyStoreKit.purchaseProduct(product, quantity: 1, atomically: true) { result in
            // handle result (same as above)
        }
    }
}

Using this purchaseProduct method guarantees that only one network call is made to StoreKit to perform the purchase, as opposed to one call to get the product and another to perform the purchase.

Handle purchases started on the App Store (iOS 11)

iOS 11 adds a new delegate method on SKPaymentTransactionObserver:

@available(iOS 11.0, *)
optional public func paymentQueue(_ queue: SKPaymentQueue, shouldAddStorePayment payment: SKPayment, for product: SKProduct) -> Bool

From Apple Docs:

This delegate method is called when the user has started an in-app purchase in the App Store, and is continuing the transaction in your app. Specifically, if your app is already installed, the method is called automatically. If your app is not yet installed when the user starts the in-app purchase in the App Store, the user gets a notification when the app installation is complete. This method is called when the user taps the notification. Otherwise, if the user opens the app manually, this method is called only if the app is opened soon after the purchase was started.

SwiftyStoreKit supports this with a new handler, called like this:

SwiftyStoreKit.shouldAddStorePaymentHandler = { payment, product in
    // return true if the content can be delivered by your app
    // return false otherwise
}

To test this in sandbox mode, open this URL in Safari:

itms-services://?action=purchaseIntent&bundleId=com.example.app&productIdentifier=product_name

More information on the WWDC17 session What's New in StoreKit (slide number 165 shows the link above).

Restore previous purchases

According to Apple - Restoring Purchased Products:

In most cases, all your app needs to do is refresh its receipt and deliver the products in its receipt. The refreshed receipt contains a record of the user’s purchases in this app, on this device or any other device.

Restoring completed transactions creates a new transaction for every completed transaction the user made, essentially replaying history for your transaction queue observer.

See the Receipt Verification section below for how to restore previous purchases using the receipt.

This section shows how to restore completed transactions with the restorePurchases method instead. When successful, the method returns all non-consumable purchases, as well as all auto-renewable subscription purchases, regardless of whether they are expired or not.

Atomic: to be used when the content is delivered immediately.

SwiftyStoreKit.restorePurchases(atomically: true) { results in
    if results.restoreFailedPurchases.count > 0 {
        print("Restore Failed: \(results.restoreFailedPurchases)")
    }
    else if results.restoredPurchases.count > 0 {
        print("Restore Success: \(results.restoredPurchases)")
    }
    else {
        print("Nothing to Restore")
    }
}

Non-Atomic: to be used when the content is delivered by the server.

SwiftyStoreKit.restorePurchases(atomically: false) { results in
    if results.restoreFailedPurchases.count > 0 {
        print("Restore Failed: \(results.restoreFailedPurchases)")
    }
    else if results.restoredPurchases.count > 0 {
        for purchase in results.restoredPurchases {
            // fetch content from your server, then:
            if purchase.needsFinishTransaction {
                SwiftyStoreKit.finishTransaction(purchase.transaction)
            }
        }
        print("Restore Success: \(results.restoredPurchases)")
    }
    else {
        print("Nothing to Restore")
    }
}

What does atomic / non-atomic mean?

When you purchase a product the following things happen:

A payment is added to the payment queue for your IAP.
When the payment has been processed with Apple, the payment queue is updated so that the appropriate transaction can be handled.
If the transaction state is purchased or restored, the app can unlock the functionality purchased by the user.
The app should call finishTransaction(_:) to complete the purchase.

This is what is recommended by Apple:

Your application should call finishTransaction(_:) only after it has successfully processed the transaction and unlocked the functionality purchased by the user.

A purchase is atomic when the app unlocks the functionality purchased by the user immediately and call finishTransaction(_:) at the same time. This is desirable if you're unlocking functionality that is already inside the app.
In cases when you need to make a request to your own server in order to unlock the functionality, you can use a non-atomic purchase instead.
Note: SwiftyStoreKit doesn't yet support downloading content hosted by Apple for non-consumable products. See this feature request.

SwiftyStoreKit provides three operations that can be performed atomically or non-atomically:

Making a purchase
Restoring purchases
Completing transactions on app launch

Downloading content hosted with Apple

Quoting Apple Docs:

When you create a product in iTunes Connect, you can associate one or more pieces of downloadable content with it. At runtime, when a product is purchased by a user, your app uses SKDownload objects to download the content from the App Store.

Your app never directly creates a SKDownload object. Instead, after a payment is processed, your app reads the transaction object’s downloads property to retrieve an array of SKDownload objects associated with the transaction.

To download the content, you queue a download object on the payment queue and wait for the content to be downloaded. After a download completes, read the download object’s contentURL property to get a URL to the downloaded content. Your app must process the downloaded file before completing the transaction. For example, it might copy the file into a directory whose contents are persistent. When all downloads are complete, you finish the transaction. After the transaction is finished, the download objects cannot be queued to the payment queue and any URLs to the downloaded content are invalid.

To start the downloads (this can be done in purchaseProduct(), completeTransactions() or restorePurchases()):

SwiftyStoreKit.purchaseProduct("com.musevisions.SwiftyStoreKit.Purchase1", quantity: 1, atomically: false) { result in
    switch result {
    case .success(let product):
        let downloads = purchase.transaction.downloads
        if !downloads.isEmpty {
            SwiftyStoreKit.start(downloads)
        }
    case .error(let error):
        print("\(error)")
    }
}

To check the updated downloads, setup a updatedDownloadsHandler block in your AppDelegate:

SwiftyStoreKit.updatedDownloadsHandler = { downloads in

    // contentURL is not nil if downloadState == .finished
    let contentURLs = downloads.flatMap { $0.contentURL }
    if contentURLs.count == downloads.count {
        // process all downloaded files, then finish the transaction
        SwiftyStoreKit.finishTransaction(downloads[0].transaction)
    }
}

To control the state of the downloads, SwiftyStoreKit offers start(), pause(), resume(), cancel() methods.

Receipt verification

According to Apple - Delivering Products:

The app receipt contains a record of the user’s purchases, cryptographically signed by Apple. For more information, see Receipt Validation Programming Guide.

Information about consumable products is added to the receipt when they’re paid for and remains in the receipt until you finish the transaction. After you finish the transaction, this information is removed the next time the receipt is updated—for example, the next time the user makes a purchase.

Information about all other kinds of purchases is added to the receipt when they’re paid for and remains in the receipt indefinitely.

When an app is first installed, the app receipt is missing.

As soon as a user completes a purchase or restores purchases, StoreKit creates and stores the receipt locally as a file, located by Bundle.main.appStoreReceiptURL.

Retrieve local receipt (encrypted)

This helper can be used to retrieve the (encrypted) local receipt data:

let receiptData = SwiftyStoreKit.localReceiptData
let receiptString = receiptData.base64EncodedString(options: [])
// do your receipt validation here

However, the receipt file may be missing or outdated.

Fetch receipt (encrypted)

Use this method to get the updated receipt:

SwiftyStoreKit.fetchReceipt(forceRefresh: true) { result in
    switch result {
    case .success(let receiptData):
        let encryptedReceipt = receiptData.base64EncodedString(options: [])
        print("Fetch receipt success:\n\(encryptedReceipt)")
    case .error(let error):
        print("Fetch receipt failed: \(error)")
    }
}

This method works as follows:

If forceRefresh = false, it returns the local receipt from file, or refreshes it if missing.
If forceRefresh = true, it always refreshes the receipt regardless.

Notes

If the local receipt is missing or forceRefresh = true when calling fetchReceipt, a network call is made to refresh it.
If the user is not logged to the App Store, StoreKit will present a popup asking to Sign In to the iTunes Store.
If the user enters valid credentials, the receipt will be refreshed.
If the user cancels, receipt refresh will fail with a Cannot connect to iTunes Store error.

If fetchReceipt is successful, it will return the encrypted receipt as a string. For this reason, a validation step is needed to get all the receipt fields in readable form. This can be done in various ways:

Validate with Apple via the AppleReceiptValidator (see verifyReceipt below).
Perform local receipt validation (see #101).
Post the receipt data and validate on server.

Verify Receipt

Use this method to (optionally) refresh the receipt and perform validation in one step.

let appleValidator = AppleReceiptValidator(service: .production, sharedSecret: "your-shared-secret")
SwiftyStoreKit.verifyReceipt(using: appleValidator, forceRefresh: false) { result in
    switch result {
    case .success(let receipt):
        print("Verify receipt success: \(receipt)")
    case .error(let error):
        print("Verify receipt failed: \(error)")
    }
}

Notes

This method is based on fetchReceipt, and the same refresh logic discussed above applies.
AppleReceiptValidator is a reference implementation that validates the receipt with Apple and results in a network call. This is prone to man-in-the-middle attacks.
You should implement your secure logic by validating your receipt locally, or sending the encrypted receipt data and validating it in your server.
Local receipt validation is not implemented (see issue #101 for details).
You can implement your own receipt validator by conforming to the ReceiptValidator protocol and passing it to verifyReceipt.

Verifying purchases and subscriptions

Once you have retrieved the receipt using the verifyReceipt method, you can verify your purchases and subscriptions by product identifier.

Verifying multiple purchases and subscriptions in one call is not yet supported (see issue #194 for more details).

If you need to verify multiple purchases / subscriptions, you can either:

manually parse the receipt dictionary returned by verifyReceipt
call verifyPurchase or verifySubscription multiple times with different product identifiers

Verify Purchase

let appleValidator = AppleReceiptValidator(service: .production, sharedSecret: "your-shared-secret")
SwiftyStoreKit.verifyReceipt(using: appleValidator) { result in
    switch result {
    case .success(let receipt):
        let productId = "com.musevisions.SwiftyStoreKit.Purchase1"
        // Verify the purchase of Consumable or NonConsumable
        let purchaseResult = SwiftyStoreKit.verifyPurchase(
            productId: productId,
            inReceipt: receipt)
            
        switch purchaseResult {
        case .purchased(let receiptItem):
            print("\(productId) is purchased: \(receiptItem)")
        case .notPurchased:
            print("The user has never purchased \(productId)")
        }
    case .error(let error):
        print("Receipt verification failed: \(error)")
    }
}

Note that for consumable products, the receipt will only include the information for a couple of minutes after the purchase.

Verify Subscription

This can be used to check if a subscription was previously purchased, and whether it is still active or if it's expired.

From Apple - Working with Subscriptions:

keep a record of the date that each piece of content is published. Read the Original Purchase Date and Subscription Expiration Date field from each receipt entry to determine the start and end dates of the subscription.

When one or more subscriptions are found for a given product id, they are returned as a ReceiptItem array ordered by expiryDate, with the first one being the newest.

let appleValidator = AppleReceiptValidator(service: .production, sharedSecret: "your-shared-secret")
SwiftyStoreKit.verifyReceipt(using: appleValidator) { result in
    switch result {
    case .success(let receipt):
        let productId = "com.musevisions.SwiftyStoreKit.Subscription"
        // Verify the purchase of a Subscription
        let purchaseResult = SwiftyStoreKit.verifySubscription(
            ofType: .autoRenewable, // or .nonRenewing (see below)
            productId: productId,
            inReceipt: receipt)
            
        switch purchaseResult {
        case .purchased(let expiryDate, let items):
            print("\(productId) is valid until \(expiryDate)\n\(items)\n")
        case .expired(let expiryDate, let items):
            print("\(productId) is expired since \(expiryDate)\n\(items)\n")
        case .notPurchased:
            print("The user has never purchased \(productId)")
        }

    case .error(let error):
        print("Receipt verification failed: \(error)")
    }
}

Auto-Renewable

let purchaseResult = SwiftyStoreKit.verifySubscription(
            ofType: .autoRenewable,
            productId: "com.musevisions.SwiftyStoreKit.Subscription",
            inReceipt: receipt)

Non-Renewing

// validDuration: time interval in seconds
let purchaseResult = SwiftyStoreKit.verifySubscription(
            ofType: .nonRenewing(validDuration: 3600 * 24 * 30),
            productId: "com.musevisions.SwiftyStoreKit.Subscription",
            inReceipt: receipt)

Notes

The expiration dates are calculated against the receipt date. This is the date of the last successful call to verifyReceipt.
When purchasing subscriptions in sandbox mode, the expiry dates are set just minutes after the purchase date for testing purposes.

Purchasing and verifying a subscription

The verifySubscription method can be used together with the purchaseProduct method to purchase a subscription and check its expiration date, like so:

let productId = "your-product-id"
SwiftyStoreKit.purchaseProduct(productId, atomically: true) { result in
    
    if case .success(let purchase) = result {
        // Deliver content from server, then:
        if purchase.needsFinishTransaction {
            SwiftyStoreKit.finishTransaction(purchase.transaction)
        }
        
        let appleValidator = AppleReceiptValidator(service: .production, sharedSecret: "your-shared-secret")
        SwiftyStoreKit.verifyReceipt(using: appleValidator) { result in
            
            if case .success(let receipt) = result {
                let purchaseResult = SwiftyStoreKit.verifySubscription(
                    ofType: .autoRenewable,
                    productId: productId,
                    inReceipt: receipt)
                
                switch purchaseResult {
                case .purchased(let expiryDate, let receiptItems):
                    print("Product is valid until \(expiryDate)")
                case .expired(let expiryDate, let receiptItems):
                    print("Product is expired since \(expiryDate)")
                case .notPurchased:
                    print("This product has never been purchased")
                }

            } else {
                // receipt verification error
            }
        }
    } else {
        // purchase error
    }
}

Subscription Groups

From Apple Docs - Offering Subscriptions:

A subscription group is a set of in-app purchases that you can create to provide users with a range of content offerings, service levels, or durations to best meet their needs. Users can only buy one subscription within a subscription group at a time. If users would want to buy more that one type of subscription — for example, to subscribe to more than one channel in a streaming app — you can put these in-app purchases in different subscription groups.

You can verify all subscriptions within the same group with the verifySubscriptions method:

let appleValidator = AppleReceiptValidator(service: .production, sharedSecret: "your-shared-secret")
SwiftyStoreKit.verifyReceipt(using: appleValidator) { result in
    switch result {
    case .success(let receipt):
        let productIds = Set([ "com.musevisions.SwiftyStoreKit.Weekly",
                               "com.musevisions.SwiftyStoreKit.Monthly",
                               "com.musevisions.SwiftyStoreKit.Yearly" ])
        let purchaseResult = SwiftyStoreKit.verifySubscriptions(productIds: productIds, inReceipt: receipt)
        switch purchaseResult {
        case .purchased(let expiryDate, let items):
            print("\(productIds) are valid until \(expiryDate)\n\(items)\n")
        case .expired(let expiryDate, let items):
            print("\(productIds) are expired since \(expiryDate)\n\(items)\n")
        case .notPurchased:
            print("The user has never purchased \(productIds)")
        }
    case .error(let error):
        print("Receipt verification failed: \(error)")
    }
}

Get distinct purchase identifiers

You can retrieve all product identifiers with the getDistinctPurchaseIds method:

let appleValidator = AppleReceiptValidator(service: .production, sharedSecret: "your-shared-secret")
SwiftyStoreKit.verifyReceipt(using: appleValidator) { result in
    switch result {
    case .success(let receipt):
        let productIds = SwiftyStoreKit.getDistinctPurchaseIds(inReceipt receipt: ReceiptInfo)
        let purchaseResult = SwiftyStoreKit.verifySubscriptions(productIds: productIds, inReceipt: receipt)
        switch purchaseResult {
        case .purchased(let expiryDate, let items):
            print("\(productIds) are valid until \(expiryDate)\n\(items)\n")
        case .expired(let expiryDate, let items):
            print("\(productIds) are expired since \(expiryDate)\n\(items)\n")
        case .notPurchased:
            print("The user has never purchased \(productIds)")
        }
    case .error(let error):
        print("Receipt verification failed: \(error)")
    }
}

Notes

The framework provides a simple block based API with robust error handling on top of the existing StoreKit framework. It does NOT persist in app purchases data locally. It is up to clients to do this with a storage solution of choice (i.e. NSUserDefaults, CoreData, Keychain).

Swift 2.x / 3.x / 4.x / 5.x

Language	Branch	Pod version	Xcode version
Swift 5.x	master	>= 0.15.0	Xcode 10.2 or greater
Swift 4.x	master	>= 0.10.4	Xcode 9 or greater
Swift 3.x	master	>= 0.5.x	Xcode 8.x
Swift 2.3	swift-2.3	0.4.x	Xcode 8, Xcode 7.3.x
Swift 2.2	swift-2.2	0.3.x	Xcode 7.3.x

Change Log

See the Releases Page.

Sample Code

The project includes demo apps for iOS and macOS showing how to use SwiftyStoreKit. Note that the pre-registered in app purchases in the demo apps are for illustration purposes only and may not work as iTunes Connect may invalidate them.

Essential Reading

I have also written about building SwiftyStoreKit on Medium:

Troubleshooting

Video Tutorials

Jared Davidson: In App Purchases! (Swift 3 in Xcode : Swifty Store Kit)

@rebeloper: Ultimate In-app Purchases Guide

Payment flows: implementation details

In order to make a purchase, two operations are needed:

Perform a SKProductRequest to obtain the SKProduct corresponding to the product identifier.
Submit the payment and listen for updated transactions on the SKPaymentQueue.

The framework takes care of caching SKProducts so that future requests for the same SKProduct don't need to perform a new SKProductRequest.

Payment queue

The following list outlines how requests are processed by SwiftyStoreKit.

SKPaymentQueue is used to queue payments or restore purchases requests.
Payments are processed serially and in-order and require user interaction.
Restore purchases requests don't require user interaction and can jump ahead of the queue.
SKPaymentQueue rejects multiple restore purchases calls.
Failed transactions only ever belong to queued payment requests.
restoreCompletedTransactionsFailedWithError is always called when a restore purchases request fails.
paymentQueueRestoreCompletedTransactionsFinished is always called following 0 or more update transactions when a restore purchases request succeeds.
A complete transactions handler is require to catch any transactions that are updated when the app is not running.
Registering a complete transactions handler when the app launches ensures that any pending transactions can be cleared.
If a complete transactions handler is missing, pending transactions can be mis-attributed to any new incoming payments or restore purchases.

The order in which transaction updates are processed is:

payments (transactionState: .purchased and .failed for matching product identifiers)
restore purchases (transactionState: .restored, or restoreCompletedTransactionsFailedWithError, or paymentQueueRestoreCompletedTransactionsFinished)
complete transactions (transactionState: .purchased, .failed, .restored, .deferred)

Any transactions where state is .purchasing are ignored.

See this pull request for full details about how the payment flows have been implemented.

Credits

Many thanks to phimage for adding macOS support and receipt verification.

Apps using SwiftyStoreKit

It would be great to showcase apps using SwiftyStoreKit here. Pull requests welcome :)

Every Plant, Ever - The sticker pack of every plant, ever.
Countdown - Countdown the days until your next vacation, deadline, or event
MDacne - Acne analysis and treatment
Pixel Picker - Image Color Picker
KType - Space shooter game
iPic - Automatically upload images and save Markdown links
iHosts - Perfect for editing /etc/hosts
Arise - Calorie counter
Truth Truth Lie - iMessage game, featured by Apple
Tactus Music Player - Alternative music player app
Drops - Language learning app
Fresh Snow - Colorado Ski Report
Zmeu Grand Canyon - Interactive hiking map & planner
OB Monitor - The app for Texas Longhorns athletics fans
Talk Dim Sum - Your dim sum companion
Sluggard - Perform simple exercises to reduce the risks of sedentary lifestyle
Debts iOS & Debts macOS - Track amounts owed

A full list of apps is published on AppSight.

License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Name		Name	Last commit message	Last commit date
Latest commit History 822 Commits
.github/ISSUE_TEMPLATE		.github/ISSUE_TEMPLATE
Screenshots		Screenshots
Sources/SwiftyStoreKit		Sources/SwiftyStoreKit
SwiftyStoreKit-iOS-Demo		SwiftyStoreKit-iOS-Demo
SwiftyStoreKit-macOS-Demo		SwiftyStoreKit-macOS-Demo
SwiftyStoreKit-tvOS-Demo		SwiftyStoreKit-tvOS-Demo
SwiftyStoreKit.xcodeproj		SwiftyStoreKit.xcodeproj
Tests/SwiftyStoreKitTests		Tests/SwiftyStoreKitTests
scripts		scripts
.gitignore		.gitignore
.swiftlint.yml		.swiftlint.yml
.travis.yml		.travis.yml
CHANGELOG.md		CHANGELOG.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
Dangerfile		Dangerfile
Gemfile		Gemfile
LICENSE.md		LICENSE.md
Package.swift		Package.swift
README.md		README.md
SwiftyStoreKit-logo.png		SwiftyStoreKit-logo.png
SwiftyStoreKit.podspec		SwiftyStoreKit.podspec

License

holla-world/SwiftyStoreKit

Folders and files

Latest commit

History

Repository files navigation

Contributions Wanted

Maintainers Wanted

Join on Slack

Content

Requirements

Installation

Swift Package Manager

Carthage

CocoaPods

Features

Contributing

Got issues / pull requests / want to contribute? Read here.

App startup

Complete Transactions

Purchases

Retrieve products info

Purchase a product (given a product id)

Purchase a product (given a SKProduct)

Handle purchases started on the App Store (iOS 11)

Restore previous purchases

What does atomic / non-atomic mean?

Downloading content hosted with Apple

Receipt verification

Retrieve local receipt (encrypted)

Fetch receipt (encrypted)

Verify Receipt

Verifying purchases and subscriptions

Verify Purchase

Verify Subscription

Auto-Renewable

Non-Renewing

Purchasing and verifying a subscription

Subscription Groups

Get distinct purchase identifiers

Notes

Swift 2.x / 3.x / 4.x / 5.x

Change Log

Sample Code

Essential Reading

Troubleshooting

Video Tutorials

Jared Davidson: In App Purchases! (Swift 3 in Xcode : Swifty Store Kit)

@rebeloper: Ultimate In-app Purchases Guide

Payment flows: implementation details

Payment queue

Credits

Apps using SwiftyStoreKit

License

About

Resources

License

Code of conduct

Stars

Watchers

Forks

Releases

Packages 0

Languages

Packages