From cd805ed899a2dd9cff9719d50632704c8c0dd70b Mon Sep 17 00:00:00 2001
From: Ovi Trif <ovitrif@proton.me>
Date: Wed, 2 Sep 2026 01:55:13 +0200
Subject: [PATCH 1/4] docs: codify paykit issuer contract

---
 .../repositories/PaykitPaymentRequestRepo.kt  | 13 +++--
 .../bitkit/repositories/PublicPaykitRepo.kt   | 13 +++--
 .../PaykitPaymentRequestRepoTest.kt           | 52 ++++++++++++++++++-
 .../repositories/PublicPaykitRepoTest.kt      | 47 +++++++++++++++++
 docs/paykit-issuer-interoperability.md        | 48 +++++++++++++++++
 docs/pubky.md                                 |  2 +
 6 files changed, 168 insertions(+), 7 deletions(-)
 create mode 100644 docs/paykit-issuer-interoperability.md

diff --git a/app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt b/app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt
index 4159a4d5d4..af64d9bb94 100644
--- a/app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt
+++ b/app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt
@@ -30,10 +30,12 @@ import kotlinx.serialization.json.JsonPrimitive
 import kotlinx.serialization.json.contentOrNull
 import kotlinx.serialization.json.jsonObject
 import kotlinx.serialization.json.jsonPrimitive
+import org.lightningdevkit.ldknode.Network
 import to.bitkit.async.appScope
 import to.bitkit.data.SettingsData
 import to.bitkit.data.SettingsStore
 import to.bitkit.di.IoDispatcher
+import to.bitkit.env.Env
 import to.bitkit.ext.runSuspendCatching
 import to.bitkit.flags.PaykitFeatureFlags
 import to.bitkit.models.PubkyPublicKeyFormat
@@ -613,6 +615,13 @@ private fun List<PaykitPaymentRequest>.withExpiredLifecycle(now: Instant): List<
 
 private val bitcoinAmountPattern = Regex("(?:[0-9]+(?:\\.[0-9]*)?|\\.[0-9]+)")
 
