fix(ocp): add more resilience around verified state fetching during gives

don't blindly accept the result from proto manager, we now audit it including reserve state when needed and calling for it ourselves.
This is specifically useful when claiming cash links for new (to user) tokens and we aren't yet streaming the mint data for this token yet.

Signed-off-by: Brandon McAnsh <git@bmcreations.dev>

Author: bmc08gt

services/opencode/src/main/kotlin/com/getcode/opencode/controllers/CurrencyController.kt

@@ -15,17 +15,25 @@ import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.emptyFlow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.scan
 import kotlinx.coroutines.flow.shareIn
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.suspendCancellableCoroutine
 import javax.inject.Inject
 import javax.inject.Singleton
-import kotlin.coroutines.resume
 
+/**
+ * Provides access to live and historical mint/currency data backed by
+ * server-streamed updates and one-shot RPCs.
+ */
 @Singleton
 class CurrencyController @Inject constructor(
     private val repository: CurrencyRepository,
 ) {
+    /**
+     * Returns a long-lived [Flow] of [LiveMintDataResponse] events for the
+     * given [mints]. The flow re-subscribes whenever the mint list changes
+     * and replays the most recent emission to late collectors.
+     */
     fun streamLiveMintData(
         scope: CoroutineScope,
         mints: Flow<List<Mint>>,
@@ -53,25 +61,48 @@ class CurrencyController @Inject constructor(
         }
     }
 
+    /**
+     * Opens a short-lived mint data stream and suspends until all required data
+     * has been received and persisted to the proto store.
+     *
+     * For most mints this waits for both exchange rates and launchpad reserve
+     * state. USDF only requires exchange rates (no reserve state exists).
+     */
     suspend fun getLiveMintData(
         scope: CoroutineScope,
         mint: Mint,
         tag: String? = null
-    ): Result<LiveMintDataResponse> = runCatching {
+    ): Result<Unit> = runCatching {
+        val needsReserveState = mint != Mint.usdf
+
         callbackFlow {
             val reference = repository.streamMintData(scope = scope, mints = listOf(mint), tag = tag) {
                 trySend(it)
             }
             awaitClose { reference.cancel() }
-        }.first()
+        }.scan(emptySet<Class<out LiveMintDataResponse>>()) { seen, response ->
+            seen + response::class.java
+        }.first { seen ->
+            seen.contains(LiveMintDataResponse.ExchangeRates::class.java) &&
+                    (!needsReserveState || seen.contains(LiveMintDataResponse.LaunchpadReserveState::class.java))
+        }
     }
 
+
+    /**
+     * Fetches static metadata (name, symbol, decimals, etc.) for the given
+     * mint [addresses] in a single RPC call.
+     */
     suspend fun getMintMetadata(
         addresses: List<Mint>
     ): Result<List<MintMetadata>> {
         return repository.getMintMetadata(addresses)
     }
 
