chore: remove deprecated paykit service methods

Author: JOHN

app/src/main/java/to/bitkit/paykit/PaykitManager.kt

@@ -69,6 +69,15 @@ class PaykitManager @Inject constructor(
     var ownerPubkey: String? = null
         private set
 
+    /**
+     * Update owner pubkey after a successful session setup.
+     * Called by ViewModels after completing Paykit Connect flow.
+     */
+    fun setOwnerPubkey(pubkey: String) {
+        ownerPubkey = pubkey
+        Logger.info("Owner pubkey updated: ${pubkey.take(12)}...", context = TAG)
+    }
+
     /**
      * Payment service instance for executing payments.
      */
@@ -108,7 +117,8 @@ class PaykitManager @Inject constructor(
         // Configure DirectoryService with first available session for authenticated writes
         pubkyRingBridge.getCachedSessions().firstOrNull()?.let { session ->
             directoryService.configureWithPubkySession(session)
-            Logger.info("DirectoryService configured with restored session", context = TAG)
+            ownerPubkey = session.pubkey
+            Logger.info("DirectoryService configured with restored session for ${session.pubkey.take(12)}...", context = TAG)
         }
 
         // Schedule background workers for session refresh and polling
@@ -174,6 +184,8 @@ class PaykitManager @Inject constructor(
             val session = pubkyRingBridge.requestSession(context)
             // Configure DirectoryService for authenticated writes to homeserver
             directoryService.configureWithPubkySession(session)
+            ownerPubkey = session.pubkey
+            Logger.info("Session obtained and ownerPubkey set: ${session.pubkey.take(12)}...", context = TAG)
             return session
         }
         throw PaykitException.PubkyRingNotInstalled

app/src/main/java/to/bitkit/paykit/services/DirectoryService.kt

@@ -495,41 +495,6 @@ removeNoiseEndpoint(transport)
         }
     }
 
