Update TokensForValueExchange to use value locked as the primary input

Author: jeffyanta

pkg/solana/currencycreator/estimate.go

@@ -13,22 +13,22 @@ func EstimateCurrentPrice(currentSupplyInQuarks uint64) *big.Float {
 }
 
 type EstimateValueExchangeArgs struct {
-	ValueInQuarks         uint64
-	CurrentSupplyInQuarks uint64
-	ValueMintDecimals     uint8
+	ValueInQuarks        uint64
+	CurrentValueInQuarks uint64
+	ValueMintDecimals    uint8
 }
 
 func EstimateValueExchange(args *EstimateValueExchangeArgs) uint64 {
 	scale := big.NewFloat(math.Pow10(int(args.ValueMintDecimals))).SetPrec(defaultCurvePrec)
 	unscaledValue := big.NewFloat(float64(args.ValueInQuarks)).SetPrec(defaultCurvePrec)
 	scaledValue := new(big.Float).Quo(unscaledValue, scale)
 
-	scale = big.NewFloat(math.Pow10(int(DefaultMintDecimals))).SetPrec(defaultCurvePrec)
-	unscaledCurrentSupply := big.NewFloat(float64(args.CurrentSupplyInQuarks)).SetPrec(defaultCurvePrec)
-	scaledCurrentSupply := new(big.Float).Quo(unscaledCurrentSupply, scale)
+	scale = big.NewFloat(math.Pow10(int(args.ValueMintDecimals))).SetPrec(defaultCurvePrec)
+	unscaledCurrentValue := big.NewFloat(float64(args.CurrentValueInQuarks)).SetPrec(defaultCurvePrec)
+	scaledCurrentValue := new(big.Float).Quo(unscaledCurrentValue, scale)
 
 	scale = big.NewFloat(math.Pow10(int(DefaultMintDecimals))).SetPrec(defaultCurvePrec)
-	scaledTokens := DefaultExponentialCurve().TokensForValueExchange(scaledCurrentSupply, scaledValue)
+	scaledTokens := DefaultExponentialCurve().TokensForValueExchange(scaledCurrentValue, scaledValue)
 	unscaledTokens := new(big.Float).Mul(scaledTokens, scale)
 
 	quarks, _ := unscaledTokens.Int64()

pkg/solana/currencycreator/estimate_test.go

@@ -2,7 +2,6 @@ package currencycreator
 
 import (
 	"fmt"
-	"math"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -15,9 +14,9 @@ func TestEstimateCurrentPrice(t *testing.T) {
 
 func TestEstimatValueExchange(t *testing.T) {
 	quarks := EstimateValueExchange(&EstimateValueExchangeArgs{
-		ValueInQuarks:         5000000,          // $5
-		CurrentSupplyInQuarks: 7232649000000000, // 723,264.9 tokens
-		ValueMintDecimals:     6,
+		ValueInQuarks:        10000000,   // $10
+		CurrentValueInQuarks: 1000000000, // $1000
+		ValueMintDecimals:    6,
 	})
 
 	fmt.Printf("%d quarks\n", quarks)
@@ -63,19 +62,19 @@ func TestEstimates_CsvTable(t *testing.T) {
 	startValue := uint64(10000)          // $0.01
 	endValue := uint64(1000000000000000) // $1T
 
-	fmt.Println("value locked,payment value,payment quarks,sell value")
+	fmt.Println("value locked,total circulating supply,new circulating supply,payment value,payment quarks,sell value")
 	for valueLocked := startValue; valueLocked <= endValue; valueLocked *= 10 {
-		circulatingSupply, _ := EstimateBuy(&EstimateBuyArgs{
+		totalCirculatingSupply, _ := EstimateBuy(&EstimateBuyArgs{
 			BuyAmountInQuarks:     valueLocked,
 			CurrentSupplyInQuarks: 0,
 			ValueMintDecimals:     6,
 		})
 
 		for paymentValue := startValue; paymentValue <= valueLocked; paymentValue *= 10 {
 			paymenQuarks := EstimateValueExchange(&EstimateValueExchangeArgs{
-				ValueInQuarks:         paymentValue,
-				CurrentSupplyInQuarks: circulatingSupply,
-				ValueMintDecimals:     6,
+				ValueInQuarks:        paymentValue,
+				CurrentValueInQuarks: valueLocked,
+				ValueMintDecimals:    6,
 			})
 
 			sellValue, _ := EstimateSell(&EstimateSellArgs{
@@ -84,9 +83,18 @@ func TestEstimates_CsvTable(t *testing.T) {
 				ValueMintDecimals:    6,
 			})
 
-			require.True(t, math.Abs(float64(paymentValue)-float64(sellValue)) <= 1)
+			diff := int64(paymentValue) - int64(sellValue)
+			require.True(t, diff >= -1 && diff <= 1)
+
+			newCirculatingSupply, _ := EstimateBuy(&EstimateBuyArgs{
+				BuyAmountInQuarks:     valueLocked - paymentValue,
+				CurrentSupplyInQuarks: 0,
+				ValueMintDecimals:     6,
+			})
+			diff = int64(totalCirculatingSupply) - int64(newCirculatingSupply) - int64(paymenQuarks)
+			require.True(t, diff >= -1 && diff <= 1)
 
-			fmt.Printf("%d,%d,%d,%d\n", valueLocked, paymentValue, paymenQuarks, sellValue)
+			fmt.Printf("%d,%d,%d,%d,%d,%d\n", valueLocked, totalCirculatingSupply, newCirculatingSupply, paymentValue, paymenQuarks, sellValue)
 		}
 	}
 }

pkg/solana/currencycreator/exponential_curve.go

@@ -61,14 +61,16 @@ func (curve *ExponentialCurve) TokensBoughtForValue(currentSupply, value *big.Fl
 	return new(big.Float).Sub(result, currentSupply)
 }
 
-// How many tokens should be exchanged for a value given the currentSupply?
-func (curve *ExponentialCurve) TokensForValueExchange(currentSupply, value *big.Float) *big.Float {
+// How many tokens should be exchanged for a value given the currentValue?
+func (curve *ExponentialCurve) TokensForValueExchange(currentValue, value *big.Float) *big.Float {
 	abOverC := new(big.Float).Quo(new(big.Float).Mul(curve.a, curve.b), curve.c)
-	expCs := expBig(new(big.Float).Mul(curve.c, currentSupply))
-	abOverCTimesExpCs := new(big.Float).Mul(abOverC, expCs)
-	oneMinusFrac := new(big.Float).Sub(big.NewFloat(1), new(big.Float).Quo(value, abOverCTimesExpCs))
-	ln := logBig(oneMinusFrac)
-	return new(big.Float).Quo(new(big.Float).Neg(ln), curve.c)
+	newValue := new(big.Float).Sub(currentValue, value)
+	currentValueOverAbOverC := new(big.Float).Quo(currentValue, abOverC)
+	newValueOverAbOverC := new(big.Float).Quo(newValue, abOverC)
+	lnTerm1 := logBig(new(big.Float).Add(big.NewFloat(1.0), currentValueOverAbOverC))
+	lnTerm2 := logBig(new(big.Float).Add(big.NewFloat(1.0), newValueOverAbOverC))
+	diffLnTerms := new(big.Float).Sub(lnTerm1, lnTerm2)
+	return new(big.Float).Quo(diffLnTerms, curve.c)
 }
 
 func DefaultExponentialCurve() *ExponentialCurve {