+internal fun supportedPaykitEndpointIdentifiers(
+    identifiers: List<String>,
+    network: Network = Env.network,
+): List<String> = identifiers
+    .filter { MethodId.fromRawValue(it, network) != null }
+    .distinct()
+
 @Suppress("CyclomaticComplexMethod", "ReturnCount")
 private fun PaymentRequestRecord.toPaykitPaymentRequest(
     expectedRole: PaymentRequestLocalRole,
@@ -626,9 +635,7 @@ private fun PaymentRequestRecord.toPaykitPaymentRequest(
     val amountSats = requestTerms.amount.value.toSats()
         ?.takeIf { it <= ULong.MAX_VALUE / 1000uL }
         ?: return null
-    val endpoints = requestTerms.acceptedPaymentEndpointIdentifiers
-        .filter { MethodId.fromRawValue(it) != null }
-        .distinct()
+    val endpoints = supportedPaykitEndpointIdentifiers(requestTerms.acceptedPaymentEndpointIdentifiers)
     if (requiresActionableRequest && endpoints.isEmpty()) return null
 
     val expiresAt = requestTerms.proposalExpiresAt?.let {
diff --git a/app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt b/app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt
index 91e277bb9c..ff81b8a2c1 100644
--- a/app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt
+++ b/app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt
@@ -105,10 +105,14 @@ class PublicPaykitRepo @Inject constructor(
         fun isOnchainPaymentOptionEnabled(settings: SettingsData): Boolean =
             settings.publicPaykitOnchainEnabled
 
-        fun parseEndpoint(methodId: String, endpointData: String): Endpoint? {
+        fun parseEndpoint(
+            methodId: String,
+            endpointData: String,
+            network: Network = Env.network,
+        ): Endpoint? {
             if (!methodIdPattern.matches(methodId)) return null
 
-            val knownMethodId = MethodId.fromRawValue(methodId) ?: return null
+            val knownMethodId = MethodId.fromRawValue(methodId, network) ?: return null
             val payload = runCatching {
                 payloadJson.decodeFromString<PaymentEndpointPayload>(endpointData)
             }.getOrNull() ?: return null
@@ -463,7 +467,10 @@ enum class MethodId(
     }
 
     companion object {
-        fun fromRawValue(value: String): MethodId? = entries.firstOrNull { it.rawValue == value }
+        fun fromRawValue(
+            value: String,
+            network: Network = Env.network,
+        ): MethodId? = entries.firstOrNull { it.rawValueForNetwork(network) == value }
     }
 }
 
diff --git a/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt
index a11dc7ec88..3abafeadea 100644
--- a/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt
+++ b/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt
@@ -22,6 +22,7 @@ import kotlinx.coroutines.test.runCurrent
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
+import org.lightningdevkit.ldknode.Network
 import org.mockito.kotlin.any
 import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.clearInvocations
@@ -49,6 +50,7 @@ import kotlin.time.Duration.Companion.seconds
 import kotlin.time.ExperimentalTime
 import kotlin.time.Instant
 
+@Suppress("LargeClass")
 class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) {
     companion object {
         private const val PAYMENT_REQUEST_ID = "550e8400-e29b-41d4-a716-446655440000"
@@ -105,6 +107,53 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) {
         assertEquals(listOf(MethodId.Bolt11.rawValue), request.acceptedPaymentEndpointIdentifiers)
     }
 
+    @Test
+    fun `refresh accepts only exact lowercase bitcoin asset`() = test {
+        whenever(paykitSdkService.paymentRequests()).thenReturn(
+            listOf(
+                paymentRequestRecord(id = "lowercase", asset = "btc"),
+                paymentRequestRecord(id = "uppercase", asset = "BTC"),
+                paymentRequestRecord(id = "mixed-case", asset = "Btc"),
+                paymentRequestRecord(id = "whitespace", asset = " btc "),
+            ),
+        )
+
+        sut.refresh().getOrThrow()
+
+        assertEquals(listOf("lowercase"), sut.pendingRequests.value.map { it.paymentRequestId })
+    }
+
+    @Test
+    fun `request filtering accepts network correct and chain independent identifiers`() {
+        val networkRails = listOf(
+            Network.BITCOIN to "bitcoin",
+            Network.TESTNET to "testnet",
+            Network.SIGNET to "signet",
+            Network.REGTEST to "regtest",
+        )
+        val scriptTypes = listOf("p2tr", "p2wpkh", "p2sh", "p2pkh")
+        val onchainIdentifiers = networkRails.flatMap { (_, rail) ->
+            scriptTypes.map { "btc-$rail-$it" }
+        }
+
+        networkRails.forEach { (network, rail) ->
+            val accepted = listOf(
+                "btc-lightning-bolt11",
+                "btc-lightning-lnurl",
+            ) + scriptTypes.map { "btc-$rail-$it" }
+            val rejected = onchainIdentifiers.filterNot { it in accepted } + listOf(
+                "BTC-$rail-p2wpkh",
+                "btc-$rail-bolt12",
+                "btc-unsupported-method",
+            )
+
+            assertEquals(
+                accepted,
+                supportedPaykitEndpointIdentifiers(accepted + accepted.first() + rejected, network),
+            )
+        }
+    }
+
     @Test
     fun `refresh rejects amounts outside the app payment range`() = test {
         whenever(paykitSdkService.paymentRequests()).thenReturn(
@@ -654,6 +703,7 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) {
         role: PaymentRequestLocalRole? = PaymentRequestLocalRole.PAYER,
         state: PaymentRequestLifecycleState = PaymentRequestLifecycleState.PROPOSED,
         amount: String = "0.001",
+        asset: String = "btc",
         expiresAt: String? = null,
         endpoints: List<String> = listOf(MethodId.Bolt11.rawValue),
         counterparty: String = COUNTERPARTY,
@@ -669,7 +719,7 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) {
         proposalOutboundStatus = null,
         proposalEventId = "proposal-event",
         terms = PaymentRequestTerms(
-            amount = PaymentRequestAmount(value = amount, asset = "btc"),
+            amount = PaymentRequestAmount(value = amount, asset = asset),
             paymentReference = PAYMENT_REFERENCE,
             proposalExpiresAt = expiresAt,
             recurrence = null,
diff --git a/app/src/test/java/to/bitkit/repositories/PublicPaykitRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PublicPaykitRepoTest.kt
index 612a5d8205..6c35825544 100644
--- a/app/src/test/java/to/bitkit/repositories/PublicPaykitRepoTest.kt
+++ b/app/src/test/java/to/bitkit/repositories/PublicPaykitRepoTest.kt
@@ -10,6 +10,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
+import org.lightningdevkit.ldknode.Network
 import org.mockito.kotlin.any
 import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.mock
@@ -25,6 +26,7 @@ import to.bitkit.services.PaykitResolvedPaymentEndpoint
 import to.bitkit.services.PaykitSdkService
 import to.bitkit.test.BaseUnitTest
 import kotlin.test.assertEquals
+import kotlin.test.assertNull
 import kotlin.test.assertTrue
 import kotlin.time.Clock
 import kotlin.time.Duration.Companion.hours
@@ -78,6 +80,51 @@ class PublicPaykitRepoTest : BaseUnitTest() {
         PublicPaykitRepo.lightningRouteHintsValidator = null
     }
 
+    @Test
+    fun `parseEndpoint accepts network correct JSON endpoint fixtures`() {
+        val fixtures = listOf(
+            Network.BITCOIN to "btc-bitcoin-p2wpkh",
+            Network.TESTNET to "btc-testnet-p2wpkh",
+            Network.SIGNET to "btc-signet-p2wpkh",
+            Network.REGTEST to "btc-regtest-p2wpkh",
+        )
+
+        fixtures.forEach { (network, identifier) ->
+            val endpoint = PublicPaykitRepo.parseEndpoint(
+                methodId = identifier,
+                endpointData = """{"value":"  address  ","min":"1000","max":"2000"}""",
+                network = network,
+            )
+
+            assertEquals(MethodId.P2wpkh, endpoint?.methodId)
+            assertEquals("address", endpoint?.value)
+            assertEquals("1000", endpoint?.min)
+            assertEquals("2000", endpoint?.max)
+        }
+    }
+
+    @Test
+    fun `parseEndpoint rejects non canonical JSON endpoint payloads`() {
+        val rejectedPayloads = listOf(
+            "bcrt1qraw",
+            """"bcrt1qjsonstring"""",
+            "{}",
+            """{"value":""}""",
+            """{"value":"   "}""",
+            """{"value":1}""",
+        )
+
+        rejectedPayloads.forEach {
+            assertNull(
+                PublicPaykitRepo.parseEndpoint(
+                    methodId = "btc-regtest-p2wpkh",
+                    endpointData = it,
+                    network = Network.REGTEST,
+                ),
+            )
+        }
+    }
+
     @Test
     fun `syncCurrentPublishedEndpoints configures SDK public endpoints`() = test {
         walletState.value = WalletState(onchainAddress = "bc1ptest")
diff --git a/docs/paykit-issuer-interoperability.md b/docs/paykit-issuer-interoperability.md
new file mode 100644
index 0000000000..aae04642f2
--- /dev/null
+++ b/docs/paykit-issuer-interoperability.md
@@ -0,0 +1,48 @@
+# Paykit Issuer Interoperability
+
+Paykit issuers must use the following shapes for payment requests and endpoint payloads that Bitkit can open.
+
+## Payment requests
+
+- Set `terms.amount.asset` to the exact lowercase value `btc`.
+- Advertise at least one endpoint identifier supported by the active Bitkit network.
+- Lightning identifiers are chain-independent:
+  - `btc-lightning-bolt11`
+  - `btc-lightning-lnurl`
+- On-chain identifiers are chain-specific and use `btc-<network>-<script>`.
+
+| Bitkit network | P2TR | P2WPKH | P2SH | P2PKH |
+| --- | --- | --- | --- | --- |
+| Bitcoin | `btc-bitcoin-p2tr` | `btc-bitcoin-p2wpkh` | `btc-bitcoin-p2sh` | `btc-bitcoin-p2pkh` |
+| Testnet | `btc-testnet-p2tr` | `btc-testnet-p2wpkh` | `btc-testnet-p2sh` | `btc-testnet-p2pkh` |
+| Signet | `btc-signet-p2tr` | `btc-signet-p2wpkh` | `btc-signet-p2sh` | `btc-signet-p2pkh` |
+| Regtest | `btc-regtest-p2tr` | `btc-regtest-p2wpkh` | `btc-regtest-p2sh` | `btc-regtest-p2pkh` |
+
+Bitkit ignores unsupported identifiers and on-chain identifiers for another network. A request with no supported identifier is not actionable.
+
+## Endpoint payloads
+
+Encode each endpoint payload as a JSON object with a non-empty string in `value`:
+
+```json
+{"value":"bcrt1qexample"}
+```
+
+Optional `min` and `max` values are strings:
+
+```json
+{"value":"lnbcrt1example","min":"1000","max":"2000"}
+```
+
+Bitkit trims surrounding whitespace from `value`. It rejects bare values, JSON strings, missing values, non-string values, and empty values.
+
+## Compatibility fixtures
+
+For every Bitkit network, issuer fixtures must prove that:
+
+- both Lightning identifiers are accepted;
+- all four on-chain identifiers for the active network are accepted;
+- on-chain identifiers for the other networks are rejected;
+- lowercase `btc` is accepted and other casing is rejected;
+- JSON objects containing a non-empty string `value` are accepted;
+- bare, missing, non-string, and empty endpoint values are rejected.
diff --git a/docs/pubky.md b/docs/pubky.md
index 2fbdc06120..742ec6967b 100644
--- a/docs/pubky.md
+++ b/docs/pubky.md
@@ -1,5 +1,7 @@
 # Pubky Integration
 
+Paykit issuers should follow the [Paykit issuer interoperability contract](paykit-issuer-interoperability.md) for payment request and endpoint shapes accepted by Bitkit.
+
 ## Overview
 
 Bitkit integrates [Pubky](https://pubky.org) decentralized identity, allowing users to connect their Pubky profile via [Pubky Ring](https://play.google.com/store/apps/details?id=to.pubky.ring) authentication. Once connected, the user's profile name and avatar appear on the home screen header, a full profile page shows their bio, links, and a shareable QR code, and the contacts screen shows followed Pubky users.

From fc8c3267093280f101034bc739b3323979af865a Mon Sep 17 00:00:00 2001
From: Ovi Trif <ovitrif@proton.me>
Date: Wed, 2 Sep 2026 02:14:42 +0200
Subject: [PATCH 2/4] test: align paykit issuer fixtures

---
 .../PaymentRequestsScreenTest.kt              |   2 +
 .../repositories/PaykitIssuerInterop.kt       |  50 ++++
 .../repositories/PaykitPaymentRequestRepo.kt  |  17 +-
 .../bitkit/repositories/PrivatePaykitRepo.kt  |   4 +-
 .../bitkit/repositories/PublicPaykitRepo.kt   |  31 +--
 .../to/bitkit/services/PaykitSdkService.kt    |   3 +-
 .../paymentrequests/PaymentRequestsScreen.kt  |   8 +-
 .../screens/wallets/send/SendConfirmScreen.kt |   6 +-
 .../repositories/PaykitIssuerInteropTest.kt   | 187 +++++++++++++
 .../PaykitPaymentRequestRepoTest.kt           |  52 +---
 .../repositories/PublicPaykitRepoTest.kt      |  47 ----
 .../paykit-issuer-interoperability.json       | 258 ++++++++++++++++++
 docs/paykit-issuer-interoperability.md        |  88 ++++--
 journeys/payment-requests/README.md           |  34 +++
 .../issuer-interoperability.xml               |  14 +
 15 files changed, 636 insertions(+), 165 deletions(-)
 create mode 100644 app/src/main/java/to/bitkit/repositories/PaykitIssuerInterop.kt
 create mode 100644 app/src/test/java/to/bitkit/repositories/PaykitIssuerInteropTest.kt
 create mode 100644 app/src/test/resources/paykit-issuer-interoperability.json
 create mode 100644 journeys/payment-requests/README.md
 create mode 100644 journeys/payment-requests/issuer-interoperability.xml

diff --git a/app/src/androidTest/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreenTest.kt b/app/src/androidTest/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreenTest.kt
index 35fd856b3d..7fb258025d 100644
--- a/app/src/androidTest/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreenTest.kt
+++ b/app/src/androidTest/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreenTest.kt
@@ -51,6 +51,8 @@ class PaymentRequestsScreenTest {
         composeTestRule.onNodeWithTag("MoneyPrimary").assertIsDisplayed()
         composeTestRule.onNodeWithTag("MoneySecondary").assertIsDisplayed()
         composeTestRule.onNodeWithTag("PaymentRequestsSeeAll").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("PaymentRequestRejectincoming").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("PaymentRequestPayincoming").assertIsDisplayed()
         composeTestRule.onNodeWithText("Dismiss").assertIsDisplayed()
     }
 
diff --git a/app/src/main/java/to/bitkit/repositories/PaykitIssuerInterop.kt b/app/src/main/java/to/bitkit/repositories/PaykitIssuerInterop.kt
new file mode 100644
index 0000000000..405cbc47e5
--- /dev/null
+++ b/app/src/main/java/to/bitkit/repositories/PaykitIssuerInterop.kt
@@ -0,0 +1,50 @@
+package to.bitkit.repositories
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.lightningdevkit.ldknode.Network
+import to.bitkit.di.json as appJson
+
+internal object PaykitIssuerInterop {
+    /** Canonical lowercase Bitcoin asset used by Paykit Payment Requests. */
+    const val BITCOIN_ASSET = "btc"
+
+    private val payloadJson = Json(appJson) {
+        prettyPrint = false
+        isLenient = false
+        encodeDefaults = false
+    }
+
+    fun supportedEndpointIdentifiers(
+        identifiers: List<String>,
+        network: Network,
+    ): List<String> = identifiers
+        .filter { MethodId.fromRawValue(it, network) != null }
+        .distinct()
+
+    fun parseEndpointPayload(endpointData: String): PaykitEndpointPayload? {
+        val payload = runCatching {
+            payloadJson.decodeFromString<PaykitEndpointPayload>(endpointData)
+        }.getOrNull() ?: return null
+        val value = payload.value.trim()
+        if (value.isEmpty()) return null
+
+        return payload.copy(value = value)
+    }
+
+    fun serializeEndpointPayload(value: String): String? {
+        val trimmedValue = value.trim()
+        if (trimmedValue.isEmpty()) return null
+
+        return payloadJson.encodeToString(PaykitEndpointPayload(value = trimmedValue))
+    }
+}
+
+@Serializable
+internal data class PaykitEndpointPayload(
+    val value: String,
+    val min: String? = null,
+    val max: String? = null,
+)
diff --git a/app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt b/app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt
index af64d9bb94..79a3f18659 100644
--- a/app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt
+++ b/app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt
@@ -615,27 +615,24 @@ private fun List<PaykitPaymentRequest>.withExpiredLifecycle(now: Instant): List<
 
 private val bitcoinAmountPattern = Regex("(?:[0-9]+(?:\\.[0-9]*)?|\\.[0-9]+)")
 
-internal fun supportedPaykitEndpointIdentifiers(
-    identifiers: List<String>,
-    network: Network = Env.network,
-): List<String> = identifiers
-    .filter { MethodId.fromRawValue(it, network) != null }
-    .distinct()
-
 @Suppress("CyclomaticComplexMethod", "ReturnCount")
-private fun PaymentRequestRecord.toPaykitPaymentRequest(
+internal fun PaymentRequestRecord.toPaykitPaymentRequest(
     expectedRole: PaymentRequestLocalRole,
     now: Instant,
     requiresActionableRequest: Boolean = true,
+    network: Network = Env.network,
 ): PaykitPaymentRequest? {
     if (localRole != expectedRole || state == PaymentRequestLifecycleState.ACTIVE_RECURRING) return null
     if (requiresActionableRequest && state != PaymentRequestLifecycleState.PROPOSED) return null
     val requestTerms = terms ?: return null
-    if (requestTerms.recurrence != null || requestTerms.amount.asset != "btc") return null
+    if (requestTerms.recurrence != null || requestTerms.amount.asset != PaykitIssuerInterop.BITCOIN_ASSET) return null
     val amountSats = requestTerms.amount.value.toSats()
         ?.takeIf { it <= ULong.MAX_VALUE / 1000uL }
         ?: return null
-    val endpoints = supportedPaykitEndpointIdentifiers(requestTerms.acceptedPaymentEndpointIdentifiers)
+    val endpoints = PaykitIssuerInterop.supportedEndpointIdentifiers(
+        requestTerms.acceptedPaymentEndpointIdentifiers,
+        network,
+    )
     if (requiresActionableRequest && endpoints.isEmpty()) return null
 
     val expiresAt = requestTerms.proposalExpiresAt?.let {
diff --git a/app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt b/app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt
index 10b24fac99..961353fd7b 100644
--- a/app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt
+++ b/app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt
@@ -541,7 +541,9 @@ class PrivatePaykitRepo @Inject constructor(
                 val consumedVersion = ensureState().contacts[publicKey]
                     ?.consumedPrivatePaymentListVersionsByReceiverPath
                     ?.get(receiverPath)
-                val amount = paymentRequest?.let { PaymentAmountContext(it.amountValue, "btc") }
+                val amount = paymentRequest?.let {
+                    PaymentAmountContext(it.amountValue, PaykitIssuerInterop.BITCOIN_ASSET)
+                }
                 val prepared = preparePrivateContactPayment(
                     publicKey = publicKey,
                     receiverPath = receiverPath,
diff --git a/app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt b/app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt
index ff81b8a2c1..c4a2af123b 100644
--- a/app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt
+++ b/app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt
@@ -8,10 +8,6 @@ import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.decodeFromString
-import kotlinx.serialization.encodeToString
-import kotlinx.serialization.json.Json
 import org.lightningdevkit.ldknode.Bolt11Invoice
 import org.lightningdevkit.ldknode.Network
 import to.bitkit.data.SettingsData
@@ -35,7 +31,6 @@ import kotlin.time.Clock
 import kotlin.time.Duration.Companion.hours
 import kotlin.time.Duration.Companion.minutes
 import kotlin.time.ExperimentalTime
-import to.bitkit.di.json as appJson
 
 sealed class PublicPaykitError(message: String) : AppError(message) {
     data object InvalidPayload : PublicPaykitError("Invalid Paykit payment endpoint payload")
@@ -78,12 +73,6 @@ class PublicPaykitRepo @Inject constructor(
     companion object {
         private val methodIdPattern = Regex("^[a-z0-9]+-[a-z0-9]+-[a-z0-9]+$")
 
-        private val payloadJson = Json(appJson) {
-            prettyPrint = false
-            isLenient = false
-            encodeDefaults = false
-        }
-
         internal val payablePreferenceOrder = listOf(
             MethodId.Bolt11,
             MethodId.Lnurl,
@@ -113,15 +102,11 @@ class PublicPaykitRepo @Inject constructor(
             if (!methodIdPattern.matches(methodId)) return null
 
             val knownMethodId = MethodId.fromRawValue(methodId, network) ?: return null
-            val payload = runCatching {
-                payloadJson.decodeFromString<PaymentEndpointPayload>(endpointData)
-            }.getOrNull() ?: return null
-            val value = payload.value.trim()
-            if (value.isEmpty()) return null
+            val payload = PaykitIssuerInterop.parseEndpointPayload(endpointData) ?: return null
 
             return Endpoint(
                 methodId = knownMethodId,
-                value = value,
+                value = payload.value,
                 min = payload.min,
                 max = payload.max,
                 rawPayload = endpointData,
@@ -129,9 +114,8 @@ class PublicPaykitRepo @Inject constructor(
         }
 
         fun serializePayload(value: String): String {
-            val trimmedValue = value.trim()
-            if (trimmedValue.isEmpty()) throw PublicPaykitError.InvalidPayload
-            return payloadJson.encodeToString(PaymentEndpointPayload(value = trimmedValue))
+            return PaykitIssuerInterop.serializeEndpointPayload(value)
+                ?: throw PublicPaykitError.InvalidPayload
         }
 
         fun hasLightningRouteHints(bolt11: String): Boolean =
@@ -473,10 +457,3 @@ enum class MethodId(
         ): MethodId? = entries.firstOrNull { it.rawValueForNetwork(network) == value }
     }
 }
-
-@Serializable
-private data class PaymentEndpointPayload(
-    val value: String,
-    val min: String? = null,
-    val max: String? = null,
-)
diff --git a/app/src/main/java/to/bitkit/services/PaykitSdkService.kt b/app/src/main/java/to/bitkit/services/PaykitSdkService.kt
index fcf69c9e75..c8e1b27609 100644
--- a/app/src/main/java/to/bitkit/services/PaykitSdkService.kt
+++ b/app/src/main/java/to/bitkit/services/PaykitSdkService.kt
@@ -83,6 +83,7 @@ import to.bitkit.ext.runSuspendCatching
 import to.bitkit.ext.toHex
 import to.bitkit.models.PubkyPublicKeyFormat
 import to.bitkit.repositories.Endpoint
+import to.bitkit.repositories.PaykitIssuerInterop
 import to.bitkit.repositories.PublicPaykitRepo
 import to.bitkit.utils.AppError
 import to.bitkit.utils.Logger
@@ -630,7 +631,7 @@ class PaykitSdkService @Inject constructor(
                         PubkyPublicKeyFormat.matches(identityStatus.publicKey, expectedIdentity)
                 ) { "Paykit identity changed before proposing the payment request" }
                 val terms = PaymentRequestTerms(
-                    amount = PaymentRequestAmount(proposal.amountValue, "btc"),
+                    amount = PaymentRequestAmount(proposal.amountValue, PaykitIssuerInterop.BITCOIN_ASSET),
                     paymentReference = PaymentReference(proposal.paymentReference),
                     proposalExpiresAt = proposal.proposalExpiresAt,
                     recurrence = null,
diff --git a/app/src/main/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreen.kt b/app/src/main/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreen.kt
index abdab879f5..a69616eadb 100644
--- a/app/src/main/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreen.kt
+++ b/app/src/main/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreen.kt
@@ -539,7 +539,9 @@ internal fun PaymentRequestCard(
                         )
                     },
                     size = ButtonSize.Small,
-                    modifier = Modifier.weight(1f),
+                    modifier = Modifier
+                        .weight(1f)
+                        .testTag("PaymentRequestReject${request.paymentRequestId}")
                 )
                 PrimaryButton(
                     text = stringResource(R.string.wallet__payment_request_pay),
@@ -553,7 +555,9 @@ internal fun PaymentRequestCard(
                         )
                     },
                     size = ButtonSize.Small,
-                    modifier = Modifier.weight(1f),
+                    modifier = Modifier
+                        .weight(1f)
+                        .testTag("PaymentRequestPay${request.paymentRequestId}")
                 )
             }
         }
diff --git a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendConfirmScreen.kt b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendConfirmScreen.kt
index cb38d9a411..38b06639ed 100644
--- a/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendConfirmScreen.kt
+++ b/app/src/main/java/to/bitkit/ui/screens/wallets/send/SendConfirmScreen.kt
@@ -213,7 +213,11 @@ private fun Content(
     onBiometricsSuccess: () -> Unit = {},
     onBiometricsFailure: () -> Unit = {},
 ) {
-    Box(modifier = modifier) {
+    Box(
+        modifier = modifier.testTag(
+            if (uiState.isPaymentRequest) "PaymentRequestConfirm" else "SendConfirm",
+        )
+    ) {
         Column(
             modifier = Modifier
                 .fillMaxSize()
diff --git a/app/src/test/java/to/bitkit/repositories/PaykitIssuerInteropTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitIssuerInteropTest.kt
new file mode 100644
index 0000000000..c4210e1d63
--- /dev/null
+++ b/app/src/test/java/to/bitkit/repositories/PaykitIssuerInteropTest.kt
@@ -0,0 +1,187 @@
+package to.bitkit.repositories
+
+import com.synonym.paykit.PaymentReference
+import com.synonym.paykit.PaymentRequestAmount
+import com.synonym.paykit.PaymentRequestLifecycleState
+import com.synonym.paykit.PaymentRequestLocalRole
+import com.synonym.paykit.PaymentRequestRecord
+import com.synonym.paykit.PaymentRequestTerms
+import com.synonym.paykit.PrivateJsonObject
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import org.junit.Test
+import org.lightningdevkit.ldknode.Network
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.time.Instant
+
+class PaykitIssuerInteropTest {
+    companion object {
+        private val NOW = Instant.parse("2026-09-02T12:00:00Z")
+        private val PAYMENT_REFERENCE = mock<PaymentReference> {
+            on { exportText() } doReturn "marketplace-order-713"
+        }
+        private val METADATA = mock<PrivateJsonObject> {
+            on { exportText() } doReturn """{"order":"713"}"""
+        }
+    }
+
+    @Test
+    fun `request fixtures match issuer contract`() {
+        val fixtures = loadFixtures()
+        assertEquals(1, fixtures.schemaVersion)
+
+        fixtures.requestFixtures.forEach { fixture ->
+            val record = paymentRequestRecord(
+                asset = fixture.asset,
+                endpointIdentifiers = fixture.acceptedPaymentEndpointIdentifiers,
+            )
+            val request = record.toPaykitPaymentRequest(
+                expectedRole = PaymentRequestLocalRole.PAYER,
+                now = NOW,
+                network = fixture.network.ldkNetwork,
+            )
+
+            assertEquals(fixture.accepted, request != null, fixture.name)
+            assertEquals(
+                fixture.expectedIdentifiers,
+                request?.acceptedPaymentEndpointIdentifiers.orEmpty(),
+                fixture.name,
+            )
+        }
+    }
+
+    @Test
+    fun `endpoint fixtures match issuer contract`() {
+        loadFixtures().endpointFixtures.forEach { fixture ->
+            val endpoint = PublicPaykitRepo.parseEndpoint(
+                methodId = fixture.identifier,
+                endpointData = fixture.payload,
+                network = Network.REGTEST,
+            )
+
+            assertEquals(fixture.accepted, endpoint != null, fixture.name)
+            assertEquals(fixture.expectedValue, endpoint?.value, fixture.name)
+            assertEquals(fixture.expectedMin, endpoint?.min, fixture.name)
+            assertEquals(fixture.expectedMax, endpoint?.max, fixture.name)
+        }
+    }
+
+    @Test
+    fun `request fixtures cover every network and chain independent lightning identifiers`() {
+        val acceptedFixtures = loadFixtures().requestFixtures.filter { it.accepted }
+
+        FixtureNetwork.entries.forEach { network ->
+            assertTrue(
+                acceptedFixtures.any {
+                    it.network == network && it.expectedIdentifiers == listOf("btc-lightning-bolt11")
+                },
+                "Missing Bolt11 fixture for '${network.serializedName}'",
+            )
+            assertTrue(
+                acceptedFixtures.any {
+                    it.network == network && it.expectedIdentifiers == listOf("btc-lightning-lnurl")
+                },
+                "Missing LNURL fixture for '${network.serializedName}'",
+            )
+            assertTrue(
+                acceptedFixtures.any {
+                    it.network == network &&
+                        it.expectedIdentifiers == listOf("btc-${network.serializedName}-p2wpkh")
+                },
+                "Missing on-chain fixture for '${network.serializedName}'",
+            )
+        }
+    }
+
+    private fun loadFixtures(): IssuerInteropFixtures {
+        val resource = requireNotNull(javaClass.classLoader?.getResource("paykit-issuer-interoperability.json")) {
+            "Missing Paykit issuer interoperability fixtures"
+        }
+        return Json.decodeFromString(resource.readText())
+    }
+
+    private fun paymentRequestRecord(
+        asset: String,
+        endpointIdentifiers: List<String>,
+    ) = PaymentRequestRecord(
+        counterparty = "pubkyissuerfixture",
+        counterpartyReceiverPath = "bitkit/server",
+        paymentRequestId = "71300000-0000-4000-8000-000000000001",
+        localRole = PaymentRequestLocalRole.PAYER,
+        state = PaymentRequestLifecycleState.PROPOSED,
+        proposalStreamItemId = 1uL,
+        proposalOutboundMessageId = null,
+        proposalOutboundStatus = null,
+        proposalEventId = "71300000-0000-4000-8000-000000000002",
+        terms = PaymentRequestTerms(
+            amount = PaymentRequestAmount(value = "0.001", asset = asset),
+            paymentReference = PAYMENT_REFERENCE,
+            proposalExpiresAt = null,
+            recurrence = null,
+            acceptedPaymentEndpointIdentifiers = endpointIdentifiers,
+            metadata = METADATA,
+        ),
+        acceptedEventId = null,
+        acceptedOutboundStatus = null,
+        rejectedEventId = null,
+        rejectedOutboundStatus = null,
+        canceledEventId = null,
+        canceledOutboundStatus = null,
+        paymentProofs = emptyList(),
+        lastStreamItemId = 1uL,
+        lastOutboundMessageId = null,
+        lastOutboundStatus = null,
+        lastEventAt = NOW.toString(),
+        invalidReason = null,
+    )
+}
+
+@Serializable
+private data class IssuerInteropFixtures(
+    val schemaVersion: Int,
+    val requestFixtures: List<RequestFixture>,
+    val endpointFixtures: List<EndpointFixture>,
+)
+
+@Serializable
+private data class RequestFixture(
+    val name: String,
+    val network: FixtureNetwork,
+    val asset: String,
+    val acceptedPaymentEndpointIdentifiers: List<String>,
+    val accepted: Boolean,
+    val expectedIdentifiers: List<String>,
+)
+
+@Serializable
+private data class EndpointFixture(
+    val name: String,
+    val identifier: String,
+    val payload: String,
+    val accepted: Boolean,
+    val expectedValue: String? = null,
+    val expectedMin: String? = null,
+    val expectedMax: String? = null,
+)
+
+@Serializable
+private enum class FixtureNetwork(
+    val ldkNetwork: Network,
+    val serializedName: String,
+) {
+    @SerialName("bitcoin")
+    Bitcoin(Network.BITCOIN, "bitcoin"),
+
+    @SerialName("testnet")
+    Testnet(Network.TESTNET, "testnet"),
+
+    @SerialName("signet")
+    Signet(Network.SIGNET, "signet"),
+
+    @SerialName("regtest")
+    Regtest(Network.REGTEST, "regtest"),
+}
diff --git a/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt
index 3abafeadea..a11dc7ec88 100644
--- a/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt
+++ b/app/src/test/java/to/bitkit/repositories/PaykitPaymentRequestRepoTest.kt
@@ -22,7 +22,6 @@ import kotlinx.coroutines.test.runCurrent
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
-import org.lightningdevkit.ldknode.Network
 import org.mockito.kotlin.any
 import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.clearInvocations
@@ -50,7 +49,6 @@ import kotlin.time.Duration.Companion.seconds
 import kotlin.time.ExperimentalTime
 import kotlin.time.Instant
 
-@Suppress("LargeClass")
 class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) {
     companion object {
         private const val PAYMENT_REQUEST_ID = "550e8400-e29b-41d4-a716-446655440000"
@@ -107,53 +105,6 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) {
         assertEquals(listOf(MethodId.Bolt11.rawValue), request.acceptedPaymentEndpointIdentifiers)
     }
 
-    @Test
-    fun `refresh accepts only exact lowercase bitcoin asset`() = test {
-        whenever(paykitSdkService.paymentRequests()).thenReturn(
-            listOf(
-                paymentRequestRecord(id = "lowercase", asset = "btc"),
-                paymentRequestRecord(id = "uppercase", asset = "BTC"),
-                paymentRequestRecord(id = "mixed-case", asset = "Btc"),
-                paymentRequestRecord(id = "whitespace", asset = " btc "),
-            ),
-        )
-
-        sut.refresh().getOrThrow()
-
-        assertEquals(listOf("lowercase"), sut.pendingRequests.value.map { it.paymentRequestId })
-    }
-
-    @Test
-    fun `request filtering accepts network correct and chain independent identifiers`() {
-        val networkRails = listOf(
-            Network.BITCOIN to "bitcoin",
-            Network.TESTNET to "testnet",
-            Network.SIGNET to "signet",
-            Network.REGTEST to "regtest",
-        )
-        val scriptTypes = listOf("p2tr", "p2wpkh", "p2sh", "p2pkh")
-        val onchainIdentifiers = networkRails.flatMap { (_, rail) ->
-            scriptTypes.map { "btc-$rail-$it" }
-        }
-
-        networkRails.forEach { (network, rail) ->
-            val accepted = listOf(
-                "btc-lightning-bolt11",
-                "btc-lightning-lnurl",
-            ) + scriptTypes.map { "btc-$rail-$it" }
-            val rejected = onchainIdentifiers.filterNot { it in accepted } + listOf(
-                "BTC-$rail-p2wpkh",
-                "btc-$rail-bolt12",
-                "btc-unsupported-method",
-            )
-
-            assertEquals(
-                accepted,
-                supportedPaykitEndpointIdentifiers(accepted + accepted.first() + rejected, network),
-            )
-        }
-    }
-
     @Test
     fun `refresh rejects amounts outside the app payment range`() = test {
         whenever(paykitSdkService.paymentRequests()).thenReturn(
@@ -703,7 +654,6 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) {
         role: PaymentRequestLocalRole? = PaymentRequestLocalRole.PAYER,
         state: PaymentRequestLifecycleState = PaymentRequestLifecycleState.PROPOSED,
         amount: String = "0.001",
-        asset: String = "btc",
         expiresAt: String? = null,
         endpoints: List<String> = listOf(MethodId.Bolt11.rawValue),
         counterparty: String = COUNTERPARTY,
@@ -719,7 +669,7 @@ class PaykitPaymentRequestRepoTest : BaseUnitTest(StandardTestDispatcher()) {
         proposalOutboundStatus = null,
         proposalEventId = "proposal-event",
         terms = PaymentRequestTerms(
-            amount = PaymentRequestAmount(value = amount, asset = asset),
+            amount = PaymentRequestAmount(value = amount, asset = "btc"),
             paymentReference = PAYMENT_REFERENCE,
             proposalExpiresAt = expiresAt,
             recurrence = null,
diff --git a/app/src/test/java/to/bitkit/repositories/PublicPaykitRepoTest.kt b/app/src/test/java/to/bitkit/repositories/PublicPaykitRepoTest.kt
index 6c35825544..612a5d8205 100644
--- a/app/src/test/java/to/bitkit/repositories/PublicPaykitRepoTest.kt
+++ b/app/src/test/java/to/bitkit/repositories/PublicPaykitRepoTest.kt
@@ -10,7 +10,6 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
-import org.lightningdevkit.ldknode.Network
 import org.mockito.kotlin.any
 import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.mock
@@ -26,7 +25,6 @@ import to.bitkit.services.PaykitResolvedPaymentEndpoint
 import to.bitkit.services.PaykitSdkService
 import to.bitkit.test.BaseUnitTest
 import kotlin.test.assertEquals
-import kotlin.test.assertNull
 import kotlin.test.assertTrue
 import kotlin.time.Clock
 import kotlin.time.Duration.Companion.hours
@@ -80,51 +78,6 @@ class PublicPaykitRepoTest : BaseUnitTest() {
         PublicPaykitRepo.lightningRouteHintsValidator = null
     }
 
-    @Test
-    fun `parseEndpoint accepts network correct JSON endpoint fixtures`() {
-        val fixtures = listOf(
-            Network.BITCOIN to "btc-bitcoin-p2wpkh",
-            Network.TESTNET to "btc-testnet-p2wpkh",
-            Network.SIGNET to "btc-signet-p2wpkh",
-            Network.REGTEST to "btc-regtest-p2wpkh",
-        )
-
-        fixtures.forEach { (network, identifier) ->
-            val endpoint = PublicPaykitRepo.parseEndpoint(
-                methodId = identifier,
-                endpointData = """{"value":"  address  ","min":"1000","max":"2000"}""",
-                network = network,
-            )
-
-            assertEquals(MethodId.P2wpkh, endpoint?.methodId)
-            assertEquals("address", endpoint?.value)
-            assertEquals("1000", endpoint?.min)
-            assertEquals("2000", endpoint?.max)
-        }
-    }
-
-    @Test
-    fun `parseEndpoint rejects non canonical JSON endpoint payloads`() {
-        val rejectedPayloads = listOf(
-            "bcrt1qraw",
-            """"bcrt1qjsonstring"""",
-            "{}",
-            """{"value":""}""",
-            """{"value":"   "}""",
-            """{"value":1}""",
-        )
-
-        rejectedPayloads.forEach {
-            assertNull(
-                PublicPaykitRepo.parseEndpoint(
-                    methodId = "btc-regtest-p2wpkh",
-                    endpointData = it,
-                    network = Network.REGTEST,
-                ),
-            )
-        }
-    }
-
     @Test
     fun `syncCurrentPublishedEndpoints configures SDK public endpoints`() = test {
         walletState.value = WalletState(onchainAddress = "bc1ptest")
diff --git a/app/src/test/resources/paykit-issuer-interoperability.json b/app/src/test/resources/paykit-issuer-interoperability.json
new file mode 100644
index 0000000000..1afd667367
--- /dev/null
+++ b/app/src/test/resources/paykit-issuer-interoperability.json
@@ -0,0 +1,258 @@
+{
+  "schemaVersion": 1,
+  "requestFixtures": [
+    {
+      "name": "bitcoin-onchain",
+      "network": "bitcoin",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-bitcoin-p2wpkh"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-bitcoin-p2wpkh"]
+    },
+    {
+      "name": "testnet-onchain",
+      "network": "testnet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-testnet-p2wpkh"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-testnet-p2wpkh"]
+    },
+    {
+      "name": "signet-onchain",
+      "network": "signet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-signet-p2wpkh"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-signet-p2wpkh"]
+    },
+    {
+      "name": "regtest-onchain",
+      "network": "regtest",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-regtest-p2wpkh"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-regtest-p2wpkh"]
+    },
+    {
+      "name": "bitcoin-bolt11",
+      "network": "bitcoin",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-lightning-bolt11"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-lightning-bolt11"]
+    },
+    {
+      "name": "testnet-bolt11",
+      "network": "testnet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-lightning-bolt11"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-lightning-bolt11"]
+    },
+    {
+      "name": "signet-bolt11",
+      "network": "signet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-lightning-bolt11"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-lightning-bolt11"]
+    },
+    {
+      "name": "regtest-bolt11",
+      "network": "regtest",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-lightning-bolt11"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-lightning-bolt11"]
+    },
+    {
+      "name": "bitcoin-lnurl",
+      "network": "bitcoin",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-lightning-lnurl"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-lightning-lnurl"]
+    },
+    {
+      "name": "testnet-lnurl",
+      "network": "testnet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-lightning-lnurl"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-lightning-lnurl"]
+    },
+    {
+      "name": "signet-lnurl",
+      "network": "signet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-lightning-lnurl"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-lightning-lnurl"]
+    },
+    {
+      "name": "regtest-lnurl",
+      "network": "regtest",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-lightning-lnurl"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-lightning-lnurl"]
+    },
+    {
+      "name": "regtest-filters-and-deduplicates",
+      "network": "regtest",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": [
+        "btc-lightning-bolt11",
+        "btc-lightning-bolt11",
+        "btc-bitcoin-p2wpkh",
+        "btc-regtest-p2wpkh",
+        "btc-unsupported-method"
+      ],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-lightning-bolt11", "btc-regtest-p2wpkh"]
+    },
+    {
+      "name": "uppercase-asset",
+      "network": "regtest",
+      "asset": "BTC",
+      "acceptedPaymentEndpointIdentifiers": ["btc-regtest-p2wpkh"],
+      "accepted": false,
+      "expectedIdentifiers": []
+    },
+    {
+      "name": "bitcoin-foreign-onchain",
+      "network": "bitcoin",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-testnet-p2wpkh"],
+      "accepted": false,
+      "expectedIdentifiers": []
+    },
+    {
+      "name": "testnet-foreign-onchain",
+      "network": "testnet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-signet-p2wpkh"],
+      "accepted": false,
+      "expectedIdentifiers": []
+    },
+    {
+      "name": "signet-foreign-onchain",
+      "network": "signet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-regtest-p2wpkh"],
+      "accepted": false,
+      "expectedIdentifiers": []
+    },
+    {
+      "name": "regtest-foreign-onchain",
+      "network": "regtest",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-bitcoin-p2wpkh"],
+      "accepted": false,
+      "expectedIdentifiers": []
+    },
+    {
+      "name": "uppercase-identifier",
+      "network": "regtest",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["BTC-regtest-p2wpkh"],
+      "accepted": false,
+      "expectedIdentifiers": []
+    },
+    {
+      "name": "unknown-identifier",
+      "network": "regtest",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-unsupported-method"],
+      "accepted": false,
+      "expectedIdentifiers": []
+    },
+    {
+      "name": "empty-identifiers",
+      "network": "regtest",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": [],
+      "accepted": false,
+      "expectedIdentifiers": []
+    }
+  ],
+  "endpointFixtures": [
+    {
+      "name": "onchain-json-value",
+      "identifier": "btc-regtest-p2wpkh",
+      "payload": "{\"value\":\"bcrt1qissuerfixture\"}",
+      "accepted": true,
+      "expectedValue": "bcrt1qissuerfixture"
+    },
+    {
+      "name": "bolt11-json-value-with-bounds",
+      "identifier": "btc-lightning-bolt11",
+      "payload": "{\"value\":\"lnbc1issuerfixture\",\"min\":\"1000\",\"max\":\"2000\"}",
+      "accepted": true,
+      "expectedValue": "lnbc1issuerfixture",
+      "expectedMin": "1000",
+      "expectedMax": "2000"
+    },
+    {
+      "name": "lnurl-trims-value",
+      "identifier": "btc-lightning-lnurl",
+      "payload": "  {\"value\":\"  lnurl1issuerfixture  \"}  ",
+      "accepted": true,
+      "expectedValue": "lnurl1issuerfixture"
+    },
+    {
+      "name": "raw-string",
+      "identifier": "btc-regtest-p2wpkh",
+      "payload": "bcrt1qissuerfixture",
+      "accepted": false
+    },
+    {
+      "name": "empty-payload",
+      "identifier": "btc-regtest-p2wpkh",
+      "payload": "",
+      "accepted": false
+    },
+    {
+      "name": "missing-value",
+      "identifier": "btc-regtest-p2wpkh",
+      "payload": "{}",
+      "accepted": false
+    },
+    {
+      "name": "empty-value",
+      "identifier": "btc-regtest-p2wpkh",
+      "payload": "{\"value\":\"\"}",
+      "accepted": false
+    },
+    {
+      "name": "whitespace-value",
+      "identifier": "btc-regtest-p2wpkh",
+      "payload": "{\"value\":\"   \"}",
+      "accepted": false
+    },
+    {
+      "name": "numeric-value",
+      "identifier": "btc-regtest-p2wpkh",
+      "payload": "{\"value\":713}",
+      "accepted": false
+    },
+    {
+      "name": "top-level-array",
+      "identifier": "btc-regtest-p2wpkh",
+      "payload": "[{\"value\":\"bcrt1qissuerfixture\"}]",
+      "accepted": false
+    },
+    {
+      "name": "malformed-json",
+      "identifier": "btc-regtest-p2wpkh",
+      "payload": "{\"value\":",
+      "accepted": false
+    },
+    {
+      "name": "unsupported-identifier",
+      "identifier": "btc-lightning-bolt12",
+      "payload": "{\"value\":\"lno1issuerfixture\"}",
+      "accepted": false
+    }
+  ]
+}
diff --git a/docs/paykit-issuer-interoperability.md b/docs/paykit-issuer-interoperability.md
index aae04642f2..8fd6b887b4 100644
--- a/docs/paykit-issuer-interoperability.md
+++ b/docs/paykit-issuer-interoperability.md
@@ -1,48 +1,86 @@
-# Paykit Issuer Interoperability
+# Paykit issuer interoperability
 
-Paykit issuers must use the following shapes for payment requests and endpoint payloads that Bitkit can open.
+This is the Bitkit issuer contract for one-time Paykit Payment Requests. It describes the request and payment-endpoint shapes an issuer must provide for Bitkit to present and open a request. The canonical accepted and rejected examples are in
+[`app/src/test/resources/paykit-issuer-interoperability.json`](../app/src/test/resources/paykit-issuer-interoperability.json).
 
-## Payment requests
+This contract records Bitkit behavior. Paykit protocol or SDK policy remains owned by Paykit.
 
-- Set `terms.amount.asset` to the exact lowercase value `btc`.
-- Advertise at least one endpoint identifier supported by the active Bitkit network.
-- Lightning identifiers are chain-independent:
-  - `btc-lightning-bolt11`
-  - `btc-lightning-lnurl`
-- On-chain identifiers are chain-specific and use `btc-<network>-<script>`.
+## Payment Request
 
-| Bitkit network | P2TR | P2WPKH | P2SH | P2PKH |
+An actionable request must satisfy all of these requirements:
+
+- The amount asset is exactly lowercase `btc`.
+- The amount is a positive decimal Bitcoin value with at most eight significant fractional digits and no more than `18,446,744,073,709,551` satoshis.
+- The request is a one-time proposal: the local role is payer, lifecycle state is proposed, and recurrence is absent.
+- The proposal expiration is absent or is a valid future ISO 8601 timestamp.
+- `acceptedPaymentEndpointIdentifiers` retains at least one identifier supported on the wallet's current network.
+
+Bitkit filters `acceptedPaymentEndpointIdentifiers` in issuer order, removes duplicates after their first occurrence, and drops unknown or wrong-network identifiers. The request remains actionable when at least one identifier survives.
+
+### Endpoint identifiers
+
+Lightning identifiers are chain-independent and are accepted on every network:
+
+- `btc-lightning-bolt11`
+- `btc-lightning-lnurl`
+
+On-chain identifiers include the wallet network:
+
+| Network | P2TR | P2WPKH | P2SH | P2PKH |
 | --- | --- | --- | --- | --- |
 | Bitcoin | `btc-bitcoin-p2tr` | `btc-bitcoin-p2wpkh` | `btc-bitcoin-p2sh` | `btc-bitcoin-p2pkh` |
 | Testnet | `btc-testnet-p2tr` | `btc-testnet-p2wpkh` | `btc-testnet-p2sh` | `btc-testnet-p2pkh` |
 | Signet | `btc-signet-p2tr` | `btc-signet-p2wpkh` | `btc-signet-p2sh` | `btc-signet-p2pkh` |
 | Regtest | `btc-regtest-p2tr` | `btc-regtest-p2wpkh` | `btc-regtest-p2sh` | `btc-regtest-p2pkh` |
 
-Bitkit ignores unsupported identifiers and on-chain identifiers for another network. A request with no supported identifier is not actionable.
+For example, a regtest issuer can propose:
 
-## Endpoint payloads
+```json
+{
+  "amount": { "value": "0.001", "asset": "btc" },
+  "paymentReference": { "text": "marketplace-order-713" },
+  "proposalExpiresAt": "2030-01-01T00:00:00Z",
+  "recurrence": null,
+  "acceptedPaymentEndpointIdentifiers": [
+    "btc-regtest-p2wpkh",
+    "btc-lightning-bolt11"
+  ],
+  "metadata": { "order": "713" }
+}
+```
+
+The object above shows the Paykit term values an issuer supplies; Paykit owns their wire serialization.
 
-Encode each endpoint payload as a JSON object with a non-empty string in `value`:
+## Payment endpoint
+
+For every advertised identifier, the endpoint payload is a JSON object. `value` is a required, non-empty string:
 
 ```json
-{"value":"bcrt1qexample"}
+{"value":"bcrt1qissuerfixture"}
 ```
 
-Optional `min` and `max` values are strings:
+Optional `min` and `max` string fields are retained:
 
 ```json
-{"value":"lnbcrt1example","min":"1000","max":"2000"}
+{"value":"lnbc1issuerfixture","min":"1000","max":"2000"}
 ```
 
-Bitkit trims surrounding whitespace from `value`. It rejects bare values, JSON strings, missing values, non-string values, and empty values.
+Bitkit trims whitespace around the payload and `value`. It rejects a bare address or invoice string, invalid JSON, a non-object top level, a missing `value`, a non-string `value`, an empty value, a whitespace-only value, or an unknown identifier.
+
+After this shape check, Bitkit validates that the value is usable: an on-chain address matches the current network, a BOLT 11 invoice is unexpired and network-correct, and an LNURL value is an LNURL-pay request.
+
+## Delivery prerequisites
+
+The issuer and wallet must be linked Paykit peers on the same receiver path before Bitkit polls the request. The issuer must advertise a usable endpoint for at least one identifier retained from the request. A request that fails the request gate is not presented; a request whose endpoint cannot be resolved is deferred until usable payment details arrive.
+
+## Contract fixtures
 
-## Compatibility fixtures
+The fixture file is the cross-platform source of truth for Bitkit iOS and Android:
 
-For every Bitkit network, issuer fixtures must prove that:
+- Request fixtures cover the network-correct P2WPKH identifier for Bitcoin, testnet, signet, and regtest.
+- Request fixtures cover both Lightning identifiers on every network.
+- Rejected request fixtures cover uppercase `BTC`, a foreign-network on-chain identifier on every network, an uppercase identifier, an unknown identifier, and an empty identifier list.
+- Endpoint fixtures accept JSON object payloads with a non-empty string `value`, including optional string bounds and surrounding whitespace.
+- Rejected endpoint fixtures cover a raw string, empty payload, missing/empty/whitespace/numeric `value`, top-level array, malformed JSON, and unsupported identifier.
 
-- both Lightning identifiers are accepted;
-- all four on-chain identifiers for the active network are accepted;
-- on-chain identifiers for the other networks are rejected;
-- lowercase `btc` is accepted and other casing is rejected;
-- JSON objects containing a non-empty string `value` are accepted;
-- bare, missing, non-string, and empty endpoint values are rejected.
+The iOS fixture suite in [PR #719](https://github.com/synonymdev/bitkit-ios/pull/719) consumes the same fixture names, inputs, and expected results. Any intentional platform difference requires changing this contract and both fixture suites together.
diff --git a/journeys/payment-requests/README.md b/journeys/payment-requests/README.md
new file mode 100644
index 0000000000..bd7870154c
--- /dev/null
+++ b/journeys/payment-requests/README.md
@@ -0,0 +1,34 @@
+# Payment Request journeys
+
+Cover incoming Paykit Payment Requests from a linked issuer. The issuer contract and exact accepted/rejected data live in
+[`docs/paykit-issuer-interoperability.md`](../../docs/paykit-issuer-interoperability.md) and
+[`app/src/test/resources/paykit-issuer-interoperability.json`](../../app/src/test/resources/paykit-issuer-interoperability.json).
+
+## Setup
+
+Run Bitkit against regtest with Paykit UI enabled. Authenticate a Pubky identity, link the fixture issuer on receiver path `bitkit/server`, and give the wallet enough on-chain balance to pay 100,000 sats. The fixture issuer must be able to publish a Paykit endpoint and send a one-time Payment Request to that linked peer.
+
+The accepted journey uses:
+
+- Payment Request ID: `71300000-0000-4000-8000-000000000001`
+- Asset: `btc`
+- Amount: `0.001`
+- Accepted identifier: `btc-regtest-p2wpkh`
+- Endpoint payload: `{"value":"bcrt1qissuerfixture"}`, replacing the placeholder address with a valid current receive address from the issuer
+
+Rejected fixture shapes stay in unit tests because Bitkit intentionally does not present requests that fail the contract gate.
+
+## Reference evidence
+
+The source wallet-leg run completed this path on regtest on 2026-08-22: Bitkit presented the incoming request, opened the on-chain payment, broadcast it, and confirmed transaction
+`cc85df0e24b54be353a57700429d144b35264c1af97f3de41c503dc52f1e4792` at height `77318`.
+
+That run established the issuer shapes captured by the fixture: lowercase `btc`, `btc-regtest-p2wpkh`, and a JSON object endpoint payload with a non-empty string `value`. The exact Debug binary SHA was not recorded, so the canonical fixture tests lock the same production gates on the current code.
+
+## Identifiers used
+
+- Incoming sheet: `PaymentRequestsSheet`
+- Request row: `PaymentRequestRow<paymentRequestId>`
+- Pay action: `PaymentRequestPay<paymentRequestId>`
+- Reject action: `PaymentRequestReject<paymentRequestId>`
+- Payment confirmation: `PaymentRequestConfirm`
diff --git a/journeys/payment-requests/issuer-interoperability.xml b/journeys/payment-requests/issuer-interoperability.xml
new file mode 100644
index 0000000000..8186700204
--- /dev/null
+++ b/journeys/payment-requests/issuer-interoperability.xml
@@ -0,0 +1,14 @@
+<journey name="Paykit Issuer Interoperability">
+  <description>
+    Verifies that the canonical accepted regtest issuer fixture reaches Bitkit and opens the payment confirmation flow. Requires the linked fixture issuer and funded regtest wallet described in README.md. Rejected shapes are covered by the shared fixture unit tests because Bitkit intentionally does not present them.
+  </description>
+  <actions>
+    <action>Launch the E2E Bitkit app with Paykit UI enabled and the fixture issuer linked on receiver path "bitkit/server"</action>
+    <action>Have the issuer publish a current regtest P2WPKH address under identifier "btc-regtest-p2wpkh" with JSON payload {"value":"&lt;current address&gt;"}</action>
+    <action>Have the issuer send proposed one-time Payment Request "71300000-0000-4000-8000-000000000001" for amount "0.001", asset "btc", and accepted identifier "btc-regtest-p2wpkh"</action>
+    <action>Verify the incoming Payment Requests sheet (id "PaymentRequestsSheet") appears</action>
+    <action>Verify request row (id "PaymentRequestRow71300000-0000-4000-8000-000000000001") shows 100,000 sats</action>
+    <action>Tap Pay (id "PaymentRequestPay71300000-0000-4000-8000-000000000001")</action>
+    <action>Verify the Payment Request confirmation screen (id "PaymentRequestConfirm") shows 100,000 sats and the issuer as recipient</action>
+  </actions>
+</journey>

From 10fba5d24664e7fca6d874daacf9183809a1c333 Mon Sep 17 00:00:00 2001
From: Ovi Trif <ovitrif@proton.me>
Date: Wed, 2 Sep 2026 03:01:42 +0200
Subject: [PATCH 3/4] test: cover every paykit script

---
 .../repositories/PaykitIssuerInteropTest.kt   |  28 +++--
 .../paykit-issuer-interoperability.json       | 104 +++++++++++++++++-
 docs/paykit-issuer-interoperability.md        |   2 +-
 3 files changed, 121 insertions(+), 13 deletions(-)

diff --git a/app/src/test/java/to/bitkit/repositories/PaykitIssuerInteropTest.kt b/app/src/test/java/to/bitkit/repositories/PaykitIssuerInteropTest.kt
index c4210e1d63..052b0136cf 100644
--- a/app/src/test/java/to/bitkit/repositories/PaykitIssuerInteropTest.kt
+++ b/app/src/test/java/to/bitkit/repositories/PaykitIssuerInteropTest.kt
@@ -71,8 +71,20 @@ class PaykitIssuerInteropTest {
     }
 
     @Test
-    fun `request fixtures cover every network and chain independent lightning identifiers`() {
+    fun `request fixtures cover every documented identifier`() {
         val acceptedFixtures = loadFixtures().requestFixtures.filter { it.accepted }
+        val expectedOnchainFixtures = FixtureNetwork.entries.flatMap { network ->
+            FixtureScript.entries.map { script ->
+                "${network.serializedName}|btc-${network.serializedName}-${script.serializedName}"
+            }
+        }.toSet()
+        val actualOnchainFixtures = acceptedFixtures.mapNotNull { fixture ->
+            val identifier = fixture.expectedIdentifiers.singleOrNull() ?: return@mapNotNull null
+            if (!identifier.startsWith("btc-${fixture.network.serializedName}-")) return@mapNotNull null
+            "${fixture.network.serializedName}|$identifier"
+        }.toSet()
+
+        assertEquals(expectedOnchainFixtures, actualOnchainFixtures)
 
         FixtureNetwork.entries.forEach { network ->
             assertTrue(
@@ -87,13 +99,6 @@ class PaykitIssuerInteropTest {
                 },
                 "Missing LNURL fixture for '${network.serializedName}'",
             )
-            assertTrue(
-                acceptedFixtures.any {
-                    it.network == network &&
-                        it.expectedIdentifiers == listOf("btc-${network.serializedName}-p2wpkh")
-                },
-                "Missing on-chain fixture for '${network.serializedName}'",
-            )
         }
     }
 
@@ -185,3 +190,10 @@ private enum class FixtureNetwork(
     @SerialName("regtest")
     Regtest(Network.REGTEST, "regtest"),
 }
+
+private enum class FixtureScript(val serializedName: String) {
+    P2tr("p2tr"),
+    P2wpkh("p2wpkh"),
+    P2sh("p2sh"),
+    P2pkh("p2pkh"),
+}
diff --git a/app/src/test/resources/paykit-issuer-interoperability.json b/app/src/test/resources/paykit-issuer-interoperability.json
index 1afd667367..0c54bb0d9c 100644
--- a/app/src/test/resources/paykit-issuer-interoperability.json
+++ b/app/src/test/resources/paykit-issuer-interoperability.json
@@ -2,7 +2,15 @@
   "schemaVersion": 1,
   "requestFixtures": [
     {
-      "name": "bitcoin-onchain",
+      "name": "bitcoin-p2tr",
+      "network": "bitcoin",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-bitcoin-p2tr"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-bitcoin-p2tr"]
+    },
+    {
+      "name": "bitcoin-p2wpkh",
       "network": "bitcoin",
       "asset": "btc",
       "acceptedPaymentEndpointIdentifiers": ["btc-bitcoin-p2wpkh"],
@@ -10,7 +18,31 @@
       "expectedIdentifiers": ["btc-bitcoin-p2wpkh"]
     },
     {
-      "name": "testnet-onchain",
+      "name": "bitcoin-p2sh",
+      "network": "bitcoin",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-bitcoin-p2sh"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-bitcoin-p2sh"]
+    },
+    {
+      "name": "bitcoin-p2pkh",
+      "network": "bitcoin",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-bitcoin-p2pkh"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-bitcoin-p2pkh"]
+    },
+    {
+      "name": "testnet-p2tr",
+      "network": "testnet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-testnet-p2tr"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-testnet-p2tr"]
+    },
+    {
+      "name": "testnet-p2wpkh",
       "network": "testnet",
       "asset": "btc",
       "acceptedPaymentEndpointIdentifiers": ["btc-testnet-p2wpkh"],
@@ -18,7 +50,31 @@
       "expectedIdentifiers": ["btc-testnet-p2wpkh"]
     },
     {
-      "name": "signet-onchain",
+      "name": "testnet-p2sh",
+      "network": "testnet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-testnet-p2sh"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-testnet-p2sh"]
+    },
+    {
+      "name": "testnet-p2pkh",
+      "network": "testnet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-testnet-p2pkh"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-testnet-p2pkh"]
+    },
+    {
+      "name": "signet-p2tr",
+      "network": "signet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-signet-p2tr"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-signet-p2tr"]
+    },
+    {
+      "name": "signet-p2wpkh",
       "network": "signet",
       "asset": "btc",
       "acceptedPaymentEndpointIdentifiers": ["btc-signet-p2wpkh"],
@@ -26,13 +82,53 @@
       "expectedIdentifiers": ["btc-signet-p2wpkh"]
     },
     {
-      "name": "regtest-onchain",
+      "name": "signet-p2sh",
+      "network": "signet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-signet-p2sh"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-signet-p2sh"]
+    },
+    {
+      "name": "signet-p2pkh",
+      "network": "signet",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-signet-p2pkh"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-signet-p2pkh"]
+    },
+    {
+      "name": "regtest-p2tr",
+      "network": "regtest",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-regtest-p2tr"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-regtest-p2tr"]
+    },
+    {
+      "name": "regtest-p2wpkh",
       "network": "regtest",
       "asset": "btc",
       "acceptedPaymentEndpointIdentifiers": ["btc-regtest-p2wpkh"],
       "accepted": true,
       "expectedIdentifiers": ["btc-regtest-p2wpkh"]
     },
+    {
+      "name": "regtest-p2sh",
+      "network": "regtest",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-regtest-p2sh"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-regtest-p2sh"]
+    },
+    {
+      "name": "regtest-p2pkh",
+      "network": "regtest",
+      "asset": "btc",
+      "acceptedPaymentEndpointIdentifiers": ["btc-regtest-p2pkh"],
+      "accepted": true,
+      "expectedIdentifiers": ["btc-regtest-p2pkh"]
+    },
     {
       "name": "bitcoin-bolt11",
       "network": "bitcoin",
diff --git a/docs/paykit-issuer-interoperability.md b/docs/paykit-issuer-interoperability.md
index 8fd6b887b4..0aca8c9532 100644
--- a/docs/paykit-issuer-interoperability.md
+++ b/docs/paykit-issuer-interoperability.md
@@ -77,7 +77,7 @@ The issuer and wallet must be linked Paykit peers on the same receiver path befo
 
 The fixture file is the cross-platform source of truth for Bitkit iOS and Android:
 
-- Request fixtures cover the network-correct P2WPKH identifier for Bitcoin, testnet, signet, and regtest.
+- Request fixtures cover every documented P2TR, P2WPKH, P2SH, and P2PKH identifier for Bitcoin, testnet, signet, and regtest.
 - Request fixtures cover both Lightning identifiers on every network.
 - Rejected request fixtures cover uppercase `BTC`, a foreign-network on-chain identifier on every network, an uppercase identifier, an unknown identifier, and an empty identifier list.
 - Endpoint fixtures accept JSON object payloads with a non-empty string `value`, including optional string bounds and surrounding whitespace.

From 299863190d7a39aabcee36d0b95674b0c6dbaf1e Mon Sep 17 00:00:00 2001
From: Ovi Trif <ovitrif@proton.me>
Date: Sat, 5 Sep 2026 01:39:46 +0200
Subject: [PATCH 4/4] test: cover paykit endpoint gaps

---
 .../paykit-issuer-interoperability.json        | 18 ++++++++++++++++++
 docs/paykit-issuer-interoperability.md         |  4 ++--
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/app/src/test/resources/paykit-issuer-interoperability.json b/app/src/test/resources/paykit-issuer-interoperability.json
index 0c54bb0d9c..489584bd9d 100644
--- a/app/src/test/resources/paykit-issuer-interoperability.json
+++ b/app/src/test/resources/paykit-issuer-interoperability.json
@@ -280,6 +280,12 @@
       "accepted": true,
       "expectedValue": "bcrt1qissuerfixture"
     },
+    {
+      "name": "foreign-network-endpoint",
+      "identifier": "btc-bitcoin-p2wpkh",
+      "payload": "{\"value\":\"bc1qissuerfixture\"}",
+      "accepted": false
+    },
     {
       "name": "bolt11-json-value-with-bounds",
       "identifier": "btc-lightning-bolt11",
@@ -289,6 +295,18 @@
       "expectedMin": "1000",
       "expectedMax": "2000"
     },
+    {
+      "name": "numeric-min",
+      "identifier": "btc-regtest-p2wpkh",
+      "payload": "{\"value\":\"bcrt1qissuerfixture\",\"min\":1000}",
+      "accepted": false
+    },
+    {
+      "name": "boolean-max",
+      "identifier": "btc-regtest-p2wpkh",
+      "payload": "{\"value\":\"bcrt1qissuerfixture\",\"max\":true}",
+      "accepted": false
+    },
     {
       "name": "lnurl-trims-value",
       "identifier": "btc-lightning-lnurl",
diff --git a/docs/paykit-issuer-interoperability.md b/docs/paykit-issuer-interoperability.md
index 0aca8c9532..f2ce0b0982 100644
--- a/docs/paykit-issuer-interoperability.md
+++ b/docs/paykit-issuer-interoperability.md
@@ -65,7 +65,7 @@ Optional `min` and `max` string fields are retained:
 {"value":"lnbc1issuerfixture","min":"1000","max":"2000"}
 ```
 
-Bitkit trims whitespace around the payload and `value`. It rejects a bare address or invoice string, invalid JSON, a non-object top level, a missing `value`, a non-string `value`, an empty value, a whitespace-only value, or an unknown identifier.
+Bitkit trims whitespace around the payload and `value`. It rejects a bare address or invoice string, invalid JSON, a non-object top level, a missing `value`, a non-string `value`, non-string `min` or `max` values, an empty value, a whitespace-only value, a wrong-network on-chain identifier, or an unknown identifier.
 
 After this shape check, Bitkit validates that the value is usable: an on-chain address matches the current network, a BOLT 11 invoice is unexpired and network-correct, and an LNURL value is an LNURL-pay request.
 
@@ -81,6 +81,6 @@ The fixture file is the cross-platform source of truth for Bitkit iOS and Androi
 - Request fixtures cover both Lightning identifiers on every network.
 - Rejected request fixtures cover uppercase `BTC`, a foreign-network on-chain identifier on every network, an uppercase identifier, an unknown identifier, and an empty identifier list.
 - Endpoint fixtures accept JSON object payloads with a non-empty string `value`, including optional string bounds and surrounding whitespace.
-- Rejected endpoint fixtures cover a raw string, empty payload, missing/empty/whitespace/numeric `value`, top-level array, malformed JSON, and unsupported identifier.
+- Rejected endpoint fixtures cover a raw string, empty payload, missing/empty/whitespace/numeric `value`, non-string bounds, a wrong-network on-chain identifier, top-level array, malformed JSON, and unsupported identifier.
 
 The iOS fixture suite in [PR #719](https://github.com/synonymdev/bitkit-ios/pull/719) consumes the same fixture names, inputs, and expected results. Any intentional platform difference requires changing this contract and both fixture suites together.