feat: reward ratio calculation

_deploy/r/gnoswap/gns/errors.gno

@@ -7,8 +7,9 @@ import (
 )
 
 var (
-	errInvalidYear     = errors.New("[GNOSWAP-GNS-001] invalid year")
-	errTooManyEmission = errors.New("[GNOSWAP-GNS-002] too many emission reward")
+	errInvalidYear                 = errors.New("[GNOSWAP-GNS-001] invalid year")
+	errTooManyEmission             = errors.New("[GNOSWAP-GNS-002] too many emission reward")
+	errCallbackEmissionChangeIsNil = errors.New("[GNOSWAP-GNS-003] callback emission change is nil")
 )
 
 func addDetailToError(err error, detail string) string {

_deploy/r/gnoswap/gns/gns.gno

@@ -205,9 +205,6 @@ func checkErr(err error) {
 // It calculates the amount of gns to mint for each halving year for block range.
 // It also handles the left emission amount if the current block range includes halving year end block.
 func calculateAmountToMint(fromHeight, toHeight int64) uint64 {
-	prevHeight := fromHeight
-	currentHeight := toHeight
-
 	// if toHeight is greater than emission end height, set toHeight to emission end height
 	endH := GetEndHeight()
 	if toHeight > endH {
@@ -259,13 +256,6 @@ func calculateAmountToMint(fromHeight, toHeight int64) uint64 {
 		}
 	}
 
-	if prevHeight == currentHeight {
-		addPerBlockMintUpdate(uint64(currentHeight), GetAmountPerBlockPerHalvingYear(GetHalvingYearByHeight(currentHeight)))
-	} else {
-		addPerBlockMintUpdate(uint64(prevHeight), GetAmountPerBlockPerHalvingYear(GetHalvingYearByHeight(prevHeight)))
-		addPerBlockMintUpdate(uint64(currentHeight), GetAmountPerBlockPerHalvingYear(GetHalvingYearByHeight(currentHeight)))
-	}
-
 	assertTooManyEmission(totalAmountToMint)
 	return totalAmountToMint
 }

_deploy/r/gnoswap/gns/halving.gno

@@ -7,7 +7,6 @@ import (
 
 	"gno.land/p/demo/avl"
 	"gno.land/p/demo/json"
-	"gno.land/r/gnoswap/v1/common"
 	"gno.land/r/gnoswap/v1/consts"
 )
 
@@ -62,6 +61,7 @@ type HalvingData struct {
 	amountPerBlock   []uint64
 }
 
+
 func (h *HalvingData) getStartBlockHeight(year int64) int64 {
 	if year == 0 {
 		return 0
@@ -195,6 +195,52 @@ func (h *HalvingData) initialize(startHeight, startTimestamp int64) {
 	}
 }
 
+var callbackEmissionChange func(amount uint64)
+
+func SetCallbackEmissionChange(callback func(amount uint64)) {
+	if callbackEmissionChange != nil {
+		panic("callbackEmissionChange already set")
+	}
+	callbackEmissionChange = callback
+}
+
+// endHeight MUST be smaller than the current height(we don't read future halving blocks with this function)
+func GetHalvingBlocksInRange(startHeight, endHeight int64) ([]int64, []uint64) {
+	halvingData := GetEmissionState().getHalvingData()
+	halvingBlocks := []int64{}
+	halvingEmissions := []uint64{}
+	for year := HALVING_START_YEAR; year <= HALVING_END_YEAR; year++ {
+		startBlock := halvingData.getStartBlockHeight(year)
+		if startBlock < startHeight {
+			continue
+		}
+		if endHeight < startBlock {
+			break
+		}
+		halvingBlocks = append(halvingBlocks, startBlock)
+		halvingEmissions = append(halvingEmissions, halvingData.getAmountPerBlock(year))
+	}
+	return halvingBlocks, halvingEmissions
+}
+
+// height MUST be smaller than the current height(we don't read future emissions)
+func GetEmission() uint64 {
+	halvingData := GetEmissionState().getHalvingData()
+	height := std.GetHeight()
+
+	for year := HALVING_START_YEAR; year <= HALVING_END_YEAR; year++ {
+		startBlock := halvingData.getStartBlockHeight(year)
+		endBlock := halvingData.getEndBlockHeight(year)
+		if startBlock <= height && height < endBlock {
+			return halvingData.getAmountPerBlock(year)
+		}
+	}
+
+	// haven't reached the start of the halvings
+	// TODO: check if returning 0 is correct
+	return 0
+}
+
 type EmissionState struct {
 	startHeight    int64
 	startTimestamp int64
@@ -343,7 +389,10 @@ func setAvgBlockTimeInMs(ms int64) {
 	adjustedAmountPerBlock := amountLeft / uint64(blockLeft)
 	// update it
 	setAmountPerBlockPerHalvingYear(currentYear, adjustedAmountPerBlock)
-	addPerBlockMintUpdate(uint64(std.GetHeight()), adjustedAmountPerBlock)
+	if callbackEmissionChange == nil {
+		panic(errCallbackEmissionChangeIsNil.Error())
+	}
+	callbackEmissionChange(adjustedAmountPerBlock)
 
 	for year := HALVING_START_YEAR; year <= HALVING_END_YEAR; year++ {
 		if year < currentYear {
@@ -371,6 +420,8 @@ func setAvgBlockTimeInMs(ms int64) {
 	}
 
 	avgBlockTimeMs = ms
+
+
 }
 
 // GetAmountByHeight returns the amount of gns to mint by height
@@ -557,30 +608,3 @@ func getHalvingYearAndEndTimestamp(timestamp int64) (int64, int64) {
 
 	return year, startTimestamp + (consts.TIMESTAMP_YEAR * year)
 }
-
-func GetCurrentEmission() uint64 {
-	emission := uint64(0)
-	perBlockMint.ReverseIterate("", common.EncodeUint(uint64(std.GetHeight())), func(key string, value interface{}) bool {
-		emission = value.(uint64)
-		return true
-	})
-	return emission
-}
-
-func EmissionUpdates(startHeight uint64, endHeight uint64) ([]uint64, []uint64) {
-	heights := make([]uint64, 0)
-	updates := make([]uint64, 0)
-	println("EmissionUpdates : ", startHeight, ", ", endHeight)
-	perBlockMint.Iterate(common.EncodeUint(startHeight), common.EncodeUint(endHeight), func(key string, value interface{}) bool {
-		println("EmissionUpdates : ", key, ", ", value)
-		heights = append(heights, common.DecodeUint(key))
-		updates = append(updates, value.(uint64))
-		return false
-	})
-
-	return heights, updates
-}
-
-func addPerBlockMintUpdate(height uint64, amount uint64) {
-	perBlockMint.Set(common.EncodeUint(height), amount)
-}

_deploy/r/gnoswap/gns/halving_test.gno

@@ -156,36 +156,48 @@ func TestGetHalvingInfo(t *testing.T) {
 
 func TestSetAvgBlockTimeInMsByAdmin(t *testing.T) {
 	t.Run("panic if caller is not admin", func(t *testing.T) {
+		oldCallback := callbackEmissionChange
+		callbackEmissionChange = func(amount uint64) {}
 		uassert.PanicsWithMessage(t,
 			"caller(g1wymu47drhr0kuq2098m792lytgtj2nyx77yrsm) has no permission",
 			func() {
 				SetAvgBlockTimeInMsByAdmin(1)
 			},
 		)
+		callbackEmissionChange = oldCallback
 	})
 
 	t.Run("success if caller is admin", func(t *testing.T) {
+		oldCallback := callbackEmissionChange
+		callbackEmissionChange = func(amount uint64) {}
 		std.TestSkipHeights(1)
-		std.TestSetRealm(adminRealm)
+		std.TestSetRealm(std.NewUserRealm(consts.ADMIN))
 		SetAvgBlockTimeInMsByAdmin(2)
 		uassert.Equal(t, GetAvgBlockTimeInMs(), int64(2))
+		callbackEmissionChange = oldCallback
 	})
 }
 
 func TestSetAvgBlockTimeInMs(t *testing.T) {
 	t.Run("panic if caller is not governance contract", func(t *testing.T) {
+		oldCallback := callbackEmissionChange
+		callbackEmissionChange = func(amount uint64) {}
 		uassert.PanicsWithMessage(t,
 			"caller(g1wymu47drhr0kuq2098m792lytgtj2nyx77yrsm) has no permission",
 			func() {
 				SetAvgBlockTimeInMs(3)
 			},
 		)
+		callbackEmissionChange = oldCallback
 	})
 
 	t.Run("success if caller is governance contract", func(t *testing.T) {
+		oldCallback := callbackEmissionChange
+		callbackEmissionChange = func(amount uint64) {}
 		std.TestSkipHeights(3)
 		std.TestSetRealm(govRealm)
 		SetAvgBlockTimeInMs(4)
 		uassert.Equal(t, GetAvgBlockTimeInMs(), int64(4))
+		callbackEmissionChange = oldCallback
 	})
 }

emission/_test_helper.gno

@@ -22,10 +22,10 @@ func resetObject(t *testing.T) {
 	t.Helper()
 
 	distributionBpsPct = avl.NewTree()
-	distributionBpsPct.Set(strconv.Itoa(LIQUIDITY_STAKER), 7500)
-	distributionBpsPct.Set(strconv.Itoa(DEVOPS), 2000)
-	distributionBpsPct.Set(strconv.Itoa(COMMUNITY_POOL), 500)
-	distributionBpsPct.Set(strconv.Itoa(GOV_STAKER), 0)
+	distributionBpsPct.Set(strconv.Itoa(LIQUIDITY_STAKER), uint64(7500))
+	distributionBpsPct.Set(strconv.Itoa(DEVOPS), uint64(2000))
+	distributionBpsPct.Set(strconv.Itoa(COMMUNITY_POOL), uint64(500))
+	distributionBpsPct.Set(strconv.Itoa(GOV_STAKER), uint64(0))
 
 	distributedToStaker = 0
 	distributedToDevOps = 0

emission/callback.gno

@@ -0,0 +1,25 @@
+package emission
+
+import (
+	"gno.land/r/gnoswap/v1/gns"
+)
+
+var callbackStakerEmissionChange func(amount uint64)
+
+func SetCallbackStakerEmissionChange(callback func(amount uint64)) {
+	if callbackStakerEmissionChange != nil {
+		panic("callbackStakerEmissionChange already set")
+	}
+	callbackStakerEmissionChange = callback
+}
+
+// Called when per-block emission is changed from the gns side.
+// It does not process non-immediate emission changes, such as halving.
+func callbackEmissionChange(amount uint64) {
+	callbackStakerEmissionChange(calculateAmount(amount, GetDistributionBpsPct(LIQUIDITY_STAKER)))
+}
+
+func init() {
+	gns.SetCallbackEmissionChange(callbackEmissionChange)
+}
+