diff --git a/_setup/gnft/gnft.gno b/_setup/gnft/gnft.gno index 9d8e122fd..e14f804c8 100644 --- a/_setup/gnft/gnft.gno +++ b/_setup/gnft/gnft.gno @@ -33,7 +33,7 @@ func mintNNFT(owner std.Address, n uint64) { func BalanceOf(user users.AddressOrName) uint64 { balance, err := nft.BalanceOf(user.Resolve()) if err != nil { - panic(err) + panic(err.Error()) } return balance @@ -42,7 +42,7 @@ func BalanceOf(user users.AddressOrName) uint64 { func OwnerOf(tid grc721.TokenID) std.Address { owner, err := nft.OwnerOf(tid) if err != nil { - panic(err) + panic(err.Error()) } return owner @@ -56,7 +56,7 @@ func GetApproved(tid grc721.TokenID) (std.Address, bool) { addr, err := nft.GetApproved(tid) if err != nil { return "", false - // panic(err) + // panic(err.Error()) } return addr, true @@ -67,21 +67,21 @@ func GetApproved(tid grc721.TokenID) (std.Address, bool) { func Approve(user users.AddressOrName, tid grc721.TokenID) { err := nft.Approve(user.Resolve(), tid) if err != nil { - panic(err) + panic(err.Error()) } } func SetApprovalForAll(user users.AddressOrName, approved bool) { err := nft.SetApprovalForAll(user.Resolve(), approved) if err != nil { - panic(err) + panic(err.Error()) } } func TransferFrom(from, to users.AddressOrName, tid grc721.TokenID) { err := nft.TransferFrom(from.Resolve(), to.Resolve(), tid) if err != nil { - panic(err) + panic(err.Error()) } } @@ -93,7 +93,7 @@ func Mint(to users.AddressOrName, tid grc721.TokenID) { assertIsAdmin(caller) err := nft.Mint(to.Resolve(), tid) if err != nil { - panic(err) + panic(err.Error()) } } @@ -103,7 +103,7 @@ func Burn(tid grc721.TokenID) { assertIsAdmin(caller) err := nft.Burn(tid) if err != nil { - panic(err) + panic(err.Error()) } } diff --git a/_setup/gns/gns.gno b/_setup/gns/gns.gno index 434a854ed..40a5e9e7e 100644 --- a/_setup/gns/gns.gno +++ b/_setup/gns/gns.gno @@ -15,8 +15,8 @@ var ( ) const ( - admin std.Address = "g12l9splsyngcgefrwa52x5a7scc29e9v086m6p4" // r3v4_xxx: CHANGE WHEN DEPLOYING TO OFFICIAL NETWORK - INTERNAL_REWARD_ACCOUNT std.Address = "g1paqttvcjcluuya9n9twyw7yacv54mt7ld3gvzm" // r3v4_xxx: CHANGE WHEN DEPLOYING TO OFFICIAL NETWORK + admin std.Address = "g12l9splsyngcgefrwa52x5a7scc29e9v086m6p4" // GSA, r3v4_xxx: CHANGE WHEN DEPLOYING TO OFFICIAL NETWORK + INTERNAL_REWARD_ACCOUNT std.Address = "g1paqttvcjcluuya9n9twyw7yacv54mt7ld3gvzm" // IRA, r3v4_xxx: CHANGE WHEN DEPLOYING TO OFFICIAL NETWORK ) func init() { @@ -27,7 +27,7 @@ func init() { gns.Mint(INTERNAL_REWARD_ACCOUNT, 400_000_000_000_000) // @INTERNAL_REWARD_ACCOUNT gns.Mint(std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5"), 100_000_000_000) // default test1 - stakerAddr := std.DerivePkgAddr("gno.land/r/demo/staker") + stakerAddr := std.DerivePkgAddr("gno.land/r/demo/staker") // r3v4_xxx: CHANGE WHEN DEPLOYING TO OFFICIAL NETWORK admins = append(admins, string(stakerAddr)) admins = append(admins, string(admin)) diff --git a/consts/consts.gno b/consts/consts.gno index 8442e7cb2..443903b29 100644 --- a/consts/consts.gno +++ b/consts/consts.gno @@ -6,7 +6,8 @@ import ( // GNOSWAP SERVICE const ( - GNOSWAP_ADMIN std.Address = "g12l9splsyngcgefrwa52x5a7scc29e9v086m6p4" + GNOSWAP_ADMIN std.Address = "g12l9splsyngcgefrwa52x5a7scc29e9v086m6p4" // GSA, r3v4_xxx: CHANGE WHEN DEPLOYING TO OFFICIAL NETWORK + INTERNAL_REWARD_ACCOUNT std.Address = "g1paqttvcjcluuya9n9twyw7yacv54mt7ld3gvzm" // 500 GNS as creation fee (r3v4_xxx: 500 or 500_000_000) POOL_CREATION_FEE uint64 = 500 @@ -35,6 +36,12 @@ const ( GOV_PATH string = "gno.land/r/demo/gov" GOV_ADDR std.Address = std.DerivePkgAddr(GOV_PATH) + + GNS_PATH string = "gno.land/r/demo/gns" + GNS_ADDR std.Address = std.DerivePkgAddr(GNS_PATH) + + GNFT_PATH string = "gno.land/r/demo/gnft" + GNFT_ADDR std.Address = std.DerivePkgAddr(GNFT_PATH) ) // NUMBER diff --git a/pool/_TEST_INIT_register_tokens_test.gno b/pool/_TEST_INIT_register_tokens_test.gno index ae98716fa..791697e8c 100644 --- a/pool/_TEST_INIT_register_tokens_test.gno +++ b/pool/_TEST_INIT_register_tokens_test.gno @@ -9,10 +9,6 @@ import ( "gno.land/r/demo/qux" - "gno.land/r/demo/fred" - - "gno.land/r/demo/thud" - "gno.land/r/demo/wugnot" "gno.land/r/demo/obl" @@ -82,36 +78,6 @@ func (QuxToken) Approve() func(spender users.AddressOrName, amount uint64) { return qux.Approve } -type FredToken struct{} - -func (FredToken) Transfer() func(to users.AddressOrName, amount uint64) { - return fred.Transfer -} -func (FredToken) TransferFrom() func(from, to users.AddressOrName, amount uint64) { - return fred.TransferFrom -} -func (FredToken) BalanceOf() func(owner users.AddressOrName) uint64 { - return fred.BalanceOf -} -func (FredToken) Approve() func(spender users.AddressOrName, amount uint64) { - return fred.Approve -} - -type ThudToken struct{} - -func (ThudToken) Transfer() func(to users.AddressOrName, amount uint64) { - return thud.Transfer -} -func (ThudToken) TransferFrom() func(from, to users.AddressOrName, amount uint64) { - return thud.TransferFrom -} -func (ThudToken) BalanceOf() func(owner users.AddressOrName) uint64 { - return thud.BalanceOf -} -func (ThudToken) Approve() func(spender users.AddressOrName, amount uint64) { - return thud.Approve -} - type WugnotToken struct{} func (WugnotToken) Transfer() func(to users.AddressOrName, amount uint64) { @@ -165,8 +131,6 @@ func init() { RegisterGRC20Interface("gno.land/r/demo/foo", FooToken{}) RegisterGRC20Interface("gno.land/r/demo/baz", BazToken{}) RegisterGRC20Interface("gno.land/r/demo/qux", QuxToken{}) - RegisterGRC20Interface("gno.land/r/demo/fred", FredToken{}) - RegisterGRC20Interface("gno.land/r/demo/thud", ThudToken{}) RegisterGRC20Interface("gno.land/r/demo/wugnot", WugnotToken{}) RegisterGRC20Interface("gno.land/r/demo/obl", OBLToken{}) RegisterGRC20Interface("gno.land/r/demo/gns", GNSToken{}) diff --git a/position/_TEST_INIT_register_tokens_test.gno b/position/_TEST_INIT_register_tokens_test.gno index 4c1f4c15f..48ff455ef 100644 --- a/position/_TEST_INIT_register_tokens_test.gno +++ b/position/_TEST_INIT_register_tokens_test.gno @@ -9,10 +9,6 @@ import ( "gno.land/r/demo/qux" - "gno.land/r/demo/fred" - - "gno.land/r/demo/thud" - "gno.land/r/demo/wugnot" "gno.land/r/demo/obl" @@ -84,36 +80,6 @@ func (QuxToken) Approve() func(spender users.AddressOrName, amount uint64) { return qux.Approve } -type FredToken struct{} - -func (FredToken) Transfer() func(to users.AddressOrName, amount uint64) { - return fred.Transfer -} -func (FredToken) TransferFrom() func(from, to users.AddressOrName, amount uint64) { - return fred.TransferFrom -} -func (FredToken) BalanceOf() func(owner users.AddressOrName) uint64 { - return fred.BalanceOf -} -func (FredToken) Approve() func(spender users.AddressOrName, amount uint64) { - return fred.Approve -} - -type ThudToken struct{} - -func (ThudToken) Transfer() func(to users.AddressOrName, amount uint64) { - return thud.Transfer -} -func (ThudToken) TransferFrom() func(from, to users.AddressOrName, amount uint64) { - return thud.TransferFrom -} -func (ThudToken) BalanceOf() func(owner users.AddressOrName) uint64 { - return thud.BalanceOf -} -func (ThudToken) Approve() func(spender users.AddressOrName, amount uint64) { - return thud.Approve -} - type WugnotToken struct{} func (WugnotToken) Transfer() func(to users.AddressOrName, amount uint64) { @@ -167,8 +133,6 @@ func init() { pl.RegisterGRC20Interface("gno.land/r/demo/foo", FooToken{}) pl.RegisterGRC20Interface("gno.land/r/demo/baz", BazToken{}) pl.RegisterGRC20Interface("gno.land/r/demo/qux", QuxToken{}) - pl.RegisterGRC20Interface("gno.land/r/demo/fred", FredToken{}) - pl.RegisterGRC20Interface("gno.land/r/demo/thud", ThudToken{}) pl.RegisterGRC20Interface("gno.land/r/demo/wugnot", WugnotToken{}) pl.RegisterGRC20Interface("gno.land/r/demo/obl", OBLToken{}) pl.RegisterGRC20Interface("gno.land/r/demo/gns", GNSToken{}) diff --git a/router/_TEST_INIT_basic_test.gno b/router/_TEST_INIT_basic_test.gno index 9888cbc64..a91aafa2f 100644 --- a/router/_TEST_INIT_basic_test.gno +++ b/router/_TEST_INIT_basic_test.gno @@ -58,7 +58,7 @@ func init() { wugnot.Approve(a2u(poolAddr), 500_000_000_000_000) - std.TestSetPrevAddr(std.Address("g1paqttvcjcluuya9n9twyw7yacv54mt7ld3gvzm")) // r3v4_xxx: CHANGE WHEN DEPLOYING TO OFFICIAL NETWORK + std.TestSetPrevAddr(std.Address("g1paqttvcjcluuya9n9twyw7yacv54mt7ld3gvzm")) // IRA, r3v4_xxx: CHANGE WHEN DEPLOYING TO OFFICIAL NETWORK gns.Approve(a2u(stakerAddr), 500_000_000_000_000) // to create internal incentive } diff --git a/router/_TEST_INIT_register_tokens_test.gno b/router/_TEST_INIT_register_tokens_test.gno index a444627cb..fa469e716 100644 --- a/router/_TEST_INIT_register_tokens_test.gno +++ b/router/_TEST_INIT_register_tokens_test.gno @@ -9,10 +9,6 @@ import ( "gno.land/r/demo/qux" - "gno.land/r/demo/fred" - - "gno.land/r/demo/thud" - "gno.land/r/demo/wugnot" "gno.land/r/demo/obl" @@ -84,36 +80,6 @@ func (QuxToken) Approve() func(spender users.AddressOrName, amount uint64) { return qux.Approve } -type FredToken struct{} - -func (FredToken) Transfer() func(to users.AddressOrName, amount uint64) { - return fred.Transfer -} -func (FredToken) TransferFrom() func(from, to users.AddressOrName, amount uint64) { - return fred.TransferFrom -} -func (FredToken) BalanceOf() func(owner users.AddressOrName) uint64 { - return fred.BalanceOf -} -func (FredToken) Approve() func(spender users.AddressOrName, amount uint64) { - return fred.Approve -} - -type ThudToken struct{} - -func (ThudToken) Transfer() func(to users.AddressOrName, amount uint64) { - return thud.Transfer -} -func (ThudToken) TransferFrom() func(from, to users.AddressOrName, amount uint64) { - return thud.TransferFrom -} -func (ThudToken) BalanceOf() func(owner users.AddressOrName) uint64 { - return thud.BalanceOf -} -func (ThudToken) Approve() func(spender users.AddressOrName, amount uint64) { - return thud.Approve -} - type WugnotToken struct{} func (WugnotToken) Transfer() func(to users.AddressOrName, amount uint64) { @@ -168,8 +134,6 @@ func init() { pool.RegisterGRC20Interface("gno.land/r/demo/foo", FooToken{}) pool.RegisterGRC20Interface("gno.land/r/demo/baz", BazToken{}) pool.RegisterGRC20Interface("gno.land/r/demo/qux", QuxToken{}) - pool.RegisterGRC20Interface("gno.land/r/demo/fred", FredToken{}) - pool.RegisterGRC20Interface("gno.land/r/demo/thud", ThudToken{}) pool.RegisterGRC20Interface("gno.land/r/demo/wugnot", WugnotToken{}) pool.RegisterGRC20Interface("gno.land/r/demo/obl", OBLToken{}) pool.RegisterGRC20Interface("gno.land/r/demo/gns", GNSToken{}) @@ -179,8 +143,6 @@ func init() { RegisterGRC20Interface("gno.land/r/demo/foo", FooToken{}) RegisterGRC20Interface("gno.land/r/demo/baz", BazToken{}) RegisterGRC20Interface("gno.land/r/demo/qux", QuxToken{}) - RegisterGRC20Interface("gno.land/r/demo/fred", FredToken{}) - RegisterGRC20Interface("gno.land/r/demo/thud", ThudToken{}) RegisterGRC20Interface("gno.land/r/demo/wugnot", WugnotToken{}) RegisterGRC20Interface("gno.land/r/demo/obl", OBLToken{}) RegisterGRC20Interface("gno.land/r/demo/gns", GNSToken{}) diff --git a/router/router_register.gno b/router/router_register.gno index b0e6b2731..12f1e4c1f 100644 --- a/router/router_register.gno +++ b/router/router_register.gno @@ -4,9 +4,9 @@ import ( "std" "gno.land/r/demo/users" -) -const APPROVED_CALLER = "g12l9splsyngcgefrwa52x5a7scc29e9v086m6p4" // r3v4_xxx: CHANGE WHEN DEPLOYING TO OFFICIAL NETWORK + "gno.land/r/demo/consts" +) var registered = []GRC20Pair{} @@ -51,7 +51,7 @@ func RegisterGRC20Interface(pkgPath string, igrc20 GRC20Interface) { // r3v4_xxx: however must be used in production // caller := std.GetOrigCaller() - // if caller != APPROVED_CALLER { + // if caller != consts.GNOSWAP_ADMIN { // panic("unauthorized address to register") // } @@ -67,7 +67,7 @@ func UnregisterGRC20Interface(pkgPath string) { // only admin can unregister caller := std.GetOrigCaller() - if caller != APPROVED_CALLER { + if caller != consts.GNOSWAP_ADMIN { panic("unauthorized address to unregister") } diff --git a/staker/_TEST_INIT_basic_test.gno b/staker/_TEST_INIT_basic_test.gno index 489f7a9ca..f17155b42 100644 --- a/staker/_TEST_INIT_basic_test.gno +++ b/staker/_TEST_INIT_basic_test.gno @@ -4,6 +4,8 @@ import ( "std" "testing" + "gno.land/r/demo/consts" + "gno.land/r/demo/gns" "gno.land/r/demo/bar" @@ -19,8 +21,7 @@ import ( ) var ( - test1 std.Address - poolAddr, posAddr, stakerAddr std.Address + test1 std.Address barPath = "gno.land/r/demo/bar" bazPath = "gno.land/r/demo/baz" @@ -32,6 +33,8 @@ var ( fee100 = uint16(100) fee500 = uint16(500) fee3000 = uint16(3000) + + max_timeout = bigint(9999999999) ) func init() { @@ -40,26 +43,22 @@ func init() { testBanker := std.GetBanker(std.BankerTypeRealmIssue) testBanker.IssueCoin(test1, "ugnot", 500_000_000_000_000) - poolAddr = std.DerivePkgAddr("gno.land/r/demo/pool") - posAddr = std.DerivePkgAddr("gno.land/r/demo/position") - stakerAddr = std.DerivePkgAddr("gno.land/r/demo/staker") - std.TestSetPrevAddr(test1) - gns.Approve(a2u(poolAddr), 500_000_000_000_000) + gns.Approve(a2u(consts.POOL_ADDR), 500_000_000_000_000) - bar.Approve(a2u(poolAddr), 500_000_000_000_000) - baz.Approve(a2u(poolAddr), 500_000_000_000_000) - foo.Approve(a2u(poolAddr), 500_000_000_000_000) - qux.Approve(a2u(poolAddr), 500_000_000_000_000) + bar.Approve(a2u(consts.POOL_ADDR), 500_000_000_000_000) + baz.Approve(a2u(consts.POOL_ADDR), 500_000_000_000_000) + foo.Approve(a2u(consts.POOL_ADDR), 500_000_000_000_000) + qux.Approve(a2u(consts.POOL_ADDR), 500_000_000_000_000) - obl.Approve(a2u(stakerAddr), 500_000_000_000_000) // to create external incentive - wugnot.Approve(a2u(stakerAddr), 500_000_000_000_000) // to create (native) external incentive + obl.Approve(a2u(consts.STAKER_ADDR), 500_000_000_000_000) // to create external incentive + wugnot.Approve(a2u(consts.STAKER_ADDR), 500_000_000_000_000) // to create (native) external incentive - wugnot.Approve(a2u(poolAddr), 500_000_000_000_000) + wugnot.Approve(a2u(consts.POOL_ADDR), 500_000_000_000_000) - std.TestSetPrevAddr(std.Address("g1paqttvcjcluuya9n9twyw7yacv54mt7ld3gvzm")) - gns.Approve(a2u(stakerAddr), 500_000_000_000_000) // to create internal incentive + std.TestSetPrevAddr(std.Address("g1paqttvcjcluuya9n9twyw7yacv54mt7ld3gvzm")) // IRA, r3v4_xxx: CHANGE WHEN DEPLOYING TO OFFICIAL NETWORK + gns.Approve(a2u(consts.STAKER_ADDR), 500_000_000_000_000) // to create internal incentive } /* HELPER */ diff --git a/staker/_TEST_INIT_register_tokens_test.gno b/staker/_TEST_INIT_register_tokens_test.gno index 1e782d4c5..bc887c8ac 100644 --- a/staker/_TEST_INIT_register_tokens_test.gno +++ b/staker/_TEST_INIT_register_tokens_test.gno @@ -9,10 +9,6 @@ import ( "gno.land/r/demo/qux" - "gno.land/r/demo/fred" - - "gno.land/r/demo/thud" - "gno.land/r/demo/wugnot" "gno.land/r/demo/obl" @@ -84,36 +80,6 @@ func (QuxToken) Approve() func(spender users.AddressOrName, amount uint64) { return qux.Approve } -type FredToken struct{} - -func (FredToken) Transfer() func(to users.AddressOrName, amount uint64) { - return fred.Transfer -} -func (FredToken) TransferFrom() func(from, to users.AddressOrName, amount uint64) { - return fred.TransferFrom -} -func (FredToken) BalanceOf() func(owner users.AddressOrName) uint64 { - return fred.BalanceOf -} -func (FredToken) Approve() func(spender users.AddressOrName, amount uint64) { - return fred.Approve -} - -type ThudToken struct{} - -func (ThudToken) Transfer() func(to users.AddressOrName, amount uint64) { - return thud.Transfer -} -func (ThudToken) TransferFrom() func(from, to users.AddressOrName, amount uint64) { - return thud.TransferFrom -} -func (ThudToken) BalanceOf() func(owner users.AddressOrName) uint64 { - return thud.BalanceOf -} -func (ThudToken) Approve() func(spender users.AddressOrName, amount uint64) { - return thud.Approve -} - type WugnotToken struct{} func (WugnotToken) Transfer() func(to users.AddressOrName, amount uint64) { @@ -168,8 +134,6 @@ func init() { pool.RegisterGRC20Interface("gno.land/r/demo/foo", FooToken{}) pool.RegisterGRC20Interface("gno.land/r/demo/baz", BazToken{}) pool.RegisterGRC20Interface("gno.land/r/demo/qux", QuxToken{}) - pool.RegisterGRC20Interface("gno.land/r/demo/fred", FredToken{}) - pool.RegisterGRC20Interface("gno.land/r/demo/thud", ThudToken{}) pool.RegisterGRC20Interface("gno.land/r/demo/wugnot", WugnotToken{}) pool.RegisterGRC20Interface("gno.land/r/demo/obl", OBLToken{}) pool.RegisterGRC20Interface("gno.land/r/demo/gns", GNSToken{}) @@ -179,8 +143,6 @@ func init() { RegisterGRC20Interface("gno.land/r/demo/foo", FooToken{}) RegisterGRC20Interface("gno.land/r/demo/baz", BazToken{}) RegisterGRC20Interface("gno.land/r/demo/qux", QuxToken{}) - RegisterGRC20Interface("gno.land/r/demo/fred", FredToken{}) - RegisterGRC20Interface("gno.land/r/demo/thud", ThudToken{}) RegisterGRC20Interface("gno.land/r/demo/wugnot", WugnotToken{}) RegisterGRC20Interface("gno.land/r/demo/obl", OBLToken{}) RegisterGRC20Interface("gno.land/r/demo/gns", GNSToken{}) diff --git a/staker/_TEST_staker_collect_reward_test.gnoa b/staker/_TEST_staker_collect_reward_test.gno similarity index 87% rename from staker/_TEST_staker_collect_reward_test.gnoa rename to staker/_TEST_staker_collect_reward_test.gno index 2213694d6..2b3696dcd 100644 --- a/staker/_TEST_staker_collect_reward_test.gnoa +++ b/staker/_TEST_staker_collect_reward_test.gno @@ -4,13 +4,13 @@ import ( "std" "testing" - p "gno.land/r/demo/pool" - pos "gno.land/r/demo/position" + pl "gno.land/r/demo/pool" + pn "gno.land/r/demo/position" - gnft "gno.land/r/demo/gnft" // GNFT, Gnoswap NFT - gns "gno.land/r/demo/gns" // GNS, Gnoswap Share + "gno.land/r/demo/gnft" + "gno.land/r/demo/gns" - obl "gno.land/r/demo/obl" // OBL, External Reward Token + "gno.land/r/demo/obl" ) func init() { @@ -31,17 +31,17 @@ func init() { func TestPoolInitCreatePool(t *testing.T) { std.TestSetOrigCaller(test1) - p.InitManual() + pl.InitManual() std.TestSkipHeights(1) - p.CreatePool(barPath, quxPath, 500, 130621891405341611593710811006) + pl.CreatePool(barPath, quxPath, 500, 130621891405341611593710811006) std.TestSkipHeights(1) } func TestPositionMint(t *testing.T) { { std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pos.Mint( + tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( barPath, // token0 quxPath, // token1 uint16(500), // fee @@ -66,7 +66,7 @@ func TestPositionMint(t *testing.T) { { std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pos.Mint( + tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( barPath, // token0 quxPath, // token1 uint16(500), // fee @@ -158,8 +158,8 @@ func TestUnstakeToken(t *testing.T) { shouldEQ(t, gnft.OwnerOf(tid(2)), test1) // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000325) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004243) // external + shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000451) // internal + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004891) // external } } diff --git a/staker/_TEST_staker_get_test.gnoa b/staker/_TEST_staker_get_test.gnoa index 63ab001ee..51bb49cfb 100644 --- a/staker/_TEST_staker_get_test.gnoa +++ b/staker/_TEST_staker_get_test.gnoa @@ -4,25 +4,26 @@ import ( "std" "testing" - gnft "gno.land/r/demo/gnft" // GNFT, Gnoswap NFT - p "gno.land/r/demo/pool" - pos "gno.land/r/demo/position" + pl "gno.land/r/demo/pool" + pn "gno.land/r/demo/position" + + "gno.land/r/demo/gnft" ) func TestPoolInitCreatePool(t *testing.T) { std.TestSetOrigCaller(test1) - p.InitManual() + pl.InitManual() std.TestSkipHeights(1) - p.CreatePool(fooPath, barPath, 500, 130621891405341611593710811006) + pl.CreatePool(fooPath, barPath, 500, 130621891405341611593710811006) std.TestSkipHeights(1) } func TestPositionMint(t *testing.T) { { std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pos.Mint( + tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( fooPath, // token0 barPath, // token1 uint16(500), // fee @@ -47,7 +48,7 @@ func TestPositionMint(t *testing.T) { { std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pos.Mint( + tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( fooPath, // token0 barPath, // token1 uint16(500), // fee diff --git a/staker/_TEST_staker_internal_external_test.gnoa b/staker/_TEST_staker_internal_external_test.gnoa new file mode 100644 index 000000000..3b842cf2d --- /dev/null +++ b/staker/_TEST_staker_internal_external_test.gnoa @@ -0,0 +1,239 @@ +package staker + +import ( + "std" + + "testing" + + pl "gno.land/r/demo/pool" + pn "gno.land/r/demo/position" + + "gno.land/r/demo/gnft" + + "gno.land/r/demo/gns" + "gno.land/r/demo/obl" +) + +func init() { + // init pool tiers + // tier 1 + poolTiers["gno.land/r/demo/bar:gno.land/r/demo/qux:500"] = 1 + + // tier 2 + poolTiers["gno.land/r/demo/bar:gno.land/r/demo/baz:100"] = 2 + poolTiers["ATOM/GNS_500"] = 2 + + // tier 3 + poolTiers["ATOM/GNOT_500"] = 3 + poolTiers["ATOM/USDT_500"] = 3 + poolTiers["ATOM/WETH_500"] = 3 +} + +func TestPoolInitCreatePool(t *testing.T) { + std.TestSetOrigCaller(test1) + + pl.InitManual() + std.TestSkipHeights(1) + + pl.CreatePool(barPath, quxPath, 500, 130621891405341611593710811006) // internal, tier 1 + pl.CreatePool(barPath, bazPath, 100, 79228162514264337593543950337) // internal, tier 2 + pl.CreatePool(fooPath, quxPath, 500, 79228162514264337593543950337) // external + std.TestSkipHeights(3) +} + +func TestMintBarQux500(t *testing.T) { + std.TestSetOrigCaller(test1) + tokenId, liquidity, amount0, amount1 := pn.Mint( + barPath, // token0 + quxPath, // token1 + fee500, // fee + int32(9000), // tickLower + int32(11000), // tickUpper + bigint(100000), // amount0Desired + bigint(100000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + max_timeout, + ) + std.TestSkipHeights(1) + + shouldEQ(t, tokenId, 1) + shouldEQ(t, gnft.OwnerOf(tid(tokenId)), GetOrigCaller()) // test1 +} + +func TestMintBarBaz100(t *testing.T) { + std.TestSetOrigCaller(test1) + tokenId, liquidity, amount0, amount1 := pn.Mint( + barPath, // token0 + bazPath, // token1 + fee100, // fee + int32(-1000), // tickLower + int32(1000), // tickUpper + bigint(100000), // amount0Desired + bigint(100000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + max_timeout, + ) + std.TestSkipHeights(1) + + shouldEQ(t, tokenId, 2) + shouldEQ(t, gnft.OwnerOf(tid(tokenId)), GetOrigCaller()) // test1 +} + +func TestMintFooQux500(t *testing.T) { + std.TestSetOrigCaller(test1) + tokenId, liquidity, amount0, amount1 := pn.Mint( + fooPath, // token0 + quxPath, // token1 + fee500, // fee + int32(-1000), // tickLower + int32(1000), // tickUpper + bigint(100000), // amount0Desired + bigint(100000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + max_timeout, + ) + std.TestSkipHeights(1) + + shouldEQ(t, tokenId, 3) + shouldEQ(t, gnft.OwnerOf(tid(tokenId)), GetOrigCaller()) // test1 +} + +func TestCreateExternalIncentive(t *testing.T) { + std.TestSetOrigCaller(test1) + + CreateExternalIncentive( + "gno.land/r/demo/foo:gno.land/r/demo/qux:500", // targetPoolPath + "gno.land/r/demo/obl", // rewardToken + 100_000_000, // rewardAmount + GetTimestamp(), // startTimestamp + GetTimestamp()+TIMESTAMP_90DAYS, // endTimestamp + ) + + std.TestSkipHeights(1) +} + +func TestStakeInternalTier1(t *testing.T) { + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(1)) + StakeToken(1) + std.TestSkipHeights(2) + + shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) + shouldEQ(t, len(deposits), 1) +} + +func TestStakeInternalTier2(t *testing.T) { + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(2)) + StakeToken(2) + std.TestSkipHeights(2) + + shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) + shouldEQ(t, len(deposits), 2) +} + +func TestStakeExternal(t *testing.T) { + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(3)) + StakeToken(3) + std.TestSkipHeights(2) + + shouldEQ(t, gnft.OwnerOf(tid(3)), GetOrigPkgAddr()) + shouldEQ(t, len(deposits), 3) +} + +func TestCollectRewardToken1(t *testing.T) { + std.TestSetPrevAddr(test1) + + // before claim + gnsOld := gns.BalanceOf(a2u(test1)) + shouldEQ(t, gnsOld, 99999998500) + + CollectReward(1) + std.TestSkipHeights(1) + + gnsNew := gns.BalanceOf(a2u(test1)) + shouldEQ(t, gnsNew, 99999999325) +} + +func TestCollectRewardToken2(t *testing.T) { + std.TestSetPrevAddr(test1) + + // before claim + gnsOld := gns.BalanceOf(a2u(test1)) + shouldEQ(t, gnsOld, 99999999325) + + CollectReward(2) + std.TestSkipHeights(1) + + gnsNew := gns.BalanceOf(a2u(test1)) + shouldEQ(t, gnsNew, 99999999820) +} + +func TestCollectRewardToken1Again(t *testing.T) { + std.TestSetPrevAddr(test1) + + // before claim + gnsOld := gns.BalanceOf(a2u(test1)) + shouldEQ(t, gnsOld, 99999999820) + + // ACCELERATE TIME + std.TestSkipHeights(100000) + + CollectReward(1) + std.TestSkipHeights(1) + + gnsNew := gns.BalanceOf(a2u(test1)) + shouldEQ(t, gnsNew, 100000000370) +} + +func TestCollectExternalReward(t *testing.T) { + std.TestSetPrevAddr(test1) + + // before claim + oblOld := obl.BalanceOf(a2u(test1)) + shouldEQ(t, oblOld, 499999900000000) + + CollectReward(3) + std.TestSkipHeights(1) + + oblNew := obl.BalanceOf(a2u(test1)) + shouldEQ(t, oblNew, 499999900000035) +} + +func TestCollectAll(t *testing.T) { + std.TestSetPrevAddr(test1) + + CollectReward(1) + CollectReward(2) + CollectReward(3) + std.TestSkipHeights(3) + + // claimed all remaining reward +} + +func TestUnstakeToken1(t *testing.T) { + std.TestSetPrevAddr(test1) + gnsOld := gns.BalanceOf(a2u(test1)) + oblOld := obl.BalanceOf(a2u(test1)) + shouldEQ(t, gnsOld, 100000000700) + shouldEQ(t, oblOld, 499999900000035) + + std.TestSkipHeights(100000) + UnstakeToken(1) + gnsNew := gns.BalanceOf(a2u(test1)) + shouldEQ(t, gnsNew, 100000001250) + + UnstakeToken(2) + gnsNew = gns.BalanceOf(a2u(test1)) + shouldEQ(t, gnsNew, 100000001580) + + UnstakeToken(3) + oblNew := obl.BalanceOf(a2u(test1)) + shouldEQ(t, oblNew, 499999900000049) + + std.TestSkipHeights(1) +} diff --git a/staker/_TEST_staker_one_external_native_test.gnoa b/staker/_TEST_staker_one_external_native_test.gnoa index 0d16305ca..c6567079b 100644 --- a/staker/_TEST_staker_one_external_native_test.gnoa +++ b/staker/_TEST_staker_one_external_native_test.gnoa @@ -4,13 +4,13 @@ import ( "std" "testing" - p "gno.land/r/demo/pool" - pos "gno.land/r/demo/position" + pl "gno.land/r/demo/pool" + pn "gno.land/r/demo/position" - gnft "gno.land/r/demo/gnft" // GNFT, Gnoswap NFT - gns "gno.land/r/demo/gns" // GNS, Gnoswap Share + "gno.land/r/demo/gnft" + "gno.land/r/demo/gns" - wugnot "gno.land/r/demo/wugnot" + "gno.land/r/demo/wugnot" ) func init() { @@ -32,17 +32,17 @@ func init() { func TestPoolInitCreatePool(t *testing.T) { std.TestSetOrigCaller(test1) - p.InitManual() + pl.InitManual() std.TestSkipHeights(1) - p.CreatePool(barPath, fooPath, 500, 130621891405341611593710811006) + pl.CreatePool(barPath, fooPath, 500, 130621891405341611593710811006) std.TestSkipHeights(1) } func TestPositionMint(t *testing.T) { { std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pos.Mint( + tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( barPath, // token0 fooPath, // token1 uint16(500), // fee @@ -67,7 +67,7 @@ func TestPositionMint(t *testing.T) { { std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pos.Mint( + tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( barPath, // token10 fooPath, // token1 uint16(500), // fee @@ -154,8 +154,8 @@ func TestUnstakeToken(t *testing.T) { shouldEQ(t, gnft.OwnerOf(tid(2)), test1) // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000325) // internal - shouldEQ(t, wugnot.BalanceOf(a2u(test1)), 2121) // external + shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000451) // internal + shouldEQ(t, wugnot.BalanceOf(a2u(test1)), 2445) // external } } diff --git a/staker/_TEST_staker_one_external_test.gnoa b/staker/_TEST_staker_one_external_test.gnoa index 26c59cab8..fa2fd4ffb 100644 --- a/staker/_TEST_staker_one_external_test.gnoa +++ b/staker/_TEST_staker_one_external_test.gnoa @@ -6,12 +6,12 @@ import ( "encoding/gjson" - p "gno.land/r/demo/pool" - pos "gno.land/r/demo/position" + pl "gno.land/r/demo/pool" + pn "gno.land/r/demo/position" - gnft "gno.land/r/demo/gnft" // GNFT, Gnoswap NFT - gns "gno.land/r/demo/gns" // GNS, Gnoswap Share - obl "gno.land/r/demo/obl" + "gno.land/r/demo/gnft" + "gno.land/r/demo/gns" + "gno.land/r/demo/obl" ) func init() { @@ -32,17 +32,17 @@ func init() { func TestPoolInitCreatePool(t *testing.T) { std.TestSetOrigCaller(test1) - p.InitManual() + pl.InitManual() std.TestSkipHeights(1) - p.CreatePool(fooPath, barPath, 500, 130621891405341611593710811006) + pl.CreatePool(fooPath, barPath, 500, 130621891405341611593710811006) std.TestSkipHeights(1) } func TestPositionMint(t *testing.T) { { std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pos.Mint( + tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( fooPath, // token0 barPath, // token1 uint16(500), // fee @@ -67,7 +67,7 @@ func TestPositionMint(t *testing.T) { { std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pos.Mint( + tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( fooPath, // token0 barPath, // token1 uint16(500), // fee @@ -161,8 +161,8 @@ func TestUnstakeToken(t *testing.T) { shouldEQ(t, gnft.OwnerOf(tid(2)), test1) // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000325) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499990000002121) // external + shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000451) // internal + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499990000002445) // external } } diff --git a/staker/_TEST_staker_one_increase_external_test.gnoa b/staker/_TEST_staker_one_increase_external_test.gnoa index 2bd192a56..de151280c 100644 --- a/staker/_TEST_staker_one_increase_external_test.gnoa +++ b/staker/_TEST_staker_one_increase_external_test.gnoa @@ -4,12 +4,12 @@ import ( "std" "testing" - p "gno.land/r/demo/pool" - pos "gno.land/r/demo/position" + pl "gno.land/r/demo/pool" + pn "gno.land/r/demo/position" - gnft "gno.land/r/demo/gnft" // GNFT, Gnoswap NFT - gns "gno.land/r/demo/gns" // GNS, Gnoswap Share - obl "gno.land/r/demo/obl" + "gno.land/r/demo/gnft" + "gno.land/r/demo/gns" + "gno.land/r/demo/obl" ) func init() { @@ -30,17 +30,17 @@ func init() { func TestPoolInitCreatePool(t *testing.T) { std.TestSetOrigCaller(test1) - p.InitManual() + pl.InitManual() std.TestSkipHeights(1) - p.CreatePool(fooPath, barPath, 500, 130621891405341611593710811006) + pl.CreatePool(fooPath, barPath, 500, 130621891405341611593710811006) std.TestSkipHeights(1) } func TestPositionMint(t *testing.T) { { std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pos.Mint( + tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( fooPath, // token0 barPath, // token1 uint16(500), // fee @@ -65,7 +65,7 @@ func TestPositionMint(t *testing.T) { { std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pos.Mint( + tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( fooPath, // token0 barPath, // token1 uint16(500), // fee @@ -144,8 +144,8 @@ func TestUnstakeToken(t *testing.T) { shouldEQ(t, gnft.OwnerOf(tid(2)), test1) // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000325) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004243) // external + shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000451) // internal + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004891) // external } } diff --git a/staker/_TEST_staker_rpc_test.gno b/staker/_TEST_staker_rpc_test.gnoa similarity index 88% rename from staker/_TEST_staker_rpc_test.gno rename to staker/_TEST_staker_rpc_test.gnoa index 6d4258a9c..87920dba8 100644 --- a/staker/_TEST_staker_rpc_test.gno +++ b/staker/_TEST_staker_rpc_test.gnoa @@ -6,12 +6,12 @@ import ( "encoding/gjson" - p "gno.land/r/demo/pool" - pos "gno.land/r/demo/position" + pl "gno.land/r/demo/pool" + pn "gno.land/r/demo/position" - gnft "gno.land/r/demo/gnft" // GNFT, Gnoswap NFT - gns "gno.land/r/demo/gns" // GNS, Gnoswap Share - obl "gno.land/r/demo/obl" // OBL, External Reward Token + "gno.land/r/demo/gnft" + "gno.land/r/demo/gns" + "gno.land/r/demo/obl" ) func init() { @@ -32,17 +32,17 @@ func init() { func TestPoolInitCreatePool(t *testing.T) { std.TestSetOrigCaller(test1) - p.InitManual() + pl.InitManual() std.TestSkipHeights(1) - p.CreatePool(barPath, quxPath, 500, 130621891405341611593710811006) + pl.CreatePool(barPath, quxPath, 500, 130621891405341611593710811006) std.TestSkipHeights(1) } func TestPositionMint(t *testing.T) { { std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pos.Mint( + tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( barPath, // token0 quxPath, // token1 uint16(500), // fee @@ -67,7 +67,7 @@ func TestPositionMint(t *testing.T) { { std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pos.Mint( + tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( barPath, // token0 quxPath, // token1 uint16(500), // fee @@ -173,8 +173,8 @@ func TestUnstakeToken(t *testing.T) { shouldEQ(t, gnft.OwnerOf(tid(2)), test1) // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000325) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004243) // external + shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000451) // internal + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004891) // external } } diff --git a/staker/reward_math.gno b/staker/reward_math.gno index 8cbadfcc9..41ea3d1d4 100644 --- a/staker/reward_math.gno +++ b/staker/reward_math.gno @@ -16,19 +16,24 @@ const ( TIMESTAMP_360DAYS = 31104000 ) -type userClaimedReward map[std.Address]map[string]bigint // address -> rewardTokenPath -> rewardTokenAmount +type userClaimedReward map[std.Address]map[uint64]map[string]bigint // address -> lpTokenId -> rewardTokenPath -> rewardTokenAmount var userClaimedRewards = make(userClaimedReward) -func userClaimedRewardAmount(address std.Address, rewardTokenPath string, rewardAmount bigint, claimeRequest bool) bigint { +func userClaimedRewardAmount(address std.Address, tokenId uint64, rewardTokenPath string, rewardAmount bigint, claimeRequest bool) bigint { userClaimed, ok := userClaimedRewards[address] // if user(address) ever claimed reward if !ok { - userClaimedRewards[address] = make(map[string]bigint) + userClaimedRewards[address] = make(map[uint64]map[string]bigint) } - claimedReward, ok := userClaimedRewards[address][rewardTokenPath] // if user(address) ever claimed rewardTokenPath + claimedPosition, ok := userClaimedRewards[address][tokenId] // if user(address) ever claimed reward from tokenId + if !ok { + userClaimedRewards[address][tokenId] = make(map[string]bigint) + } + + claimedReward, ok := userClaimedRewards[address][tokenId][rewardTokenPath] // if user(address) ever claimed rewardTokenPath if !ok { if claimeRequest { // if user is claiming rewardTokenPath - userClaimedRewards[address][rewardTokenPath] = rewardAmount // add rewardTokenPath to userClaimedRewards + userClaimedRewards[address][tokenId][rewardTokenPath] = rewardAmount // add rewardTokenPath to userClaimedRewards return rewardAmount } else { // if user is not claiming rewardTokenPath return rewardAmount @@ -39,7 +44,7 @@ func userClaimedRewardAmount(address std.Address, rewardTokenPath string, reward var claimableAmount bigint if claimeRequest { // if user is claiming rewardTokenPath claimableAmount = rewardAmount - claimedReward - userClaimedRewards[address][rewardTokenPath] += claimableAmount + userClaimedRewards[address][tokenId][rewardTokenPath] += claimableAmount return claimableAmount } else { // if user is not claiming rewardTokenPath claimableAmount = rewardAmount - claimedReward @@ -83,12 +88,12 @@ func rewardMathComputeInternalRewardAmount(tokenId uint64, deposit Deposit) bigi finalRewardQ := myWholeRewardX96 * bigint(rewardRatio) finalReward := finalRewardQ / consts.Q96 / consts.Q96 / consts.Q96 / consts.Q96 / consts.Q96 / 100 / 100 - // why do we need to divide by (Q96 ^ 5) + // divide by (Q96 ^ 5) // #1 ~ 2: used by getPoolTierAndRatio() // #3 : used by poolRewardPerBlockX96 // #4 ~ 5: used by getMyLiquidityRatio() - // why do we need to divide by (100 ^ 2) + // divide by (100 ^ 2) // #1: to convert `listTierRatio()` return value to percentage // #2: to convert `getRewardRatio()` return value to percentage @@ -105,7 +110,7 @@ func rewardMathComputeExternalRewardAmount(tokenId uint64, deposit Deposit, ince monthlyReward = incentive.rewardAmount / 3 case incentiveDuration > TIMESTAMP_90DAYS: // 1 second reward == total reward amount / reward duration - monthlyReward = incentive.rewardAmount / bigint(incentiveDuration) + monthlyReward = incentive.rewardAmount / bigint(incentiveDuration) * 2592000 // 30 days default: panic(ufmt.Sprintf("[STAKER] reward_math.gno || incentiveDuration(%d) should be at least 90 days", incentiveDuration)) } diff --git a/staker/staker.gno b/staker/staker.gno index b35cd4d85..c7df3629e 100644 --- a/staker/staker.gno +++ b/staker/staker.gno @@ -6,15 +6,13 @@ import ( "gno.land/p/demo/common" "gno.land/p/demo/ufmt" - gnft "gno.land/r/demo/gnft" // GNFT, Gnoswap NFT - gns "gno.land/r/demo/gns" // GNS, Gnoswap Share + "gno.land/r/demo/consts" - pl "gno.land/r/demo/pool" - pos "gno.land/r/demo/position" -) + "gno.land/r/demo/gnft" + "gno.land/r/demo/gns" -const ( - INTERNAL_REWARD_ACCOUNT = std.Address("g1paqttvcjcluuya9n9twyw7yacv54mt7ld3gvzm") // r3v4_xxx: CHANGE WHEN DEPLOYING TO OFFICIAL NETWORK + pl "gno.land/r/demo/pool" + pn "gno.land/r/demo/position" ) var ( @@ -106,11 +104,11 @@ func StakeToken(tokenId uint64) (string, bigint, bigint) { ) // check tokenId has liquidity or not - liquidity := pos.PositionGetPositionLiquidity(tokenId) + liquidity := pn.PositionGetPositionLiquidity(tokenId) require(liquidity > 0, ufmt.Sprintf("[STAKER] staker.gno__StakeToken() || tokenId(%d) has no liquidity", tokenId)) // check pool path from tokenid - poolKey := pos.PositionGetPositionPoolKey(tokenId) + poolKey := pn.PositionGetPositionPoolKey(tokenId) // staked status deposit := deposits[tokenId] @@ -135,13 +133,13 @@ func CollectReward( require(PrevRealmAddr() == deposit.owner, ufmt.Sprintf("[STAKER] staker.gno__CollectReward() || only owner(%s) can collect reward from tokenId(%d), PrevRealmAddr()(%s)", deposit.owner, tokenId, PrevRealmAddr())) // poolPath to collect reward - poolPath := pos.PositionGetPositionPoolKey(tokenId) + poolPath := pn.PositionGetPositionPoolKey(tokenId) // get all external reward list for this pool for _, incentiveId := range poolIncentives[poolPath] { incentive := incentives[incentiveId] externalReward := rewardMathComputeExternalRewardAmount(tokenId, deposit, incentive) // external reward - externalReward = userClaimedRewardAmount(deposit.owner, incentive.rewardToken, bigint(externalReward), true) + externalReward = userClaimedRewardAmount(deposit.owner, tokenId, incentive.rewardToken, bigint(externalReward), true) if externalReward > 0 { transferByRegisterCall(incentive.rewardToken, deposit.owner, uint64(externalReward)) @@ -153,11 +151,11 @@ func CollectReward( // default `Internal` reward internalGNS := rewardMathComputeInternalRewardAmount(tokenId, deposit) - internalGNS = userClaimedRewardAmount(deposit.owner, "gno.land/r/demo/gns", bigint(internalGNS), true) + internalGNS = userClaimedRewardAmount(deposit.owner, tokenId, consts.GNS_PATH, bigint(internalGNS), true) if internalGNS > 0 { // transfer it - gns.TransferFrom(a2u(INTERNAL_REWARD_ACCOUNT), a2u(deposit.owner), uint64(internalGNS)) + gns.TransferFrom(a2u(consts.INTERNAL_REWARD_ACCOUNT), a2u(deposit.owner), uint64(internalGNS)) } } @@ -170,13 +168,13 @@ func UnstakeToken(tokenId uint64) (string, bigint, bigint) { require(PrevRealmAddr() == deposit.owner, ufmt.Sprintf("[STAKER] staker.gno__UnstakeToken() || only owner(%s) can unstake their token(%d), PrevRealmAddr()(%s)", deposit.owner, tokenId, PrevRealmAddr())) // poolPath to unstake lp token - poolPath := pos.PositionGetPositionPoolKey(tokenId) + poolPath := pn.PositionGetPositionPoolKey(tokenId) // get all external reward list for this pool for _, incentiveId := range poolIncentives[poolPath] { incentive := incentives[incentiveId] externalReward := rewardMathComputeExternalRewardAmount(tokenId, deposit, incentive) // external reward - externalReward = userClaimedRewardAmount(deposit.owner, incentive.rewardToken, externalReward, true) + externalReward = userClaimedRewardAmount(deposit.owner, tokenId, incentive.rewardToken, externalReward, true) if externalReward > 0 { transferByRegisterCall(incentive.rewardToken, deposit.owner, uint64(externalReward)) @@ -188,10 +186,10 @@ func UnstakeToken(tokenId uint64) (string, bigint, bigint) { // default `Internal` reward internalGNS := rewardMathComputeInternalRewardAmount(tokenId, deposit) - internalGNS = userClaimedRewardAmount(deposit.owner, "gno.land/r/demo/gns", internalGNS, true) + internalGNS = userClaimedRewardAmount(deposit.owner, tokenId, consts.GNS_PATH, internalGNS, true) if internalGNS > 0 { // transfer it - gns.TransferFrom(a2u(INTERNAL_REWARD_ACCOUNT), a2u(deposit.owner), uint64(internalGNS)) + gns.TransferFrom(a2u(consts.INTERNAL_REWARD_ACCOUNT), a2u(deposit.owner), uint64(internalGNS)) } // unstaked status @@ -214,7 +212,7 @@ func EndExternalIncentive(refundee, targetPoolPath, rewardToken string) { // 1. admin can end incentive without refund // 2. refundee can end incentive with refund switch GetOrigCaller() { - case std.Address("g16kvq0mra3atvr07lkdwc2x6jqmna8a4kt0e85d"): // ADMIN + case consts.GNOSWAP_ADMIN: // r3v4_xxx: // admin can end incentive without refund incentives = deleteFromIncentives(incentives, incentiveId) for i, v := range poolIncentives[targetPoolPath] { @@ -281,18 +279,18 @@ func deleteFromIncentives(m map[string]Incentive, key string) map[string]Incenti } func getTokenPairBalanceFromPosition(tokenId uint64) (bigint, bigint) { - poolKey := pos.PositionGetPositionPoolKey(tokenId) + poolKey := pn.PositionGetPositionPoolKey(tokenId) pool := pl.GetPoolFromPoolPath(poolKey) currentX96 := pool.PoolGetSlot0SqrtPriceX96() - lowerX96 := common.TickMathGetSqrtRatioAtTick(pos.PositionGetPositionTickLower(tokenId)) - upperX96 := common.TickMathGetSqrtRatioAtTick(pos.PositionGetPositionTickUpper(tokenId)) + lowerX96 := common.TickMathGetSqrtRatioAtTick(pn.PositionGetPositionTickLower(tokenId)) + upperX96 := common.TickMathGetSqrtRatioAtTick(pn.PositionGetPositionTickUpper(tokenId)) token0Balance, token1Balance := common.LiquidityAmountsGetAmountsForLiquidity( currentX96, lowerX96, upperX96, - pos.PositionGetPositionLiquidity(tokenId), + pn.PositionGetPositionLiquidity(tokenId), ) return token0Balance, token1Balance diff --git a/staker/staker_register.gno b/staker/staker_register.gno index ceabe8987..22937a775 100644 --- a/staker/staker_register.gno +++ b/staker/staker_register.gno @@ -6,9 +6,9 @@ import ( "gno.land/r/demo/users" "gno.land/p/demo/ufmt" -) -const APPROVED_CALLER = "g12l9splsyngcgefrwa52x5a7scc29e9v086m6p4" // r3v4_xxx: CHANGE WHEN DEPLOYING TO OFFICIAL NETWORK + "gno.land/r/demo/consts" +) var registered = []GRC20Pair{} @@ -53,7 +53,7 @@ func RegisterGRC20Interface(pkgPath string, igrc20 GRC20Interface) { // r3v4_xxx: however must be used in production // caller := std.GetOrigCaller() - // if caller != APPROVED_CALLER { + // if caller != consts.GNOSWAP_ADMIN { // panic("unauthorized address to register") // } @@ -69,7 +69,7 @@ func UnregisterGRC20Interface(pkgPath string) { // only admin can unregister caller := std.GetOrigCaller() - if caller != APPROVED_CALLER { + if caller != consts.GNOSWAP_ADMIN { panic("unauthorized address to unregister") }