@tapayadot/accept-react-native 1.19.1 → 1.20.0

package/CHANGELOG.md

@@ -9,6 +9,36 @@ Each release must have a `## [x.y.z]` section that matches the `version` in
 `package.json`. The publish workflow refuses to release a version whose section
 is missing or empty.
 
+## [1.20.0] - 2026-10-29
+
+Carries Accept SDK for Android 1.20.0 to Expo apps. The core, optional self-installer, Android NFC,
+and Sunmi NFC artifacts are version-locked to 1.20.0.
+
+### Added
+
+- **Optional NFC tag sessions through `Accept.nfc`.** Set the config plugin's `nfc` option to
+  `true` for phones and other Android-NFC devices, or `{ "sunmi": true }` to also include Sunmi
+  P-series support. Sessions read and write Mifare Classic, Type 2 and ISO-DEP tags using
+  `Uint8Array`, expose their selected `TagInfo`, and report their one-shot end reason. They need
+  `Accept.initialize()`, not an authenticated merchant or the Accept plugin app.
+- **`TagSessionError` preserves NFC failures.** Its `reason`, `authLost`, and optional `vendorCode`
+  distinguish retryable reader/tag failures from malformed arguments and integration errors.
+- **`AcceptPluginPackages` exports the production and sandbox plugin package names** for native
+  device-policy controllers adding the selected plugin to Android's lock-task allowlist.
+
+### Changed
+
+- **Payments take the reader from an open NFC session.** Its `ended` promise resolves with
+  `PAYMENT`; a new session reports `READER_BUSY` until the payment releases the reader.
+- **The Android AAR is now minified.** The wrapper uses only the supported public SDK, NFC, domain,
+  and exception APIs, so obfuscation of `com.tapaya.accept.internal` does not change its API.
+
+### Fixed
+
+- **Forward-compatible backend enum values no longer discard otherwise usable responses.** Fields
+  the Android SDK only filters on now skip unknown values; public business, onboarding and payment
+  state enums keep their existing failure behavior.
+
 ## [1.19.1] - 2026-10-20
 
 Carries Accept SDK for Android 1.19.1 to Expo apps. Both `com.tapaya:accept` and the optional

package/README.md

