Dear Apple Technical Support Team,
We have encountered a potential issue related to transaction handling while using StoreKit v2, and would greatly appreciate your assistance in confirming the behavior or providing any relevant guidance.
Issue Description:
When calling Transaction.unfinished and listening to Transaction.updates on the client side, we noticed that some transactions—despite having already been processed and successfully completed with finish()—are being returned again upon the next app launch, which results in duplicate receipt uploads.
Current Handling Flow:
1. Upon app launch:
• Iterate over Transaction.unfinished to retrieve unfinished transactions;
• Simultaneously listen for transaction changes via Transaction.updates (e.g., renewals, refunds);
2. For each verified transaction, we immediately call await transaction.finish();
3. We then construct a transaction model, store it locally, and report it to our backend for receipt verification;
4. After the server successfully verifies the receipt, the client deletes the corresponding local record;
5. On every app launch, the client checks for any locally stored receipts that haven’t been uploaded, and re-uploads them if necessary.
Key Code Snippets:
private static func verifyReceipt(receiptResult: VerificationResult) -> Transaction? {
switch receiptResult {
case .unverified(_, _):
return nil
case .verified(let signedType):
return signedType
}
}
public static func handleUnfinishedTransactions(payConfig: YCStoreKitPayConfig, complete: ((YCStoreKitReceiptModel?) -> Void)?) {
Task.detached {
for await unfinishedResult in Transaction.unfinished {
let transaction = YCStoreKitV2Manager.verifyReceipt(receiptResult: unfinishedResult)
if let transaction {
await transaction.finish()
if transaction.revocationDate == nil {
let receipt = YCStoreKitV2Manager.createStoreKitReceiptModel(
transation: transaction,
jwsString: unfinishedResult.jwsRepresentation,
payConfig: payConfig,
isRenew: false
)
complete?(receipt)
}
}
}
}
}
private func observeTransactionUpdates() -> Task<Void, Never> {
return Task {
for await updateResult in Transaction.updates {
let transaction = YCStoreKitV2Manager.verifyReceipt(receiptResult: updateResult)
if let transaction {
await transaction.finish()
if transaction.revocationDate == nil {
let receipt = YCStoreKitV2Manager.createStoreKitReceiptModel(
transation: transaction,
jwsString: updateResult.jwsRepresentation,
payConfig: self.payConfig,
isRenew: false
)
self.callProgressChanged(.receiptPrepared, receiptModel: receipt, errorType: .none, error: nil)
}
}
}
}
}
Our Questions:
1. Is it possible for Transaction.unfinished or Transaction.updates to return transactions that have already been finished?
Specifically, if a transaction was successfully finished in a previous app launch, could it still be returned again during the next launch?
2. Are there any flaws in our current handling process?
Our current sequence is: finish() → construct model → local save → report to server → delete after verification. Could this order lead to timing issues where StoreKit considers a transaction unfinished?
3. If we need your assistance in investigating specific user transaction records or logs, what key information should we provide?
We greatly appreciate your support and look forward to your response to help us further optimize our transaction processing logic.
