Feat: intermediary commit before cleanup

packages/mana/balance.go

+package mana
+
+import (
+	"fmt"
+)
+
+type Balance struct {
+	calculator                 *Calculator
+	currentBalance             uint64
+	lastErosion                uint64
+	roundingErrorInLastErosion float64
+}
+
+func NewBalance(calculator *Calculator) *Balance {
+	return &Balance{
+		calculator:                 calculator,
+		currentBalance:             0,
+		lastErosion:                0,
+		roundingErrorInLastErosion: 0,
+	}
+}
+
+func (balance *Balance) GetValue() uint64 {
+	return balance.currentBalance
+}
+
+func (balance *Balance) AddTransfer(movedCoins uint64, receivedTime uint64, spentTime uint64) {
+	gainedMana, lastErosion, _ := balance.calculator.ManaOfTransferDiscrete(movedCoins, receivedTime, spentTime)
+
+	if lastErosion >= balance.lastErosion {
+		balance.Erode(lastErosion)
+	} else {
+		fmt.Println("empty")
+		// revert old actions
+		// apply new
+		// replay old
+	}
+
+	balance.currentBalance += gainedMana
+}
+
+func (balance *Balance) Erode(erosionTime uint64) {
+	if balance.lastErosion <= erosionTime {
+		balance.currentBalance, balance.lastErosion, _ = balance.calculator.ErodedManaDiscrete(balance.currentBalance, balance.lastErosion, erosionTime)
+	} else {
+		fmt.Println("empty")
+		// revert old erosions
+	}
+}

packages/mana/calculator.go