@@ -49,12 +49,16 @@ npx expo run:android
 | Option | Default | What it does |
 | --- | --- | --- |
 | `selfInstall` | `false` | Lets the SDK install the plugin app itself on terminals with no app store. See [Installing the plugin app](#installing-the-plugin-app). |
+| `nfc` | `false` | Adds NFC tag sessions. Use `true` for Android NFC or `{ "sunmi": true }` to add both Android and Sunmi readers. See [NFC tag sessions](#nfc-tag-sessions). |
 
 ```json
 {
   "expo": {
     "plugins": [
-      ["@tapayadot/accept-react-native", { "selfInstall": true }]
+      [
+        "@tapayadot/accept-react-native",
+        { "selfInstall": true, "nfc": { "sunmi": true } }
+      ]
     ]
   }
 }
@@ -65,6 +69,12 @@ npx expo run:android
 you to justify it on your listing, so leave the option off unless your terminals are
 storeless. Changing it takes effect on the next `npx expo prebuild`.
 
+`nfc: true` adds `com.tapaya:accept-nfc`, Android's NFC permission, and a non-required NFC feature
+declaration, so Play does not hide the app from devices without Android NFC. `nfc: { "sunmi": true }`
+also adds `com.tapaya:accept-nfc-sunmi`, which embeds Sunmi PayLib and carries only
+`com.sunmi.perm.CONTACTLESS_CARD`. The Sunmi option always includes the base NFC artifact; enabling
+base NFC alone never includes PayLib or the Sunmi permission.
+
 Beyond those options the plugin only raises `minSdkVersion` to 30. Everything else the SDK needs — the
 `INTERNET`, `ACCESS_NETWORK_STATE`, and location permissions, the `<queries>` entries that
 make the plugin app visible on API 30+, and the activities that run a payment on a
@@ -120,12 +130,16 @@ Everything hangs off the default export.
 | SDK      | `Accept.sdk`       | `version`, `isProduction`, `deviceId()`, `minimumAmounts()`                     |
 | Merchant | `Accept.merchant`  | `info()`, `config()`, `onboardingStatus()`, `availableCurrencies()`             |
 | Payments | `Accept.payments`  | `pay()`, `payAsync()`, `status()`, `cancel()`, `refund()`, `setOptions()`       |
+| NFC      | `Accept.nfc`       | `isSupported()`, `openSession()` and tag read/write sessions                   |
 | Plugin   | `Accept.plugin`    | `isInstalled()`, `install()`, `activateTerminal()`, `status()`, `updateInfo()`, `logout()` |
 | Displays | `Accept.displays`  | `all()`, `customerFacing()`, `isDualScreen`                                     |
 
 Top-level: `initialize()`, `clear()`, `setTheme()`, `getTheme()`,
 `createLocalThemeImageUri()`, `setLogLevel()`, `setDebugLoggingEnabled()`, `setLogger()`.
 
+The named `AcceptPluginPackages` export contains the production and sandbox plugin package names
+for device-policy controllers configuring Android lock-task allowlists.
+
 ### Lifecycle
 
 `Accept.state` moves `idle → initialized → authenticated`:
@@ -208,6 +222,71 @@ nfcPosition: {
 },
 ```
 
+### NFC tag sessions
+
+Tag sessions use the device's reader directly, without the Accept plugin. They require
+`Accept.initialize()`, but not `Accept.auth.authenticate()`. Enable the optional artifact first:
+
+```json
+["@tapayadot/accept-react-native", { "nfc": true }]
+```
+
+Use `{ "nfc": { "sunmi": true } }` for an APK that also runs on Sunmi P-series terminals. The SDK
+selects the available backend at runtime: Android NFC on phones, Sunmi's pay service on P-series.
+
+```ts
+import Accept, { TagSessionError } from '@tapayadot/accept-react-native';
+
+Accept.initialize();
+
+if (Accept.nfc.isSupported()) {
+  const session = await Accept.nfc.openSession({ tapWaitMs: 30_000 });
+  session.ended.then((reason) => console.log('session ended:', reason));
+
+  try {
+    if (session.info.family === 'NTAG') {
+      const pages = await session.readPages(4); // Uint8Array, 16 bytes
+      console.log(Array.from(pages));
+    }
+  } catch (error) {
+    if (TagSessionError.is(error)) {
+      console.log(error.reason, error.authLost, error.vendorCode);
+    } else {
+      throw error;
+    }
+  } finally {
+    await session.close();
+  }
+}
+```
+
+`TagSession` supports Mifare Classic authentication, block and value operations; Type 2 page,
+password, Ultralight C and raw-frame operations; and ISO-DEP APDUs. Binary inputs and results are
+`Uint8Array`. A payment takes priority over a tag session: starting `Accept.payments.pay()` ends the
+session with `PAYMENT`, and opening a session during a payment fails with `READER_BUSY`.
+
+Writes pass straight through. Lock bits, OTP pages, Classic sector trailers, passwords, and value
+operations can permanently change a tag; the caller owns any confirmation and safety policy.
+When phone NFC is switched off, `isSupported()` remains true because the reader exists and
+`openSession()` rejects with `NFC_DISABLED` so the app can ask the user to enable it.
+
+If NFC was not enabled in the config plugin, `isSupported()` returns false and `openSession()`
+rejects with `ERR_NFC_NOT_CONFIGURED` and rebuild instructions.
+
+### Plugin package names and lock task
+
+```ts
+import { AcceptPluginPackages } from '@tapayadot/accept-react-native';
+
+AcceptPluginPackages.PRODUCTION; // com.tapaya.accept.plugin
+AcceptPluginPackages.SANDBOX;    // com.tapaya.accept.plugin.sandbox
+AcceptPluginPackages.ALL;        // readonly array containing both
+```
+
+These names are for a native device-policy controller calling
+`DevicePolicyManager.setLockTaskPackages`. Manifest package queries make the plugin visible but do
+not authorize it for lock task.
+
 ### Dual-screen terminals
 
 On dual-sided hardware, run the payment UI on the customer-facing panel while your app keeps
@@ -363,7 +442,8 @@ Expo inlines `EXPO_PUBLIC_*` variables into the bundle at build time.
 
 The example needs a real device with the Accept plugin app installed; an emulator has no card
 reader. Tap **Login** to mint a merchant token and authenticate, then **activateTerminal()** once
-before the first payment.
+before the first payment. The NFC tag-session controls need only `initialize()` and a supported
+Android or Sunmi reader; they do not need login, activation, or the plugin app.
 
 ## License
 

package/android/build.gradle

@@ -60,14 +60,41 @@ def selfInstall = Boolean.parseBoolean(
   String.valueOf(safeExtGet(selfInstallProperty, findProperty(selfInstallProperty) ?: false))
 )
 
+// NFC tag sessions are optional. The source set is optional as well as the dependency: keeping
+// references to `com.tapaya.accept.nfc` out of the default build is what lets an app omit the AAR
+// entirely, rather than merely omitting it at runtime after Kotlin compiled against it.
+def nfcProperty = "tapaya.accept.nfc"
+def nfcSunmiProperty = "tapaya.accept.nfcSunmi"
+def nfcSunmi = Boolean.parseBoolean(
+  String.valueOf(safeExtGet(nfcSunmiProperty, findProperty(nfcSunmiProperty) ?: false))
+)
+// Sunmi's artifact extends the base NFC artifact. Treat a manually-set Sunmi property as an
+// implicit base opt-in too, matching the config plugin and avoiding an invalid bare-RN setup.
+def nfc = nfcSunmi || Boolean.parseBoolean(
+  String.valueOf(safeExtGet(nfcProperty, findProperty(nfcProperty) ?: false))
+)
+
+android.sourceSets.main.java.srcDir(nfc ? "src/nfc/java" : "src/nfcDisabled/java")
+
 dependencies {
     // Published to Maven Central; no additional repository declaration is needed.
-    implementation 'com.tapaya:accept:1.19.1'
+    implementation 'com.tapaya:accept:1.20.0'
 
     // Optional, and version-locked to the line above: the installer calls into `:accept` internals
     // that are not part of the public surface, so a skew between the two is a runtime failure
     // rather than a resolution error.
     if (selfInstall) {
-        implementation 'com.tapaya:accept-installer:1.19.1'
+        implementation 'com.tapaya:accept-installer:1.20.0'
+    }
+
+    if (nfc) {
+        implementation 'com.tapaya:accept-nfc:1.20.0'
+    }
+
+    // Kept separate from the base artifact because it embeds Sunmi PayLib and merges the vendor's
+    // CONTACTLESS_CARD permission. `nfcSunmi` implies `nfc`, so both direct pins are present and
+    // version-skew checks can keep the extension line locked to the core SDK.
+    if (nfcSunmi) {
+        implementation 'com.tapaya:accept-nfc-sunmi:1.20.0'
     }
 }

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

@@ -39,6 +39,7 @@ class AcceptSdkReactNativeModule : Module() {
     private val paymentJobs = ConcurrentHashMap<String, Job>()
 
     private var stateJob: Job? = null
+    private val nfcBridge by lazy { createNfcBridge(appContext) }
 
     override fun definition() = ModuleDefinition {
         Name("AcceptSdkReactNative")
@@ -52,6 +53,7 @@ class AcceptSdkReactNativeModule : Module() {
         }
 
         OnDestroy {
+            nfcBridge.destroy()
             stateJob = null
             paymentJobs.clear()
             scope.cancel()
@@ -186,6 +188,62 @@ class AcceptSdkReactNativeModule : Module() {
             sdkCall { Accept.payments.refund(paymentToken, parseRefundReason(reason)).name }
         }
 
+        // ── NFC tag sessions ──────────────────────────────────────────────────
+
+        Function("isNfcSupported") { nfcBridge.isSupported() }
+
+        AsyncFunction("openNfcSession") Coroutine { timeouts: Map<String, Any?> ->
+            nfcBridge.openSession(timeouts)
+        }
+
+        AsyncFunction("awaitNfcSessionEnd") Coroutine { sessionId: String ->
+            nfcBridge.awaitSessionEnd(sessionId)
+        }
+
+        Function("releaseNfcSession") { sessionId: String -> nfcBridge.releaseSession(sessionId) }
+
+        AsyncFunction("nfcAuthenticateClassic") Coroutine {
+                sessionId: String, block: Int, keyType: String, key: List<Int> ->
+            nfcBridge.authenticateClassic(sessionId, block, keyType, key)
+        }
+        AsyncFunction("nfcReadBlock") Coroutine { sessionId: String, block: Int ->
+            nfcBridge.readBlock(sessionId, block)
+        }
+        AsyncFunction("nfcWriteBlock") Coroutine { sessionId: String, block: Int, data: List<Int> ->
+            nfcBridge.writeBlock(sessionId, block, data)
+        }
+        AsyncFunction("nfcIncrement") Coroutine { sessionId: String, block: Int, value: Int ->
+            nfcBridge.increment(sessionId, block, value)
+        }
+        AsyncFunction("nfcDecrement") Coroutine { sessionId: String, block: Int, value: Int ->
+            nfcBridge.decrement(sessionId, block, value)
+        }
+        AsyncFunction("nfcTransfer") Coroutine { sessionId: String, block: Int ->
+            nfcBridge.transfer(sessionId, block)
+        }
+        AsyncFunction("nfcRestore") Coroutine { sessionId: String, block: Int ->
+            nfcBridge.restore(sessionId, block)
+        }
+        AsyncFunction("nfcReadPages") Coroutine { sessionId: String, startPage: Int ->
+            nfcBridge.readPages(sessionId, startPage)
+        }
+        AsyncFunction("nfcWritePage") Coroutine { sessionId: String, page: Int, data: List<Int> ->
+            nfcBridge.writePage(sessionId, page, data)
+        }
+        AsyncFunction("nfcPasswordAuth") Coroutine { sessionId: String, password: List<Int> ->
+            nfcBridge.passwordAuth(sessionId, password)
+        }
+        AsyncFunction("nfcUltralightCAuth") Coroutine { sessionId: String, key: List<Int> ->
+            nfcBridge.ultralightCAuth(sessionId, key)
+        }
+        AsyncFunction("nfcTransceiveType2") Coroutine { sessionId: String, frame: List<Int> ->
+            nfcBridge.transceiveType2(sessionId, frame)
+        }
+        AsyncFunction("nfcTransmitApdu") Coroutine { sessionId: String, apdu: List<Int> ->
+            nfcBridge.transmitApdu(sessionId, apdu)
+        }
+        AsyncFunction("closeNfcSession") Coroutine { sessionId: String -> nfcBridge.close(sessionId) }
+
         // ── Plugin ──────────────────────────────────────────────────────────────
 
         Function("isPluginInstalled") { sdkCallSync { Accept.plugin.isInstalled() } }

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

@@ -0,0 +1,35 @@
+package com.tapaya.acceptsdkreactnative
+
+import expo.modules.kotlin.AppContext
+
+/**
+ * Dependency-free boundary between the Expo module and the optional NFC artifacts.
+ *
+ * Gradle supplies exactly one implementation: the real bridge when NFC is opted in, or a stub
+ * when it is not. Only bridge-safe primitives cross this interface so the default build never
+ * loads a class whose signature mentions `com.tapaya.accept.nfc`.
+ */
+internal interface NfcBridge {
+    fun isSupported(): Boolean
+    suspend fun openSession(timeouts: Map<String, Any?>): Map<String, Any?>
+    suspend fun awaitSessionEnd(sessionId: String): String
+    fun releaseSession(sessionId: String)
+    suspend fun authenticateClassic(sessionId: String, block: Int, keyType: String, key: List<Int>)
+    suspend fun readBlock(sessionId: String, block: Int): List<Int>
+    suspend fun writeBlock(sessionId: String, block: Int, data: List<Int>)
+    suspend fun increment(sessionId: String, block: Int, value: Int)
+    suspend fun decrement(sessionId: String, block: Int, value: Int)
+    suspend fun transfer(sessionId: String, block: Int)
+    suspend fun restore(sessionId: String, block: Int)
+    suspend fun readPages(sessionId: String, startPage: Int): List<Int>
+    suspend fun writePage(sessionId: String, page: Int, data: List<Int>)
+    suspend fun passwordAuth(sessionId: String, password: List<Int>): List<Int>
+    suspend fun ultralightCAuth(sessionId: String, key: List<Int>)
+    suspend fun transceiveType2(sessionId: String, frame: List<Int>): List<Int>
+    suspend fun transmitApdu(sessionId: String, apdu: List<Int>): List<Int>
+    suspend fun close(sessionId: String)
+    fun destroy()
+}
+
+/** Supplied by the selected `src/nfc*` source set. */
+internal fun createNfcBridge(appContext: AppContext): NfcBridge = PlatformNfcBridge(appContext)

package/android/src/nfc/java/com/tapaya/acceptsdkreactnative/PlatformNfcBridge.kt

@@ -0,0 +1,215 @@
+package com.tapaya.acceptsdkreactnative
+
+import androidx.activity.ComponentActivity
+import androidx.lifecycle.Lifecycle
+import com.tapaya.accept.Accept
+import com.tapaya.accept.AcceptException
+import com.tapaya.accept.nfc.MifareKeyType
+import com.tapaya.accept.nfc.TagInfo
+import com.tapaya.accept.nfc.TagSession
+import com.tapaya.accept.nfc.TagSessionException
+import com.tapaya.accept.nfc.TagTimeouts
+import com.tapaya.accept.nfc.nfc
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.CodedException
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicLong
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import org.json.JSONObject
+
+/** Real NFC bridge, compiled only when `tapaya.accept.nfc=true`. */
+internal class PlatformNfcBridge(
+    private val appContext: AppContext,
+) : NfcBridge {
+    private val sessions = ConcurrentHashMap<String, TagSession>()
+    private val nextSessionId = AtomicLong()
+    private val cleanupScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+    override fun isSupported(): Boolean = nfcCallSync { Accept.nfc.isSupported() }
+
+    override suspend fun openSession(timeouts: Map<String, Any?>): Map<String, Any?> = nfcCall {
+        val activity = appContext.currentActivity as? ComponentActivity
+            ?: throw CodedException(
+                "ERR_NFC_ACTIVITY_UNAVAILABLE",
+                "NFC tag sessions need the app's foreground Android activity, but none is available.",
+                null,
+            )
+        if (!activity.lifecycle.currentState.isAtLeast(Lifecycle.State.RESUMED)) {
+            throw CodedException(
+                "ERR_NFC_ACTIVITY_UNAVAILABLE",
+                "NFC tag sessions need the foreground Android activity to be resumed. " +
+                    "Wait until the app is active, then call openSession() again.",
+                null,
+            )
+        }
+        val session = try {
+            Accept.nfc.openSession(activity, parseTimeouts(timeouts))
+        } catch (error: IllegalStateException) {
+            throw CodedException(
+                "ERR_NFC_ACTIVITY_UNAVAILABLE",
+                error.message ?: "The Android activity must be resumed before opening an NFC session.",
+                error,
+            )
+        }
+        val id = "nfc-${nextSessionId.incrementAndGet()}"
+        sessions[id] = session
+        mapOf("sessionId" to id, "info" to session.info.serialize())
+    }
+
+    override suspend fun awaitSessionEnd(sessionId: String): String =
+        nfcCall { session(sessionId).ended.filterNotNull().first().name }
+
+    override fun releaseSession(sessionId: String) {
+        // `ended` is the authority: never let a stray JavaScript release make a live reader
+        // unreachable. The JS wrapper calls this only after awaitSessionEnd settles.
+        sessions[sessionId]?.takeIf { it.ended.value != null }?.let { sessions.remove(sessionId, it) }
+    }
+
+    override suspend fun authenticateClassic(sessionId: String, block: Int, keyType: String, key: List<Int>) =
+        nfcCall {
+            val parsedKeyType = MifareKeyType.entries.firstOrNull { it.name == keyType }
+                ?: invalidArgument("unsupported Mifare key type: $keyType")
+            session(sessionId).authenticateClassic(block, parsedKeyType, key.toByteArray("key"))
+        }
+
+    override suspend fun readBlock(sessionId: String, block: Int): List<Int> =
+        nfcCall { session(sessionId).readBlock(block).toUnsignedList() }
+
+    override suspend fun writeBlock(sessionId: String, block: Int, data: List<Int>) =
+        nfcCall { session(sessionId).writeBlock(block, data.toByteArray("data")) }
+
+    override suspend fun increment(sessionId: String, block: Int, value: Int) =
+        nfcCall { session(sessionId).increment(block, value) }
+
+    override suspend fun decrement(sessionId: String, block: Int, value: Int) =
+        nfcCall { session(sessionId).decrement(block, value) }
+
+    override suspend fun transfer(sessionId: String, block: Int) =
+        nfcCall { session(sessionId).transfer(block) }
+
+    override suspend fun restore(sessionId: String, block: Int) =
+        nfcCall { session(sessionId).restore(block) }
+
+    override suspend fun readPages(sessionId: String, startPage: Int): List<Int> =
+        nfcCall { session(sessionId).readPages(startPage).toUnsignedList() }
+
+    override suspend fun writePage(sessionId: String, page: Int, data: List<Int>) =
+        nfcCall { session(sessionId).writePage(page, data.toByteArray("data")) }
+
+    override suspend fun passwordAuth(sessionId: String, password: List<Int>): List<Int> =
+        nfcCall { session(sessionId).passwordAuth(password.toByteArray("password")).toUnsignedList() }
+
+    override suspend fun ultralightCAuth(sessionId: String, key: List<Int>) =
+        nfcCall { session(sessionId).ultralightCAuth(key.toByteArray("key")) }
+
+    override suspend fun transceiveType2(sessionId: String, frame: List<Int>): List<Int> =
+        nfcCall { session(sessionId).transceiveType2(frame.toByteArray("frame")).toUnsignedList() }
+
+    override suspend fun transmitApdu(sessionId: String, apdu: List<Int>): List<Int> =
+        nfcCall { session(sessionId).transmitApdu(apdu.toByteArray("apdu")).toUnsignedList() }
+
+    override suspend fun close(sessionId: String) = nfcCall {
+        sessions[sessionId]?.close()
+        Unit
+    }
+
+    override fun destroy() {
+        val active = sessions.values.toList()
+        sessions.clear()
+        cleanupScope.launch {
+            try {
+                active.forEach { session -> runCatching { session.close() } }
+            } finally {
+                cleanupScope.cancel()
+            }
+        }
+    }
+
+    private fun session(id: String): TagSession = sessions[id]
+        ?: throw TagSessionException(
+            reason = com.tapaya.accept.nfc.TagErrorReason.SESSION_ENDED,
+            message = "the NFC tag session has ended",
+        )
+}
+
+private fun TagInfo.serialize(): Map<String, Any?> = mapOf(
+    "uidHex" to uidHex,
+    "family" to family.name,
+    "sak" to sak,
+    "atqaHex" to atqaHex,
+    "atsHex" to atsHex,
+    "memoryBytes" to memoryBytes,
+    "versionHex" to versionHex,
+)
+
+private fun parseTimeouts(values: Map<String, Any?>): TagTimeouts = try {
+    TagTimeouts(
+        tapWait = values.duration("tapWaitMs", 30_000),
+        operation = values.duration("operationMs", 1_000),
+        reselect = values.duration("reselectMs", 1_000),
+        idle = values.duration("idleMs", 10_000),
+    )
+} catch (error: IllegalArgumentException) {
+    invalidArgument(error.message ?: "invalid NFC timeout", error)
+}
+
+private fun Map<String, Any?>.duration(key: String, defaultMs: Long) = when (val value = this[key]) {
+    null -> defaultMs.milliseconds
+    is Number -> {
+        val number = value.toDouble()
+        if (!number.isFinite() || number % 1.0 != 0.0) invalidArgument("$key must be a whole number of milliseconds")
+        number.toLong().milliseconds
+    }
+    else -> invalidArgument("$key must be a number of milliseconds")
+}
+
+private fun List<Int>.toByteArray(name: String): ByteArray = ByteArray(size) { index ->
+    val value = this[index]
+    if (value !in 0..255) invalidArgument("$name[$index] must be between 0 and 255")
+    value.toByte()
+}
+
+private fun ByteArray.toUnsignedList(): List<Int> = map { it.toInt() and 0xFF }
+
+private fun invalidArgument(message: String, cause: Throwable? = null): Nothing =
+    throw CodedException("ERR_INVALID_ARGUMENT", message, cause)
+
+private suspend fun <T> nfcCall(block: suspend () -> T): T = try {
+    block()
+} catch (error: CancellationException) {
+    throw error
+} catch (error: AcceptException) {
+    throw AcceptCodedException(error)
+} catch (error: TagSessionException) {
+    throw TagSessionCodedException(error)
+} catch (error: IllegalArgumentException) {
+    invalidArgument(error.message ?: "invalid NFC argument", error)
+}
+
+private fun <T> nfcCallSync(block: () -> T): T = try {
+    block()
+} catch (error: AcceptException) {
+    throw AcceptCodedException(error)
+}
+
+private class TagSessionCodedException(error: TagSessionException) : CodedException(
+    "TagSessionException",
+    JSONObject(
+        mapOf(
+            "code" to "TagSessionException",
+            "message" to (error.message ?: error.reason.name),
+            "reason" to error.reason.name,
+            "authLost" to error.authLost,
+            "vendorCode" to error.vendorCode,
+        ),
+    ).toString(),
+    error,
+)

package/android/src/nfcDisabled/java/com/tapaya/acceptsdkreactnative/PlatformNfcBridge.kt

@@ -0,0 +1,38 @@
+package com.tapaya.acceptsdkreactnative
+
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.CodedException
+
+/** NFC surface used when the host app did not opt into either optional NFC artifact. */
+internal class PlatformNfcBridge(
+    @Suppress("UNUSED_PARAMETER") appContext: AppContext,
+) : NfcBridge {
+    override fun isSupported(): Boolean = false
+
+    override suspend fun openSession(timeouts: Map<String, Any?>): Map<String, Any?> = notConfigured()
+    override suspend fun awaitSessionEnd(sessionId: String): String = notConfigured()
+    override fun releaseSession(sessionId: String) = Unit
+    override suspend fun authenticateClassic(sessionId: String, block: Int, keyType: String, key: List<Int>) = notConfigured()
+    override suspend fun readBlock(sessionId: String, block: Int): List<Int> = notConfigured()
+    override suspend fun writeBlock(sessionId: String, block: Int, data: List<Int>) = notConfigured()
+    override suspend fun increment(sessionId: String, block: Int, value: Int) = notConfigured()
+    override suspend fun decrement(sessionId: String, block: Int, value: Int) = notConfigured()
+    override suspend fun transfer(sessionId: String, block: Int) = notConfigured()
+    override suspend fun restore(sessionId: String, block: Int) = notConfigured()
+    override suspend fun readPages(sessionId: String, startPage: Int): List<Int> = notConfigured()
+    override suspend fun writePage(sessionId: String, page: Int, data: List<Int>) = notConfigured()
+    override suspend fun passwordAuth(sessionId: String, password: List<Int>): List<Int> = notConfigured()
+    override suspend fun ultralightCAuth(sessionId: String, key: List<Int>) = notConfigured()
+    override suspend fun transceiveType2(sessionId: String, frame: List<Int>): List<Int> = notConfigured()
+    override suspend fun transmitApdu(sessionId: String, apdu: List<Int>): List<Int> = notConfigured()
+    override suspend fun close(sessionId: String) = notConfigured()
+    override fun destroy() = Unit
+
+    private fun notConfigured(): Nothing = throw CodedException(
+        "ERR_NFC_NOT_CONFIGURED",
+        "NFC tag sessions are not included in this build. Set `nfc: true` (or " +
+            "`nfc: { sunmi: true }`) on the @tapayadot/accept-react-native config plugin, " +
+            "then run `npx expo prebuild --clean` and rebuild the Android app.",
+        null,
+    )
+}

package/build/Accept.d.ts

@@ -1,4 +1,4 @@
-import type { AcceptDisplay, AcceptLogEntry, AcceptLogLevel, AcceptSubscription, AcceptTheme, ActivateTerminalResult, InitializeOptions, MerchantConfig, MerchantInformation, MinimumAmount, OnboardingStatus, PayResult, PaymentEvent, PaymentOptions, PaymentRequest, PaymentState, PaymentStatus, PaymentSubscription, PluginStatus, PluginUpdateInfo, RefundReason, SdkState } from "./Accept.types";
+import type { AcceptDisplay, AcceptLogEntry, AcceptLogLevel, AcceptSubscription, AcceptTheme, ActivateTerminalResult, InitializeOptions, MerchantConfig, MerchantInformation, MinimumAmount, OnboardingStatus, PayResult, PaymentEvent, PaymentOptions, PaymentRequest, PaymentState, PaymentStatus, PaymentSubscription, PluginStatus, PluginUpdateInfo, RefundReason, SdkState, TagSession, TagTimeouts } from "./Accept.types";
 /**
  * Entry point to the Accept SDK. Mirrors the `Accept` object in the Accept SDK for Android, so the
  * Android reference documentation applies unchanged.
@@ -137,6 +137,12 @@ export declare const Accept: {
          */
         refund(paymentToken: string, reason: RefundReason): Promise<PaymentState>;
     };
+    nfc: {
+        /** Whether this device has a reader the configured NFC backend can use. */
+        isSupported(): boolean;
+        /** Waits for a tag and opens a session on it using the foreground Android activity. */
+        openSession(timeouts?: TagTimeouts): Promise<TagSession>;
+    };
     plugin: {
         /**
          * Whether the plugin app is installed on this device.

package/build/Accept.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Accept.d.ts","sourceRoot":"","sources":["../src/Accept.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,WAAW,EACX,sBAAsB,EACtB,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,SAAS,EACT,YAAY,EACZ,cAAc,EACd,cAAc,EACd,YAAY,EACZ,aAAa,EACb,mBAAmB,EACnB,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,QAAQ,EACT,MAAM,gBAAgB,CAAC;AA4UxB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM;;QAxUjB;;;;;WAKG;oCACyB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;;;QASlD,iGAAiG;0BAClF,MAAM;QAIrB;;;;WAIG;+BACiB,OAAO;QAI3B;;;;;;;;WAQG;oBACS,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;QAIlC;;;;WAIG;0BACe,OAAO,CAAC,aAAa,EAAE,CAAC;;;QAS1C;;;;WAIG;gBACK,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAI3C;;;;WAIG;kBACO,OAAO,CAAC,cAAc,CAAC;QAIjC;;;;WAIG;4BACiB,OAAO,CAAC,gBAAgB,CAAC;QAI7C;;;;WAIG;+BACoB,OAAO,CAAC,MAAM,EAAE,CAAC;;;QASxC;;;;;;WAMG;4BACiB,cAAc,GAAG,IAAI;QAIzC;;;;;;;;;;;;;;;;WAgBG;qBAEQ,cAAc,YACb,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GACtC,mBAAmB;QAqBtB;;;;;;;WAOG;0BACe,cAAc,GAAG,OAAO,CAAC,SAAS,CAAC;QAUrD;;;;;WAKG;6BACkB,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;QAIpD;;;;;;WAMG;6BACkB,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QAInD;;;;;;WAMG;6BACkB,MAAM,UAAU,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;;;QASzE;;;;WAIG;uBACY,OAAO;QAItB;;;;;;;;;;;;;;;;;;;;WAoBG;mBACQ,OAAO,CAAC,IAAI,CAAC;QAIxB;;;;;;;WAOG;4BACiB,OAAO,CAAC,sBAAsB,CAAC;QAInD;;;;WAIG;kBACO,OAAO,CAAC,YAAY,CAAC;QAI/B;;;;;;;;;WASG;sBACW,OAAO,CAAC,gBAAgB,CAAC;QAIvC;;;;WAIG;kBACO,OAAO,CAAC,IAAI,CAAC;;;QAYvB,iEAAiE;eAC1D,aAAa,EAAE;QAItB;;;WAGG;0BACe,aAAa,GAAG,IAAI;QAItC,gEAAgE;+BAC5C,OAAO;;IAgC3B;;;;;OAKG;yBACiB,iBAAiB,GAAQ,IAAI;IAIjD,yCAAyC;oBAC5B,QAAQ;IAIrB;;;OAGG;+BACwB,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,kBAAkB;IAIzE;;;;;OAKG;aACM,OAAO,CAAC,IAAI,CAAC;IAItB;;;OAGG;oCAC6B,OAAO,GAAG,IAAI;IAI9C;;;OAGG;uBACgB,cAAc,GAAG,IAAI;IAIxC;;;OAGG;wBACiB,CAAC,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI;IAMnE;;;;;;OAMG;oBACa,WAAW,GAAG,IAAI,GAAG,IAAI;IAIzC;;;OAGG;gBACS,WAAW,GAAG,IAAI;IAI9B;;;;;;;;;;;OAWG;qCAEO,MAAM,kBACC,MAAM,GACpB,MAAM;CAKV,CAAC"}
+{"version":3,"file":"Accept.d.ts","sourceRoot":"","sources":["../src/Accept.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,WAAW,EACX,sBAAsB,EACtB,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,SAAS,EACT,YAAY,EACZ,cAAc,EACd,cAAc,EACd,YAAY,EACZ,aAAa,EACb,mBAAmB,EACnB,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,QAAQ,EAER,UAAU,EAEV,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAodxB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM;;QA/cjB;;;;;WAKG;oCACyB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;;;QASlD,iGAAiG;0BAClF,MAAM;QAIrB;;;;WAIG;+BACiB,OAAO;QAI3B;;;;;;;;WAQG;oBACS,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;QAIlC;;;;WAIG;0BACe,OAAO,CAAC,aAAa,EAAE,CAAC;;;QAS1C;;;;WAIG;gBACK,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAI3C;;;;WAIG;kBACO,OAAO,CAAC,cAAc,CAAC;QAIjC;;;;WAIG;4BACiB,OAAO,CAAC,gBAAgB,CAAC;QAI7C;;;;WAIG;+BACoB,OAAO,CAAC,MAAM,EAAE,CAAC;;;QASxC;;;;;;WAMG;4BACiB,cAAc,GAAG,IAAI;QAIzC;;;;;;;;;;;;;;;;WAgBG;qBAEQ,cAAc,YACb,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GACtC,mBAAmB;QAqBtB;;;;;;;WAOG;0BACe,cAAc,GAAG,OAAO,CAAC,SAAS,CAAC;QAUrD;;;;;WAKG;6BACkB,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;QAIpD;;;;;;WAMG;6BACkB,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QAInD;;;;;;WAMG;6BACkB,MAAM,UAAU,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;;;QA8HzE,2EAA2E;uBAC5D,OAAO;QAItB,uFAAuF;+BAC3D,WAAW,GAAQ,OAAO,CAAC,UAAU,CAAC;;;QAYlE;;;;WAIG;uBACY,OAAO;QAItB;;;;;;;;;;;;;;;;;;;;WAoBG;mBACQ,OAAO,CAAC,IAAI,CAAC;QAIxB;;;;;;;WAOG;4BACiB,OAAO,CAAC,sBAAsB,CAAC;QAInD;;;;WAIG;kBACO,OAAO,CAAC,YAAY,CAAC;QAI/B;;;;;;;;;WASG;sBACW,OAAO,CAAC,gBAAgB,CAAC;QAIvC;;;;WAIG;kBACO,OAAO,CAAC,IAAI,CAAC;;;QAYvB,iEAAiE;eAC1D,aAAa,EAAE;QAItB;;;WAGG;0BACe,aAAa,GAAG,IAAI;QAItC,gEAAgE;+BAC5C,OAAO;;IAiC3B;;;;;OAKG;yBACiB,iBAAiB,GAAQ,IAAI;IAIjD,yCAAyC;oBAC5B,QAAQ;IAIrB;;;OAGG;+BACwB,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,kBAAkB;IAIzE;;;;;OAKG;aACM,OAAO,CAAC,IAAI,CAAC;IAItB;;;OAGG;oCAC6B,OAAO,GAAG,IAAI;IAI9C;;;OAGG;uBACgB,cAAc,GAAG,IAAI;IAIxC;;;OAGG;wBACiB,CAAC,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI;IAMnE;;;;;;OAMG;oBACa,WAAW,GAAG,IAAI,GAAG,IAAI;IAIzC;;;OAGG;gBACS,WAAW,GAAG,IAAI;IAI9B;;;;;;;;;;;OAWG;qCAEO,MAAM,kBACC,MAAM,GACpB,MAAM;CAKV,CAAC"}