fix(ocp/fiat): handle HALF_UP rounding when currency doesn't support decimals

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

Author: bmc08gt

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

@@ -11,6 +11,7 @@ import kotlinx.serialization.Serializable
 import java.math.BigDecimal
 import java.math.RoundingMode
 import java.text.DecimalFormat
+import java.util.Currency
 import java.util.Locale
 
 @Serializable
@@ -79,8 +80,7 @@ data class Fiat(
         }
 
         val formatter = DecimalFormat.getInstance(Locale.US).apply {
-            val decimalDigits =
-                java.util.Currency.getInstance(currencyCode.name).defaultFractionDigits
+            val decimalDigits = Currency.getInstance(currencyCode.name).defaultFractionDigits
             val preferredDigits = when (formatting) {
                 is Formatting.Length -> formatting.decimalPlaces
                 Formatting.None -> decimalDigits
@@ -90,7 +90,7 @@ data class Fiat(
             }
             minimumFractionDigits = preferredDigits
             maximumFractionDigits = preferredDigits
-            roundingMode = ROUNDING_MODE
+            roundingMode = if (decimalDigits == 0) RoundingMode.DOWN else ROUNDING_MODE
             (this as DecimalFormat).decimalFormatSymbols =
                 decimalFormatSymbols.apply {
                     currencySymbol = ""
@@ -133,6 +133,8 @@ data class Fiat(
         includeCommas = false
     ).toDouble()
 
+    fun valueNonZero(): Boolean = toDouble() != 0.0
+
     fun valueLessThan(other: Fiat): Boolean = toDouble() < other.toDouble()
     fun valueGreaterThan(other: Fiat): Boolean = toDouble() > other.toDouble()
     fun valueGreaterThanOrEqualTo(other: Fiat): Boolean = toDouble() >= other.toDouble()

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

@@ -103,33 +103,37 @@ data class LocalFiat(
             // USD is a 1:1 fx so we can be blind here
             val fx = rate.fx * usdFx.toDouble()
 
-            val sellAmount = Fiat.tokenBalance(quarks.toLong(), token = token)
+            val sellAmountUsd = Fiat.tokenBalance(quarks.toLong(), token = token)
 
             if (debug) {
                 println("############## EXCHANGE REPORT ###################")
-                println("requested quarks:   ${usdValue.quarks * 1_000_000}")
-                println("balance quarks:     ${balance?.quarks?.times(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")
-                println("sellAmount:         ${sellAmount.formatted(formatting = Fiat.Formatting.Length(10))}")
+                println("requested currency:  ${rate.currency.name}")
+                println("requested amount: ${amount.formatted()}")
+                println("requested quarks (in USD): ${usdValue.quarks * 1_000_000}")
+                println("balance quarks (in USD): ${balance?.quarks?.times(1_000_000)}")
+                println("capped quarks (in USD): ${cappedValue.quarks * 1_000_000}")
+                println("circulating supply (of ${token.symbol}): $circulatingSupply")
+                println("calculated quarks: $quarks")
+                println("units: $units")
+                println("fx: $fx")
+                println("sellAmount: ${sellAmountUsd.formatted(formatting = Fiat.Formatting.Length(token.decimals))}")
                 println("##################################################")
             }
 
             trace(
                 tag = "LocalFiat",
                 message = "Bill created",
                 metadata = {
-                    "requested quarks" to usdValue.quarks * 1_000_000
-                    "balance quarks" to balance?.quarks?.times(1_000_000)
+                    "requested currency" to rate.currency.name
+                    "requested amount" to amount.formatted()
+                    "requested quarks (in USD)" to usdValue.quarks * 1_000_000
+                    "balance quarks (in USD)" to balance?.quarks?.times(1_000_000)
+                    "capped quarks (in USD)" to cappedValue.quarks * 1_000_000
+                    "circulating supply of ${token.symbol}" to circulatingSupply
                     "calculated quarks" to quarks
                     "units" to units
                     "fx" to fx
-                    "circulating supply" to circulatingSupply
-                    "capped value" to cappedValue.quarks * 1_000_000
-                    "sell amount" to sellAmount.formatted(formatting = Fiat.Formatting.Length(10))
+                    "sell amount (in USD)" to sellAmountUsd.formatted(formatting = Fiat.Formatting.Length(token.decimals))
                 }
             )