refactor: Launchpad Architecture Refactoring

_deploy/r/gnoswap/common/liquidity_amounts_test.gno

@@ -240,7 +240,7 @@ func TestGetLiquidityForAmounts(t *testing.T) {
 	}{
 		{
 			name:          "Basic Liquidity Calculation - Token0 Dominant",
-			sqrtRatioX96:  q96.ToString(), // 현재 가격이 Q96
+			sqrtRatioX96:  q96.ToString(),
 			sqrtRatioAX96: (new(u256.Uint).Mul(q96, u256.NewUint(4))).ToString(),
 			sqrtRatioBX96: (new(u256.Uint).Mul(q96, u256.NewUint(16))).ToString(),
 			amount0:       "1000000",

gov/staker/api_staker.gno

@@ -57,31 +57,31 @@ func GetLockedInfoByAddress(addr std.Address) string {
 func GetClaimableRewardByAddress(addr std.Address) string {
 	en.MintAndDistributeGns()
 
-	emissionReward, exist := userEmissionReward.Get(addr.String())
-	if !exist {
+	rewardState.finalize(getCurrentBalance(), getCurrentProtocolFeeBalance())
+
+	emissionReward, protocolFeeRewards := rewardState.CalculateReward(addr)
+
+	if emissionReward == 0 && len(protocolFeeRewards) == 0 {
 		return ""
 	}
 
 	data := json.Builder().
 		WriteString("height", formatInt(std.GetHeight())).
 		WriteString("now", formatInt(time.Now().Unix())).
-		WriteString("emissionReward", formatUint(emissionReward.(uint64))).
+		WriteString("emissionReward", formatUint(emissionReward)).
 		Node()
 
-	protocolFees, exist := userProtocolFeeReward.Get(addr.String())
-	if exist {
+	if len(protocolFeeRewards) > 0 {
 		pfArr := json.ArrayNode("", nil)
-		protocolFees.(*avl.Tree).Iterate("", "", func(key string, value interface{}) bool {
-			amount := value.(uint64)
-			if amount > 0 {
+		for tokenPath, protocolFeeReward := range protocolFeeRewards {
+			if protocolFeeReward > 0 {
 				pfObj := json.Builder().
-					WriteString("tokenPath", key).
-					WriteString("amount", formatUint(amount)).
+					WriteString("tokenPath", tokenPath).
+					WriteString("amount", formatUint(protocolFeeReward)).
 					Node()
 				pfArr.AppendArray(pfObj)
 			}
-			return false
-		})
+		}
 
 		data.AppendObject("protocolFees", pfArr)
 	}

gov/staker/api_staker_test.gno

@@ -0,0 +1,125 @@
+package staker
+
+import (
+	"std"
+	"testing"
+	"time"
+
+	"gno.land/p/demo/json"
+	"gno.land/p/demo/testutils"
+	"gno.land/p/demo/uassert"
+)
+
+func TestGetLockedInfoByAddress(t *testing.T) {
+	addr := testutils.TestAddress("locked_info_test")
+
+	now := uint64(time.Now().Unix())
+	lockedGNSList := []lockedGNS{
+		{amount: 1000, unlock: now - 100}, // already unlocked
+		{amount: 2000, unlock: now + 100}, // still locked
+		{amount: 3000, unlock: now - 50},  // already unlocked
+	}
+	addrLockedGns.Set(addr.String(), lockedGNSList)
+
+	result := GetLockedInfoByAddress(addr)
+
+	node := json.Must(json.Unmarshal([]byte(result)))
+
+	uassert.True(t, node.HasKey("height"))
+	uassert.True(t, node.HasKey("now"))
+	uassert.True(t, node.HasKey("totalLocked"))
+	uassert.True(t, node.HasKey("claimableAmount"))
+
+	// summation of all the locked quantities
+	totalLocked, err := node.MustKey("totalLocked").GetString()
+	uassert.NoError(t, err)
+	uassert.Equal(t, totalLocked, "6000") // 1000 + 2000 + 3000 = 6000
+
+	claimableAmount, err := node.MustKey("claimableAmount").GetString()
+	uassert.NoError(t, err)
+	uassert.Equal(t, claimableAmount, "4000") // 1000 + 3000 = 4000
+}
+
+func TestGetLockedInfoByAddress_NoLocks(t *testing.T) {
+	addr := testutils.TestAddress("no_locks_test")
+
+	// no quantities are locked here
+	result := GetLockedInfoByAddress(addr)
+	uassert.Equal(t, result, "")
+}
+
+func TestGetLockedInfoByAddress_EmptyLocks(t *testing.T) {
+	addr := testutils.TestAddress("empty_locks_test")
+
+	addrLockedGns.Set(addr.String(), []lockedGNS{})
+
+	result := GetLockedInfoByAddress(addr)
+
+	node := json.Must(json.Unmarshal([]byte(result)))
+	uassert.True(t, node.HasKey("height"))
+	uassert.True(t, node.HasKey("now"))
+	uassert.True(t, node.HasKey("totalLocked"))
+	uassert.True(t, node.HasKey("claimableAmount"))
+
+	totalLocked, err := node.MustKey("totalLocked").GetString()
+	uassert.NoError(t, err)
+	uassert.Equal(t, totalLocked, "0")
+
+	claimableAmount, err := node.MustKey("claimableAmount").GetString()
+	uassert.NoError(t, err)
+	uassert.Equal(t, claimableAmount, "0")
+}
+
+func TestGetClaimableRewardByAddress(t *testing.T) {
+	addr := testutils.TestAddress("claimable_test")
+
+	rewardState.AddStake(uint64(std.GetHeight()), addr, 100, 0, nil)
+
+	currentGNSBalance = 1000
+	// userEmissionReward.Set(addr.String(), uint64(1000))
+
+	currentProtocolFeeBalance["token1:token2"] = 500
+	currentProtocolFeeBalance["token2:token3"] = 300
+	//pfTree := avl.NewTree()
+	//pfTree.Set("token1:token2", uint64(500))
+	//pfTree.Set("token2:token3", uint64(300))
+	//userProtocolFeeReward.Set(addr.String(), pfTree)
+
+	result := GetClaimableRewardByAddress(addr)
+
+	node := json.Must(json.Unmarshal([]byte(result)))
+
+	uassert.True(t, node.HasKey("height"))
+	uassert.True(t, node.HasKey("now"))
+
+	emissionReward, err := node.MustKey("emissionReward").GetString()
+	uassert.NoError(t, err)
+	uassert.Equal(t, emissionReward, "1000")
+
+	protocolFees := node.MustKey("protocolFees")
+	uassert.True(t, protocolFees.IsArray())
+
+	protocolFees.ArrayEach(func(i int, fee *json.Node) {
+		tokenPath, err := fee.MustKey("tokenPath").GetString()
+		uassert.NoError(t, err)
+
+		amount, err := fee.MustKey("amount").GetString()
+		uassert.NoError(t, err)
+
+		switch tokenPath {
+		case "token1:token2":
+			uassert.Equal(t, amount, "500")
+		case "token2:token3":
+			uassert.Equal(t, amount, "300")
+		default:
+			t.Errorf("unexpected tokenPath: %s", tokenPath)
+		}
+	})
+}
+
+func TestGetClaimableRewardByAddress_NoRewards(t *testing.T) {
+	addr := testutils.TestAddress("no_reward_test")
+
+	result := GetClaimableRewardByAddress(addr)
+	uassert.Equal(t, result, "")
+}