@tapayadot/accept-react-native 1.3.3 → 1.14.1

package/android/src/main/java/com/tapaya/acceptsdkreactnative/AcceptSdkReactNativeModule.kt

@@ -1,744 +1,262 @@
 package com.tapaya.acceptsdkreactnative
 
 import android.util.Base64
-import com.google.gson.Gson
 import com.tapaya.accept.Accept
-import com.tapaya.accept.AcceptDemoApi
-import com.tapaya.accept.external.IdentityData
-import com.tapaya.core.model.external.AcceptEnvironment
-import com.tapaya.core.model.external.AcceptUiBehavior
-import com.tapaya.core.model.external.BusinessType
-import com.tapaya.core.model.external.Currency
-import com.tapaya.core.model.external.NfcIndicator
-import com.tapaya.core.model.external.NfcPosition
-import com.tapaya.core.model.external.NfcZone
-import com.tapaya.core.model.external.PaymentMethod
-import com.tapaya.core.model.external.RefundReason
-import com.tapaya.core.model.external.exception.AcceptException
-import com.tapaya.core.model.external.intent.CardChargeIntent
-import com.tapaya.core.model.external.intent.CardRefundIntent
-import com.tapaya.core.model.external.intent.CertisInstantPaymentIntent
-import com.tapaya.core.model.external.intent.SepaInstantPaymentIntent
-import com.tapaya.core.model.external.result.AbstractPaymentResult
-import com.tapaya.core.model.external.result.CardPaymentResult
-import com.tapaya.core.model.external.result.CertisInstantPaymentResult
-import com.tapaya.core.model.external.result.SepaInstantPaymentResult
-import com.tapaya.core.ui.theme.AcceptColorTheme
-import com.tapaya.core.ui.theme.AcceptImageSource
-import com.tapaya.core.ui.theme.AcceptImageTheme
-import com.tapaya.core.ui.theme.AcceptThemeConfiguration
-import com.tapaya.core.ui.theme.AcceptThemeSource
-import com.tapaya.core.ui.theme.GradientColors
-import expo.modules.interfaces.permissions.PermissionsStatus
+import com.tapaya.accept.AcceptLogLevel
+import com.tapaya.accept.AcceptLogger
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.functions.Coroutine
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
-import expo.modules.kotlin.records.Field
-import expo.modules.kotlin.records.Record
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlin.coroutines.resume
-import kotlin.coroutines.resumeWithException
-
-//region-start
-class CardPaymentIntentReactNative : Record {
-    @Field
-    var paymentIntentId: String = ""
-
-    @Field
-    var amount: Long = 0L
-
-    @Field
-    var requestedCurrency: String = ""
-
-    @Field
-    var settlementCurrency: String = ""
-
-    fun toCardInstantPaymentIntent(): CardChargeIntent {
-        val requested = Currency.valueOf(requestedCurrency)
-        return CardChargeIntent(
-            paymentIntentId = paymentIntentId,
-            amount = amount,
-            requestedCurrency = requested,
-            settlementCurrency = if (settlementCurrency.isEmpty()) requested else Currency.valueOf(settlementCurrency)
-        )
-    }
-}
-
-class CardPaymentResultReactNative(
-    @Field
-    var status: String = "",
-    @Field
-    var readerStatus: String = "",
-    @Field
-    var last4: String = "",
-    @Field
-    var companyName: String = "",
-    @Field
-    var companyAddress1: String = "",
-    @Field
-    var companyAddress2: String = "",
-    @Field
-    var companyCity: String = "",
-    @Field
-    var companyCountry: String = "",
-    @Field
-    var terminalId: String = "",
-    @Field
-    var authorizationCode: String = "",
-    @Field
-    var brand: String = "",
-    @Field
-    var reason: String = "",
-    @Field
-    var receiptUrl: String? = null,
-    @Field
-    var refundToken: String? = null,
-    @Field
-    var type: String = "",
-) : Record
-
-fun CardPaymentResult.toReactNative(): CardPaymentResultReactNative {
-    return CardPaymentResultReactNative(
-        status = status.name.lowercase(),
-        readerStatus = readerStatus?.name?.lowercase() ?: "",
-        last4 = last4 ?: "",
-        companyName = companyName ?: "",
-        companyAddress1 = companyAddress1 ?: "",
-        companyAddress2 = companyAddress2 ?: "",
-        companyCity = companyCity ?: "",
-        companyCountry = companyCountry.toCountryAlpha2(),
-        terminalId = terminalId ?: "",
-        authorizationCode = authorizationCode ?: "",
-        brand = brand?.name ?: "",
-        reason = reason?.name ?: "",
-        receiptUrl = receiptUrl,
-        refundToken = refundToken,
-        type = "card"
-    )
-}
-
-class SepaPaymentIntentReactNative : Record {
-    @Field
-    var paymentIntentId: String = ""
-
-    @Field
-    var amount: Long = 0L
-
-    @Field
-    var requestedCurrency: String = ""
-
-    @Field
-    var settlementCurrency: String = ""
-
-    fun toSepaInstantPaymentIntent(): SepaInstantPaymentIntent {
-        val requested = Currency.valueOf(requestedCurrency)
-        return SepaInstantPaymentIntent(
-            paymentIntentId = paymentIntentId,
-            amount = amount,
-            requestedCurrency = requested,
-            settlementCurrency = if (settlementCurrency.isEmpty()) requested else Currency.valueOf(settlementCurrency)
-        )
-    }
-}
-
-class SepaPaymentInstantResultReactNative(
-    @Field
-    var status: String = "",
-    @Field
-    var postponed: Boolean = false,
-    @Field
-    var receivedAt: String = "",
-    @Field
-    var receivedFromIban: String = "",
-    @Field
-    var receiptUrl: String? = null,
-    @Field
-    var type: String = "",
-) : Record
-
-fun SepaInstantPaymentResult.toReactNative(): SepaPaymentInstantResultReactNative {
-    return SepaPaymentInstantResultReactNative(
-        status = status.name.lowercase(),
-        postponed = postponed,
-        receivedAt = receivedAt.toString(),
-        receivedFromIban = receivedFromIban ?: "",
-        receiptUrl = receiptUrl,
-        type = "sepa"
-    )
-}
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+/**
+ * Expo module wrapping the Accept SDK for Android.
+ *
+ * The bridge is deliberately flat: every SDK surface is exposed as a `<surface><Method>` function
+ * and the namespaced `Accept.auth.*` / `Accept.payments.*` shape is reassembled in TypeScript. The
+ * Kotlin SDK's two non-request/response surfaces — `Accept.state` and the `Flow<PaymentEvent>`
+ * returned by `pay()` — become the `onStateChange` and `onPaymentEvent` events.
+ */
+class AcceptSdkReactNativeModule : Module() {
 
-class CertisPaymentIntentReactNative : Record {
-    @Field
-    var paymentIntentId: String = ""
+    /**
+     * Scope for the SDK's flow collection. Main-immediate because the payment flow it collects
+     * launches activities, and cancelled wholesale when the module goes away so an in-flight
+     * payment's collector can't outlive the JavaScript context it reports to.
+     */
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
 
-    @Field
-    var amount: Long = 0L
+    /** Live `pay()` collectors, keyed by the request id the caller correlates its events with. */
+    private val paymentJobs = ConcurrentHashMap<String, Job>()
 
-    @Field
-    var requestedCurrency: String = ""
+    private var stateJob: Job? = null
 
-    @Field
-    var settlementCurrency: String = ""
+    override fun definition() = ModuleDefinition {
+        Name("AcceptSdkReactNative")
 
-    fun toCertisInstantPaymentIntent(): CertisInstantPaymentIntent {
-        val requested = Currency.valueOf(requestedCurrency)
-        return CertisInstantPaymentIntent(
-            paymentIntentId = paymentIntentId,
-            amount = amount,
-            requestedCurrency = requested,
-            settlementCurrency = if (settlementCurrency.isEmpty()) requested else Currency.valueOf(settlementCurrency)
-        )
-    }
-}
+        Events(EVENT_STATE_CHANGE, EVENT_PAYMENT, EVENT_LOG)
 
-class CertisPaymentInstantResultReactNative(
-    @Field
-    var status: String = "",
-    @Field
-    var postponed: Boolean = false,
-    @Field
-    var receivedAt: String = "",
-    @Field
-    var receivedFromIban: String = "",
-    @Field
-    var receiptUrl: String? = null,
-    @Field
-    var type: String = "",
-) : Record
-
-fun CertisInstantPaymentResult.toReactNative(): CertisPaymentInstantResultReactNative {
-    return CertisPaymentInstantResultReactNative(
-        status = status.name.lowercase(),
-        postponed = postponed,
-        receivedAt = receivedAt.toString(),
-        receivedFromIban = receivedFromIban ?: "",
-        receiptUrl = receiptUrl,
-        type = "certis"
-    )
-}
+        OnCreate {
+            stateJob = scope.launch {
+                Accept.state.collect { sendEvent(EVENT_STATE_CHANGE, mapOf("state" to it.serialize())) }
+            }
+        }
 
-class RefundIntentReactNative : Record {
-    @Field
-    var paymentToken: String = ""
+        OnDestroy {
+            stateJob = null
+            paymentJobs.clear()
+            scope.cancel()
+        }
 
-    @Field
-    var refundToken: String? = null
+        // ── Lifecycle ───────────────────────────────────────────────────────────
 
-    @Field
-    var reason: String = "customerRequest"
-}
+        Function("initialize") { isProduction: Boolean ->
+            Accept.initialize(appContext.reactContext ?: throw Exceptions.ReactContextLost(), isProduction)
+        }
 
-class RefundResultReactNative(
-    @Field
-    var refundToken: String? = null,
-    @Field
-    var status: String = "",
-    @Field
-    var refundReason: String = "",
-) : Record
+        Function("getState") { Accept.state.value.serialize() }
 
+        AsyncFunction("clear") Coroutine { -> sdkCall { Accept.clear() } }
 
-class GradientColorsRecord : Record {
-    @Field var start: String = ""
-    @Field var end: String = ""
-}
+        // ── Diagnostics ─────────────────────────────────────────────────────────
 
-class AcceptColorThemeRecord : Record {
-    @Field var accent: String = ""
-    @Field var error: String = ""
-    @Field var warning: String = ""
-    @Field var success: String = ""
-    @Field var brandGradientColors: GradientColorsRecord? = null
-    @Field var brandSubtleGradientColors: GradientColorsRecord? = null
-
-    fun toAcceptColorTheme(): AcceptColorTheme = AcceptColorTheme(
-        accent = accent.toComposeColor(),
-        error = error.toComposeColor(),
-        warning = warning.toComposeColor(),
-        success = success.toComposeColor(),
-        brandGradientColors = brandGradientColors?.let { GradientColors(it.start.toComposeColor(), it.end.toComposeColor()) },
-        brandSubtleGradientColors = brandSubtleGradientColors?.let { GradientColors(it.start.toComposeColor(), it.end.toComposeColor()) },
-    )
-}
+        Function("setDebugLoggingEnabled") { enabled: Boolean -> Accept.setDebugLoggingEnabled(enabled) }
 
-class AcceptImageThemeRecord : Record {
-    @Field var brandLogo: String = ""
-    @Field var toolbarLogo: String = ""
-    @Field var solidLogo: String = ""
-
-    fun toAcceptImageTheme(): AcceptImageTheme = try {
-        AcceptImageTheme(
-            brandLogo = AcceptImageSource.Data(Base64.decode(brandLogo, Base64.DEFAULT)),
-            toolbarLogo = AcceptImageSource.Data(Base64.decode(toolbarLogo, Base64.DEFAULT)),
-            solidLogo = AcceptImageSource.Data(Base64.decode(solidLogo, Base64.DEFAULT)),
-        )
-    } catch (e: IllegalArgumentException) {
-        throw Exception("ThemeError: invalid base64 image data — ${e.message}")
-    }
-}
+        Function("setLogLevel") { level: String -> Accept.setLogLevel(parseLogLevel(level)) }
 
-class AcceptThemeConfigurationRecord : Record {
-    @Field var themeId: String? = null
-    @Field var colors: AcceptColorThemeRecord? = null
-    @Field var images: AcceptImageThemeRecord? = null
-
-    @OptIn(AcceptDemoApi::class)
-    fun toAcceptThemeConfiguration(): AcceptThemeConfiguration {
-        themeId?.let { id ->
-            return AcceptThemeConfiguration(
-                colors = AcceptThemeSource.ById(id),
-                images = AcceptThemeSource.ById(id),
-            )
+        /**
+         * Mirrors the SDK's logs onto [EVENT_LOG] so JavaScript can route them into its own
+         * logging stack. Disabling restores the SDK's default Logcat sink.
+         */
+        Function("setLogForwardingEnabled") { enabled: Boolean ->
+            Accept.setLogger(if (enabled) EventLogger() else null)
         }
-        return AcceptThemeConfiguration(
-            colors = colors?.let { AcceptThemeSource.Local(it.toAcceptColorTheme()) } ?: AcceptThemeSource.Default,
-            images = images?.let { AcceptThemeSource.Local(it.toAcceptImageTheme()) } ?: AcceptThemeSource.Default,
-        )
-    }
-}
 
-private fun String.toComposeColor(): androidx.compose.ui.graphics.Color = try {
-    androidx.compose.ui.graphics.Color(android.graphics.Color.parseColor(this))
-} catch (e: IllegalArgumentException) {
-    throw Exception("ThemeError: invalid color '$this'. Expected #RRGGBB or #AARRGGBB — ${e.message}")
-}
+        // ── Theming ─────────────────────────────────────────────────────────────
 
-private fun Int?.toCountryAlpha2(): String = when (this) {
-    8 -> "AL"
-    20 -> "AD"
-    40 -> "AT"
-    51 -> "AM"
-    56 -> "BE"
-    70 -> "BA"
-    100 -> "BG"
-    112 -> "BY"
-    191 -> "HR"
-    196 -> "CY"
-    203 -> "CZ"
-    208 -> "DK"
-    233 -> "EE"
-    234 -> "FO"
-    246 -> "FI"
-    250 -> "FR"
-    268 -> "GE"
-    276 -> "DE"
-    292 -> "GI"
-    300 -> "GR"
-    304 -> "GL"
-    336 -> "VA"
-    348 -> "HU"
-    352 -> "IS"
-    372 -> "IE"
-    380 -> "IT"
-    398 -> "KZ"
-    417 -> "KG"
-    428 -> "LV"
-    438 -> "LI"
-    440 -> "LT"
-    442 -> "LU"
-    470 -> "MT"
-    492 -> "MC"
-    498 -> "MD"
-    499 -> "ME"
-    528 -> "NL"
-    578 -> "NO"
-    616 -> "PL"
-    620 -> "PT"
-    642 -> "RO"
-    643 -> "RU"
-    674 -> "SM"
-    688 -> "RS"
-    703 -> "SK"
-    705 -> "SI"
-    724 -> "ES"
-    752 -> "SE"
-    756 -> "CH"
-    792 -> "TR"
-    804 -> "UA"
-    807 -> "MK"
-    826 -> "GB"
-    else -> ""
-}
+        Function("setTheme") { theme: Map<String, Any?>? -> Accept.setTheme(theme?.let(::parseTheme)) }
 
-private fun String.toPaymentMethod(): PaymentMethod = when (this) {
-    "CARD" -> PaymentMethod.CARD
-    "SEPA" -> PaymentMethod.SEPA_INST
-    "CERTIS" -> PaymentMethod.CERTIS
-    "CRYPTO" -> PaymentMethod.CRYPTO
-    else -> throw IllegalArgumentException("Unknown payment method: $this")
-}
+        Function("getTheme") { Accept.getTheme()?.serialize() }
 
-private fun PaymentMethod.toJsString(): String = when (this) {
-    PaymentMethod.CARD -> "CARD"
-    PaymentMethod.SEPA_INST -> "SEPA"
-    PaymentMethod.CERTIS -> "CERTIS"
-    PaymentMethod.CRYPTO -> "CRYPTO"
-}
+        Function("createLocalThemeImageUri") { base64: String, fileExtension: String ->
+            Accept.createLocalThemeImageUri(Base64.decode(base64, Base64.DEFAULT), fileExtension)
+        }
 
-private fun String.toRefundReason(): RefundReason = when (this) {
-    "customerRequest" -> RefundReason.CUSTOMER_REQUEST
-    "duplicate" -> RefundReason.DUPLICATE
-    "fraudulent" -> RefundReason.FRAUDULENT
-    "expiredCharge" -> RefundReason.EXPIRED_CHARGE
-    else -> throw IllegalArgumentException("Unknown refund reason: $this")
-}
+        // ── Auth ────────────────────────────────────────────────────────────────
 
-class NfcPositionRecord : Record {
-    @Field var xBias: Float = 0f
-    @Field var yBias: Float = 0f
-}
-
-class NfcZoneRecord : Record {
-    @Field var indicator: String = "DEFAULT"
-    @Field var position: NfcPositionRecord? = null
+        AsyncFunction("authenticate") Coroutine { merchantToken: String ->
+            sdkCall { Accept.auth.authenticate(merchantToken) }
+        }
 
-    fun toNfcZone(): NfcZone {
-        val pos = position?.let { NfcPosition.Custom(it.xBias, it.yBias) } ?: NfcPosition.Default
-        return NfcZone(indicator = indicator.toNfcIndicator(), position = pos)
-    }
-}
+        // ── SDK ─────────────────────────────────────────────────────────────────
 
-class AcceptUiBehaviorRecord : Record {
-    @Field var resultScreenDurationSeconds: Int = 10
-    @Field var showResultScreen: Boolean = true
-    @Field var nfcZone: NfcZoneRecord? = null
+        Function("getSdkVersion") { Accept.sdk.version }
 
-    fun toAcceptUiBehavior(): AcceptUiBehavior = AcceptUiBehavior(
-        resultScreenDurationSeconds = resultScreenDurationSeconds,
-        showResultScreen = showResultScreen,
-        nfcZone = nfcZone?.toNfcZone(),
-    )
-}
+        Function("isProduction") { sdkCallSync { Accept.sdk.isProduction } }
 
-private fun String.toNfcIndicator(): NfcIndicator = when (this) {
-    "DEFAULT" -> NfcIndicator.DEFAULT
-    "ABOVE" -> NfcIndicator.ABOVE
-    "BELOW" -> NfcIndicator.BELOW
-    "FRONT" -> NfcIndicator.FRONT
-    "BEHIND" -> NfcIndicator.BEHIND
-    else -> throw IllegalArgumentException("Unknown NFC indicator: $this")
-}
+        AsyncFunction("getDeviceId") Coroutine { -> sdkCall { Accept.sdk.deviceId() } }
 
-class KybPrefillDataRecord : Record {
-    @Field var businessType: String? = null
-    @Field var countryCode: String? = null
-    @Field var registrationNumber: String? = null
-    @Field var vatNumber: String? = null
-    @Field var legalName: String? = null
-    @Field var addressLine1: String? = null
-    @Field var addressLine2: String? = null
-    @Field var city: String? = null
-    @Field var postalCode: String? = null
-    @Field var merchantCategoryCode: Int? = null
-    @Field var businessEmail: String? = null
-    @Field var bankAccountIban: String? = null
-    @Field var businessUrl: String? = null
-    @Field var productDescription: String? = null
-    @Field var supportPhone: String? = null
-
-    fun toIdentityData(): IdentityData = IdentityData(
-        businessType = businessType?.let { BusinessType.valueOf(it) },
-        countryCode = countryCode,
-        registrationNumber = registrationNumber,
-        vatNumber = vatNumber,
-        legalName = legalName,
-        addressLine1 = addressLine1,
-        addressLine2 = addressLine2,
-        city = city,
-        postalCode = postalCode,
-        merchantCategoryCode = merchantCategoryCode,
-        businessEmail = businessEmail,
-        bankAccountIban = bankAccountIban,
-        businessUrl = businessUrl,
-        productDescription = productDescription,
-        supportPhone = supportPhone,
-    )
-}
+        AsyncFunction("getMinimumAmounts") Coroutine { ->
+            sdkCall { Accept.sdk.minimumAmounts().map { it.serialize() } }
+        }
 
-//endregion-end
+        // ── Merchant ────────────────────────────────────────────────────────────
 
-class AcceptSdkReactNativeModule : Module() {
-    override fun definition() = ModuleDefinition {
-        Name("AcceptSdkReactNative")
+        AsyncFunction("getMerchantInfo") Coroutine { -> sdkCall { Accept.merchant.info()?.serialize() } }
 
-        Events(
-            "onCardPaymentStatusChange",
-            "onSepaPaymentStatusChange",
-            "onCertisPaymentStatusChange",
-            "onCardPaymentException",
-            "onSepaPaymentException",
-            "onCertisPaymentException",
-        )
-
-        AsyncFunction("initialize") Coroutine { demo: Boolean, theme: AcceptThemeConfigurationRecord? ->
-            val context = appContext.reactContext ?: throw Exception("Context not available")
-            val environment = if (demo) AcceptEnvironment.SANDBOX else AcceptEnvironment.PRODUCTION
-            Accept.initialize(context, environment, theme?.toAcceptThemeConfiguration() ?: AcceptThemeConfiguration.Default)
-        }
+        AsyncFunction("getMerchantConfig") Coroutine { -> sdkCall { Accept.merchant.config().serialize() } }
 
-        AsyncFunction("setTheme") Coroutine { theme: AcceptThemeConfigurationRecord ->
-            Accept.setThemeConfiguration(theme.toAcceptThemeConfiguration())
-            return@Coroutine
+        AsyncFunction("getOnboardingStatus") Coroutine { ->
+            sdkCall { Accept.merchant.onboardingStatus().serialize() }
         }
 
-        AsyncFunction("setUiBehavior") { behavior: AcceptUiBehaviorRecord ->
-            Accept.setUiBehavior(behavior.toAcceptUiBehavior())
+        AsyncFunction("getAvailableCurrencies") Coroutine { -> sdkCall { Accept.merchant.availableCurrencies() } }
+
+        // ── Payments ────────────────────────────────────────────────────────────
+
+        /**
+         * Sets the session-wide payment defaults. `setOptions` keeps every option the caller
+         * doesn't name, so each key present in [options] is applied by its own call — that is what
+         * lets a caller set one default without disturbing the others, and it keeps an absent key
+         * distinct from an explicit `null` timeout.
+         */
+        Function("setPaymentOptions") { options: Map<String, Any?> ->
+            options.receiptConfig()?.let { Accept.payments.setOptions(receiptConfig = it) }
+            options.nfcPosition()?.let { Accept.payments.setOptions(nfcPosition = it) }
+            options.display()?.let { Accept.payments.setOptions(display = it) }
+            if (options.containsKey("transactionTimeoutMs")) {
+                Accept.payments.setOptions(transactionTimeout = options.transactionTimeout())
+            }
         }
 
-        AsyncFunction("authenticate") Coroutine { token: String ->
-            return@Coroutine suspendCancellableCoroutine<Boolean> { continuation ->
-                try {
-                    Accept.authenticate(
-                        token,
-                        onSuccess = { continuation.resume(true) },
-                        onError = { error -> (error as? Throwable)?.let { continuation.resumeWithException(it) } }
-                    )
-                } catch (e: Exception) {
-                    continuation.resumeWithException(e)
+        /**
+         * Starts a payment and streams its `Flow<PaymentEvent>` onto [EVENT_PAYMENT], tagged with
+         * [requestId]. Returns as soon as the collector is running; the caller learns the outcome
+         * from the terminal `result` or `creationFailed` event.
+         */
+        Function("startPayment") { requestId: String, request: Map<String, Any?> ->
+            val job = scope.launch {
+                Accept.payments.pay(
+                    amount = request.amount(),
+                    currency = request.currency(),
+                    paymentToken = request["paymentToken"] as? String,
+                    receiptConfig = request.receiptConfig(),
+                    nfcPosition = request.nfcPosition(),
+                    metadata = parseMetadata(request.metadata()),
+                    tip = request.tip(),
+                    transactionTimeout = request.transactionTimeout(),
+                    display = request.display(),
+                ).collect { event ->
+                    sendEvent(EVENT_PAYMENT, mapOf("requestId" to requestId, "event" to event.serialize()))
                 }
+                paymentJobs.remove(requestId)
             }
+            paymentJobs[requestId] = job
         }
 
-        Function("getStatus") { ->
-            try {
-                return@Function Accept.status.name
-            } catch (e: Exception) {
-                throw e
-            }
+        /**
+         * Stops reporting events for [requestId]. This detaches the listener only — the plugin's
+         * payment UI is already on screen by then, and is dismissed by the user or by
+         * `cancelPayment(paymentToken)` against the backend.
+         */
+        Function("stopPaymentEvents") { requestId: String ->
+            paymentJobs.remove(requestId)?.cancel()
         }
 
-        AsyncFunction("getPaymentStatus") Coroutine { paymentIntentId: String ->
-            return@Coroutine suspendCancellableCoroutine<String> { continuation ->
-                try {
-                    Accept.getPaymentStatus(
-                        paymentIntentId,
-                        { result: AbstractPaymentResult ->
-                            val mapped = when (result) {
-                                is CardPaymentResult -> result.toReactNative()
-                                is CertisInstantPaymentResult -> result.toReactNative()
-                                is SepaInstantPaymentResult -> result.toReactNative()
-                                else -> throw Exception("Unsupported payment result type")
-                            }
-
-                            continuation.resume(Gson().toJson(mapped))
-                        },
-                        { error: AcceptException ->
-                            (error as? Throwable)?.let { continuation.resumeWithException(it) }
-                        }
-                    )
-                } catch (e: Exception) {
-                    continuation.resumeWithException(e)
-                }
-            }
+        AsyncFunction("getPaymentStatus") Coroutine { paymentToken: String ->
+            sdkCall { Accept.payments.status(paymentToken).serialize() }
         }
 
-        AsyncFunction("requestLocationPermission") Coroutine { ->
-            return@Coroutine suspendCancellableCoroutine<Boolean> { continuation ->
-                appContext.permissions?.askForPermissions(
-                    {
-                        val result = it.map { (_, value) ->
-                            value.status == PermissionsStatus.GRANTED
-                        }.reduce { acc, i -> acc.and(i) }
-                        continuation.resume(result)
-                    },
-                    "android.permission.ACCESS_FINE_LOCATION",
-                    "android.permission.ACCESS_COARSE_LOCATION"
-                )
-            }
+        AsyncFunction("cancelPayment") Coroutine { paymentToken: String ->
+            sdkCall { Accept.payments.cancel(paymentToken).name }
         }
 
-        AsyncFunction("logOut") Coroutine { ->
-            return@Coroutine suspendCancellableCoroutine<Boolean> { continuation ->
-                try {
-                    Accept.logOut {
-                        continuation.resume(true)
-                    }
-                } catch (e: Exception) {
-                    continuation.resumeWithException(e)
-                }
-            }
+        AsyncFunction("refundPayment") Coroutine { paymentToken: String, reason: String ->
+            sdkCall { Accept.payments.refund(paymentToken, parseRefundReason(reason)).name }
         }
 
-        AsyncFunction("isPaymentPending") { ->
-            try {
-                return@AsyncFunction Accept.isPaymentPending()
-            } catch (e: Exception) {
-                throw e
-            }
-        }
+        // ── Plugin ──────────────────────────────────────────────────────────────
 
-        AsyncFunction("presentKyb") Coroutine { prefilling: KybPrefillDataRecord? ->
-            Accept.identity.presentKyb(prefilling?.toIdentityData())
-        }
+        Function("isPluginInstalled") { sdkCallSync { Accept.plugin.isInstalled() } }
 
-        AsyncFunction("getOnboardingStatus") Coroutine { ->
-            val status = Accept.identity.getOnboardingStatus()
-            return@Coroutine mapOf(
-                "isOnboarded" to status.isOnboarded,
-                "paymentMethods" to status.paymentMethods.map { pm ->
-                    mapOf(
-                        "method" to pm.method.toJsString(),
-                        "status" to pm.status.name,
-                    )
-                },
-            )
-        }
+        AsyncFunction("installPlugin") Coroutine { -> sdkCall { Accept.plugin.install() } }
 
-        AsyncFunction("getPaymentMethodStatus") Coroutine { method: String ->
-            val status = Accept.identity.getPaymentMethodStatus(method.toPaymentMethod())
-            return@Coroutine status.name
-        }
+        AsyncFunction("activateTerminal") Coroutine { -> sdkCall { Accept.plugin.activateTerminal().serialize() } }
 
-        AsyncFunction("startCardPayment") Coroutine { paymentIntent: CardPaymentIntentReactNative ->
-            return@Coroutine suspendCancellableCoroutine<CardPaymentResultReactNative> { continuation ->
-                try {
-                    Accept.cardTerminal.process(
-                        paymentIntent.toCardInstantPaymentIntent(),
-                        onResult = {
-                            continuation.resume(it.toReactNative())
-                        },
-                        onStatus = {
-                            sendEvent("onCardPaymentStatusChange", mapOf("data" to it.name.lowercase()))
-                        },
-                        onError = {
-                            sendEvent("onCardPaymentException", it.toReactNative())
-                        }
-                    )
-                } catch (e: Exception) {
-                    continuation.resumeWithException(e)
-                }
-            }
-        }
+        AsyncFunction("getPluginStatus") Coroutine { -> sdkCall { Accept.plugin.status().serialize() } }
 
-        AsyncFunction("startSepaPayment") Coroutine { paymentIntent: SepaPaymentIntentReactNative ->
-            return@Coroutine suspendCancellableCoroutine<SepaPaymentInstantResultReactNative> { continuation ->
-                try {
-                    Accept.sepaTerminal.process(
-                        paymentIntent.toSepaInstantPaymentIntent(),
-                        onResult = {
-                            continuation.resume(it.toReactNative())
-                        },
-                        onStatus = {
-                            sendEvent("onSepaPaymentStatusChange", mapOf("data" to it.name.lowercase()))
-                        },
-                        onError = {
-                            sendEvent("onSepaPaymentException", it.toReactNative())
-                        }
-                    )
-                } catch (e: Exception) {
-                    continuation.resumeWithException(e)
-                }
-            }
-        }
+        AsyncFunction("getPluginUpdateInfo") Coroutine { -> sdkCall { Accept.plugin.updateInfo().serialize() } }
 
-        AsyncFunction("startCertisPayment") Coroutine { paymentIntent: CertisPaymentIntentReactNative ->
-            return@Coroutine suspendCancellableCoroutine<CertisPaymentInstantResultReactNative> { continuation ->
-                try {
-                    Accept.certisTerminal.process(
-                        paymentIntent.toCertisInstantPaymentIntent(),
-                        onResult = {
-                            continuation.resume(it.toReactNative())
-                        },
-                        onStatus = {
-                            sendEvent("onCertisPaymentStatusChange", mapOf("data" to it.name.lowercase()))
-                        },
-                        onError = {
-                            sendEvent("onCertisPaymentException", it.toReactNative())
-                        }
-                    )
-                } catch (e: Exception) {
-                    continuation.resumeWithException(e)
-                }
-            }
-        }
+        AsyncFunction("logoutPlugin") Coroutine { -> sdkCall { Accept.plugin.logout() } }
 
-        AsyncFunction("refund") Coroutine { intent: RefundIntentReactNative ->
-            return@Coroutine suspendCancellableCoroutine<RefundResultReactNative> { continuation ->
-                try {
-                    val refundIntent = CardRefundIntent(
-                        sourcePaymentToken = intent.paymentToken,
-                        refundReason = intent.reason.toRefundReason(),
-                        refundToken = intent.refundToken,
-                    )
-                    Accept.cardTerminal.process(
-                        refundIntent,
-                        onResult = { result ->
-                            continuation.resume(
-                                RefundResultReactNative(
-                                    refundToken = result.refundToken,
-                                    status = result.status.name.lowercase(),
-                                    refundReason = intent.reason,
-                                )
-                            )
-                        },
-                        onStatus = { /* refund flow emits no UI status */ },
-                        onError = { error ->
-                            continuation.resumeWithException(error as Throwable)
-                        }
-                    )
-                } catch (e: Exception) {
-                    continuation.resumeWithException(e)
-                }
-            }
-        }
+        // ── Displays ────────────────────────────────────────────────────────────
 
-        AsyncFunction("cancelActivePayment") { ->
-            if (!Accept.isPaymentPending()) {
-                throw Exception("NoActivePayment")
-            }
-            Accept.cardTerminal.reset()
-            Accept.sepaTerminal.reset()
-            Accept.certisTerminal.reset()
-        }
+        Function("getDisplays") { Accept.displays.all().map { it.serialize() } }
 
-        AsyncFunction("enableDemoMode") { ->
-            Accept.enableDemoMode()
-        }
+        Function("getCustomerFacingDisplay") { Accept.displays.customerFacing()?.serialize() }
 
-        AsyncFunction("disableDemoMode") { ->
-            Accept.disableDemoMode()
-        }
+        Function("isDualScreen") { Accept.displays.isDualScreen }
+    }
 
-        AsyncFunction("isDemoMode") { ->
-            Accept.isDemoMode()
+    /** Forwards the SDK's consumer-facing logs to JavaScript as [EVENT_LOG]. */
+    private inner class EventLogger : AcceptLogger {
+        override fun log(level: AcceptLogLevel, tag: String, message: String, throwable: Throwable?) {
+            sendEvent(
+                EVENT_LOG,
+                mapOf(
+                    "level" to level.name,
+                    "tag" to tag,
+                    "message" to message,
+                    "throwable" to throwable?.message,
+                ),
+            )
         }
+    }
 
-        AsyncFunction("isCompanionAppInstalled") { ->
-            return@AsyncFunction Accept.isCompanionAppInstalled()
-        }
+    private companion object {
+        const val EVENT_STATE_CHANGE = "onStateChange"
+        const val EVENT_PAYMENT = "onPaymentEvent"
+        const val EVENT_LOG = "onLog"
+    }
+}
 
-        AsyncFunction("pairWithCompanionApp") Coroutine { ->
-            return@Coroutine suspendCancellableCoroutine<Unit> { continuation ->
-                try {
-                    Accept.pairWithCompanionApp(
-                        onSuccess = { continuation.resume(Unit) },
-                        onError = { error -> continuation.resumeWithException(error as Throwable) }
-                    )
-                } catch (e: Exception) {
-                    continuation.resumeWithException(e)
-                }
-            }
-        }
+// ── Request map accessors ───────────────────────────────────────────────────────
+//
+// `pay()` and `setOptions()` read the same option names out of two different maps (a per-payment
+// request and the session defaults), so the accessors are shared. Each returns null when the key is
+// absent, which is exactly what the SDK reads as "use the default".
 
-        AsyncFunction("presentCompanionAppSheet") Coroutine { ->
-            return@Coroutine suspendCancellableCoroutine<Unit> { continuation ->
-                try {
-                    Accept.presentCompanionAppSheet(
-                        onSuccess = { continuation.resume(Unit) },
-                        onError = { error -> continuation.resumeWithException(error as Throwable) }
-                    )
-                } catch (e: Exception) {
-                    continuation.resumeWithException(e)
-                }
-            }
-        }
+private fun Map<String, Any?>.amount(): Long = (this["amount"] as? Number)?.toLong()
+    ?: throw CodedException("ERR_INVALID_ARGUMENT", "amount is required", null)
 
-    }
+private fun Map<String, Any?>.currency(): String = this["currency"] as? String
+    ?: throw CodedException("ERR_INVALID_ARGUMENT", "currency is required", null)
 
-    private fun AcceptException.toReactNative(): Map<String, String> {
-        return mapOf(
-            "message" to ((this as Throwable).message ?: ""),
-            "exception" to ((this as Throwable).cause?.stackTraceToString() ?: "")
-        )
-    }
-}
+private fun Map<String, Any?>.tip(): Long? = (this["tip"] as? Number)?.toLong()
+
+private fun Map<String, Any?>.transactionTimeout() =
+    (this["transactionTimeoutMs"] as? Number)?.toLong()?.milliseconds
+
+@Suppress("UNCHECKED_CAST")
+private fun Map<String, Any?>.receiptConfig() =
+    (this["receiptConfig"] as? Map<String, Any?>)?.let(::parseReceiptConfig)
+
+@Suppress("UNCHECKED_CAST")
+private fun Map<String, Any?>.nfcPosition() =
+    (this["nfcPosition"] as? Map<String, Any?>)?.let(::parseNfcPosition)
+
+@Suppress("UNCHECKED_CAST")
+private fun Map<String, Any?>.display() =
+    (this["display"] as? Map<String, Any?>)?.let(::parsePaymentDisplay)
+
+@Suppress("UNCHECKED_CAST")
+private fun Map<String, Any?>.metadata() = this["metadata"] as? Map<String, Any?>