fix: expose rejected incoming payment requests

app/src/main/java/to/bitkit/repositories/PaykitPaymentRequestRepo.kt

@@ -8,6 +8,7 @@ import com.synonym.paykit.OutboundPrivateMessageStatus
 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 com.synonym.paykit.PrivateStreamCounterpartyIntakeReport
 import kotlinx.coroutines.CoroutineDispatcher
@@ -80,6 +81,25 @@ data class PaykitPaymentRequest(
     val billingPeriod: PaykitBillingPeriod? = null,
     val paymentProofKind: PaykitPaymentProofKind? = null,
 ) {
+    enum class ParseFailure(
+        val logValue: String,
+        val shouldLogIncomingRejection: Boolean = true,
+    ) {
+        MissingLocalRole("missing_local_role"),
+        OutgoingRequest("outgoing_request", shouldLogIncomingRejection = false),
+        UnsupportedLocalRole("unsupported_local_role"),
+        NonActionableState("non_actionable_state", shouldLogIncomingRejection = false),
+        MissingTerms("missing_terms"),
+        RecurringRequest("recurring_request", shouldLogIncomingRejection = false),
+        UnsupportedRecurrence("unsupported_recurrence"),
+        UnsupportedAsset("unsupported_asset"),
+        InvalidAmount("invalid_amount"),
+        AmountOutOfRange("amount_out_of_range"),
+        NoSupportedEndpoint("no_supported_endpoint"),
+        InvalidExpiration("invalid_expiration"),
+        Expired("expired", shouldLogIncomingRejection = false),
+    }
+
     val id: PaykitPaymentRequestId
         get() = PaykitPaymentRequestId(
             paymentRequestId,
@@ -109,6 +129,63 @@ data class PaykitPaymentRequest(
             counterpartyReceiverPath == subscription.counterpartyReceiverPath
 }
 
+internal sealed interface PaykitPaymentRequestParseResult {
+    data class Parsed(val request: PaykitPaymentRequest) : PaykitPaymentRequestParseResult
+    data class Rejected(val reason: PaykitPaymentRequest.ParseFailure) : PaykitPaymentRequestParseResult
+}
+
+@Singleton
+class PaykitPaymentRequestDiagnostics @Inject constructor() {
+    companion object {
+        private const val TAG = "PaykitPaymentRequestDiagnostics"
+    }
+
+    internal fun logParseRejection(
+        counterparty: String,
+        reason: PaykitPaymentRequest.ParseFailure,
+    ) {
+        Logger.warn(
+            "Rejected incoming Paykit payment request: category='parse' reason='${reason.logValue}' " +
+                "counterparty='${counterparty.redactedForPaymentRequestDiagnostics()}'",
+            context = TAG,
+        )
+    }
+
+    internal fun logPresentationRejection(
+        counterparty: String,
+        reason: IncomingPaykitPaymentRequestFailureReason,
+    ) {
+        Logger.warn(
+            "Rejected incoming Paykit payment request presentation: category='${reason.category}' " +
+                "reason='${reason.logValue}' " +
+                "counterparty='${counterparty.redactedForPaymentRequestDiagnostics()}'",
+            context = TAG,
+        )
+    }
+
+    internal fun logPresentationFailure(
+        counterparty: String,
+        error: Throwable,
+    ) {
+        Logger.warn(
+            "Failed to resolve incoming Paykit payment request: " +
+                "category='resolution' errorType='${error::class.simpleName ?: "Unknown"}' " +
+                "counterparty='${counterparty.redactedForPaymentRequestDiagnostics()}'",
+            context = TAG,
+        )
+    }
+}
+
+private fun String.redactedForPaymentRequestDiagnostics(): String =
+    PubkyPublicKeyFormat.normalized(this)?.let(PubkyPublicKeyFormat::redacted) ?: "<invalid>"
+
+private data class ParsedPaykitPaymentRequestTerms(
+    val terms: PaymentRequestTerms,
+    val amountSats: ULong,
+    val endpoints: List<String>,
+    val expiresAt: Instant?,
+)
+
 enum class PaykitPaymentRequestDeliveryStatus { Queued, Sent }
 
 enum class PaykitPaymentRequestDirection { Incoming, Outgoing }
@@ -153,6 +230,7 @@ class PaykitPaymentRequestRepo @Inject constructor(
     private val paykitSdkService: PaykitSdkService,
     private val settingsStore: SettingsStore,
     private val presentationStore: PaykitPaymentRequestPresentationStore,
+    private val diagnostics: PaykitPaymentRequestDiagnostics,
     private val paymentProofStore: PaykitPaymentProofStore,
     private val paymentProofRepo: PaykitPaymentProofRepo,
     private val subscriptionNotificationScheduler: PaykitSubscriptionNotificationScheduler,
@@ -538,6 +616,8 @@ class PaykitPaymentRequestRepo @Inject constructor(
     fun isPending(request: PaykitPaymentRequest): Boolean =
         !request.isExpired(clock.now()) && _pendingRequests.value.any { it.id == request.id }
 
+    fun isExpired(request: PaykitPaymentRequest): Boolean = request.isExpired(clock.now())
+
     fun isProcessing(request: PaykitPaymentRequest): Boolean = synchronized(processingLock) {
         request.id in processingRequestIds
     }
@@ -618,8 +698,16 @@ class PaykitPaymentRequestRepo @Inject constructor(
                 else -> null
             }
         }
-        val oneTimeIncoming = records.mapNotNull {
-            it.toPaykitPaymentRequest(PaymentRequestLocalRole.PAYER, now)
+        val oneTimeIncoming = records.mapNotNull { record ->
+            when (val result = record.parseIncomingPaykitPaymentRequest(now)) {
+                is PaykitPaymentRequestParseResult.Parsed -> result.request
+                is PaykitPaymentRequestParseResult.Rejected -> {
+                    if (result.reason.shouldLogIncomingRejection) {
+                        diagnostics.logParseRejection(record.counterparty, result.reason)
+                    }
+                    null
+                }
+            }
         }.filter { it.id !in locallyCompletedRequestIds && it.id !in locallyInFlightRequestIds }
         val incoming = (dueRequests + oneTimeIncoming).sortedBy { it.createdAt }
         val oneTimeHistory = records.mapNotNull { it.toPaykitPaymentRequestHistory(now) }.map { request ->
@@ -971,79 +1059,141 @@ private fun List<PaykitPaymentRequest>.withExpiredLifecycle(now: Instant): List<
 
 private val bitcoinAmountPattern = Regex("(?:[0-9]+(?:\\.[0-9]*)?|\\.[0-9]+)")
 
-@Suppress("CyclomaticComplexMethod", "ReturnCount", "LongMethod")
+internal fun PaymentRequestRecord.parseIncomingPaykitPaymentRequest(
+    now: Instant,
+): PaykitPaymentRequestParseResult = parsePaykitPaymentRequest(
+    expectedRole = PaymentRequestLocalRole.PAYER,
+    now = now,
+    requiresActionableRequest = true,
+)
+
 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
+): PaykitPaymentRequest? = when (
+    val result = parsePaykitPaymentRequest(expectedRole, now, requiresActionableRequest, network)
+) {
+    is PaykitPaymentRequestParseResult.Parsed -> result.request
+    is PaykitPaymentRequestParseResult.Rejected -> null
+}
+
+@Suppress("CyclomaticComplexMethod", "ReturnCount", "LongMethod")
+private fun PaymentRequestRecord.parsePaykitPaymentRequest(
+    expectedRole: PaymentRequestLocalRole,
+    now: Instant,
+    requiresActionableRequest: Boolean = true,
+    network: Network = Env.network,
+): PaykitPaymentRequestParseResult {
+    val role = localRole
+        ?: return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.MissingLocalRole)
+    if (role != expectedRole) {
+        return PaykitPaymentRequestParseResult.Rejected(
+            if (expectedRole == PaymentRequestLocalRole.PAYER && role == PaymentRequestLocalRole.PAYEE) {
+                PaykitPaymentRequest.ParseFailure.OutgoingRequest
+            } else {
+                PaykitPaymentRequest.ParseFailure.UnsupportedLocalRole
+            },
+        )
+    }
     if (
         requiresActionableRequest &&
         state != PaymentRequestLifecycleState.PROPOSED &&
         state != PaymentRequestLifecycleState.ACCEPTED
     ) {
-        return null
+        return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.NonActionableState)
+    }
+    if (state == PaymentRequestLifecycleState.ACTIVE_RECURRING) {
+        return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.RecurringRequest)
+    }
+    val requestTerms = terms
+        ?: return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.MissingTerms)
+    if (requestTerms.recurrence != null) {
+        return PaykitPaymentRequestParseResult.Rejected(
+            if (toPaykitSubscription() != null) {
+                PaykitPaymentRequest.ParseFailure.RecurringRequest
+            } else {
+                PaykitPaymentRequest.ParseFailure.UnsupportedRecurrence
+            },
+        )
+    }
+    if (requestTerms.amount.asset != PaykitIssuerInterop.BITCOIN_ASSET) {
+        return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.UnsupportedAsset)
     }
