akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/plugins/iap/android/IapPlugin.kt

@@ -0,0 +1,358 @@
+package com.akanjs.plugins.iap
+
+import android.content.ActivityNotFoundException
+import android.content.Intent
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import com.android.billingclient.api.AcknowledgePurchaseParams
+import com.android.billingclient.api.BillingClient
+import com.android.billingclient.api.BillingClient.BillingResponseCode
+import com.android.billingclient.api.BillingClient.ProductType
+import com.android.billingclient.api.BillingClientStateListener
+import com.android.billingclient.api.BillingFlowParams
+import com.android.billingclient.api.BillingResult
+import com.android.billingclient.api.ConsumeParams
+import com.android.billingclient.api.PendingPurchasesParams
+import com.android.billingclient.api.ProductDetails
+import com.android.billingclient.api.Purchase
+import com.android.billingclient.api.PurchasesUpdatedListener
+import com.android.billingclient.api.QueryProductDetailsParams
+import com.android.billingclient.api.QueryPurchasesParams
+import com.akanjs.runtime.AkanNativeErrorCode
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeReply
+import com.akanjs.runtime.AkanNativeRetained
+import com.akanjs.runtime.AkanNativeVoidReply
+
+/**
+ * In-app purchase with the Play Billing Library (akanjs readiness O6-3), the opt-in module: its
+ * closure (native/android/maven.lock.json) goes only into apps with this plugin.
+ * - One BillingClient per plugin, connected by the first call and again by any call that finds it
+ *   disconnected. Not enableAutoServiceReconnection: on a device without Play billing it reports the
+ *   setup as OK and then spends three seconds on retries in every call before SERVICE_DISCONNECTED
+ *   (seen on the emulator); connecting ourselves answers BILLING_UNAVAILABLE (UNSUPPORTED) at once. Pending
+ *   purchases are enabled for one-time products (cash payments and the like): purchase() answers
+ *   "pending" and the purchase arrives later through onPurchasesUpdated, or getUnfinished() at the next
+ *   start.
+ * - onPurchasesUpdated answers the waiting purchase() call; anything else it reports (a pending
+ *   purchase that completed, a purchase made outside the flow) is a "transaction" event, kept until
+ *   the first listener (C2 AkanNativeRetained).
+ * - A transaction's id is the purchase token (the order id is missing while pending). finish()
+ *   consumes (consume: true) or acknowledges; Google refunds a purchase not acknowledged in three days.
+ * - Google Play has no restore: restore() and getEntitlements() query what the account owns.
+ */
+class IapPlugin(private val context: AkanNativePluginContext) : IapPluginSpec, PurchasesUpdatedListener {
+    private val app = context.activity.applicationContext
+    private val events = IapEvents(context)
+    private val retained = AkanNativeRetained<IapTransaction>()
+    private val main = Handler(Looper.getMainLooper())
+    private val details = HashMap<String, ProductDetails>()
+    private val onConnected = ArrayList<(BillingResult) -> Unit>()
+    private var connecting = false
+    private var waiting: Waiting? = null
+
+    private class Waiting(val productId: String, val reply: AkanNativeReply<IapPurchaseResult>)
+
+    private val client: BillingClient = BillingClient.newBuilder(app)
+        .setListener(this)
+        .enablePendingPurchases(PendingPurchasesParams.newBuilder().enableOneTimeProducts().build())
+        .build()
+
+    /** Billing calls back on the main thread; this makes sure of it. */
+    private fun onMain(block: () -> Unit) {
+        if (Looper.myLooper() == Looper.getMainLooper()) block() else main.post(block)
+    }
+
+    private fun connected(reply: AkanNativeReply<*>, block: () -> Unit) = connection { result ->
+        if (result.responseCode == BillingResponseCode.OK) block() else reject(reply, result)
+    }
+
+    private fun connection(block: (BillingResult) -> Unit) {
+        if (client.isReady) return block(BillingResult.newBuilder().setResponseCode(BillingResponseCode.OK).build())
+        onConnected.add(block)
+        if (connecting) return
+        connecting = true
+        client.startConnection(object : BillingClientStateListener {
+            override fun onBillingSetupFinished(result: BillingResult) = onMain {
+                connecting = false
+                val waiting = onConnected.toList()
+                onConnected.clear()
+                for (callback in waiting) callback(result)
+            }
+
+            override fun onBillingServiceDisconnected() = onMain { connecting = false }
+        })
+    }
+
+    override fun destroy() {
+        client.endConnection()
+    }
+
+    // ------------------------------------------------------------ products
+
+    override fun canMakePayments(reply: AkanNativeReply<IapCanMakePaymentsResult>) = connection { result ->
+        reply.resolve(IapCanMakePaymentsResult(value = result.responseCode == BillingResponseCode.OK))
+    }
+
+    override fun getProducts(args: IapGetProductsArgs, reply: AkanNativeReply<IapGetProductsResult>) {
+        if (args.ids.isEmpty()) return reply.resolve(IapGetProductsResult(products = emptyList(), invalidIds = emptyList()))
+        val types = when (args.type) {
+            IapGetProductsArgsType.INAPP -> listOf(ProductType.INAPP)
+            IapGetProductsArgsType.SUBS -> listOf(ProductType.SUBS)
+            null -> listOf(ProductType.INAPP, ProductType.SUBS)
+        }
+        connected(reply) {
+            query(args.ids, types, reply) { found ->
+                val ids = found.map { it.productId }.toSet()
+                reply.resolve(IapGetProductsResult(products = found.map(::product), invalidIds = args.ids.filter { it !in ids }))
+            }
+        }
+    }
+
+    /** Queries each product type in turn (a query takes one type). */
+    private fun query(ids: List<String>, types: List<String>, reply: AkanNativeReply<*>, done: (List<ProductDetails>) -> Unit) {
+        val found = ArrayList<ProductDetails>()
+        fun next(index: Int) {
+            if (index == types.size) return done(found)
+            val products = ids.filter { id -> found.none { it.productId == id } }.map {
+                QueryProductDetailsParams.Product.newBuilder().setProductId(it).setProductType(types[index]).build()
+            }
+            if (products.isEmpty()) return done(found)
+            client.queryProductDetailsAsync(QueryProductDetailsParams.newBuilder().setProductList(products).build()) { result, response ->
+                onMain {
+                    if (result.responseCode != BillingResponseCode.OK) return@onMain reject(reply, result)
+                    for (d in response.productDetailsList) {
+                        details[d.productId] = d
+                        found.add(d)
+                    }
+                    next(index + 1)
+                }
+            }
+        }
+        next(0)
+    }
+
+    // ------------------------------------------------------------ purchase
+
+    override fun purchase(args: IapPurchaseArgs, reply: AkanNativeReply<IapPurchaseResult>) {
+        if (waiting != null) return reply.reject(AkanNativeErrorCode.INVALID_ARGS, "another purchase is in progress")
+        val account = args.accountId
+        if (account != null && account.length > 64) return reply.reject(AkanNativeErrorCode.INVALID_ARGS, "accountId: at most 64 characters on Google Play")
+        connected(reply) {
+            val cached = details[args.productId]
+            if (cached != null) launch(cached, args, reply)
+            else query(listOf(args.productId), listOf(ProductType.INAPP, ProductType.SUBS), reply) { found ->
+                val d = found.firstOrNull() ?: return@query reply.reject(AkanNativeErrorCode.NOT_FOUND, "no Google Play product ${args.productId}")
+                launch(d, args, reply)
+            }
+        }
+    }
+
+    private fun launch(d: ProductDetails, args: IapPurchaseArgs, reply: AkanNativeReply<IapPurchaseResult>) {
+        val token = args.offerToken ?: if (d.productType == ProductType.SUBS) {
+            val offers = d.subscriptionOfferDetails.orEmpty()
+            (offers.firstOrNull { it.offerId == null } ?: offers.firstOrNull())?.offerToken
+        } else {
+            d.oneTimePurchaseOfferDetails?.offerToken
+        }
+        val product = BillingFlowParams.ProductDetailsParams.newBuilder().setProductDetails(d)
+        if (token != null) product.setOfferToken(token)
+        val flow = BillingFlowParams.newBuilder().setProductDetailsParamsList(listOf(product.build()))
+        args.accountId?.let { flow.setObfuscatedAccountId(it) }
+        waiting = Waiting(d.productId, reply)
+        val result = client.launchBillingFlow(context.activity, flow.build())
+        if (result.responseCode != BillingResponseCode.OK) {
+            waiting = null
+            reject(reply, result)
+        }
+    }
+
+    override fun onPurchasesUpdated(result: BillingResult, purchases: List<Purchase>?) = onMain {
+        val list = purchases.orEmpty()
+        val flow = waiting
+        if (flow != null) {
+            val mine = list.firstOrNull { flow.productId in it.products }
+            if (result.responseCode != BillingResponseCode.OK || mine != null) {
+                waiting = null
+                when {
+                    result.responseCode != BillingResponseCode.OK -> reject(flow.reply, result)
+                    mine!!.purchaseState == Purchase.PurchaseState.PURCHASED -> flow.reply.resolve(IapPurchaseResult(status = IapPurchaseStatus.PURCHASED, transaction = transaction(mine)))
+                    else -> flow.reply.resolve(IapPurchaseResult(status = IapPurchaseStatus.PENDING))
+                }
+                for (other in list) if (other !== mine) retained.emit(transaction(other), true)
+                return@onMain
+            }
+        }
+        if (result.responseCode == BillingResponseCode.OK) for (p in list) retained.emit(transaction(p), true)
+    }
+
+    override fun finish(args: IapFinishArgs, reply: AkanNativeVoidReply) = connected(reply) {
+        val token = args.transactionId
+        if (args.consume == true) {
+            client.consumeAsync(ConsumeParams.newBuilder().setPurchaseToken(token).build()) { result, _ ->
+                onMain { if (result.responseCode == BillingResponseCode.OK) reply.resolve() else reject(reply, result) }
+            }
+        } else {
+            client.acknowledgePurchase(AcknowledgePurchaseParams.newBuilder().setPurchaseToken(token).build()) { result ->
+                onMain { if (result.responseCode == BillingResponseCode.OK) reply.resolve() else reject(reply, result) }
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ owned
+
+    override fun getUnfinished(reply: AkanNativeReply<IapTransactionsResult>) =
+        owned(reply) { it.purchaseState == Purchase.PurchaseState.PURCHASED && !it.isAcknowledged }
+
+    override fun getEntitlements(reply: AkanNativeReply<IapTransactionsResult>) =
+        owned(reply) { it.purchaseState == Purchase.PurchaseState.PURCHASED }
+
+    override fun restore(reply: AkanNativeReply<IapTransactionsResult>) = getEntitlements(reply)
+
+    private fun owned(reply: AkanNativeReply<IapTransactionsResult>, keep: (Purchase) -> Boolean) = connected(reply) {
+        val out = ArrayList<IapTransaction>()
+        val types = listOf(ProductType.INAPP, ProductType.SUBS)
+        fun next(index: Int) {
+            if (index == types.size) return reply.resolve(IapTransactionsResult(transactions = out))
+            client.queryPurchasesAsync(QueryPurchasesParams.newBuilder().setProductType(types[index]).build()) { result, purchases ->
+                onMain {
+                    if (result.responseCode != BillingResponseCode.OK) return@onMain reject(reply, result)
+                    for (p in purchases) if (keep(p)) out.add(transaction(p))
+                    next(index + 1)
+                }
+            }
+        }
+        next(0)
+    }
+
+    override fun manageSubscriptions(args: IapManageSubscriptionsArgs, reply: AkanNativeVoidReply) {
+        val url = StringBuilder("https://play.google.com/store/account/subscriptions")
+        args.productId?.let { url.append("?sku=").append(Uri.encode(it)).append("&package=").append(Uri.encode(app.packageName)) }
+        try {
+            context.activity.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url.toString())))
+            reply.resolve()
+        } catch (_: ActivityNotFoundException) {
+            reply.reject(AkanNativeErrorCode.UNSUPPORTED, "nothing can open the Google Play subscriptions page")
+        }
+    }
+
+    // ------------------------------------------------------------ events
+
+    override fun startListening(event: String) {
+        if (event != "transaction") return
+        retained.listen(this) { transaction ->
+            events.transaction(transaction)
+            true
+        }
+    }
+
+    override fun stopListening(event: String) {
+        if (event == "transaction") retained.unlisten(this)
+    }
+
+    // ------------------------------------------------------------ JSON
+
+    private fun transaction(p: Purchase) = IapTransaction(
+        id = p.purchaseToken,
+        productId = p.products.firstOrNull() ?: "",
+        state = if (p.purchaseState == Purchase.PurchaseState.PURCHASED) IapTransactionState.PURCHASED else IapTransactionState.PENDING,
+        purchaseDate = p.purchaseTime.toDouble(),
+        quantity = p.quantity.toDouble(),
+        autoRenewing = p.isAutoRenewing,
+        acknowledged = p.isAcknowledged,
+        accountId = p.accountIdentifiers?.obfuscatedAccountId,
+        verification = IapVerification(
+            purchaseToken = p.purchaseToken,
+            orderId = p.orderId,
+            packageName = p.packageName,
+            originalJson = p.originalJson,
+            signature = p.signature,
+        ),
+    )
+
+    private fun product(d: ProductDetails): IapProduct {
+        val offers = ArrayList<IapOffer>()
+        var regular: IapPricingPhase? = null
+        if (d.productType == ProductType.SUBS) {
+            for (o in d.subscriptionOfferDetails.orEmpty()) {
+                val phases = o.pricingPhases.pricingPhaseList.map(::phase)
+                if (o.offerId == null && regular == null) regular = phases.lastOrNull()
+                offers.add(IapOffer(kind = if (o.offerId == null) IapOfferKind.BASE else IapOfferKind.PROMOTIONAL, token = o.offerToken, id = o.offerId, basePlanId = o.basePlanId, tags = o.offerTags, phases = phases))
+            }
+        } else {
+            val base = d.oneTimePurchaseOfferDetails
+            val all = d.oneTimePurchaseOfferDetailsList ?: listOfNotNull(base)
+            for (o in all) {
+                val phase = IapPricingPhase(displayPrice = o.formattedPrice, price = o.priceAmountMicros / 1_000_000.0, currency = o.priceCurrencyCode, cycles = 1.0, mode = IapPaymentMode.PAY_UP_FRONT)
+                if (regular == null && (o.offerId == null || o === base)) regular = phase
+                offers.add(IapOffer(kind = if (o.offerId == null) IapOfferKind.ONE_TIME else IapOfferKind.PROMOTIONAL, token = o.offerToken, id = o.offerId, tags = o.offerTags, phases = listOf(phase)))
+            }
+        }
+        val price = regular ?: offers.firstOrNull()?.phases?.lastOrNull()
+        return IapProduct(
+            id = d.productId,
+            type = if (d.productType == ProductType.SUBS) IapProductType.SUBSCRIPTION else IapProductType.ONE_TIME,
+            // name is the product's own title; title adds the app's name in parentheses.
+            title = d.name,
+            description = d.description,
+            displayPrice = price?.displayPrice ?: "",
+            price = price?.price ?: 0.0,
+            currency = price?.currency ?: "",
+            subscriptionPeriod = if (d.productType == ProductType.SUBS) price?.period else null,
+            offers = offers,
+        )
+    }
+
+    private fun phase(p: ProductDetails.PricingPhase): IapPricingPhase {
+        val mode = when {
+            p.priceAmountMicros == 0L -> IapPaymentMode.FREE_TRIAL
+            p.recurrenceMode == ProductDetails.RecurrenceMode.INFINITE_RECURRING -> IapPaymentMode.RECURRING
+            p.recurrenceMode == ProductDetails.RecurrenceMode.FINITE_RECURRING -> IapPaymentMode.PAY_AS_YOU_GO
+            else -> IapPaymentMode.PAY_UP_FRONT
+        }
+        return IapPricingPhase(
+            displayPrice = p.formattedPrice,
+            price = p.priceAmountMicros / 1_000_000.0,
+            currency = p.priceCurrencyCode,
+            period = period(p.billingPeriod),
+            cycles = if (mode == IapPaymentMode.RECURRING) 0.0 else p.billingCycleCount.toDouble(),
+            mode = mode,
+        )
+    }
+
+    private fun reject(reply: AkanNativeReply<*>, result: BillingResult) {
+        val (code, name) = when (result.responseCode) {
+            BillingResponseCode.USER_CANCELED -> AkanNativeErrorCode.CANCELLED to "USER_CANCELED"
+            BillingResponseCode.ITEM_UNAVAILABLE -> AkanNativeErrorCode.NOT_FOUND to "ITEM_UNAVAILABLE"
+            BillingResponseCode.BILLING_UNAVAILABLE -> AkanNativeErrorCode.UNSUPPORTED to "BILLING_UNAVAILABLE"
+            BillingResponseCode.FEATURE_NOT_SUPPORTED -> AkanNativeErrorCode.UNSUPPORTED to "FEATURE_NOT_SUPPORTED"
+            BillingResponseCode.ITEM_ALREADY_OWNED -> AkanNativeErrorCode.INVALID_ARGS to "ITEM_ALREADY_OWNED"
+            BillingResponseCode.ITEM_NOT_OWNED -> AkanNativeErrorCode.INVALID_ARGS to "ITEM_NOT_OWNED"
+            BillingResponseCode.DEVELOPER_ERROR -> AkanNativeErrorCode.INVALID_ARGS to "DEVELOPER_ERROR"
+            BillingResponseCode.NETWORK_ERROR -> AkanNativeErrorCode.INTERNAL to "NETWORK_ERROR"
+            BillingResponseCode.SERVICE_UNAVAILABLE -> AkanNativeErrorCode.INTERNAL to "SERVICE_UNAVAILABLE"
+            BillingResponseCode.SERVICE_DISCONNECTED -> AkanNativeErrorCode.INTERNAL to "SERVICE_DISCONNECTED"
+            // SERVICE_TIMEOUT (-3) is deprecated; it and ERROR (6) end here.
+            else -> AkanNativeErrorCode.INTERNAL to "ERROR"
+        }
+        val detail = result.debugMessage.takeIf { it.isNotEmpty() }?.let { ": $it" } ?: ""
+        reply.reject(code, "Google Play billing $name (${result.responseCode})$detail")
+    }
+
+    companion object {
+        private val PERIOD = Regex("^P(\\d+)([DWMY])$")
+
+        /** An ISO 8601 billing period as Play writes it: P1W, P1M, P3M, P1Y, P3D. */
+        fun period(iso: String): IapPeriod? {
+            val match = PERIOD.find(iso) ?: return null
+            val unit = when (match.groupValues[2]) {
+                "D" -> IapPeriodUnit.DAY
+                "W" -> IapPeriodUnit.WEEK
+                "M" -> IapPeriodUnit.MONTH
+                else -> IapPeriodUnit.YEAR
+            }
+            return IapPeriod(unit = unit, value = match.groupValues[1].toDouble())
+        }
+    }
+}

