refactor: Launchpad Architecture Refactoring (#451)

* chore: remove function prefix from panic msg

* save

* save

* test: reward handler

* feat: deposit handler

* fix error

* reward distributor

* update test

* update docs

* fix

* refactor deposit, launchpad, reward

* reduce type size

* fix rpc

* refactor: error message

* fix

* fix

* test: json builder

* update deposit test

* test: reward

* fix

* add launchpad new logic

* catch compile errors

* fix: weird interface nil error

* refactor: reward empty

* fix: when collecting deposit, check claimable Time
(not ended height)

* test: fix

* test: fix MultipleDeposit

* test: fix TestValidateRewardCollection
- no such error

* resolved some comments

* remove  unnecessary things

* remove unnecessary json builder functuion

* refactor: event message

* update launchpad test

* fix: reward_calculation

* remove dummy_test file

* additional refactor for `CreateProject`

* fix: prevent throwing nil deref error in `CollectRewardByProjectId`

* validate json creation

* save

* fix fee protocol

* remove: token register

* fix compile error for reward03 test

* paritally fix: `CollectRewardByProjectId` -- update `RewardState`

* fix

* refactor: clean code and add comments for functions

* test: reward calculation

* update reward test

* refactor: deposit refactoring

* refactor: create project

* refactor: deposit

* refactor: reward by projectId

* refactor: deposit and reward

* refactor: left reward

* refactor: reward test

* refactor: move test code into test folder

* refactor: remove unused code

* chore: remove some comments

* chore: remove comments

* remove: hard-coded string

* remove: invalid comments

* fix: check duplicate collect gns

---------

Co-authored-by: 0xTopaz <[email protected]>
Co-authored-by: mconcat <[email protected]>
Co-authored-by: n3wbie <[email protected]>

_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, "")
+}