-    val requestTerms = terms ?: return null
-    if (requestTerms.recurrence != null || requestTerms.amount.asset != PaykitIssuerInterop.BITCOIN_ASSET) return null
     val amountSats = requestTerms.amount.value.toPaykitSats()
-        ?.takeIf { it <= ULong.MAX_VALUE / 1000uL }
-        ?: return null
+        ?: return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.InvalidAmount)
+    if (amountSats > ULong.MAX_VALUE / 1000uL) {
+        return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.AmountOutOfRange)
+    }
     val endpoints = PaykitIssuerInterop.supportedEndpointIdentifiers(
         requestTerms.acceptedPaymentEndpointIdentifiers,
         network,
     )
-    if (requiresActionableRequest && endpoints.isEmpty()) return null
+    if (requiresActionableRequest && endpoints.isEmpty()) {
+        return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.NoSupportedEndpoint)
+    }
 
     val expiresAt = requestTerms.proposalExpiresAt?.let {
-        runCatching { Instant.parse(it) }.getOrNull() ?: return null
+        runCatching { Instant.parse(it) }.getOrNull()
+            ?: return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.InvalidExpiration)
     }
     val isExpiredProposal = state == PaymentRequestLifecycleState.PROPOSED && expiresAt?.let { it <= now } == true
     if (requiresActionableRequest && isExpiredProposal) {
-        return null
+        return PaykitPaymentRequestParseResult.Rejected(PaykitPaymentRequest.ParseFailure.Expired)
     }
 