+package mana
+
+import (
+	"math"
+)
+
+type Calculator struct {
+	decayInterval   uint64
+	decayRate       float64
+	coinsPerMana    uint64
+	decayFactor     float64
+	manaScaleFactor float64
+}
+
+func NewCalculator(decayInterval uint64, decayRate float64, coinsPerMana uint64) (result *Calculator) {
+	result = &Calculator{
+		decayInterval: decayInterval,
+		decayRate:     decayRate,
+		coinsPerMana:  coinsPerMana,
+		decayFactor:   1 - decayRate,
+	}
+
+	// make mana reach exactly the token supply
+	result.manaScaleFactor = result.decayRate / result.decayFactor
+
+	return
+}
+
+func (calculator *Calculator) ManaOfTransferDiscrete(movedCoins uint64, receivedTime uint64, spentTime uint64) (result uint64, lastErosion uint64, roundingError float64) {
+	if spentTime <= receivedTime {
+		return 0, 0, 0
+	}
+
+	baseMana := movedCoins / calculator.coinsPerMana
+	scaleFactor := 1 - calculator.decayRate
+	erosionIntervals := spentTime/calculator.decayInterval - receivedTime/calculator.decayInterval
+
+	var totalManaReceived float64
+
+	switch true {
+	// no decay intervals
+	case erosionIntervals == 0:
+		lastIntervalDuration := spentTime - receivedTime
+		if lastIntervalDuration != 0 {
+			totalManaReceived += float64(CoinTimeDestroyed(baseMana, lastIntervalDuration))
+		}
+
+		lastErosion = 0
+
+	// only 1 decay interval
+	case erosionIntervals == 1:
+		firstIntervalDuration := calculator.decayInterval - receivedTime%calculator.decayInterval
+		gainsInFirstInterval := float64(CoinTimeDestroyed(baseMana, firstIntervalDuration)) * math.Pow(scaleFactor, float64(erosionIntervals))
+		totalManaReceived += gainsInFirstInterval
+
+		lastIntervalDuration := spentTime % calculator.decayInterval
+		if lastIntervalDuration != 0 {
+			totalManaReceived += float64(CoinTimeDestroyed(baseMana, lastIntervalDuration))
+		}
+
+		lastErosion = spentTime - lastIntervalDuration
+
+	// multiple decay intervals
+	default:
+		firstIntervalDuration := calculator.decayInterval - receivedTime%calculator.decayInterval
+		gainsInFirstInterval := float64(CoinTimeDestroyed(baseMana, firstIntervalDuration)) * math.Pow(scaleFactor, float64(erosionIntervals))
+		totalManaReceived += gainsInFirstInterval
+
+		gainsInConsecutiveIntervals := float64(CoinTimeDestroyed(baseMana, calculator.decayInterval)) * scaleFactor * (1 - math.Pow(scaleFactor, float64(erosionIntervals-1))) / (1 - scaleFactor)
+		totalManaReceived += gainsInConsecutiveIntervals
+
+		lastIntervalDuration := spentTime % calculator.decayInterval
+		if lastIntervalDuration != 0 {
+			totalManaReceived += float64(CoinTimeDestroyed(baseMana, lastIntervalDuration))
+		}
+
+		lastErosion = spentTime - lastIntervalDuration
+	}
+
+	result = uint64(totalManaReceived)
+	roundingError = totalManaReceived - float64(result)
+
+	return
+}
+
+func (calculator *Calculator) ManaOfTransferContinuous(movedCoins uint64, heldTime uint64) (result uint64, roundingError float64) {
+	relativeDecayTime := float64(heldTime) / float64(calculator.decayInterval)
+
+	erosionFactor := (1-math.Pow(calculator.decayFactor, float64(relativeDecayTime+1)))/calculator.decayRate - 1
+
+	gainedMana := float64(movedCoins) * calculator.manaScaleFactor * erosionFactor
+
+	result = uint64(math.Round(gainedMana))
+	roundingError = gainedMana - float64(result)
+
+	return
+}
+
+func (calculator *Calculator) ManaOfTransferContinuous1(movedCoins uint64, heldTime uint64) (result uint64, roundingError float64) {
+	gainsInConsecutiveIntervals := (float64(movedCoins) / calculator.decayRate) * (1 - math.Pow(math.E, -calculator.decayRate*float64(heldTime)))
+
+	result = uint64(gainsInConsecutiveIntervals)
+	roundingError = gainsInConsecutiveIntervals - float64(result)
+
+	return
+}
+
+func (calculator *Calculator) ErodedManaContinuous(mana uint64, erosionTime uint64) (result uint64, roundingError float64) {
+	if erosionTime == 0 {
+		result = mana
+		roundingError = 0
+
+		return
+	}
+
+	growthFactor := math.Log(1-calculator.decayRate) / float64(calculator.decayInterval)
+	erodedMana := float64(mana) * math.Pow(math.E, growthFactor*float64(erosionTime))
+
+	result = uint64(erodedMana)
+	roundingError = erodedMana - float64(result)
+
+	return
+}
+
+func (calculator *Calculator) ErodedManaDiscrete(mana uint64, erosionStartTime uint64, erosionEndTime uint64) (result uint64, lastErosion uint64, roundingError float64) {
+	if erosionStartTime > erosionEndTime {
+		panic("negative erosion duration")
+	}
+
+	erosionIntervals := erosionEndTime/calculator.decayInterval - erosionStartTime/calculator.decayInterval
+	erodedValue := math.Pow(float64(1-calculator.decayRate), float64(erosionIntervals)) * float64(mana)
+
+	result = uint64(erodedValue)
+	lastErosion = erosionEndTime
+	roundingError = erodedValue - float64(result)
+
+	return
+}

packages/mana/mana.go

 package mana
 
-import (
-	"math"
-)
-
 func CoinTimeDestroyed(transferredValue uint64, parkedTime uint64) uint64 {
 	return transferredValue * parkedTime
 }
 
-func ManaOfTransfer(value uint64, receivedTime uint64, spentTime uint64) (result uint64) {
-	firstIntervalDuration := DECAY_INTERVAL - receivedTime%DECAY_INTERVAL
-	lastIntervalDuration := spentTime % DECAY_INTERVAL
-	erosionCount := (spentTime - receivedTime) / DECAY_INTERVAL
-
-	gainsInFirstInterval := CoinTimeDestroyed(value, firstIntervalDuration)
-	gainsInLastInterval := CoinTimeDestroyed(value, lastIntervalDuration)
-	gainsPerConsecutiveInterval := CoinTimeDestroyed(value, DECAY_INTERVAL)
-
-	scaleFactor := 1 - DECAY_RATE
-
-	erodedGainsOfFirstInterval := uint64(float64(gainsInFirstInterval) * math.Pow(scaleFactor, float64(erosionCount)))
-
-	var erodedGainsOfConsecutiveIntervals uint64
-	if erosionCount >= 1 {
-		erodedGainsOfConsecutiveIntervals = uint64(float64(gainsPerConsecutiveInterval) * scaleFactor * (1 - math.Pow(scaleFactor, float64(erosionCount-1))) / (1 - scaleFactor))
-	}
-
-	result += erodedGainsOfFirstInterval
-	result += erodedGainsOfConsecutiveIntervals
-	result += gainsInLastInterval
-
-	return
-}
-
 const (
-	DECAY_INTERVAL = 100
-	DECAY_RATE     = 0.5
+	DECAY_INTERVAL = 10
+	DECAY_RATE     = 0.01
+	COINS_PER_MANA = 10
 )

