chore: add estimation test for ensuring buy,sell, and value exchange remain in symmetry

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

Author: bmc08gt

libs/currency-math/src/main/kotlin/com/flipcash/libs/currency/math/Estimator.kt

@@ -2,7 +2,6 @@ package com.flipcash.libs.currency.math
 
 import com.flipcash.libs.currency.math.internal.DefaultMintDecimals
 import java.math.BigDecimal
-import kotlin.math.min
 
 object Estimator {
     /**
@@ -97,11 +96,11 @@ object Estimator {
         return runCatching {
             val curve = ExponentialCurve.getOrThrow()
             val valueScale = BigDecimal.TEN.pow(mintDecimals, mc)
-            val unscaledValue = BigDecimal("$valueInQuarks")
+            val unscaledValue = BigDecimal(valueInQuarks)
             val scaledValue = unscaledValue.divide(valueScale, mc)
 
             val tokenScale = BigDecimal.TEN.pow(DefaultMintDecimals, mc)
-            val unscaledCurrentSupply = BigDecimal("$currentSupplyInQuarks")
+            val unscaledCurrentSupply = BigDecimal(currentSupplyInQuarks)
             val scaledCurrentSupply = unscaledCurrentSupply.divide(tokenScale, mc)
 
             curve.tokensForValueExchange(scaledCurrentSupply, scaledValue).getOrThrow()
@@ -134,15 +133,15 @@ object Estimator {
             val amountScale = BigDecimal.TEN.pow(mintDecimals, mc)
 
             val unscaledBuyAmount = BigDecimal(amountInQuarks, mc)
-            val scaledBuyAmount = unscaledBuyAmount.divide(amountScale, mc)
+            val scaledBuyAmount = unscaledBuyAmount.divideWithHighPrecision(amountScale)
 
             val unscaledCurrentSupply = BigDecimal(currentSupplyInQuarks, mc)
-            val scaledCurrentSupply = unscaledCurrentSupply.divide(tokenScale, mc)
+            val scaledCurrentSupply = unscaledCurrentSupply.divideWithHighPrecision(tokenScale)
 
             val scaledTokens = curve.tokensBoughtForValue(scaledCurrentSupply, scaledBuyAmount).getOrThrow()
             val unscaledTokens = scaledTokens.multiply(tokenScale, mc)
 
-            val feePctValue = BigDecimal(feeBps).divide(BigDecimal("10000"), mc)
+            val feePctValue = BigDecimal(feeBps).divideWithHighPrecision(BigDecimal("10000"))
             val scaledFees = scaledTokens.multiply(feePctValue, mc)
             val unscaledFees = scaledFees.multiply(tokenScale, mc)
 
@@ -197,7 +196,6 @@ object Estimator {
             val unscaledCurrentValue = BigDecimal(currentValueInQuarks, mc)
             val scaledCurrentValue = unscaledCurrentValue.divide(tokenScale, mc)
 
-
             val scaledTokens = curve.valueFromSellingTokens(scaledCurrentValue, scaledSellAmount).getOrThrow()
             val unscaledTokens = scaledTokens.multiply(tokenScale, mc)
 

libs/currency-math/src/test/java/com/flipcash/libs/currency/math/EstimationTests.kt

@@ -3,8 +3,13 @@ package com.flipcash.libs.currency.math
 import com.flipcash.libs.currency.math.internal.DefaultMintMaxQuarkSupply
 import java.math.BigDecimal
 import java.math.BigInteger
+import java.math.RoundingMode
+import kotlin.math.abs
+import kotlin.math.roundToLong
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.fail
 
 class EstimationTests {
 
@@ -77,4 +82,59 @@ class EstimationTests {
 
         assertEquals( expectedTotal, (received2 + fees2).toBigInteger())
     }
+
+    /**
+     * This test generates a CSV table to verify the symmetry and accuracy of the buy, sell, and
+     * value exchange estimations across a wide range of values. It simulates a scenario where an
+     * initial amount (`valueLocked`) is used to buy tokens from a zero supply. Then, for various
+     * sub-amounts (`paymentValue`), it calculates the corresponding token amount (`paymentQuarks`)
+     * and immediately sells them back.
+     *
+     * The core assertion is that the value received from selling the tokens (`sellValue`) should be
+     * almost identical to the original `paymentValue`, accounting for potential minor rounding
+     * discrepancies (hence the tolerance of `1.0`).
+     *
+     * The test iterates through logarithmically scaled values for `valueLocked` and `paymentValue`,
+     * starting from 10,000 and going up to 1 quadrillion quarks, ensuring the formulas hold
+     * for both small and extremely large numbers.
+     *
+     */
+    @Test
+    fun `estimate csv table`() {
+        val startValue = 10_000L
+        val endValue = 1_000_000_000_000_000L
+
+        println("value locked,payment value,payment quarks,sell value")
+        var valueLocked = startValue
+        while (valueLocked <= endValue) {
+            val (circulatingSupply, _) = Estimator.buy(
+                amountInQuarks = valueLocked,
+                currentSupplyInQuarks = 0L,
+                mintDecimals = 6,
+                feeBps = 0
+            ).getOrThrow()
+
+            var paymentValue = startValue
+            while (paymentValue <= valueLocked) {
+                val paymentQuarks = Estimator.valueExchangeAsQuarks(
+                    valueInQuarks = paymentValue,
+                    currentSupplyInQuarks = circulatingSupply.setScale(0, RoundingMode.HALF_UP).toDouble().roundToLong(),
+                    mintDecimals = 6,
+                ).getOrThrow()
+
+                val (sellValue, _) = Estimator.sell(
+                    amountInQuarks = paymentQuarks.toLong(),
+                    currentValueInQuarks = valueLocked,
+                    mintDecimals = 6,
+                    feeBps = 0
+                ).getOrThrow()
+
+
+                assertTrue { abs(paymentValue.toDouble() - sellValue.toDouble()) <= 1.0 }
+                println("$valueLocked,$paymentValue,${paymentQuarks.toBigInteger()},${sellValue.toBigInteger()}")
+                paymentValue *= 10L
+            }
+            valueLocked *= 10L
+        }
+    }
 }