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

Signed-off-by: Brandon McAnsh <[email protected]>

Author: bmc08gt

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

@@ -249,6 +249,9 @@ internal class PoolBettingViewModel @Inject constructor(
             .onResult(
                 onSuccess = { isDistributed ->
                     dispatchEvent(Event.OnFundsDistributed(isDistributed))
+                },
+                onError = {
+                    dispatchEvent(Event.OnFundsDistributed(true))
                 }
             ).launchIn(viewModelScope)
 
@@ -446,20 +449,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,
                             )
@@ -493,7 +496,9 @@ internal class PoolBettingViewModel @Inject constructor(
 
                     }
                     is PaymentEvent.OnPaymentSuccess -> {
-                        event.acknowledge(true) {}
+                        event.acknowledge(true) {
+                            dispatchEvent(Event.OnFundsDistributed(true))
+                        }
                     }
                 }
             }

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/InternalPaymentController.kt

@@ -214,6 +214,7 @@ internal class InternalPaymentController(
                 when (error) {
                     is PaymentError.InsufficientBalance -> presentInsufficientFundsError()
                     is PaymentError.NoOwnerForDistribution -> presentPaymentFailedError()
+                    is PaymentError.NoPoolBalance -> presentPaymentFailedError()
                 }
             }
 
@@ -253,4 +254,5 @@ sealed interface PaymentError {
     data class InsufficientBalance(override val message: String? = "Insufficient balance for payment") :
         PaymentError, Throwable(message)
     data class NoOwnerForDistribution(override val message: String? = "No owner for distribution") : PaymentError, Throwable(message)
+    data class NoPoolBalance(override val message: String? = "No pool balance") : PaymentError, Throwable(message)
 }

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()
+
         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

@@ -12,7 +12,11 @@ import com.flipcash.services.models.NetworkPoolBetOutcome
 import com.flipcash.services.models.NetworkPoolResolution
 import com.flipcash.services.user.UserManager
 import com.getcode.ed25519.Ed25519
+import com.getcode.opencode.controllers.AccountController
 import com.getcode.opencode.controllers.TransactionController
+import com.getcode.opencode.exchange.Exchange
+import com.getcode.opencode.model.accounts.AccountCluster
+import com.getcode.opencode.model.accounts.AccountType
 import com.getcode.opencode.model.core.ID
 import com.getcode.opencode.model.core.RandomId
 import com.getcode.opencode.model.financial.Distribution
@@ -23,6 +27,8 @@ import javax.inject.Inject
 class InternalPoolResolveDelegate @Inject constructor(
     private val transactionController: TransactionController,
     private val userManager: UserManager,
+    private val accountController: AccountController,
+    private val exchange: Exchange,
 ) : PoolResolveDelegate {
     override suspend fun resolvePool(
         pool: Pool,
@@ -46,14 +52,19 @@ class InternalPoolResolveDelegate @Inject constructor(
             bets = bets,
         )
 
-        val distributions = poolWithBets.buildDistributionList(resolution)
+        val distributions = runCatching { poolWithBets.buildDistributionList(owner, 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 {
@@ -63,25 +74,59 @@ class InternalPoolResolveDelegate @Inject constructor(
         }
     }
 
-    private fun PoolWithBets.buildDistributionList(resolution: PoolResolution.DecisionMade): List<Distribution> {
+    private suspend fun PoolWithBets.buildDistributionList(
+        owner: AccountCluster,
+        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 poolBalance = accountController.getAccount(
+            accountOwner = owner,
+            requestingOwner = owner,
+            predicate = { account ->
+                val indexMatch = account.index.toLong() == pool.derivationIndex
+                val addressMatch = account.address == pool.fundingDestination
+                val isPool = account.accountType == AccountType.Pool
+                indexMatch && addressMatch && isPool
+            },
+        ).getOrNull()?.balance
+
+        if (poolBalance == null) {
+            throw PaymentError.NoPoolBalance()
+        }
+
+        val winnerCount = matchingBets.count()
+
+        // Calculate base amount per winner and remainder
+        val baseAmountPerWinner = poolBalance.quarks / winnerCount
+        val remainderQuarks = poolBalance.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

@@ -134,18 +134,17 @@ class PoolsCoordinator @Inject constructor(
     suspend fun isPoolDistributed(pool: Pool): Result<Boolean> {
         val owner = userManager.accountCluster
             ?: return Result.failure(Throwable("No account cluster"))
-        return accountController.getAccounts(
+        return accountController.getAccount(
             accountOwner = owner,
             requestingOwner = owner,
-        ).map {
-            val info = it.accounts.values.firstOrNull { account ->
+            predicate = { account ->
                 val indexMatch = account.index.toLong() == pool.derivationIndex
                 val addressMatch = account.address == pool.fundingDestination
                 val isPool = account.accountType == AccountType.Pool
                 indexMatch && addressMatch && isPool
-            } ?: return Result.failure(Throwable("Account for pool not found"))
-
-            info.balance == Fiat.Zero
+            }
+        ).map {
+            it.balance == Fiat.Zero
         }.onFailure {
             return Result.failure(it)
         }
@@ -159,35 +158,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/controllers/AccountController.kt

@@ -4,6 +4,7 @@ import com.getcode.crypt.MnemonicPhrase
 import com.getcode.ed25519.Ed25519
 import com.getcode.opencode.internal.network.api.intents.IntentCreateAccount
 import com.getcode.opencode.model.accounts.AccountCluster
+import com.getcode.opencode.model.accounts.AccountInfo
 import com.getcode.opencode.model.accounts.AccountResponse
 import com.getcode.opencode.model.accounts.PoolAccount
 import com.getcode.opencode.model.core.ID
@@ -50,4 +51,23 @@ class AccountController @Inject constructor(
             requestingOwner = requestingOwner.authority.keyPair
         )
     }
+
+    suspend fun getAccount(
+        accountOwner: AccountCluster,
+        requestingOwner: AccountCluster,
+        predicate: (AccountInfo) -> Boolean,
+    ): Result<AccountInfo> {
+        return getAccounts(
+            accountOwner = accountOwner,
+            requestingOwner = requestingOwner,
+        ).map {
+            it.accounts.values.find(predicate)
+        }.fold(
+            onSuccess = {
+                if (it != null) Result.success(it)
+                else Result.failure(NoSuchElementException())
+            },
+            onFailure = { Result.failure(it) }
+        )
+    }
 }

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?