packages/mana/mana_test.go

@@ -2,15 +2,82 @@ package mana
 
 import (
 	"fmt"
+	"math"
 	"testing"
+
+	"github.com/magiconair/properties/assert"
 )
 
-func TestManaOfTransfer(t *testing.T) {
-	fmt.Println(ManaOfTransfer(50, 10, 110))
-	fmt.Println(ManaOfTransfer(50, 0, 190))
-	fmt.Println(ManaOfTransfer(50, 0, 200))
-	fmt.Println(ManaOfTransfer(50, 0, 290))
-	fmt.Println(ManaOfTransfer(50, 0, 300))
-	fmt.Println(ManaOfTransfer(50, 0, 390))
-	fmt.Println(ManaOfTransfer(50, 0, 400))
+func BenchmarkCalculator_ManaOfTransferContinuous(b *testing.B) {
+	calculator := NewCalculator(10, 0.1, 1)
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		calculator.ManaOfTransferContinuous(10000000, 100000000000)
+	}
+}
+
+func TestBalance_Erode(t *testing.T) {
+	calculator := NewCalculator(50, 0.1, 9)
+	balance := NewBalance(calculator)
+
+	calculator1 := NewCalculator(5000, 0.2, 1)
+
+	fmt.Println("===")
+	fmt.Println(calculator1.ManaOfTransferContinuous(1000, 5000000))
+	fmt.Println(calculator.ManaOfTransferDiscrete(1000, 0, 50))
+
+	balance.AddTransfer(500, 0, 10)
+
+	assert.Equal(t, balance.GetValue(), uint64(450))
+
+	balance.Erode(20)
+
+	assert.Equal(t, balance.GetValue(), uint64(405))
+
+	balance.Erode(40)
+
+	assert.Equal(t, balance.GetValue(), uint64(328))
+}
+
+func calcManaContinuous(calculator *Calculator, coins uint64, timeHeld uint64) (result uint64, roundingError float64) {
+	scaleFactor := 1 - math.Pow(1-calculator.decayRate, float64(timeHeld)/float64(calculator.decayInterval))
+	fmt.Println(scaleFactor)
+	erodedGains := float64(coins) * float64(calculator.decayInterval) * scaleFactor
+
+	result = uint64(erodedGains)
+	roundingError = erodedGains - float64(result)
+
+	return
+}
+
+func TestCalculator_ManaOfTransfer(t *testing.T) {
+	manaCalculator := NewCalculator(10, 0.1, 10)
+
+	var mana, lastErosion uint64
+	var roundingError float64
+
+	mana, lastErosion, _ = manaCalculator.ManaOfTransferDiscrete(49, 0, 0)
+	assert.Equal(t, mana, uint64(0))
+	assert.Equal(t, lastErosion, uint64(0))
+
+	fmt.Println(calcManaContinuous(manaCalculator, 50, 10))
+	fmt.Println(manaCalculator.ManaOfTransferDiscrete(50, 0, 10))
+	fmt.Println(calcManaContinuous(manaCalculator, 50, 20))
+	fmt.Println(manaCalculator.ManaOfTransferDiscrete(50, 0, 20))
+
+	mana, lastErosion, _ = manaCalculator.ManaOfTransferDiscrete(49, 0, 1)
+	assert.Equal(t, mana, uint64(4))
+	assert.Equal(t, lastErosion, uint64(0))
+
+	mana, lastErosion, _ = manaCalculator.ManaOfTransferDiscrete(49, 0, 10)
+	assert.Equal(t, mana, uint64(36))
+	assert.Equal(t, lastErosion, uint64(10))
+
+	mana, lastErosion, _ = manaCalculator.ManaOfTransferDiscrete(50, 0, 31)
+	assert.Equal(t, mana, uint64(101))
+	assert.Equal(t, lastErosion, uint64(30))
+
+	fmt.Println(roundingError)
 }