Merge branch 'main' into change-positionID

gnoswap-labs · Feb 5, 2025 · a6a7b11 · a6a7b11
2 parents d158c63 + cc5622e
commit a6a7b11
Show file tree

Hide file tree

Showing 40 changed files with 387 additions and 392 deletions.
diff --git a/contract/p/gnoswap/int256/conversion_test.gno b/contract/p/gnoswap/int256/conversion_test.gno
@@ -142,7 +142,7 @@ func TestSet(t *testing.T) {
 
 		got := z.ToString()
 		if got != tc.want {
-			t.Errorf("Set(%s) = %s, want %s", tc.x, got, tc.want)
+			t.Errorf("set(%s) = %s, want %s", tc.x, got, tc.want)
 		}
 	}
 }

diff --git a/contract/r/gnoswap/gns/_helper_test.gno b/contract/r/gnoswap/gns/_helper_test.gno
@@ -22,8 +22,8 @@ func resetObject(t *testing.T) {
 func resetGnsTokenObject(t *testing.T) {
 	t.Helper()
 
-	Token, privateLedger = grc20.NewToken("Gnoswap", "GNS", 6)
-	UserTeller = Token.CallerTeller()
+	token, privateLedger = grc20.NewToken("Gnoswap", "GNS", 6)
+	UserTeller = token.CallerTeller()
 	owner = ownable.NewWithAddress(consts.ADMIN)
 	privateLedger.Mint(owner.Owner(), INITIAL_MINT_AMOUNT)
 }
diff --git a/contract/r/gnoswap/gns/gns.gno b/contract/r/gnoswap/gns/gns.gno
@@ -21,7 +21,7 @@ const (
 
 var (
 	owner         *ownable.Ownable
-	Token         *grc20.Token
+	token         *grc20.Token
 	privateLedger *grc20.PrivateLedger
 	UserTeller    grc20.Teller
 
@@ -34,11 +34,11 @@ var (
 
 func init() {
 	owner = ownable.NewWithAddress(consts.ADMIN)
-	Token, privateLedger = grc20.NewToken("Gnoswap", "GNS", 6)
-	UserTeller = Token.CallerTeller()
+	token, privateLedger = grc20.NewToken("Gnoswap", "GNS", 6)
+	UserTeller = token.CallerTeller()
 
 	privateLedger.Mint(owner.Owner(), INITIAL_MINT_AMOUNT)
-	getter := func() *grc20.Token { return Token }
+	getter := func() *grc20.Token { return token }
 	grc20reg.Register(getter, "")
 
 	// Initial amount set to 900_000_000_000_000 (MAXIMUM_SUPPLY - INITIAL_MINT_AMOUNT).
@@ -50,31 +50,31 @@ func init() {
 }
 
 func TotalSupply() uint64 {
-	return Token.TotalSupply()
+	return token.TotalSupply()
 }
 
 func GetName() string {
-	return Token.GetName()
+	return token.GetName()
 }
 
 func GetSymbol() string {
-	return Token.GetSymbol()
+	return token.GetSymbol()
 }
 
 func GetDecimals() uint {
-	return Token.GetDecimals()
+	return token.GetDecimals()
 }
 
 func KnownAccounts() int {
-	return Token.KnownAccounts()
+	return token.KnownAccounts()
 }
 
 func BalanceOf(owner std.Address) uint64 {
-	return Token.BalanceOf(owner)
+	return token.BalanceOf(owner)
 }
 
 func Allowance(owner, spender std.Address) uint64 {
-	return Token.Allowance(owner, spender)
+	return token.Allowance(owner, spender)
 }
 
 func MintGns(address std.Address) uint64 {
@@ -155,10 +155,10 @@ func Render(path string) string {
 
 	switch {
 	case path == "":
-		return Token.RenderHome()
+		return token.RenderHome()
 	case c == 2 && parts[0] == "balance":
 		owner := std.Address(parts[1])
-		balance := Token.BalanceOf(owner)
+		balance := token.BalanceOf(owner)
 		return ufmt.Sprintf("%d\n", balance)
 	default:
 		return "404\n"

diff --git a/contract/r/gnoswap/gns/halving.gno b/contract/r/gnoswap/gns/halving.gno
@@ -29,7 +29,7 @@ const (
 )
 
 var (
-	HALVING_AMOUNTS_PER_YEAR = [HALVING_END_YEAR]uint64{
+	halvingAmountsPerYear = [HALVING_END_YEAR]uint64{
 		18_750_000_000_000 * 12, // Year 1:  225000000000000
 		18_750_000_000_000 * 12, // Year 2:  225000000000000
 		9_375_000_000_000 * 12,  // Year 3:  112500000000000
@@ -566,7 +566,7 @@ func setAmountPerBlockPerHalvingYear(year int64, amount uint64) {
 }
 
 func GetHalvingAmountsPerYear(year int64) uint64 {
-	return HALVING_AMOUNTS_PER_YEAR[year-1]
+	return halvingAmountsPerYear[year-1]
 }
 
 func GetEndHeight() int64 {

diff --git a/contract/r/gnoswap/gov/staker/api_staker_test.gno b/contract/r/gnoswap/gov/staker/api_staker_test.gno
@@ -73,7 +73,7 @@ func TestGetLockedInfoByAddress_EmptyLocks(t *testing.T) {
 func TestGetClaimableRewardByAddress(t *testing.T) {
 	addr := testutils.TestAddress("claimable_test")
 
-	rewardState.AddStake(uint64(std.GetHeight()), addr, 100, 0, nil)
+	rewardState.addStake(uint64(std.GetHeight()), addr, 100, 0, nil)
 
 	currentGNSBalance = 1000
 	// userEmissionReward.Set(addr.String(), uint64(1000))

diff --git a/contract/r/gnoswap/gov/staker/reward_calculation.gno b/contract/r/gnoswap/gov/staker/reward_calculation.gno
@@ -174,7 +174,7 @@ func (self *RewardState) deductReward(staker std.Address, currentBalance uint64)
 	return reward64, protocolFeeRewards
 }
 
-// This function MUST be called as a part of AddStake or RemoveStake
+// This function MUST be called as a part of addStake or removeStake
 // CurrentBalance / StakeChange / IsRemoveStake will be updated in those functions
 func (self *RewardState) finalize(currentBalance uint64, currentProtocolFeeBalances map[string]uint64) {
 	if self.TotalStake == uint64(0) {
@@ -207,7 +207,7 @@ func (self *RewardState) finalize(currentBalance uint64, currentProtocolFeeBalan
 	}
 }
 
-func (self *RewardState) AddStake(currentHeight uint64, staker std.Address, amount uint64, currentBalance uint64, currentProtocolFeeBalances map[string]uint64) {
+func (self *RewardState) addStake(currentHeight uint64, staker std.Address, amount uint64, currentBalance uint64, currentProtocolFeeBalances map[string]uint64) {
 	self.finalize(currentBalance, currentProtocolFeeBalances)
 
 	self.TotalStake += amount
@@ -249,7 +249,7 @@ func (self *RewardState) AddStake(currentHeight uint64, staker std.Address, amou
 	self.info.Set(staker.String(), info)
 }
 
-func (self *RewardState) Claim(staker std.Address, currentBalance uint64, currentProtocolFeeBalances map[string]uint64) (uint64, map[string]uint64) {
+func (self *RewardState) claim(staker std.Address, currentBalance uint64, currentProtocolFeeBalances map[string]uint64) (uint64, map[string]uint64) {
 	if !self.info.Has(staker.String()) {
 		return 0, make(map[string]uint64)
 	}
@@ -266,7 +266,7 @@ func (self *RewardState) Claim(staker std.Address, currentBalance uint64, curren
 	return reward, protocolFeeRewards
 }
 
-func (self *RewardState) RemoveStake(staker std.Address, amount uint64, currentBalance uint64, currentProtocolFeeBalances map[string]uint64) (uint64, map[string]uint64) {
+func (self *RewardState) removeStake(staker std.Address, amount uint64, currentBalance uint64, currentProtocolFeeBalances map[string]uint64) (uint64, map[string]uint64) {
 	self.finalize(currentBalance, currentProtocolFeeBalances)
 
 	reward, protocolFeeRewards := self.deductReward(staker, currentBalance)
@@ -316,10 +316,10 @@ func SetAmountByProjectWallet(addr std.Address, amount uint64, add bool) {
 	currentAmount := getAmountByProjectWallet(addr)
 	if add {
 		amountByProjectWallet.Set(addr.String(), currentAmount+amount)
-		rewardState.AddStake(uint64(std.GetHeight()), caller, amount, getCurrentBalance(), getCurrentProtocolFeeBalance())
+		rewardState.addStake(uint64(std.GetHeight()), caller, amount, getCurrentBalance(), getCurrentProtocolFeeBalance())
 	} else {
 		amountByProjectWallet.Set(addr.String(), currentAmount-amount)
-		rewardState.RemoveStake(caller, amount, getCurrentBalance(), getCurrentProtocolFeeBalance())
+		rewardState.removeStake(caller, amount, getCurrentBalance(), getCurrentProtocolFeeBalance())
 	}
 }
 

diff --git a/contract/r/gnoswap/gov/staker/reward_calculation_test.gno b/contract/r/gnoswap/gov/staker/reward_calculation_test.gno
@@ -10,10 +10,10 @@ func TestRewardCalculation_1_1(t *testing.T) {
 	state := NewRewardState()
 
 	current := 100
-	state.AddStake(10, testutils.TestAddress("alice"), 100, uint64(current), make(map[string]uint64))
+	state.addStake(10, testutils.TestAddress("alice"), 100, uint64(current), make(map[string]uint64))
 
 	current += 100
-	reward, _ := state.RemoveStake(testutils.TestAddress("alice"), 100, uint64(current), make(map[string]uint64))
+	reward, _ := state.removeStake(testutils.TestAddress("alice"), 100, uint64(current), make(map[string]uint64))
 
 	if reward != 100+100 {
 		t.Errorf("expected reward %d, got %d", 100+100, reward)
@@ -24,21 +24,21 @@ func TestRewardCalculation_1_2(t *testing.T) {
 	state := NewRewardState()
 
 	current := 100
-	state.AddStake(10, testutils.TestAddress("alice"), 100, uint64(current), make(map[string]uint64))
+	state.addStake(10, testutils.TestAddress("alice"), 100, uint64(current), make(map[string]uint64))
 
 	current += 100
-	reward, _ := state.RemoveStake(testutils.TestAddress("alice"), 100, uint64(current), make(map[string]uint64))
+	reward, _ := state.removeStake(testutils.TestAddress("alice"), 100, uint64(current), make(map[string]uint64))
 	current -= int(reward)
 
 	if reward != 100+100 {
 		t.Errorf("expected reward %d, got %d", 100+100, reward)
 	}
 
 	current += 100
-	state.AddStake(12, testutils.TestAddress("bob"), 100, uint64(current), make(map[string]uint64))
+	state.addStake(12, testutils.TestAddress("bob"), 100, uint64(current), make(map[string]uint64))
 
 	current += 100
-	reward, _ = state.RemoveStake(testutils.TestAddress("bob"), 100, uint64(current), make(map[string]uint64))
+	reward, _ = state.removeStake(testutils.TestAddress("bob"), 100, uint64(current), make(map[string]uint64))
 	current -= int(reward)
 	if reward != 100+100 {
 		t.Errorf("expected reward %d, got %d", 100+100, reward)
@@ -50,56 +50,55 @@ func TestRewardCalculation_1_3(t *testing.T) {
 
 	// Alice takes 100 GNS
 	current := 100
-	state.AddStake(10, testutils.TestAddress("alice"), 10, uint64(current), make(map[string]uint64))
+	state.addStake(10, testutils.TestAddress("alice"), 10, uint64(current), make(map[string]uint64))
 
 	// Alice takes 100 GNS
 	current += 100
-	state.AddStake(11, testutils.TestAddress("bob"), 10, uint64(current), make(map[string]uint64))
+	state.addStake(11, testutils.TestAddress("bob"), 10, uint64(current), make(map[string]uint64))
 
 	// Alice takes 50 GNS, Bob takes 50 GNS
 	current += 100
-	reward, _ := state.RemoveStake(testutils.TestAddress("alice"), 10, uint64(current), make(map[string]uint64))
+	reward, _ := state.removeStake(testutils.TestAddress("alice"), 10, uint64(current), make(map[string]uint64))
 	current -= int(reward)
 	if reward != 100+100+50 {
 		t.Errorf("expected reward %d, got %d", 100+100+50, reward)
 	}
 
 	// Bob takes 100 GNS
 	current += 100
-	reward, _ = state.RemoveStake(testutils.TestAddress("bob"), 10, uint64(current), make(map[string]uint64))
+	reward, _ = state.removeStake(testutils.TestAddress("bob"), 10, uint64(current), make(map[string]uint64))
 	current -= int(reward)
 	if reward != 100+50 {
 		t.Errorf("expected reward %d, got %d", 100+50, reward)
 	}
 }
 
-
 func TestRewardCalculation_1_4(t *testing.T) {
 	state := NewRewardState()
 
 	// Alice takes 100 GNS
 	current := 100
-	state.AddStake(10, testutils.TestAddress("alice"), 10, uint64(current), make(map[string]uint64))
+	state.addStake(10, testutils.TestAddress("alice"), 10, uint64(current), make(map[string]uint64))
 
 	// Alice takes 200GNS
 	current += 200
-	state.AddStake(11, testutils.TestAddress("bob"), 30, uint64(current), make(map[string]uint64))
+	state.addStake(11, testutils.TestAddress("bob"), 30, uint64(current), make(map[string]uint64))
 
 	// Alice 25, Bob 75
 	current += 100
-	state.AddStake(12, testutils.TestAddress("charlie"), 10, uint64(current), make(map[string]uint64))
+	state.addStake(12, testutils.TestAddress("charlie"), 10, uint64(current), make(map[string]uint64))
 
 	// Alice 20, Bob 60, Charlie 20
 	current += 100
-	reward, _ := state.RemoveStake(testutils.TestAddress("alice"), 10, uint64(current), make(map[string]uint64))
+	reward, _ := state.removeStake(testutils.TestAddress("alice"), 10, uint64(current), make(map[string]uint64))
 	current -= int(reward)
 	if reward != 100+200+25+20 {
 		t.Errorf("expected reward %d, got %d", 100+200+25+20, reward)
 	}
 
 	// Bob 75, Charlie 25
 	current += 100
-	reward, _ = state.RemoveStake(testutils.TestAddress("bob"), 30, uint64(current), make(map[string]uint64))
+	reward, _ = state.removeStake(testutils.TestAddress("bob"), 30, uint64(current), make(map[string]uint64))
 	current -= int(reward)
 	if reward != 75+60+75 {
 		t.Errorf("expected reward %d, got %d", 75+60+75, reward)

diff --git a/contract/r/gnoswap/gov/staker/staker.gno b/contract/r/gnoswap/gov/staker/staker.gno
@@ -80,7 +80,7 @@ func Delegate(to std.Address, amount uint64) {
 		))
 	}
 
-	rewardState.AddStake(uint64(std.GetHeight()), caller, amount, getCurrentBalance(), getCurrentProtocolFeeBalance())
+	rewardState.addStake(uint64(std.GetHeight()), caller, amount, getCurrentBalance(), getCurrentProtocolFeeBalance())
 
 	// GNS // caller -> GovStaker
 	gns.TransferFrom(caller, std.CurrentRealm().Addr(), amount)
@@ -201,7 +201,7 @@ func Undelegate(from std.Address, amount uint64) {
 		))
 	}
 
-	reward, protocolFeeRewards := rewardState.RemoveStake(caller, amount, getCurrentBalance(), getCurrentProtocolFeeBalance())
+	reward, protocolFeeRewards := rewardState.removeStake(caller, amount, getCurrentBalance(), getCurrentProtocolFeeBalance())
 
 	// burn equivalent amount of xGNS
 	xgns.Burn(caller, amount)
@@ -306,7 +306,7 @@ func CollectReward() {
 	prevAddr, prevPkgPath := getPrev()
 	caller := std.PrevRealm().Addr()
 
-	reward, protocolFeeRewards := rewardState.Claim(caller, getCurrentBalance(), getCurrentProtocolFeeBalance())
+	reward, protocolFeeRewards := rewardState.claim(caller, getCurrentBalance(), getCurrentProtocolFeeBalance())
 
 	// XXX (@notJoon): There could be cases where the reward pool is empty, In such case,
 	// it seems appropriate to return 0 and continue processing.
@@ -372,7 +372,7 @@ func CollectRewardFromLaunchPad(to std.Address) {
 
 	prevAddr, prevPkgPath := getPrev()
 
-	emissionReward, protocolFeeRewards := rewardState.Claim(to, getCurrentBalance(), getCurrentProtocolFeeBalance())
+	emissionReward, protocolFeeRewards := rewardState.claim(to, getCurrentBalance(), getCurrentProtocolFeeBalance())
 	if emissionReward > 0 {
 		gns.Transfer(to, emissionReward)
 		std.Emit(

diff --git a/contract/r/gnoswap/gov/staker/staker_test.gno b/contract/r/gnoswap/gov/staker/staker_test.gno
@@ -483,7 +483,7 @@ func TestCollectReward(t *testing.T) {
 	std.TestSetRealm(user2Realm)
 	user := user2Realm.Addr().String()
 
-	rewardState.AddStake(uint64(std.GetHeight()), std.Address(user), 10, 0, make(map[string]uint64))
+	rewardState.addStake(uint64(std.GetHeight()), std.Address(user), 10, 0, make(map[string]uint64))
 
 	// set a fake emission reward
 	//userEmissionReward.Set(user, uint64(50_000))

diff --git a/contract/r/gnoswap/launchpad/api_deposit.gno b/contract/r/gnoswap/launchpad/api_deposit.gno
@@ -32,7 +32,7 @@ func ApiGetClaimableDepositByAddress(address std.Address) uint64 {
 		}
 
 		rwd, _ := rewardStates.Get(deposit.projectId, deposit.tier)
-		reward := rwd.Claim(depositId, uint64(std.GetHeight()))
+		reward := rwd.claim(depositId, uint64(std.GetHeight()))
 
 		gnsToUser += reward
 	}