chore(ocp): include balance capping in LocalFiat#valueExchangeIn

additionally add some debug logging that can be turned on when needed

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

Author: bmc08gt

apps/flipcash/features/cash/src/main/kotlin/com/flipcash/app/cash/internal/CashScreenViewModel.kt

@@ -149,10 +149,11 @@ internal class CashScreenViewModel @Inject constructor(
                             if (rate.currency != CurrencyCode.USD) {
                                 exchange.fetchRatesIfNeeded()
                             }
-                            val token = stateFlow.value.token!!.token
+                            val (token, balance) = stateFlow.value.token!!
                             val amountFiat = LocalFiat.valueExchangeIn(
                                 amount =  Fiat(amount, rate.currency),
                                 token = token,
+                                balance = balance.underlyingTokenAmount,
                                 rate = rate,
                             )
 
@@ -294,7 +295,7 @@ internal class CashScreenViewModel @Inject constructor(
             .filter { !(checkBalanceLimit() || checkSendLimit()) }
             .onEach { data ->
                 dispatchEvent(Event.UpdateLoadingState(loading = true))
-                val token = stateFlow.value.token!!.token
+                val (token, balance) = stateFlow.value.token!!
                 val rate = exchange.entryRate
                 // if we are USD we can skip the rate fetch since its 1:1
                 if (token.address == Mint.usdc) {
@@ -306,6 +307,7 @@ internal class CashScreenViewModel @Inject constructor(
                 val amountFiat = LocalFiat.valueExchangeIn(
                     amount = Fiat(data.amountData.amount, rate.currency),
                     token = token,
+                    balance = balance.underlyingTokenAmount,
                     rate = rate,
                 )
 

apps/flipcash/features/withdrawal/src/main/kotlin/com/flipcash/app/withdrawal/WithdrawalViewModel.kt

@@ -279,6 +279,7 @@ internal class WithdrawalViewModel @Inject constructor(
                 val amountFiat = LocalFiat.valueExchangeIn(
                     amount = Fiat(data.amountData.amount, rate.currency),
                     token = token,
+                    balance = stateFlow.value.token!!.balance,
                     rate = rate,
                 )
 
@@ -419,7 +420,8 @@ internal class WithdrawalViewModel @Inject constructor(
                     LocalFiat.valueExchangeIn(
                         fee,
                         token = token,
-                        rate = exchange.rateToUsd(CurrencyCode.USD)!!
+                        balance = stateFlow.value.token!!.balance,
+                        rate = exchange.rateToUsd(CurrencyCode.USD)!!,
                     ).underlyingTokenAmount
                 }
 

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

@@ -113,6 +113,14 @@ data class Fiat(
         currencyCode = rate.currency
     )
 
+    fun convertingToUsdIfNeeded(rate: Rate): Fiat {
+        return if (rate.currency != CurrencyCode.USD) {
+            convertingTo(Rate(1 / rate.fx, rate.currency))
+        } else {
+            this
+        }
+    }
+
     // Comparable implementation
     override fun compareTo(other: Fiat): Int = this.quarks.compareTo(other.quarks)
 
@@ -208,4 +216,6 @@ fun Number.toFiat(currencyCode: CurrencyCode = CurrencyCode.USD): Fiat = when (t
     is Long -> Fiat(this, currencyCode)
     is Double -> Fiat(this, currencyCode)
     else -> throw IllegalArgumentException("Unsupported number type")
-}
+}
+
+fun min(a: Fiat, b: Fiat): Fiat = if (a < b) a else b

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

@@ -63,16 +63,14 @@ data class LocalFiat(
         fun valueExchangeIn(
             amount: Fiat,
             token: Token,
+            balance: Fiat = Fiat.Zero,
             rate: Rate,
+            debug: Boolean = false,
         ): LocalFiat {
-            val usdValue = if (rate.currency != CurrencyCode.USD) {
-                amount.convertingTo(Rate(1 / rate.fx, rate.currency))
-            } else {
-                amount
-            }
+            val usdValue = amount.convertingToUsdIfNeeded(rate)
 
             if (token.address == Mint.usdc) {
-                // this doesn't need a calcuated value exchange since we are USDC
+                // this doesn't need a calculated value exchange since we are USDC
                return if (rate.currency != CurrencyCode.USD) {
                    LocalFiat(
                        usdc = usdValue,
@@ -83,25 +81,38 @@ data class LocalFiat(
                }
             }
 
+            val circulatingSupply = token.launchpadMetadata?.currentCirculatingSupplyQuarks ?: 0
 
+            val cappedValue = min(balance, usdValue)
 
             // determine quarks to exchange for the desired amount
             val quarks = Estimator.valueExchangeAsQuarks(
-                valueInQuarks = usdValue.quarks,
-                currentSupplyInQuarks = token.launchpadMetadata?.currentCirculatingSupplyQuarks
-                    ?: 0,
+                valueInQuarks = cappedValue.quarks,
+                currentSupplyInQuarks = circulatingSupply,
                 mintDecimals = 6, // usdc is 6 decimals
             ).getOrThrow()
 
             // determine the "full units" of the token being exchanged
             val units = quarks.units()
             // determine the exchange rate (native amount / units of token) (USD based)
-            val usdFx = BigDecimal(usdValue.decimalValue).divideWithHighPrecision(units)
+            val usdFx = BigDecimal(cappedValue.decimalValue).divideWithHighPrecision(units)
 
             // determine the relative exchange rate of the token in the currency selected
             // USD is a 1:1 fx so we can be blind here
             val fx = rate.fx * usdFx.toDouble()
 
+            if (debug) {
+                println("requested quarks:   ${usdValue.quarks * 1_000_000}")
+                println("balance quarks:     ${balance.quarks * 1_000_000}")
+                println("capped quarks:      ${cappedValue.quarks * 1_000_000}")
+                println("circulating supply: $circulatingSupply")
+                println("calculated quarks:  $quarks")
+                println("units:              $units")
+                println("fx:                 $fx")
+                val sellAmount = Fiat.tokenBalance(quarks.toLong(), token = token)
+                println("sellAmount:         ${sellAmount.formatted(formatting = Fiat.Formatting.Length(10))}")
+            }
+
             return LocalFiat(
                 underlyingTokenAmount = Fiat(quarks.toLong(), CurrencyCode.USD),
                 nativeAmount = amount,
@@ -126,9 +137,26 @@ fun Iterable<LocalFiat>.sum(): LocalFiat {
             acc
         }
 
-        base.copy(
-            underlyingTokenAmount = base.underlyingTokenAmount + localFiat.underlyingTokenAmount,
-            nativeAmount = base.nativeAmount + localFiat.nativeAmount,
-        )
+        base + localFiat
     }
 }
+
+operator fun LocalFiat.minus(other: LocalFiat): LocalFiat {
+    if (mint != other.mint) throw IllegalArgumentException("Mint is mismatched")
+    if (rate.currency != other.rate.currency) throw IllegalArgumentException("Currency is mismatched")
+
+    return copy(
+        underlyingTokenAmount = underlyingTokenAmount - other.underlyingTokenAmount,
+        nativeAmount = nativeAmount - other.nativeAmount
+    )
+}
+
+operator fun LocalFiat.plus(other: LocalFiat): LocalFiat {
+    if (mint != other.mint) throw IllegalArgumentException("Mint is mismatched")
+    if (rate.currency != other.rate.currency) throw IllegalArgumentException("Currency is mismatched")
+
+    return copy(
+        underlyingTokenAmount = underlyingTokenAmount + other.underlyingTokenAmount,
+        nativeAmount = nativeAmount + other.nativeAmount
+    )
+}