-    return PaykitPaymentRequest(
-        paymentRequestId = paymentRequestId,
-        counterparty = counterparty,
-        counterpartyReceiverPath = counterpartyReceiverPath,
-        amountValue = requestTerms.amount.value,
-        amountSats = amountSats,
-        note = requestTerms.metadata.note(),
-        createdAt = lastEventAt?.let { runCatching { Instant.parse(it) }.getOrNull() },
-        expiresAt = expiresAt,
-        acceptedPaymentEndpointIdentifiers = endpoints,
-        deliveryStatus = if (expectedRole == PaymentRequestLocalRole.PAYEE) {
-            if (proposalOutboundStatus == OutboundPrivateMessageStatus.SENT) {
-                PaykitPaymentRequestDeliveryStatus.Sent
-            } else {
-                PaykitPaymentRequestDeliveryStatus.Queued
-            }
-        } else {
-            null
-        },
-        direction = if (expectedRole == PaymentRequestLocalRole.PAYER) {
-            PaykitPaymentRequestDirection.Incoming
-        } else {
-            PaykitPaymentRequestDirection.Outgoing
-        },
-        lifecycleState = if (state == PaymentRequestLifecycleState.PROPOSED && expiresAt?.let { it <= now } == true) {
-            PaymentRequestLifecycleState.PROPOSAL_EXPIRED
-        } else {
-            state
-        },
-        paymentProofKind = paymentProofs.lastOrNull()?.let {
-            PaykitPaymentProofKind.fromPaymentEndpointIdentifier(it.paymentEndpointIdentifier)
-        },
-    )
+    val parsedTerms = ParsedPaykitPaymentRequestTerms(requestTerms, amountSats, endpoints, expiresAt)
+    return PaykitPaymentRequestParseResult.Parsed(toPaykitPaymentRequest(expectedRole, parsedTerms, now))
 }
 
