feat: add proposal storage with identity-scoped persistence

JOHN · JOHN · commit 8a2c53dcf52b · 2026-01-02T14:21:59.000-05:00
diff --git a/app/src/main/java/to/bitkit/paykit/storage/SubscriptionProposalStorage.kt b/app/src/main/java/to/bitkit/paykit/storage/SubscriptionProposalStorage.kt
@@ -0,0 +1,241 @@
+package to.bitkit.paykit.storage
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import to.bitkit.paykit.workers.DiscoveredSubscriptionProposal
+import to.bitkit.utils.Logger
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Manages persistent storage of subscription proposals.
+ *
+ * Proposals are persisted per-identity to avoid leaking data across identities.
+ * Seen IDs are tracked to prevent duplicate notifications.
+ *
+ * Accept/decline is local-only (no remote delete on provider storage).
+ */
+@Singleton
+class SubscriptionProposalStorage @Inject constructor(
+    private val keychain: PaykitKeychainStorage,
+) {
+    companion object {
+        private const val TAG = "SubscriptionProposalStorage"
+    }
+
+    private var proposalsCache: MutableMap<String, List<StoredProposal>>? = null
+    private var seenIdsCache: MutableMap<String, Set<String>>? = null
+    private var declinedIdsCache: MutableMap<String, Set<String>>? = null
+
+    private fun proposalsKey(identityPubkey: String) = "proposals.$identityPubkey"
+    private fun seenIdsKey(identityPubkey: String) = "proposals.seen.$identityPubkey"
+    private fun declinedIdsKey(identityPubkey: String) = "proposals.declined.$identityPubkey"
+
+    /**
+     * List all stored proposals for the given identity.
+     */
+    fun listProposals(identityPubkey: String): List<StoredProposal> {
+        if (proposalsCache?.containsKey(identityPubkey) == true) {
+            return proposalsCache!![identityPubkey]!!
+        }
+
+        return try {
+            val data = keychain.retrieve(proposalsKey(identityPubkey)) ?: return emptyList()
+            val json = String(data)
+            val proposals = Json.decodeFromString<List<StoredProposal>>(json)
+            if (proposalsCache == null) proposalsCache = mutableMapOf()
+            proposalsCache!![identityPubkey] = proposals
+            proposals
+        } catch (e: Exception) {
+            Logger.error("Failed to load proposals", e, context = TAG)
+            emptyList()
+        }
+    }
+
+    /**
+     * Get pending proposals (not accepted or declined).
+     */
+    fun pendingProposals(identityPubkey: String): List<StoredProposal> {
+        val declined = getDeclinedIds(identityPubkey)
+        return listProposals(identityPubkey).filter { it.status == ProposalStatus.PENDING && it.id !in declined }
+    }
+
+    /**
+     * Save a discovered proposal. Returns true if this is a new proposal.
+     */
+    suspend fun saveProposal(
+        identityPubkey: String,
+        proposal: DiscoveredSubscriptionProposal,
+    ): Boolean {
+        val proposals = listProposals(identityPubkey).toMutableList()
+        val existing = proposals.indexOfFirst { it.id == proposal.subscriptionId }
+
+        if (existing >= 0) {
+            return false
+        }
+
+        proposals.add(
+            StoredProposal(
+                id = proposal.subscriptionId,
+                providerPubkey = proposal.providerPubkey,
+                amountSats = proposal.amountSats,
+                description = proposal.description,
+                frequency = proposal.frequency,
+                createdAt = proposal.createdAt,
+                status = ProposalStatus.PENDING,
+            ),
+        )
+        persistProposals(identityPubkey, proposals)
+        return true
+    }
+
+    /**
+     * Mark a proposal as accepted.
+     */
+    suspend fun markAccepted(identityPubkey: String, proposalId: String) {
+        val proposals = listProposals(identityPubkey).toMutableList()
+        val index = proposals.indexOfFirst { it.id == proposalId }
+        if (index >= 0) {
+            proposals[index] = proposals[index].copy(status = ProposalStatus.ACCEPTED)
+            persistProposals(identityPubkey, proposals)
+        }
+    }
+
+    /**
+     * Mark a proposal as declined (local-only, hides from inbox).
+     */
+    suspend fun markDeclined(identityPubkey: String, proposalId: String) {
+        val declined = getDeclinedIds(identityPubkey).toMutableSet()
+        declined.add(proposalId)
+        persistDeclinedIds(identityPubkey, declined)
+
+        val proposals = listProposals(identityPubkey).toMutableList()
+        val index = proposals.indexOfFirst { it.id == proposalId }
+        if (index >= 0) {
+            proposals[index] = proposals[index].copy(status = ProposalStatus.DECLINED)
+            persistProposals(identityPubkey, proposals)
+        }
+    }
+
+    /**
+     * Check if a proposal has been seen (notified about).
+     */
+    fun hasSeen(identityPubkey: String, proposalId: String): Boolean {
+        return getSeenIds(identityPubkey).contains(proposalId)
+    }
+
+    /**
+     * Mark a proposal as seen (prevents duplicate notifications).
+     */
+    suspend fun markSeen(identityPubkey: String, proposalId: String) {
+        val seen = getSeenIds(identityPubkey).toMutableSet()
+        seen.add(proposalId)
+        persistSeenIds(identityPubkey, seen)
+    }
+
+    /**
+     * Clear all data for an identity.
+     */
+    suspend fun clearAll(identityPubkey: String) {
+        keychain.delete(proposalsKey(identityPubkey))
+        keychain.delete(seenIdsKey(identityPubkey))
+        keychain.delete(declinedIdsKey(identityPubkey))
+        proposalsCache?.remove(identityPubkey)
+        seenIdsCache?.remove(identityPubkey)
+        declinedIdsCache?.remove(identityPubkey)
+    }
+
+    private fun getSeenIds(identityPubkey: String): Set<String> {
+        if (seenIdsCache?.containsKey(identityPubkey) == true) {
+            return seenIdsCache!![identityPubkey]!!
+        }
+
+        return try {
+            val data = keychain.retrieve(seenIdsKey(identityPubkey)) ?: return emptySet()
+            val json = String(data)
+            val ids = Json.decodeFromString<Set<String>>(json)
+            if (seenIdsCache == null) seenIdsCache = mutableMapOf()
+            seenIdsCache!![identityPubkey] = ids
+            ids
+        } catch (e: Exception) {
+            Logger.error("Failed to load seen proposal IDs", e, context = TAG)
+            emptySet()
+        }
+    }
+
+    private fun getDeclinedIds(identityPubkey: String): Set<String> {
+        if (declinedIdsCache?.containsKey(identityPubkey) == true) {
+            return declinedIdsCache!![identityPubkey]!!
+        }
+
+        return try {
+            val data = keychain.retrieve(declinedIdsKey(identityPubkey)) ?: return emptySet()
+            val json = String(data)
+            val ids = Json.decodeFromString<Set<String>>(json)
+            if (declinedIdsCache == null) declinedIdsCache = mutableMapOf()
+            declinedIdsCache!![identityPubkey] = ids
+            ids
+        } catch (e: Exception) {
+            Logger.error("Failed to load declined proposal IDs", e, context = TAG)
+            emptySet()
+        }
+    }
+
+    private suspend fun persistProposals(identityPubkey: String, proposals: List<StoredProposal>) {
+        try {
+            val json = Json.encodeToString(proposals)
+            keychain.store(proposalsKey(identityPubkey), json.toByteArray())
+            if (proposalsCache == null) proposalsCache = mutableMapOf()
+            proposalsCache!![identityPubkey] = proposals
+        } catch (e: Exception) {
+            Logger.error("Failed to persist proposals", e, context = TAG)
+            throw PaykitStorageException.SaveFailed(proposalsKey(identityPubkey))
+        }
+    }
+
+    private suspend fun persistSeenIds(identityPubkey: String, ids: Set<String>) {
+        try {
+            val json = Json.encodeToString(ids)
+            keychain.store(seenIdsKey(identityPubkey), json.toByteArray())
+            if (seenIdsCache == null) seenIdsCache = mutableMapOf()
+            seenIdsCache!![identityPubkey] = ids
+        } catch (e: Exception) {
+            Logger.error("Failed to persist seen proposal IDs", e, context = TAG)
+        }
+    }
+
+    private suspend fun persistDeclinedIds(identityPubkey: String, ids: Set<String>) {
+        try {
+            val json = Json.encodeToString(ids)
+            keychain.store(declinedIdsKey(identityPubkey), json.toByteArray())
+            if (declinedIdsCache == null) declinedIdsCache = mutableMapOf()
+            declinedIdsCache!![identityPubkey] = ids
+        } catch (e: Exception) {
+            Logger.error("Failed to persist declined proposal IDs", e, context = TAG)
+        }
+    }
+}
+
+/**
+ * A stored subscription proposal with local status.
+ */
+@Serializable
+data class StoredProposal(
+    val id: String,
+    val providerPubkey: String,
+    val amountSats: Long,
+    val description: String?,
+    val frequency: String,
+    val createdAt: Long,
+    val status: ProposalStatus,
+)
+
+@Serializable
+enum class ProposalStatus {
+    PENDING,
+    ACCEPTED,
+    DECLINED,
+}
+
diff --git a/app/src/main/java/to/bitkit/paykit/viewmodels/SubscriptionsViewModel.kt b/app/src/main/java/to/bitkit/paykit/viewmodels/SubscriptionsViewModel.kt
@@ -14,6 +14,7 @@ import to.bitkit.paykit.models.Subscription
 import to.bitkit.paykit.models.SubscriptionProposal
 import to.bitkit.paykit.services.DirectoryService
 import to.bitkit.paykit.storage.AutoPayStorage
