Add minimum dollar value for a holder to be included in count (#164)

Author: jeffyanta

ocp/worker/currency/holder/runtime.go

@@ -16,12 +16,17 @@ import (
 	"github.com/code-payments/ocp-server/ocp/data/account"
 	"github.com/code-payments/ocp-server/ocp/data/currency"
 	"github.com/code-payments/ocp-server/ocp/worker"
+	"github.com/code-payments/ocp-server/solana/currencycreator"
 )
 
 const (
 	historicalUpdateTimeInterval = time.Hour
 )
 
+var (
+	minHoldingValue = common.ToCoreMintQuarks(10)
+)
+
 type holderRuntime struct {
 	log  *zap.Logger
 	data ocp_data.Provider
@@ -59,16 +64,16 @@ func (p *holderRuntime) Start(runtimeCtx context.Context, interval time.Duration
 }
 
 func (p *holderRuntime) UpdateAllLaunchpadCurrencyHolderCounts(ctx context.Context) {
-	liveHolderRecordsByMint, err := p.data.GetAllLiveCurrencyHolderCounts(ctx)
+	liveReserveRecordsByMint, err := p.data.GetAllLiveCurrencyReserves(ctx)
 	if err != nil {
 		p.log.With(zap.Error(err)).Warn("failed getting all available currencies")
 		return
 	}
 
-	for mint := range liveHolderRecordsByMint {
+	for mint, reserveRecord := range liveReserveRecordsByMint {
 		log := p.log.With(zap.String("mint", mint))
 
-		holderCount, err := p.countHoldersForMint(ctx, mint)
+		holderCount, err := p.countHoldersForMint(ctx, mint, reserveRecord.SupplyFromBonding)
 		if err != nil {
 			log.With(zap.Error(err)).Warn("failed counting holders for mint")
 			continue
@@ -112,7 +117,16 @@ func (p *holderRuntime) UpdateAllLaunchpadCurrencyHolderCounts(ctx context.Conte
 	}
 }
 
-func (p *holderRuntime) countHoldersForMint(ctx context.Context, mint string) (uint64, error) {
+func (p *holderRuntime) countHoldersForMint(ctx context.Context, mint string, currentSupply uint64) (uint64, error) {
+	minHoldings := currencycreator.EstimateValueExchange(&currencycreator.EstimateValueExchangeArgs{
+		CurrentSupplyInQuarks: currentSupply,
+		ValueInQuarks:         minHoldingValue,
+		ValueMintDecimals:     uint8(common.CoreMintDecimals),
+	})
+	if minHoldings == 0 {
+		return 0, nil
+	}
+
 	accountRecords, err := p.data.GetAccountInfosByMintAndType(ctx, mint, commonpb.AccountType_PRIMARY)
 	if err == account.ErrAccountInfoNotFound {
 		return 0, nil
@@ -139,7 +153,7 @@ func (p *holderRuntime) countHoldersForMint(ctx context.Context, mint string) (u
 
 	var count uint64
 	for _, bal := range balances {
-		if bal > 0 {
+		if bal >= minHoldings {
 			count++
 		}
 	}

solana/currencycreator/discrete_exponential_curve.go

@@ -205,3 +205,104 @@ func (c *DiscreteExponentialCurve) ValueToTokens(currentSupply, value *big.Float
 
 	return totalTokens
 }
+
+// TokensForValueExchange calculates the number of tokens that should be exchanged
+// (sold) starting at `currentSupply` to receive `value` in return.
+// This is equivalent to "How many tokens do I need to sell to get Y value?"
+// Returns nil if the supply is beyond table bounds or if there aren't enough tokens.
+// Supports fractional tokens - does not round up or down.
+func (c *DiscreteExponentialCurve) TokensForValueExchange(currentSupply, value *big.Float) *big.Float {
+	zero := big.NewFloat(0)
+	if value.Cmp(zero) == 0 {
+		return big.NewFloat(0)
+	}
+
+	stepSizeFloat := big.NewFloat(DiscretePricingStepSize)
+	scaleFloat := new(big.Float).SetPrec(defaultCurvePrec).SetInt(c.scale)
+
+	// Calculate start step
+	startStepFloat := new(big.Float).SetPrec(defaultCurvePrec).Quo(currentSupply, stepSizeFloat)
+	startStepInt, _ := startStepFloat.Int(nil)
+	startStep := startStepInt.Int64()
+
+	if startStep < 0 || int(startStep) >= len(DiscretePricingTable) {
+		return nil
+	}
+
+	// Convert value to scaled float for comparison with scaled prices
+	valueScaled := new(big.Float).SetPrec(defaultCurvePrec).Mul(value, scaleFloat)
+
+	// Calculate tokens available in the current partial step (from step boundary to currentSupply)
+	startStepBoundary := new(big.Float).SetPrec(defaultCurvePrec).Mul(big.NewFloat(float64(startStep)), stepSizeFloat)
+	tokensInCurrentPartialStep := new(big.Float).SetPrec(defaultCurvePrec).Sub(currentSupply, startStepBoundary)
+	startPrice := new(big.Float).SetPrec(defaultCurvePrec).SetInt(DiscretePricingTable[startStep])
+	costOfCurrentPartialStep := new(big.Float).SetPrec(defaultCurvePrec).Mul(tokensInCurrentPartialStep, startPrice)
+
+	// If the value fits within the current partial step, divide value by price for fractional tokens
+	if valueScaled.Cmp(costOfCurrentPartialStep) <= 0 {
+		tokens := new(big.Float).SetPrec(defaultCurvePrec).Quo(valueScaled, startPrice)
+		return tokens
+	}
+
+	// We can at least consume the entire current partial step
+	remainingValueScaled := new(big.Float).SetPrec(defaultCurvePrec).Sub(valueScaled, costOfCurrentPartialStep)
+
+	// baseCumulative is the total value of all complete steps below startStep (steps 0..startStep-1)
+	baseCumulative := new(big.Float).SetPrec(defaultCurvePrec).SetInt(DiscreteCumulativeValueTable[startStep])
+
+	// Check if there's enough value in the entire supply below
+	if remainingValueScaled.Cmp(baseCumulative) > 0 {
+		return nil
+	}
+
+	// Target cumulative: find endStep where cumulative[endStep] >= baseCumulative - remainingValueScaled
+	targetCumulative := new(big.Float).SetPrec(defaultCurvePrec).Sub(baseCumulative, remainingValueScaled)
+
+	// Convert to big.Int for binary search (use ceiling to avoid overshooting complete steps)
+	targetCumulativeInt, accuracy := targetCumulative.Int(nil)
+	if accuracy == big.Below {
+		targetCumulativeInt.Add(targetCumulativeInt, big.NewInt(1))
+	}
+
+	// Binary search for the smallest endStep where cumulative[endStep] >= targetCumulativeInt
+	low := 0
+	high := int(startStep)
+
+	for low < high {
+		mid := (low + high) / 2
+		if DiscreteCumulativeValueTable[mid].Cmp(targetCumulativeInt) >= 0 {
+			high = mid
+		} else {
+			low = mid + 1
+		}
+	}
+
+	endStep := low
+
+	// Calculate tokens from complete steps (selling steps startStep-1 down to endStep)
+	endStepSupply := new(big.Float).SetPrec(defaultCurvePrec).Mul(big.NewFloat(float64(endStep)), stepSizeFloat)
+	tokensFromCompleteSteps := new(big.Float).SetPrec(defaultCurvePrec).Sub(startStepBoundary, endStepSupply)
+
+	// Calculate remaining value after complete steps
+	cumulativeAtEndStep := new(big.Float).SetPrec(defaultCurvePrec).SetInt(DiscreteCumulativeValueTable[endStep])
+	valueUsedForCompleteSteps := new(big.Float).SetPrec(defaultCurvePrec).Sub(baseCumulative, cumulativeAtEndStep)
+	remainingValue := new(big.Float).SetPrec(defaultCurvePrec).Sub(remainingValueScaled, valueUsedForCompleteSteps)
+
+	// Sell fractional tokens in the step below endStep with remaining value
+	var tokensInEndPartialStep *big.Float
+	if remainingValue.Cmp(zero) > 0 {
+		if endStep == 0 {
+			return nil
+		}
+		endPrice := new(big.Float).SetPrec(defaultCurvePrec).SetInt(DiscretePricingTable[endStep-1])
+		tokensInEndPartialStep = new(big.Float).SetPrec(defaultCurvePrec).Quo(remainingValue, endPrice)
+	} else {
+		tokensInEndPartialStep = new(big.Float).SetPrec(defaultCurvePrec).SetFloat64(0)
+	}
+
+	// Total tokens = partial top step + complete middle steps + fractional bottom step
+	totalTokens := new(big.Float).SetPrec(defaultCurvePrec).Add(tokensInCurrentPartialStep, tokensFromCompleteSteps)
+	totalTokens.Add(totalTokens, tokensInEndPartialStep)
+
+	return totalTokens
+}

solana/currencycreator/discrete_exponential_curve_test.go

@@ -443,6 +443,211 @@ func TestDiscreteFractionalSupply(t *testing.T) {
 	assertApproxEq(t, tokensBack, big.NewFloat(10), 0.0000000001, "Tokens from fractional supply")
 }
 
+func TestDiscreteTokensForValueExchangeZeroValue(t *testing.T) {
+	curve := DefaultDiscreteExponentialCurve()
+
+	// Test with 0 value from various supplies
+	for _, supplyVal := range []float64{0, 50, 100, 1000, 10000} {
+		supply := big.NewFloat(supplyVal)
+		value := big.NewFloat(0)
+		tokens := curve.TokensForValueExchange(supply, value)
+		if tokens.Cmp(big.NewFloat(0)) != 0 {
+			t.Errorf("0 value from supply %f should yield 0 tokens, got %s",
+				supplyVal, tokens.Text('f', 18))
+		}
+	}
+}
+
+func TestDiscreteTokensForValueExchangeWithinSingleStep(t *testing.T) {
+	curve := DefaultDiscreteExponentialCurve()
+
+	// Supply at 50, sell tokens within the same step (step 0)
+	supply := big.NewFloat(50)
+	price0 := big.NewFloat(0.01)
+
+	// Value for 25 tokens at price0 = 0.25
+	valueFor25 := new(big.Float).Mul(price0, big.NewFloat(25))
+	tokens := curve.TokensForValueExchange(supply, valueFor25)
+	assertApproxEq(t, tokens, big.NewFloat(25), 0.0000000001, "Tokens for value within single step")
+}
+
+func TestDiscreteTokensForValueExchangeCrossingBoundary(t *testing.T) {
+	curve := DefaultDiscreteExponentialCurve()
+
+	// Supply at 250, sell tokens crossing step boundaries
+	supply := big.NewFloat(250)
+	sellTokens := big.NewFloat(150)
+
+	// Calculate the value of selling 150 tokens from supply 250
+	// (that's TokensToValue from supply 100 to 250)
+	newSupply := new(big.Float).Sub(supply, sellTokens)
+	value := curve.TokensToValue(newSupply, sellTokens)
+
+	// Now TokensForValueExchange should return 150
+	tokensResult := curve.TokensForValueExchange(supply, value)
+	assertApproxEq(t, tokensResult, sellTokens, 1, "Tokens for value crossing boundary")
+}
+
+func TestDiscreteTokensForValueExchangeRoundtrip(t *testing.T) {
+	curve := DefaultDiscreteExponentialCurve()
+
+	testCases := []struct {
+		supply float64
+		tokens float64
+	}{
+		{100, 50},
+		{100, 100},
+		{250, 150},
+		{500, 250},
+		{1000, 500},
+		{1000, 1000},
+		{10000, 5000},
+		{50000, 25000},
+	}
+
+	for _, tc := range testCases {
+		supply := big.NewFloat(tc.supply)
+		sellTokens := big.NewFloat(tc.tokens)
+
+		// Calculate value of selling these tokens
+		newSupply := new(big.Float).Sub(supply, sellTokens)
+		value := curve.TokensToValue(newSupply, sellTokens)
+		if value == nil {
+			t.Errorf("TokensToValue returned nil for supply=%f, tokens=%f", tc.supply, tc.tokens)
+			continue
+		}
+
+		// Roundtrip: value -> tokens should give back the original tokens
+		tokensBack := curve.TokensForValueExchange(supply, value)
+		if tokensBack == nil {
+			t.Errorf("TokensForValueExchange returned nil for supply=%f, value=%s", tc.supply, value.Text('f', 18))
+			continue
+		}
+
+		assertApproxEq(t, tokensBack, sellTokens, 1,
+			fmt.Sprintf("Roundtrip value->tokens for supply=%f, tokens=%f", tc.supply, tc.tokens))
+	}
+}
+
+func TestDiscreteTokensForValueExchangeFractionalRoundtrip(t *testing.T) {
+	curve := DefaultDiscreteExponentialCurve()
+
+	testCases := []struct {
+		supply float64
+		tokens float64
+	}{
+		{50.5, 25.3},
+		{100.25, 50.75},
+		{250.123, 100.456},
+		{1000.5, 500.25},
+		{10000.5, 1234.567},
+	}
+
+	for _, tc := range testCases {
+		supply := big.NewFloat(tc.supply)
+		sellTokens := big.NewFloat(tc.tokens)
+
+		// Calculate value of selling these tokens
+		newSupply := new(big.Float).Sub(supply, sellTokens)
+		value := curve.TokensToValue(newSupply, sellTokens)
+		if value == nil {
+			t.Errorf("TokensToValue returned nil for supply=%f, tokens=%f", tc.supply, tc.tokens)
+			continue
+		}
+
+		// Roundtrip: value -> tokens should give back the original tokens
+		tokensBack := curve.TokensForValueExchange(supply, value)
+		if tokensBack == nil {
+			t.Errorf("TokensForValueExchange returned nil for supply=%f, value=%s", tc.supply, value.Text('f', 18))
+			continue
+		}
+
+		assertApproxEq(t, tokensBack, sellTokens, 0.0000000001,
+			fmt.Sprintf("Fractional roundtrip value->tokens for supply=%f, tokens=%f", tc.supply, tc.tokens))
+	}
+}
+
+func TestDiscreteTokensForValueExchangeEntireSupply(t *testing.T) {
+	curve := DefaultDiscreteExponentialCurve()
+
+	// Selling the entire supply should return all tokens
+	supply := big.NewFloat(1000)
+	zero := big.NewFloat(0)
+	totalValue := curve.TokensToValue(zero, supply)
+
+	tokens := curve.TokensForValueExchange(supply, totalValue)
+	assertApproxEq(t, tokens, supply, 1, "Selling entire supply should return all tokens")
+}
+
+func TestDiscreteTokensForValueExchangeExceedsSupplyReturnsNil(t *testing.T) {
+	curve := DefaultDiscreteExponentialCurve()
+
+	supply := big.NewFloat(100)
+	zero := big.NewFloat(0)
+	totalValue := curve.TokensToValue(zero, supply)
+
+	// Try to extract more value than the entire supply is worth
+	excessValue := new(big.Float).Add(totalValue, big.NewFloat(1))
+	tokens := curve.TokensForValueExchange(supply, excessValue)
+	if tokens != nil {
+		t.Errorf("Value exceeding supply should return nil, got %s", tokens.Text('f', 18))
+	}
+}
+
+func TestDiscreteTokensForValueExchangeZeroSupplyReturnsNil(t *testing.T) {
+	curve := DefaultDiscreteExponentialCurve()
+
+	// At zero supply, any positive value should return nil
+	supply := big.NewFloat(0)
+	value := big.NewFloat(1)
+	tokens := curve.TokensForValueExchange(supply, value)
+	if tokens != nil {
+		t.Errorf("Zero supply with positive value should return nil, got %s", tokens.Text('f', 18))
+	}
+}
+
+func TestDiscreteTokensForValueExchangeSellingInPartsEqualsSellingAllAtOnce(t *testing.T) {
+	curve := DefaultDiscreteExponentialCurve()
+
+	supply := big.NewFloat(500)
+
+	// Sell 300 tokens total: first sell for some value, then sell more for more value
+	sellTokens := big.NewFloat(300)
+	newSupply := new(big.Float).Sub(supply, sellTokens)
+	totalValue := curve.TokensToValue(newSupply, sellTokens)
+
+	// Split the value into two parts
+	value1 := new(big.Float).Quo(totalValue, big.NewFloat(3))
+	value2 := new(big.Float).Sub(totalValue, value1)
+
+	// Sell for value1 first
+	tokens1 := curve.TokensForValueExchange(supply, value1)
+	supplyAfterFirstSell := new(big.Float).Sub(supply, tokens1)
+
+	// Then sell for value2
+	tokens2 := curve.TokensForValueExchange(supplyAfterFirstSell, value2)
+
+	// Total tokens should equal selling all at once
+	tokensAll := curve.TokensForValueExchange(supply, totalValue)
+	tokensParts := new(big.Float).Add(tokens1, tokens2)
+
+	assertApproxEq(t, tokensParts, tokensAll, 1,
+		"Selling in parts should equal selling all at once")
+}
+
+func TestDiscreteTokensForValueExchangeLargeAcrossManySteps(t *testing.T) {
+	curve := DefaultDiscreteExponentialCurve()
+
+	supply := big.NewFloat(1234567)
+	sellTokens := big.NewFloat(10000)
+
+	newSupply := new(big.Float).Sub(supply, sellTokens)
+	value := curve.TokensToValue(newSupply, sellTokens)
+
+	tokensBack := curve.TokensForValueExchange(supply, value)
+	assertApproxEq(t, tokensBack, sellTokens, 1, "Large exchange across many steps roundtrip")
+}
+
 func TestGenerateDiscreteCurveTable(t *testing.T) {
 	t.Skip()