+private fun PaymentRequestRecord.toPaykitPaymentRequest(
+    expectedRole: PaymentRequestLocalRole,
+    parsedTerms: ParsedPaykitPaymentRequestTerms,
+    now: Instant,
+) = PaykitPaymentRequest(
+    paymentRequestId = paymentRequestId,
+    counterparty = counterparty,
+    counterpartyReceiverPath = counterpartyReceiverPath,
+    amountValue = parsedTerms.terms.amount.value,
+    amountSats = parsedTerms.amountSats,
+    note = parsedTerms.terms.metadata.note(),
+    createdAt = lastEventAt?.let { runCatching { Instant.parse(it) }.getOrNull() },
+    expiresAt = parsedTerms.expiresAt,
+    acceptedPaymentEndpointIdentifiers = parsedTerms.endpoints,
+    deliveryStatus = if (expectedRole == PaymentRequestLocalRole.PAYEE) {
+        if (proposalOutboundStatus == OutboundPrivateMessageStatus.SENT) {
+            PaykitPaymentRequestDeliveryStatus.Sent
+        } else {
+            PaykitPaymentRequestDeliveryStatus.Queued
+        }
+    } else {
+        null
+    },
+    direction = if (expectedRole == PaymentRequestLocalRole.PAYER) {
+        PaykitPaymentRequestDirection.Incoming
+    } else {
+        PaykitPaymentRequestDirection.Outgoing
+    },
+    lifecycleState = if (
+        state == PaymentRequestLifecycleState.PROPOSED && parsedTerms.expiresAt?.let { it <= now } == true
+    ) {
+        PaymentRequestLifecycleState.PROPOSAL_EXPIRED
+    } else {
+        state
+    },
+    paymentProofKind = paymentProofs.lastOrNull()?.let {
+        PaykitPaymentProofKind.fromPaymentEndpointIdentifier(it.paymentEndpointIdentifier)
+    },
+)
+
 private fun PaymentRequestRecord.toPaykitPaymentRequestHistory(now: Instant): PaykitPaymentRequest? {
     val role = localRole ?: return null
     if (role == PaymentRequestLocalRole.UNKNOWN) return null
-    return toPaykitPaymentRequest(role, now, requiresActionableRequest = false)
+    return when (val result = parsePaykitPaymentRequest(role, now, requiresActionableRequest = false)) {
+        is PaykitPaymentRequestParseResult.Parsed -> result.request
+        is PaykitPaymentRequestParseResult.Rejected -> null
+    }
 }
 
 private fun PaymentRequestRecord.toCreatedPaykitPaymentRequest(

app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt

@@ -371,8 +371,6 @@ class PrivatePaykitRepo @Inject constructor(
                 val publicKey = normalizedPublicKey(request.counterparty) ?: throw PrivatePaykitError.InvalidPublicKey
                 beginContactPayment(publicKey, request).getOrThrow()
             }
-        }.onFailure {
-            Logger.warn("Failed to present incoming Paykit payment request", it, context = TAG)
         }
 
     suspend fun beginPaymentRequestWaitingForUpdatedList(

app/src/main/java/to/bitkit/repositories/PublicPaykitRepo.kt

@@ -52,6 +52,35 @@ sealed interface PublicPaykitPaymentResult {
     data object WaitingForUpdatedPaymentList : PublicPaykitPaymentResult
 }
 
+internal enum class IncomingPaykitPaymentRequestFailureReason(
+    val logValue: String,
+) {
+    NoSupportedEndpoint("no_supported_endpoint"),
+    EndpointNotPayable("endpoint_not_payable"),
+    PaymentDetailsPending("payment_details_pending"),
+    InvalidPaymentTarget("invalid_payment_target"),
+    PaymentTargetNotRoutable("payment_target_not_routable"),
+    RequestExpired("request_expired"),
+    ResolutionFailed("resolution_failed"),
+    ;
+
+    val category: String
+        get() = when (this) {
+            NoSupportedEndpoint, EndpointNotPayable, PaymentDetailsPending, ResolutionFailed -> "resolution"
+            InvalidPaymentTarget, PaymentTargetNotRoutable, RequestExpired -> "presentation"
+        }
+}
+
+internal val PublicPaykitPaymentResult.incomingPaymentRequestFailureReason:
+    IncomingPaykitPaymentRequestFailureReason?
+    get() = when (this) {
+        is PublicPaykitPaymentResult.Opened -> null
+        PublicPaykitPaymentResult.NoEndpoint -> IncomingPaykitPaymentRequestFailureReason.NoSupportedEndpoint
+        PublicPaykitPaymentResult.NotOpened -> IncomingPaykitPaymentRequestFailureReason.EndpointNotPayable
+        PublicPaykitPaymentResult.WaitingForUpdatedPaymentList ->
+            IncomingPaykitPaymentRequestFailureReason.PaymentDetailsPending
+    }
+
 data class PrivatePaykitPaymentContext(
     val receiverPath: String,
     val paymentListVersion: ULong,

app/src/main/java/to/bitkit/ui/screens/paymentrequests/PaymentRequestsScreen.kt

@@ -522,7 +522,7 @@ internal fun PaymentRequestCard(
                 }
             )
             .clickableAlpha(enabled = onClick != null) { onClick?.invoke() }
-            .testTag("PaymentRequestRow-${request.paymentRequestId}"),
+            .testTag("PaymentRequestRow-${request.paymentRequestId}")
     ) {
         Row(
             verticalAlignment = Alignment.CenterVertically,