-    /**
-     * Discover pending payment requests from the directory.
-     *
-     * DEPRECATED: This method lists our own storage which is the wrong model.
-     * Use [discoverPendingRequestsFromPeer] to poll each known contact's storage.
-     *
-     * For backwards compatibility, this method will still work if requests are
-     * addressed to our raw pubkey (legacy format).
-     */
-    @Deprecated("Use discoverPendingRequestsFromPeer to poll known contacts")
-    suspend fun discoverPendingRequests(ownerPubkey: String): List<to.bitkit.paykit.workers.DiscoveredRequest> {
-        val adapter = pubkyStorage.createUnauthenticatedAdapter(homeserverURL)
-        val scope = PaykitV0Protocol.recipientScope(ownerPubkey)
-        val requestsPath = "${PaykitV0Protocol.PAYKIT_V0_PREFIX}/${PaykitV0Protocol.REQUESTS_SUBPATH}/$scope/"
-
-        return try {
-            val requestFiles = pubkyStorage.listDirectory(requestsPath, adapter, ownerPubkey)
-
-            requestFiles.mapNotNull { requestId ->
-                try {
-                    val requestPath = "$requestsPath$requestId"
-                    val envelopeBytes = pubkyStorage.retrieve(requestPath, adapter, ownerPubkey)
-                    val envelopeJson = envelopeBytes?.let { String(it) }
-                    decryptAndParsePaymentRequest(requestId, envelopeJson, ownerPubkey)
-                } catch (e: Exception) {
-                    Logger.error("Failed to parse request $requestId", e, context = TAG)
-                    null
-                }
-            }
-        } catch (e: Exception) {
-            Logger.error("Failed to discover pending requests for $ownerPubkey", e, context = TAG)
-            emptyList()
-        }
-    }
-
     /**
      * Discover subscription proposals from a peer's storage.
      *
@@ -569,42 +534,6 @@ removeNoiseEndpoint(transport)
         }
     }
 
-    /**
-     * Discover subscription proposals from the directory.
-     *
-     * DEPRECATED: This method uses the wrong storage model.
-     * Use [discoverSubscriptionProposalsFromPeer] to poll each known provider's storage.
-     */
-    @Deprecated("Use discoverSubscriptionProposalsFromPeer to poll known providers")
-    suspend fun discoverSubscriptionProposals(
-        ownerPubkey: String,
-    ): List<to.bitkit.paykit.workers.DiscoveredSubscriptionProposal> {
-        val adapter = pubkyStorage.createUnauthenticatedAdapter(homeserverURL)
-        val scope = PaykitV0Protocol.subscriberScope(ownerPubkey)
-        val proposalsPath =
-            "${PaykitV0Protocol.PAYKIT_V0_PREFIX}/${PaykitV0Protocol.SUBSCRIPTION_PROPOSALS_SUBPATH}/$scope/"
-
-        return try {
-            val proposalFiles = pubkyStorage.listDirectory(proposalsPath, adapter, ownerPubkey)
-
-            proposalFiles.mapNotNull { proposalId ->
-                try {
-                    val proposalPath = "$proposalsPath$proposalId"
-                    val envelopeBytes = pubkyStorage.retrieve(proposalPath, adapter, ownerPubkey)
-                    val envelopeJson = envelopeBytes?.let { String(it) }
-                    // NOTE: This deprecated method cannot verify provider binding since we don't know who we're polling
-                    decryptAndParseSubscriptionProposal(proposalId, envelopeJson, ownerPubkey, expectedProviderPubkey = null)
-                } catch (e: Exception) {
-                    Logger.error("Failed to parse proposal $proposalId", e, context = TAG)
-                    null
-                }
-            }
-        } catch (e: Exception) {
-            Logger.error("Failed to discover subscription proposals for $ownerPubkey", e, context = TAG)
-            emptyList()
-        }
-    }
-
     /**
      * Publish a subscription proposal to our storage for the subscriber to discover.
      * The proposal is stored ENCRYPTED at the canonical v0 path:

app/src/main/java/to/bitkit/paykit/services/NoisePaymentService.kt

@@ -404,10 +404,12 @@ class NoisePaymentService @Inject constructor(
      * an incoming Noise connection.
      * 
      * @param port Port to listen on
+     * @param externalHost Optional external host address for publishing endpoint (for relay/NAT traversal)
      * @param onRequest Callback invoked when a payment request is received
      */
     suspend fun startBackgroundServer(
         port: Int,
+        externalHost: String? = null,
         onRequest: (NoisePaymentRequest) -> Unit
     ) = withContext(Dispatchers.IO) {
         if (isServerRunning) {
@@ -424,6 +426,11 @@ class NoisePaymentService @Inject constructor(
 
             Logger.info("Noise server started on port $port", context = TAG)
 
+            // Update Noise endpoint on homeserver with actual host/port
+            // This allows other clients to discover how to connect for real-time Noise payments
+            // Note: For mobile, externalHost should be provided by a relay/NAT traversal service
+            updateNoiseEndpointOnServer(port, externalHost)
+
             // Accept a single connection (push-wake mode)
             val clientSocket = serverSocket?.accept()
             if (clientSocket != null) {
@@ -440,6 +447,46 @@ class NoisePaymentService @Inject constructor(
         }
     }
 
+    /**
+     * Update Noise endpoint on homeserver with current server address.
+     * Best-effort: failures are logged but don't stop the server.
+     */
+    private suspend fun updateNoiseEndpointOnServer(port: Int, externalHost: String?) {
+        try {
+            val keypair = keyManager.getCachedNoiseKeypair() ?: run {
+                Logger.warn("Cannot update Noise endpoint: no keypair cached", context = TAG)
+                return
+            }
+
+            // Use provided host, or fall back to local IP for testing
+            val host = externalHost ?: getLocalIpAddress() ?: "localhost"
+
+            directoryService.publishNoiseEndpoint(
+                host = host,
+                port = port,
+                noisePubkey = keypair.publicKeyHex,
+                metadata = null,
+            )
+            Logger.info("Updated Noise endpoint to $host:$port", context = TAG)
+        } catch (e: Exception) {
+            // Log but don't fail - server is already running
+            Logger.warn("Failed to update Noise endpoint: ${e.message}", context = TAG)
+        }
+    }
+
+    /**
+     * Get local IP address for testing purposes.
+     * In production, use a relay service for NAT traversal.
+     */
+    private fun getLocalIpAddress(): String? = try {
+        java.net.NetworkInterface.getNetworkInterfaces()?.asSequence()
+            ?.flatMap { it.inetAddresses.asSequence() }
+            ?.firstOrNull { !it.isLoopbackAddress && it is java.net.Inet4Address }
+            ?.hostAddress
+    } catch (e: Exception) {
+        null
+    }
+
     /**
      * Stop the background server
      */