+import to.bitkit.paykit.storage.SubscriptionProposalStorage
 import to.bitkit.paykit.storage.SubscriptionStorage
 import to.bitkit.paykit.workers.DiscoveredSubscriptionProposal
 import dagger.hilt.android.lifecycle.HiltViewModel
@@ -26,6 +27,7 @@ import javax.inject.Inject
 @HiltViewModel
 class SubscriptionsViewModel @Inject constructor(
     private val subscriptionStorage: SubscriptionStorage,
+    private val proposalStorage: SubscriptionProposalStorage,
     private val directoryService: DirectoryService,
     private val autoPayStorage: AutoPayStorage,
     private val keyManager: KeyManager,
@@ -146,7 +148,17 @@ class SubscriptionsViewModel @Inject constructor(
                 return@launch
             }
             runCatching {
-                directoryService.discoverSubscriptionProposals(ownerPubkey)
+                // Load from persisted storage (polling worker handles discovery)
+                proposalStorage.pendingProposals(ownerPubkey).map { stored ->
+                    DiscoveredSubscriptionProposal(
+                        subscriptionId = stored.id,
+                        providerPubkey = stored.providerPubkey,
+                        amountSats = stored.amountSats,
+                        description = stored.description,
+                        frequency = stored.frequency,
+                        createdAt = stored.createdAt,
+                    )
+                }
             }.onSuccess { proposals ->
                 _uiState.update { it.copy(incomingProposals = proposals, isLoadingProposals = false) }
             }.onFailure { e ->
@@ -196,6 +208,12 @@ class SubscriptionsViewModel @Inject constructor(
         viewModelScope.launch {
             _uiState.update { it.copy(isAccepting = true, error = null) }
 
+            val ownerPubkey = keyManager.getCurrentPublicKeyZ32()
+            if (ownerPubkey == null) {
+                _uiState.update { it.copy(isAccepting = false, error = "No identity configured") }
+                return@launch
+            }
+
             val subscription = Subscription.create(
                 providerName = proposal.providerPubkey.take(8),
                 providerPubkey = proposal.providerPubkey,
@@ -207,6 +225,9 @@ class SubscriptionsViewModel @Inject constructor(
             runCatching {
                 subscriptionStorage.saveSubscription(subscription)
 
+                // Mark proposal as accepted in proposal storage
+                proposalStorage.markAccepted(ownerPubkey, proposal.subscriptionId)
+
                 if (enableAutopay) {
                     val rule = AutoPayRule(
                         id = subscription.id,
@@ -229,10 +250,6 @@ class SubscriptionsViewModel @Inject constructor(
                         autoPayStorage.savePeerLimit(limit)
                     }
                 }
-
-                // NOTE: In the v0 provider-storage model, proposals are stored on the provider's
-                // homeserver. Subscribers cannot delete proposals from provider storage.
-                // Mark as accepted locally; the proposal remains on provider storage (their cleanup).
             }.onSuccess {
                 loadSubscriptions()
                 loadIncomingProposals()
@@ -254,13 +271,9 @@ class SubscriptionsViewModel @Inject constructor(
                 return@launch
             }
 
-            // NOTE: In the v0 provider-storage model, proposals are stored on the provider's
-            // homeserver. Subscribers cannot delete proposals from provider storage.
-            // Mark as declined locally; the proposal remains on provider storage (their cleanup).
             runCatching {
-                // Local-only decline: remove from seen set to avoid re-showing
-                // (actual remote delete is not possible in provider-storage model)
-                Logger.debug("Declining proposal ${proposal.subscriptionId} (local-only)", context = TAG)
+                // Mark as declined in proposal storage (local-only; no remote delete)
+                proposalStorage.markDeclined(ownerPubkey, proposal.subscriptionId)
             }.onSuccess {
                 loadIncomingProposals()
                 _uiState.update { it.copy(isDeclining = false) }
diff --git a/app/src/main/java/to/bitkit/paykit/workers/PaykitPollingWorker.kt b/app/src/main/java/to/bitkit/paykit/workers/PaykitPollingWorker.kt
@@ -57,6 +57,8 @@ class PaykitPollingWorker @AssistedInject constructor(
     private val paykitManager: PaykitManager,
     private val paymentService: PaykitPaymentService,
     private val paymentRequestStorage: PaymentRequestStorage,
+    private val proposalStorage: to.bitkit.paykit.storage.SubscriptionProposalStorage,
+    private val keyManager: to.bitkit.paykit.KeyManager,
 ) : CoroutineWorker(appContext, workerParams) {
 
     companion object {
@@ -68,7 +70,7 @@ class PaykitPollingWorker @AssistedInject constructor(
         private const val NODE_READY_TIMEOUT_MS = 30_000L
         private const val MIN_BACKOFF_MILLIS = 10_000L
 
-        // Set of seen request IDs to avoid duplicate notifications
+        // Set of seen payment request IDs to avoid duplicate notifications (in-memory cache only)
         private val seenRequestIds = mutableSetOf<String>()
 
         fun schedule(context: Context) {
@@ -297,8 +299,35 @@ class PaykitPollingWorker @AssistedInject constructor(
     }
 
     private suspend fun processSubscriptionProposal(request: DiscoveredRequest) {
-        // Subscription proposals always need manual approval
-        sendSubscriptionProposalNotification(request)
+        val identityPubkey = keyManager.getCurrentPublicKeyZ32()
+        if (identityPubkey.isNullOrBlank()) {
+            Logger.warn("No identity pubkey, skipping proposal processing", context = TAG)
+            return
+        }
+
+        // Check if already seen (prevents duplicate notifications across restarts)
+        if (proposalStorage.hasSeen(identityPubkey, request.requestId)) {
+            Logger.debug("Proposal ${request.requestId} already seen, skipping notification", context = TAG)
+            return
+        }
+
+        // Persist the proposal and mark as seen
+        val proposal = DiscoveredSubscriptionProposal(
+            subscriptionId = request.requestId,
+            providerPubkey = request.fromPubkey,
+            amountSats = request.amountSats,
+            description = request.description,
+            frequency = "monthly", // Default if not specified
+            createdAt = request.createdAt,
+        )
+
+        val isNew = proposalStorage.saveProposal(identityPubkey, proposal)
+        proposalStorage.markSeen(identityPubkey, request.requestId)
+
+        // Only notify for new proposals
+        if (isNew) {
+            sendSubscriptionProposalNotification(request)
+        }
     }
 
     private suspend fun executePayment(request: DiscoveredRequest): kotlin.Result<Unit> = runCatching {
diff --git a/app/src/test/java/to/bitkit/paykit/viewmodels/SubscriptionsViewModelTest.kt b/app/src/test/java/to/bitkit/paykit/viewmodels/SubscriptionsViewModelTest.kt