+    /**
+     * Fetches historical price/exchange data for [mint] denominated in
+     * [currencyCode] over the specified [windowedRange].
+     */
     suspend fun getHistoricalMintData(
         mint: Mint,
         currencyCode: CurrencyCode,

services/opencode/src/main/kotlin/com/getcode/opencode/internal/network/services/CurrencyService.kt

@@ -11,18 +11,14 @@ import com.getcode.opencode.internal.network.api.CurrencyApi
 import com.getcode.opencode.internal.network.extensions.foldWithSuppression
 import com.getcode.opencode.internal.network.streamers.LiveMintDataStreamer
 import com.getcode.opencode.internal.network.streamers.ManagedMintStream
-import com.getcode.opencode.internal.network.streamers.OcpMintStreamingReference
 import com.getcode.opencode.model.core.errors.GetHistoricalMintDataError
 import com.getcode.opencode.model.core.errors.GetMintsError
-import com.getcode.opencode.model.core.errors.GetRatesError
 import com.getcode.opencode.model.financial.CurrencyCode
 import com.getcode.opencode.model.financial.HistoricalMintData
 import com.getcode.opencode.model.financial.MintMetadata
-import com.getcode.opencode.model.financial.Rate
 import com.getcode.solana.keys.Mint
 import com.getcode.solana.keys.PublicKey
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.datetime.Instant
 import javax.inject.Inject
 
 internal class CurrencyService @Inject constructor(

services/opencode/src/main/kotlin/com/getcode/opencode/internal/transactors/GiveBillTransactor.kt

@@ -16,6 +16,7 @@ import com.getcode.opencode.model.financial.LocalFiat
 import com.getcode.opencode.model.financial.Token
 import com.getcode.opencode.model.transactions.TransactionMetadata
 import com.getcode.opencode.utils.nonce
+import com.getcode.solana.keys.Mint
 import com.getcode.solana.keys.PublicKey
 import com.getcode.utils.CodeServerError
 import com.getcode.utils.TraceType
@@ -106,15 +107,7 @@ internal class GiveBillTransactor(
         val sendingAmount = amount
             ?: return logAndFail(GiveTransactorError.Other(message = "No amount. Did you call with() first?"))
 
-        // Resolve the verified state for the given currency/token pair using a fallback chain:
-        // 1. Use the provided state directly if available
-        // 2. Otherwise, check the local proto store
-        // 3. If still missing, fetch live mint data (which internally persists to the store) and re-query
-        val verifiedState = providedVerifiedState
-            ?: verifiedProtoManager.getVerifiedStateFor(sendingAmount.rate.currency, desiredToken.address)
-            ?: currencyController.getLiveMintData(scope, desiredToken.address)
-                .map { verifiedProtoManager.getVerifiedStateFor(sendingAmount.rate.currency, desiredToken.address) }
-                .getOrNull()
+        val verifiedState = resolveVerifiedState(sendingAmount, desiredToken)
             ?: return logAndFail(GiveTransactorError.Other("Failed to get verified state"))
 
         val exchangeData = verifiedState.exchangeDataFor(
@@ -173,15 +166,8 @@ internal class GiveBillTransactor(
 
         receivingAccount = transferRequest.account
 
-        /**
-         * At transfer time:
-         * 1. If providedVerifiedState exists → use it (caller knows best)
-         * 2. Otherwise → try fresh from proto store
-         * 3. Otherwise → fall back to the upfront-resolved state
-         */
-        val transferVerifiedState = providedVerifiedState
-            ?: verifiedProtoManager.getVerifiedStateFor(sendingAmount.rate.currency, desiredToken.address)
-            ?: verifiedState
+        val transferVerifiedState = resolveVerifiedState(sendingAmount, desiredToken)
+            ?: return logAndFail(GiveTransactorError.Other("Failed to get verified state"))
 
         val transferExchangeData = transferVerifiedState.exchangeDataFor(
             amount = sendingAmount,
@@ -223,6 +209,54 @@ internal class GiveBillTransactor(
         scope.cancel()
     }
 
+    /**
+     * Resolve the verified state for the given currency/token pair using a fallback chain:
+     * 1. Use the provided state directly if available
+     * 2. Otherwise, check the local proto store
+     * 3. If still missing, fetch live mint data (which internally persists to the store) and re-query
+     */
+    private suspend fun resolveVerifiedState(
+        sendingAmount: LocalFiat,
+        desiredToken: Token
+    ): VerifiedState? {
+        val currency = sendingAmount.rate.currency
+        val mint = desiredToken.address
+        val label = "${currency}/${desiredToken.symbol}"
+        val needsReserveState = mint != Mint.usdf
+
+        providedVerifiedState?.let {
+            trace(tag = tag, message = "Using provided verified state for $label")
+            return it
+        }
+
+        verifiedProtoManager.getVerifiedStateFor(currency, mint)?.let {
+            if (!needsReserveState || it.reserveProto != null) {
+                trace(tag = tag, message = "Resolved verified state from proto store for $label")
+                return it
+            }
+
+            trace(tag = tag, message = "Proto store hit but missing reserve state for $label — fetching live mint data")
+        }
+
+        trace(tag = tag, message = "Proto store miss — fetching live mint data for ${desiredToken.symbol}")
+
+        return currencyController.getLiveMintData(scope, mint)
+            .onFailure { cause ->
+                trace(
+                    tag = tag,
+                    message = "Live mint data fetch failed for ${desiredToken.symbol}",
+                    type = TraceType.Error,
+                    error = cause
+                )
+            }
+            .map { verifiedProtoManager.getVerifiedStateFor(currency, mint) }
+            .getOrNull()
+            ?.also {
+                trace(tag = tag, message = "Resolved verified state after live mint fetch for $label")
+            }
+    }
+
+
     sealed class GiveTransactorError(
         override val message: String? = null,
         override val cause: Throwable? = null