package/vendor/@akanjs/native/plugins/iap/ios/IapPlugin.swift

@@ -0,0 +1,306 @@
+import StoreKit
+import UIKit
+
+/// In-app purchase with StoreKit 2 (akanjs readiness O6-3).
+/// - Transaction.updates is read once per process (IapStore, App scope), from the first plugin's
+///   creation, which is the app's launch: StoreKit delivers unfinished transactions there right away,
+///   and Ask to Buy approvals, renewals, refunds and purchases on other devices later. They reach the
+///   page as "transaction" events, kept until the first listener (C2 AkanNativeRetained); a window made
+///   again listens to the same stream. A transaction that purchase() answered is not sent again.
+/// - The page verifies `verification.jws` on its server (App Store Server API) and then finish()es.
+///   StoreKit's own check is only reported (`verified`); an unverified transaction still reaches the
+///   page, which must not grant it.
+/// - `appReceipt` is the old receipt file (deprecated in iOS 18, still written), for servers that still
+///   call verifyReceipt (akanjs-change-requests R5-7).
+/// - Products and transactions seen this session are kept, so purchase() and finish() need no second
+///   lookup; finish() falls back to Transaction.unfinished.
+/// The process's StoreKit state (App scope): the update stream, the transactions seen (for finish),
+/// and the ids purchase() answered.
+@MainActor
+final class IapStore {
+    static let shared = IapStore()
+    let retained = AkanNativeRetained<IapTransaction>()
+    var seen: [UInt64: Transaction] = [:]
+    var answered: Set<UInt64> = []
+    private var started = false
+
+    func start() {
+        guard !started else { return }
+        started = true
+        Task {
+            for await result in Transaction.updates {
+                let id = result.unsafePayloadValue.id
+                // A purchase that purchase() answered may come here too (it should not); send it once.
+                if self.answered.remove(id) != nil { continue }
+                self.retained.emit(IapPlugin.transaction(result), retain: true)
+            }
+        }
+    }
+}
+
+final class IapPlugin: IapPluginSpec {
+    static let id = "iap"
+    private let context: AkanNativePluginContext
+    private lazy var events = IapEvents(context)
+    private var products: [String: Product] = [:]
+    private var store: IapStore { IapStore.shared }
+
+    init(context: AkanNativePluginContext) {
+        self.context = context
+        IapStore.shared.start()
+    }
+
+    // MARK: products
+
+    func canMakePayments(_ reply: AkanNativeReply<IapCanMakePaymentsResult>) {
+        reply.resolve(IapCanMakePaymentsResult(value: AppStore.canMakePayments))
+    }
+
+    func getProducts(_ args: IapGetProductsArgs, _ reply: AkanNativeReply<IapGetProductsResult>) {
+        Task {
+            do {
+                let found = try await Product.products(for: args.ids)
+                var out: [IapProduct] = []
+                for product in found {
+                    products[product.id] = product
+                    out.append(await Self.product(product))
+                }
+                let ids = Set(found.map(\.id))
+                reply.resolve(IapGetProductsResult(products: out, invalidIds: args.ids.filter { !ids.contains($0) }))
+            } catch {
+                reply.reject(Self.code(error), "App Store products: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    private func product(_ id: String) async throws -> Product? {
+        if let product = products[id] { return product }
+        let product = try await Product.products(for: [id]).first
+        if let product { products[id] = product }
+        return product
+    }
+
+    // MARK: purchase
+
+    func purchase(_ args: IapPurchaseArgs, _ reply: AkanNativeReply<IapPurchaseResult>) {
+        var options: Set<Product.PurchaseOption> = []
+        if let account = args.accountId {
+            guard let uuid = UUID(uuidString: account) else {
+                return reply.reject(.invalidArgs, "accountId must be a UUID on iOS (StoreKit's appAccountToken)")
+            }
+            options.insert(.appAccountToken(uuid))
+        }
+        if let quantity = args.quantity {
+            guard quantity >= 1, quantity == quantity.rounded(), quantity <= 10 else {
+                return reply.reject(.invalidArgs, "quantity must be a whole number from 1 to 10")
+            }
+            options.insert(.quantity(Int(quantity)))
+        }
+        if let offer = args.promotionalOffer {
+            options.formUnion(Product.PurchaseOption.promotionalOffer(offer.offerId, compactJWS: offer.jws))
+        }
+        Task {
+            do {
+                guard let product = try await product(args.productId) else {
+                    return reply.reject(.notFound, "no App Store product \(args.productId)")
+                }
+                let result: Product.PurchaseResult
+                if #available(iOS 17.0, *), let scene = context.windowScene {
+                    result = try await product.purchase(confirmIn: scene, options: options)
+                } else {
+                    result = try await product.purchase(options: options)
+                }
+                switch result {
+                case .success(let verification):
+                    store.answered.insert(verification.unsafePayloadValue.id)
+                    reply.resolve(IapPurchaseResult(status: .purchased, transaction: Self.transaction(verification)))
+                case .pending:
+                    reply.resolve(IapPurchaseResult(status: .pending))
+                case .userCancelled:
+                    reply.reject(.cancelled, "the purchase was cancelled")
+                @unknown default:
+                    reply.reject(.internalError, "unknown purchase result")
+                }
+            } catch {
+                reply.reject(Self.code(error), "purchase failed: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    func finish(_ args: IapFinishArgs, _ reply: AkanNativeReply<Void>) {
+        guard let id = UInt64(args.transactionId) else {
+            return reply.reject(.invalidArgs, "transactionId is not an App Store transaction id")
+        }
+        Task {
+            var found = store.seen[id]
+            if found == nil {
+                for await result in Transaction.unfinished where result.unsafePayloadValue.id == id {
+                    found = result.unsafePayloadValue
+                    break
+                }
+            }
+            guard let found else { return reply.reject(.notFound, "no unfinished transaction \(id)") }
+            await found.finish()
+            store.seen[id] = nil
+            reply.resolve()
+        }
+    }
+
+    // MARK: owned
+
+    func getUnfinished(_ reply: AkanNativeReply<IapTransactionsResult>) {
+        Task { reply.resolve(IapTransactionsResult(transactions: await collect(Transaction.unfinished))) }
+    }
+
+    func getEntitlements(_ reply: AkanNativeReply<IapTransactionsResult>) {
+        Task { reply.resolve(IapTransactionsResult(transactions: await collect(Transaction.currentEntitlements))) }
+    }
+
+    func restore(_ reply: AkanNativeReply<IapTransactionsResult>) {
+        Task {
+            do {
+                try await AppStore.sync()
+            } catch {
+                return reply.reject(Self.code(error), "App Store sync: \(error.localizedDescription)")
+            }
+            reply.resolve(IapTransactionsResult(transactions: await collect(Transaction.currentEntitlements)))
+        }
+    }
+
+    private func collect(_ transactions: Transaction.Transactions) async -> [IapTransaction] {
+        var out: [IapTransaction] = []
+        for await result in transactions { out.append(Self.transaction(result)) }
+        return out
+    }
+
+    func manageSubscriptions(_ args: IapManageSubscriptionsArgs, _ reply: AkanNativeReply<Void>) {
+        guard let scene = context.windowScene else { return reply.reject(.unsupported, "no window scene to show the sheet in") }
+        Task {
+            do {
+                if #available(iOS 17.0, *), let id = args.productId, let group = try await product(id)?.subscription?.subscriptionGroupID {
+                    try await AppStore.showManageSubscriptions(in: scene, subscriptionGroupID: group)
+                } else {
+                    try await AppStore.showManageSubscriptions(in: scene)
+                }
+                reply.resolve()
+            } catch {
+                reply.reject(Self.code(error), "manage subscriptions: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    // MARK: events
+
+    /// Each window's plugin listens under its own key; the bridge stops it when the page ends.
+    private var listenKey: String { "iap-\(ObjectIdentifier(self).hashValue)" }
+
+    func startListening(_ event: String) {
+        guard event == "transaction" else { return }
+        store.retained.listen(listenKey) { [weak self] transaction in
+            guard let self else { return false }
+            self.events.transaction(transaction)
+            return true
+        }
+    }
+
+    func stopListening(_ event: String) {
+        store.retained.unlisten(listenKey)
+    }
+
+    // MARK: JSON
+
+    static func transaction(_ result: VerificationResult<Transaction>) -> IapTransaction {
+        let t = result.unsafePayloadValue
+        IapStore.shared.seen[t.id] = t
+        var verified = false
+        if case .verified = result { verified = true }
+        return IapTransaction(
+            id: String(t.id),
+            productId: t.productID,
+            state: t.revocationDate == nil ? .purchased : .revoked,
+            purchaseDate: Self.ms(t.purchaseDate),
+            quantity: Double(t.purchasedQuantity),
+            originalId: String(t.originalID),
+            expirationDate: t.expirationDate.map(Self.ms),
+            revocationDate: t.revocationDate.map(Self.ms),
+            accountId: t.appAccountToken?.uuidString.lowercased(),
+            environment: t.environment.rawValue,
+            verified: verified,
+            verification: IapVerification(
+                jws: result.jwsRepresentation,
+                transactionId: String(t.id),
+                originalTransactionId: String(t.originalID),
+                appReceipt: Self.appReceipt()
+            )
+        )
+    }
+
+    private static func ms(_ date: Date) -> Double { (date.timeIntervalSince1970 * 1000).rounded() }
+
+    private static func appReceipt() -> String? {
+        guard let url = Bundle.main.appStoreReceiptURL, let data = try? Data(contentsOf: url) else { return nil }
+        return data.base64EncodedString()
+    }
+
+    private static func product(_ p: Product) async -> IapProduct {
+        let currency = p.priceFormatStyle.currencyCode
+        let price = NSDecimalNumber(decimal: p.price).doubleValue
+        let type: IapProductType = switch p.type {
+        case .consumable: .consumable
+        case .autoRenewable: .subscription
+        case .nonRenewable: .nonRenewingSubscription
+        default: .nonConsumable
+        }
+        var offers: [IapOffer] = []
+        var eligible: Bool?
+        if let sub = p.subscription {
+            offers.append(IapOffer(kind: .base, phases: [IapPricingPhase(displayPrice: p.displayPrice, price: price, currency: currency, period: period(sub.subscriptionPeriod), cycles: 0, mode: .recurring)]))
+            if let intro = sub.introductoryOffer { offers.append(offer(intro, .introductory, currency)) }
+            for promo in sub.promotionalOffers { offers.append(offer(promo, .promotional, currency)) }
+            if #available(iOS 18.0, *) {
+                for winBack in sub.winBackOffers { offers.append(offer(winBack, .winBack, currency)) }
+            }
+            eligible = await sub.isEligibleForIntroOffer
+        } else {
+            offers.append(IapOffer(kind: .oneTime, phases: [IapPricingPhase(displayPrice: p.displayPrice, price: price, currency: currency, cycles: 1, mode: .payUpFront)]))
+        }
+        return IapProduct(
+            id: p.id, type: type, title: p.displayName, description: p.description,
+            displayPrice: p.displayPrice, price: price, currency: currency,
+            subscriptionPeriod: p.subscription.map { period($0.subscriptionPeriod) },
+            subscriptionGroupId: p.subscription?.subscriptionGroupID,
+            introOfferEligible: eligible,
+            offers: offers
+        )
+    }
+
+    private static func offer(_ o: Product.SubscriptionOffer, _ kind: IapOfferKind, _ currency: String) -> IapOffer {
+        let mode: IapPaymentMode = switch o.paymentMode {
+        case .freeTrial: .freeTrial
+        case .payUpFront: .payUpFront
+        default: .payAsYouGo
+        }
+        let phase = IapPricingPhase(displayPrice: o.displayPrice, price: NSDecimalNumber(decimal: o.price).doubleValue, currency: currency, period: period(o.period), cycles: Double(o.periodCount), mode: mode)
+        return IapOffer(kind: kind, id: o.id, phases: [phase])
+    }
+
+    private static func period(_ p: Product.SubscriptionPeriod) -> IapPeriod {
+        let unit: IapPeriodUnit = switch p.unit {
+        case .day: .day
+        case .week: .week
+        case .month: .month
+        default: .year
+        }
+        return IapPeriod(unit: unit, value: Double(p.value))
+    }
+
+    private static func code(_ error: any Error) -> AkanNativeErrorCode {
+        switch error {
+        case StoreKitError.userCancelled: .cancelled
+        case StoreKitError.notAvailableInStorefront, Product.PurchaseError.productUnavailable: .notFound
+        case Product.PurchaseError.purchaseNotAllowed: .permissionDenied
+        case is Product.PurchaseError: .invalidArgs
+        default: .internalError
+        }
+    }
+}