chore(flipcash/pools): handle distributions based on raw quarks

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

Author: bmc08gt

apps/flipcash/features/pools/src/main/kotlin/com/flipcash/app/pools/internal/betting/PoolBettingViewModel.kt

@@ -446,20 +446,20 @@ internal class PoolBettingViewModel @Inject constructor(
             .mapNotNull { resolution ->
                 val rendezvous = stateFlow.value.rendezvous
                 if (rendezvous == null) return@mapNotNull null
-
+                val pool = stateFlow.value.metadata
                 PaymentRequest.ResolvePool(
-                    pool = stateFlow.value.metadata,
+                    pool = pool,
                     bets = stateFlow.value.bets,
                     rendezvous = rendezvous,
                     resolution = resolution,
                 ) {
                     poolsCoordinator.closePool(
-                        pool = stateFlow.value.metadata,
+                        pool = pool,
                         rendezvous = rendezvous,
                     ).fold(
                         onSuccess = {
                             poolsCoordinator.resolvePool(
-                                poolId = stateFlow.value.metadata.id,
+                                pool = pool,
                                 rendezvous = rendezvous,
                                 resolution = resolution,
                             )

apps/flipcash/features/pools/src/main/kotlin/com/flipcash/app/pools/internal/list/components/PoolSummaryRow.kt

@@ -6,13 +6,16 @@ import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.Icon
 import androidx.compose.material.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
@@ -22,7 +25,13 @@ import com.flipcash.app.core.pools.PoolResolution
 import com.flipcash.app.core.pools.PoolUserSummary
 import com.flipcash.app.theme.FlipcashDesignSystem
 import com.flipcash.features.pools.R
+import com.getcode.opencode.compose.ExchangeStub
+import com.getcode.opencode.compose.LocalExchange
+import com.getcode.opencode.model.financial.CurrencyCode
 import com.getcode.opencode.model.financial.Fiat
+import com.getcode.opencode.model.financial.Rate
+import com.getcode.opencode.model.financial.div
+import com.getcode.opencode.model.financial.times
 import com.getcode.opencode.model.financial.toFiat
 import com.getcode.solana.keys.PublicKey
 import com.getcode.theme.CodeTheme

apps/flipcash/shared/payments/src/main/kotlin/com/flipcash/app/payments/internal/InternalPoolBidDelegate.kt

@@ -36,8 +36,10 @@ internal class InternalPoolBidDelegate @Inject constructor(
             return
         }
 
+        exchange.fetchRatesIfNeeded(force = true)
+
         val localizedAmount = LocalFiat(
-            usdc = amount.convertingTo(exchange.rateForUsd()),
+            usdc = amount.convertingTo(exchange.rateToUsd(amount.currencyCode)!!),
             converted = amount,
         )
 

apps/flipcash/shared/payments/src/main/kotlin/com/flipcash/app/payments/internal/InternalPoolResolveDelegate.kt

@@ -13,6 +13,7 @@ import com.flipcash.services.models.NetworkPoolResolution
 import com.flipcash.services.user.UserManager
 import com.getcode.ed25519.Ed25519
 import com.getcode.opencode.controllers.TransactionController
+import com.getcode.opencode.exchange.Exchange
 import com.getcode.opencode.model.core.ID
 import com.getcode.opencode.model.core.RandomId
 import com.getcode.opencode.model.financial.Distribution
@@ -23,6 +24,7 @@ import javax.inject.Inject
 class InternalPoolResolveDelegate @Inject constructor(
     private val transactionController: TransactionController,
     private val userManager: UserManager,
+    private val exchange: Exchange,
 ) : PoolResolveDelegate {
     override suspend fun resolvePool(
         pool: Pool,
@@ -46,14 +48,20 @@ class InternalPoolResolveDelegate @Inject constructor(
             bets = bets,
         )
 
-        val distributions = poolWithBets.buildDistributionList(resolution)
+        exchange.fetchRatesIfNeeded()
+        val distributions = runCatching { poolWithBets.buildDistributionList(resolution) }
+
+        distributions.exceptionOrNull()?.let {
+            onError(it)
+            return
+        }
 
         val poolAccount = userManager.poolAccountAt(pool.derivationIndex)
 
         transactionController.distributeFunds(
             owner = owner,
             from = poolAccount.cluster,
-            distributions = distributions
+            distributions = distributions.getOrNull().orEmpty()
         ).map {
             it.id.bytes
         }.onSuccess {
@@ -65,23 +73,42 @@ class InternalPoolResolveDelegate @Inject constructor(
 
     private fun PoolWithBets.buildDistributionList(resolution: PoolResolution.DecisionMade): List<Distribution> {
         val paidBets = bets.filter { it.hasPaidForBet }
-
         // 1. if the decision was to refund, then all paid bets are returned
         if (resolution is PoolResolution.Refund) {
+            val rate = exchange.rateToUsd(pool.buyIn.currencyCode)
+                ?: throw IllegalArgumentException("No rate found for ${pool.buyIn.currencyCode}")
+            val usdc = pool.buyIn.convertingTo(rate)
             return paidBets.map {
                 Distribution(
                     destination = it.payoutDestination,
-                    amount = pool.buyIn,
+                    amount = usdc,
                 )
             }
         }
 
         val matchingBets = paidBets.filter { it.selectedOutcome.matchesResolution(resolution) }
+        val rate = exchange.rateToUsd(pool.totalPoolAmount.currencyCode)
+            ?: throw IllegalArgumentException("No rate found for ${pool.totalPoolAmount.currencyCode}")
+
+        val totalPoolInUsdc = pool.totalPoolAmount.convertingTo(rate)
+        val winnerCount = matchingBets.count()
+
+        // Calculate base amount per winner and remainder
+        val baseAmountPerWinner = totalPoolInUsdc.quarks / winnerCount
+        val remainderQuarks = totalPoolInUsdc.quarks % winnerCount
+
         // 2. otherwise, pay out all winning (matching bets)
-        return matchingBets.map {
+        // unequal remainder is added to the 'remainderQuarks' winners
+        return matchingBets.mapIndexed { index, bet ->
+            val amount = if (index < remainderQuarks) {
+                // Add 1 extra quark to the first 'remainderQuarks' winners
+                baseAmountPerWinner + 1
+            } else {
+                baseAmountPerWinner
+            }
             Distribution(
-                destination = it.payoutDestination,
-                amount = winningAmountForResolution(resolution)
+                destination = bet.payoutDestination,
+                amount = Fiat(amount)
             )
         }
     }

apps/flipcash/shared/pools/src/main/kotlin/com/flipcash/app/pools/PoolsCoordinator.kt

@@ -159,35 +159,32 @@ class PoolsCoordinator @Inject constructor(
         pool: Pool,
         rendezvous: KeyPair,
     ): Result<Instant> {
-        val metadata = domainToNetworkMapper.map(pool)
-        return controller.closePool(metadata, rendezvous)
-            .onSuccess { closedAt ->
+        // ensure we are working with an up-to-date instance of a pool
+        return controller.getPool(pool.id)
+            .fold(
+                onSuccess = {
+                    controller.closePool(it.metadata, rendezvous)
+                },
+                onFailure = {
+                    Result.failure(it)
+                }
+            ).onSuccess { closedAt ->
                 dataSource.closePool(pool.id, closedAt)
             }
     }
 
     suspend fun resolvePool(
-        poolId: ID,
+        pool: Pool,
         resolution: PoolResolution.DecisionMade,
         rendezvous: KeyPair
     ): Result<Unit> {
-        return controller.getPool(poolId)
-            .fold(
-                onSuccess = {
-                    controller.resolvePool(
-                        pool = it.metadata,
-                        rendezvous = rendezvous,
-                        resolution = PoolResolutionConverter.toPoolResolution(resolution as PoolResolution),
-                    )
-                },
-                onFailure = { Result.failure(it) }
-            ).fold(
-                onSuccess = {
-                    dataSource.resolvePool(poolId, resolution)
-                    Result.success(Unit)
-                },
-                onFailure = { Result.failure(it) }
-            )
+        return controller.resolvePool(
+            pool = domainToNetworkMapper.map(pool),
+            rendezvous = rendezvous,
+            resolution = PoolResolutionConverter.toPoolResolution(resolution as PoolResolution),
+        ).onSuccess {
+            dataSource.resolvePool(pool.id, resolution)
+        }
     }
 
     suspend fun placeBet(

services/opencode-compose/src/main/kotlin/com/getcode/opencode/compose/Exchange.kt

@@ -65,7 +65,7 @@ private class ExchangeNull(override val staleThreshold: Duration = 1.days) : Exc
         return null
     }
 
-    override suspend fun fetchRatesIfNeeded() = Unit
+    override suspend fun fetchRatesIfNeeded(force: Boolean) = Unit
 
     override fun rateFor(currencyCode: CurrencyCode): Rate? {
         return null

services/opencode-compose/src/main/kotlin/com/getcode/opencode/compose/ExchangeStub.kt

@@ -76,7 +76,7 @@ class ExchangeStub(
         ).let { if (it == 0) null else it }
     }
 
-    override suspend fun fetchRatesIfNeeded() = Unit
+    override suspend fun fetchRatesIfNeeded(force: Boolean) = Unit
 
     override fun rateFor(currencyCode: CurrencyCode): Rate? {
         return providedRates[currencyCode]

services/opencode/src/main/kotlin/com/getcode/opencode/exchange/Exchange.kt

@@ -25,7 +25,7 @@ interface Exchange {
     fun getFlagByCurrency(currencyCode: String?): Int?
     fun getFlag(countryCode: String): Int?
 
-    suspend fun fetchRatesIfNeeded()
+    suspend fun fetchRatesIfNeeded(force: Boolean = false)
 
     fun rateFor(currencyCode: CurrencyCode): Rate?
 

services/opencode/src/main/kotlin/com/getcode/opencode/internal/exchange/OpenCodeExchange.kt

@@ -132,8 +132,8 @@ internal class OpenCodeExchange @Inject constructor(
         }
     }
 
-    override suspend fun fetchRatesIfNeeded() {
-        if (isStale) {
+    override suspend fun fetchRatesIfNeeded(force: Boolean) {
+        if (isStale || force) {
             retryable(
                 call = {
                     val now = Clock.System.now()

services/opencode/src/main/kotlin/com/getcode/opencode/model/financial/Distribution.kt

@@ -6,7 +6,7 @@ import com.getcode.solana.keys.PublicKey
  * Represents a distribution of a specific fiat amount to a destination public key.
  *
  * @property destination The public key of the recipient of the distribution. This must ALWAYS be a primary account.
- * @property amount The amount of funds to distribute to the destination
+ * @property amount The amount of funds (in quarks) to distribute to the destination
  */
 data class Distribution(
     val destination: PublicKey,