From ca14ad1a61652b0ce8938907e5292824e01d4ed0 Mon Sep 17 00:00:00 2001 From: n3wbie Date: Tue, 27 Feb 2024 16:48:36 +0900 Subject: [PATCH 1/2] fix: fee should be collected from contract, not user --- pool/withdrawal_fee.gno | 12 ++++++------ staker/reward_fee.gno | 13 ++++++++++--- 2 files changed, 16 insertions(+), 9 deletions(-) diff --git a/pool/withdrawal_fee.gno b/pool/withdrawal_fee.gno index 43e97c95..48af294d 100644 --- a/pool/withdrawal_fee.gno +++ b/pool/withdrawal_fee.gno @@ -19,7 +19,7 @@ func HandleWithdrawalFee( token1Path string, amount1 bigint, ) (bigint, bigint) { - requirePrevRealmPath(consts.POSITION_PATH, ufmt.Sprintf("[POOL] withdrawal_fee.gno__HandleWithdrawFee() || expected PrevRealmPath(%s), got %s", consts.POSITION_PATH, PrevRealmPath())) + requirePrevRealmPath(consts.POSITION_PATH, ufmt.Sprintf("[POOL] withdrawal_fee.gno__HandleWithdrawFee() || expected std.PrevRealm().PkgPath()(%s), got %s", consts.POSITION_PATH, std.PrevRealm().PkgPath())) if withdrawalFee == 0 { return amount0, amount1 @@ -28,11 +28,11 @@ func HandleWithdrawalFee( feeAmount0 := amount0 * withdrawalFee / bigint(100) feeAmount1 := amount1 * withdrawalFee / bigint(100) - ok := transferFromByRegisterCall(token0Path, GetOrigCaller(), consts.FEE_COLLECTOR, uint64(feeAmount0)) - require(ok, ufmt.Sprintf("[POOL] withdrawal_fee.gno__HandleWithdrawFee() || expected transferFromByRegisterCall(%s, %s, %s, %s) == true", token0Path, GetOrigCaller(), consts.FEE_COLLECTOR, feeAmount0)) + ok := transferFromByRegisterCall(token0Path, std.GetOrigCaller(), consts.FEE_COLLECTOR, uint64(feeAmount0)) + require(ok, ufmt.Sprintf("[POOL] withdrawal_fee.gno__HandleWithdrawFee() || expected transferFromByRegisterCall(%s, %s, %s, %s) == true", token0Path, std.GetOrigCaller(), consts.FEE_COLLECTOR, feeAmount0)) - ok = transferFromByRegisterCall(token1Path, GetOrigCaller(), consts.FEE_COLLECTOR, uint64(feeAmount1)) - require(ok, ufmt.Sprintf("[POOL] withdrawal_fee.gno__HandleWithdrawFee() || expected transferFromByRegisterCall(%s, %s, %s, %s) == true", token1Path, GetOrigCaller(), consts.FEE_COLLECTOR, feeAmount1)) + ok = transferFromByRegisterCall(token1Path, std.GetOrigCaller(), consts.FEE_COLLECTOR, uint64(feeAmount1)) + require(ok, ufmt.Sprintf("[POOL] withdrawal_fee.gno__HandleWithdrawFee() || expected transferFromByRegisterCall(%s, %s, %s, %s) == true", token1Path, std.GetOrigCaller(), consts.FEE_COLLECTOR, feeAmount1)) return amount0 - feeAmount0, amount1 - feeAmount1 } @@ -42,7 +42,7 @@ func SetWithdrawalFee(fee bigint) { std.AssertOriginCall() // MUST BE ADMIN - require(isAdmin(GetOrigCaller()), ufmt.Sprintf("[POOL] withdrawal_fee.gno__SetFeeProtocol() || caller(%s) must be admin", GetOrigCaller())) + require(isAdmin(std.GetOrigCaller()), ufmt.Sprintf("[POOL] withdrawal_fee.gno__SetFeeProtocol() || caller(%s) must be admin", std.GetOrigCaller())) require(fee >= 0, ufmt.Sprintf("[POOL] withdrawal_fee.gno__SetFeeProtocol() || fee(%d) must be >= 0", fee)) diff --git a/staker/reward_fee.gno b/staker/reward_fee.gno index 179a4b35..76ceea94 100644 --- a/staker/reward_fee.gno +++ b/staker/reward_fee.gno @@ -15,14 +15,21 @@ var ( func handleRewardFee( tokenPath string, amount bigint, + internal bool, ) bigint { if rewardFee == 0 { return amount } feeAmount := amount * rewardFee / bigint(100) - ok := transferFromByRegisterCall(tokenPath, GetOrigCaller(), consts.FEE_COLLECTOR, uint64(feeAmount)) - require(ok, ufmt.Sprintf("[STAKER] reward_fee.gno__HandleRewardFee() || expected transferFromByRegisterCall(%s, %s, %s, %s) == true", tokenPath, GetOrigCaller(), consts.FEE_COLLECTOR, feeAmount)) + + if internal { // if internal, reward is in IRA + ok := transferFromByRegisterCall(tokenPath, consts.INTERNAL_REWARD_ACCOUNT, consts.FEE_COLLECTOR, uint64(feeAmount)) + require(ok, ufmt.Sprintf("[STAKER] reward_fee.gno__HandleRewardFee() || expected transferFromByRegisterCall(%s, %s, %s, %s) == true", tokenPath, consts.INTERNAL_REWARD_ACCOUNT, consts.FEE_COLLECTOR, feeAmount)) + } else { // if external, reward is in staker contract + ok := transferByRegisterCall(tokenPath, consts.FEE_COLLECTOR, uint64(feeAmount)) + require(ok, ufmt.Sprintf("[STAKER] reward_fee.gno__HandleRewardFee() || expected transferByRegisterCall(%s, %s, %s) == true", tokenPath, consts.FEE_COLLECTOR, feeAmount)) + } return amount - feeAmount } @@ -32,7 +39,7 @@ func SetRewardFee(fee bigint) { std.AssertOriginCall() // MUST BE ADMIN - require(consts.GNOSWAP_ADMIN == GetOrigCaller(), ufmt.Sprintf("[STAKER] reward_fee.gno__SetFeeProtocol() || caller(%s) must be admin", GetOrigCaller())) + require(consts.GNOSWAP_ADMIN == std.GetOrigCaller(), ufmt.Sprintf("[STAKER] reward_fee.gno__SetFeeProtocol() || caller(%s) must be admin", std.GetOrigCaller())) require(fee >= 0, ufmt.Sprintf("[STAKER] reward_fee.gno__SetFeeProtocol() || fee(%d) must be >= 0", fee)) From eda794d0ce33f620294e5aee6b2635ce73f11c9f Mon Sep 17 00:00:00 2001 From: n3wbie Date: Tue, 27 Feb 2024 16:49:03 +0900 Subject: [PATCH 2/2] feat: test cases init its own state, not globally --- ...o => _TEST_0_INIT_TOKEN_REGISTER_test.gno} | 28 +- ..._TEST_0_INIT_VARIABLE_AND_HELPER_test.gno} | 140 +++------- ...TEST_scenario_01_full_happy_case_test.gno} | 258 ++++++++++-------- ...cenario_02_FAIL_too_small_amount_test.gnoa | 46 ++-- ...ario_03_FAIL_too_small_liquidity_test.gnoa | 48 ++-- ...ario_04_router_one_route_one_hop_test.gnoa | 142 +++++----- ...ario_05_router_one_route_two_hop_test.gnoa | 134 ++++----- ...uter_one_route_three_hop_println_test.gnoa | 82 +++--- ...e_three_hop_large_amount_println_test.gnoa | 77 +++--- ...sition_one_route_one_hop_println_test.gnoa | 51 ++-- ...uter_only_upper_position_println_test.gnoa | 57 ++-- ..._scenario_99_router_uniswap_sdk_test.gnoa} | 69 +++-- pool/_RPC_api.gno | 7 +- ...o => _TEST_0_INIT_TOKEN_REGISTER_test.gno} | 0 ..._TEST_0_INIT_VARIABLE_AND_HELPER_test.gno} | 46 +--- ...ST_rpc_get_test.gno => _TEST_get_test.gno} | 37 ++- pool/_TEST_pool_dryswap_and_swap_test.gnoa | 23 +- pool/_TEST_pool_multi_token_test.gnoa | 122 +++++---- pool/_TEST_pool_native_swap_test.gnoa | 32 ++- pool/_TEST_pool_single_lp_test.gnoa | 43 +-- pool/_TEST_rpc_test.gnoa | 46 +++- pool/emergency_halt.gno | 4 +- pool/gno_helper.gno | 30 -- pool/pool.gno | 26 +- pool/pool_manager.gno | 9 +- .../{pool_register.gno => token_register.gno} | 0 pool/utils.gno | 2 +- position/_RPC_api.gno | 6 +- ...o => _TEST_0_INIT_TOKEN_REGISTER_test.gno} | 1 + ..._TEST_0_INIT_VARIABLE_AND_HELPER_test.gno} | 52 +--- ..._test.gnoa => _TEST_position_api_test.gno} | 25 +- ...TEST_position_increase_decrease_test.gnoa} | 56 ++-- position/_TEST_position_test.gnoa | 54 ++-- ...st_two_position_used_single_swap_test.gnoa | 39 ++- position/gno_helper.gno | 22 -- position/liquidity_management.gno | 3 +- position/position.gno | 24 +- position/util.gno | 3 +- router/_RPC_api.gno | 6 +- ...o => _TEST_0_INIT_TOKEN_REGISTER_test.gno} | 1 + .../_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno | 62 +++++ router/_TEST_INIT_basic_test.gno | 106 ------- router/_TEST_router_ratio_test.gnoa | 43 +-- ...swap_route_1route_1hop_out_range_test.gnoa | 26 +- ...EST_router_swap_route_1route_1hop_test.gno | 165 ----------- ...ST_router_swap_route_1route_1hop_test.gnoa | 172 ++++++++++++ ..._route_1route_2hop_native_in_out_test.gnoa | 87 +++--- ..._route_1route_3hop_native_middle_test.gnoa | 58 ++-- ...ST_router_swap_route_2route_2hop_test.gno} | 51 ++-- router/_TEST_routes_find_swap_path_test.gnoa | 57 ++-- router/gno_helper.gno | 9 - router/router.gno | 76 ------ router/router_dry.gno | 86 ++++++ ...router_register.gno => token_register.gno} | 0 staker/_RPC_api_incentive.gno | 7 +- staker/_RPC_api_stake.gno | 13 +- ...o => _TEST_0_INIT_TOKEN_REGISTER_test.gno} | 1 + .../_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno | 75 +++++ staker/_TEST_INIT_basic_test.gno | 131 --------- staker/_TEST_staker_collect_reward_test.gno | 225 ++++++++------- staker/_TEST_staker_get_test.gnoa | 169 +++++++----- .../_TEST_staker_internal_external_test.gnoa | 83 ++++-- ..._TEST_staker_one_external_native_test.gnoa | 217 ++++++++------- staker/_TEST_staker_one_external_test.gnoa | 215 ++++++++------- ...EST_staker_one_increase_external_test.gnoa | 238 +++++++++------- staker/_TEST_staker_rpc_get_test.gnoa | 224 ++++++++------- staker/_TEST_staker_rpc_test.gnoa | 189 ------------- staker/gno_helper.gno | 26 -- staker/incentive_id.gno | 6 +- staker/reward_math.gno | 5 +- staker/staker.gno | 35 +-- ...staker_register.gno => token_register.gno} | 0 staker/utils.gno | 2 +- 73 files changed, 2378 insertions(+), 2332 deletions(-) rename _test/{_TEST_INIT_register_tokens_test.gno => _TEST_0_INIT_TOKEN_REGISTER_test.gno} (98%) rename _test/{_TEST_INIT_basic_test.gno => _TEST_0_INIT_VARIABLE_AND_HELPER_test.gno} (54%) rename _test/{_TEST_scenario_01_full_happy_case_test.gnoa => _TEST_scenario_01_full_happy_case_test.gno} (64%) rename _test/{_TEST_scenario_99_router_uniswap_sdk_test.gno => _TEST_scenario_99_router_uniswap_sdk_test.gnoa} (80%) rename pool/{_TEST_INIT_register_tokens_test.gno => _TEST_0_INIT_TOKEN_REGISTER_test.gno} (100%) rename pool/{_TEST_INIT_basic_test.gno => _TEST_0_INIT_VARIABLE_AND_HELPER_test.gno} (53%) rename pool/{_TEST_rpc_get_test.gno => _TEST_get_test.gno} (88%) rename pool/{pool_register.gno => token_register.gno} (100%) rename position/{_TEST_INIT_register_tokens_test.gno => _TEST_0_INIT_TOKEN_REGISTER_test.gno} (99%) rename position/{_TEST_INIT_basic_test.gno => _TEST_0_INIT_VARIABLE_AND_HELPER_test.gno} (56%) rename position/{_TEST_position_api_test.gnoa => _TEST_position_api_test.gno} (78%) rename position/{_TEST_position_increase_decrease_test.gno => _TEST_position_increase_decrease_test.gnoa} (67%) rename router/{_TEST_INIT_register_tokens_test.gno => _TEST_0_INIT_TOKEN_REGISTER_test.gno} (99%) create mode 100644 router/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno delete mode 100644 router/_TEST_INIT_basic_test.gno delete mode 100644 router/_TEST_router_swap_route_1route_1hop_test.gno create mode 100644 router/_TEST_router_swap_route_1route_1hop_test.gnoa rename router/{_TEST_router_swap_route_2route_2hop_test.gnoa => _TEST_router_swap_route_2route_2hop_test.gno} (78%) create mode 100644 router/router_dry.gno rename router/{router_register.gno => token_register.gno} (100%) rename staker/{_TEST_INIT_register_tokens_test.gno => _TEST_0_INIT_TOKEN_REGISTER_test.gno} (99%) create mode 100644 staker/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno delete mode 100644 staker/_TEST_INIT_basic_test.gno delete mode 100644 staker/_TEST_staker_rpc_test.gnoa rename staker/{staker_register.gno => token_register.gno} (100%) diff --git a/_test/_TEST_INIT_register_tokens_test.gno b/_test/_TEST_0_INIT_TOKEN_REGISTER_test.gno similarity index 98% rename from _test/_TEST_INIT_register_tokens_test.gno rename to _test/_TEST_0_INIT_TOKEN_REGISTER_test.gno index a3c5400d..1640bd12 100644 --- a/_test/_TEST_INIT_register_tokens_test.gno +++ b/_test/_TEST_0_INIT_TOKEN_REGISTER_test.gno @@ -1,6 +1,8 @@ package swap_scenario import ( + "std" + "gno.land/r/demo/foo" "gno.land/r/demo/bar" @@ -15,6 +17,8 @@ import ( "gno.land/r/demo/gns" + "gno.land/r/demo/consts" + "gno.land/r/demo/users" pl "gno.land/r/demo/pool" @@ -131,30 +135,32 @@ func (GNSToken) Approve() func(spender users.AddressOrName, amount uint64) { } func init() { + std.TestSetOrigCaller(consts.GNOSWAP_ADMIN) + // POOL - pl.RegisterGRC20Interface("gno.land/r/demo/bar", BarToken{}) pl.RegisterGRC20Interface("gno.land/r/demo/foo", FooToken{}) + pl.RegisterGRC20Interface("gno.land/r/demo/bar", BarToken{}) pl.RegisterGRC20Interface("gno.land/r/demo/baz", BazToken{}) pl.RegisterGRC20Interface("gno.land/r/demo/qux", QuxToken{}) pl.RegisterGRC20Interface("gno.land/r/demo/wugnot", WugnotToken{}) pl.RegisterGRC20Interface("gno.land/r/demo/obl", OBLToken{}) pl.RegisterGRC20Interface("gno.land/r/demo/gns", GNSToken{}) - // STAKER - sr.RegisterGRC20Interface("gno.land/r/demo/bar", BarToken{}) - sr.RegisterGRC20Interface("gno.land/r/demo/foo", FooToken{}) - sr.RegisterGRC20Interface("gno.land/r/demo/baz", BazToken{}) - sr.RegisterGRC20Interface("gno.land/r/demo/qux", QuxToken{}) - sr.RegisterGRC20Interface("gno.land/r/demo/wugnot", WugnotToken{}) - sr.RegisterGRC20Interface("gno.land/r/demo/obl", OBLToken{}) - sr.RegisterGRC20Interface("gno.land/r/demo/gns", GNSToken{}) - // ROUTER - rr.RegisterGRC20Interface("gno.land/r/demo/bar", BarToken{}) rr.RegisterGRC20Interface("gno.land/r/demo/foo", FooToken{}) + rr.RegisterGRC20Interface("gno.land/r/demo/bar", BarToken{}) rr.RegisterGRC20Interface("gno.land/r/demo/baz", BazToken{}) rr.RegisterGRC20Interface("gno.land/r/demo/qux", QuxToken{}) rr.RegisterGRC20Interface("gno.land/r/demo/wugnot", WugnotToken{}) rr.RegisterGRC20Interface("gno.land/r/demo/obl", OBLToken{}) rr.RegisterGRC20Interface("gno.land/r/demo/gns", GNSToken{}) + + // STAKER + sr.RegisterGRC20Interface("gno.land/r/demo/foo", FooToken{}) + sr.RegisterGRC20Interface("gno.land/r/demo/bar", BarToken{}) + sr.RegisterGRC20Interface("gno.land/r/demo/baz", BazToken{}) + sr.RegisterGRC20Interface("gno.land/r/demo/qux", QuxToken{}) + sr.RegisterGRC20Interface("gno.land/r/demo/wugnot", WugnotToken{}) + sr.RegisterGRC20Interface("gno.land/r/demo/obl", OBLToken{}) + sr.RegisterGRC20Interface("gno.land/r/demo/gns", GNSToken{}) } diff --git a/_test/_TEST_INIT_basic_test.gno b/_test/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno similarity index 54% rename from _test/_TEST_INIT_basic_test.gno rename to _test/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno index 0fd18242..5916cb0d 100644 --- a/_test/_TEST_INIT_basic_test.gno +++ b/_test/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno @@ -5,74 +5,71 @@ import ( "strconv" "testing" - "gno.land/p/demo/grc/grc20" "gno.land/p/demo/grc/grc721" - "gno.land/r/demo/users" "gno.land/r/demo/consts" - "gno.land/r/demo/bar" - "gno.land/r/demo/baz" - "gno.land/r/demo/foo" - "gno.land/r/demo/gns" - "gno.land/r/demo/obl" - "gno.land/r/demo/qux" - - "gno.land/r/demo/wugnot" -) - -const ( - MAX_TIMEOUT bigint = 9999999999 + "gno.land/r/demo/users" ) var ( - test1 std.Address + gsa std.Address = consts.GNOSWAP_ADMIN + test1 std.Address = std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") - barPath = "gno.land/r/demo/bar" - barObj = bar.GetGRC20() + fooPath string = "gno.land/r/demo/foo" + barPath string = "gno.land/r/demo/bar" + bazPath string = "gno.land/r/demo/baz" + quxPath string = "gno.land/r/demo/qux" - bazPath = "gno.land/r/demo/baz" - bazObj = baz.GetGRC20() + oblPath string = "gno.land/r/demo/obl" + // wugnotPath string = "gno.land/r/demo/wugnot" // from consts + // gnsPath string = "gno.land/r/demo/gns" // from consts - fooPath = "gno.land/r/demo/foo" - fooObj = foo.GetGRC20() + fee100 uint16 = 100 + fee500 uint16 = 500 + fee3000 uint16 = 3000 - quxPath = "gno.land/r/demo/qux" - quxObj = qux.GetGRC20() - - wugnotPath = "gno.land/r/demo/wugnot" - // wugnotObj = wugnot.GetGRC20() - - gnsPath = "gno.land/r/demo/gns" - gnsObj = gns.GetGRC20() - - oblPath = "gno.land/r/demo/obl" - oblObj = obl.GetGRC20() - - fee100 = uint16(100) - fee500 = uint16(500) - fee3000 = uint16(3000) + max_timeout bigint = 9999999999 ) -func init() { - test1 = std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") - // prepare ugnot +/* UTIL */ +func ugnotBalanceOf(addr std.Address) uint64 { testBanker := std.GetBanker(std.BankerTypeRealmIssue) - testBanker.IssueCoin(test1, "ugnot", 500_000_000_000_000) - std.TestSetPrevAddr(test1) + coins := testBanker.GetCoins(addr) + if len(coins) == 0 { + return 0 + } - gns.Approve(a2u(consts.POOL_ADDR), 500_000_000_000_000) + return uint64(testBanker.GetCoins(addr)[0].Amount) +} - 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) +func a2u(addr std.Address) users.AddressOrName { + return users.AddressOrName(addr) +} - wugnot.Approve(a2u(consts.POOL_ADDR), 500_000_000_000_000) +func tid(tokenId interface{}) grc721.TokenID { + if tokenId == nil { + panic("tid() || tokenId is nil") + } + switch tokenId.(type) { + case bigint: + return grc721.TokenID(string(tokenId.(bigint))) + case string: + return grc721.TokenID(tokenId.(string)) + case int: + return grc721.TokenID(strconv.Itoa(tokenId.(int))) + case uint64: + return grc721.TokenID(strconv.Itoa(int(tokenId.(uint64)))) + case grc721.TokenID: + return tokenId.(grc721.TokenID) + default: + panic("[STAKER] utils.gno__tid() || unsupported tokenId type") + } } -/* HELPER */ +/* TEST HELPER */ func shouldEQ(t *testing.T, got, expected interface{}) { if got != expected { t.Errorf("got %v, expected %v", got, expected) @@ -118,52 +115,3 @@ func shouldPanicWithMsg(t *testing.T, f func(), msg string) { }() f() } - -func balanceOf(token *grc20.AdminToken, addr std.Address) uint64 { - balance, err := token.BalanceOf(addr) - if err != nil { - panic(err) - } - - return balance -} - -func a2u(addr std.Address) users.AddressOrName { - return users.AddressOrName(addr) -} - -func tid(tokenId interface{}) grc721.TokenID { - if tokenId == nil { - panic("tid() || tokenId is nil") - } - - switch tokenId.(type) { - case bigint: - return grc721.TokenID(string(tokenId.(bigint))) - case string: - return grc721.TokenID(tokenId.(string)) - case int: - return grc721.TokenID(strconv.Itoa(tokenId.(int))) - case uint64: - return grc721.TokenID(strconv.Itoa(int(tokenId.(uint64)))) - case grc721.TokenID: - return tokenId.(grc721.TokenID) - default: - panic("[STAKER] utils.gno__tid() || unsupported tokenId type") - } -} - -func ugnotBalanceOf(addr std.Address) uint64 { - testBanker := std.GetBanker(std.BankerTypeRealmIssue) - - coins := testBanker.GetCoins(addr) - if len(coins) == 0 { - return 0 - } - - return uint64(testBanker.GetCoins(addr)[0].Amount) -} - -func wugnotBalanceOf(addr std.Address) uint64 { - return wugnot.BalanceOf(a2u(addr)) -} diff --git a/_test/_TEST_scenario_01_full_happy_case_test.gnoa b/_test/_TEST_scenario_01_full_happy_case_test.gno similarity index 64% rename from _test/_TEST_scenario_01_full_happy_case_test.gnoa rename to _test/_TEST_scenario_01_full_happy_case_test.gno index b2f851c4..41411864 100644 --- a/_test/_TEST_scenario_01_full_happy_case_test.gnoa +++ b/_test/_TEST_scenario_01_full_happy_case_test.gno @@ -32,17 +32,15 @@ var ( ) func TestPoolInitByAdmin(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetOrigCaller(gsa) pl.InitManual() + std.TestSkipHeights(1) } func TestPoolCreatePools(t *testing.T) { - std.TestSetOrigCaller(test1) - - // approve gns to CreatePool (500 gns for 1 pool) - gns.Approve(a2u(consts.POOL_ADDR), 500*10) // x10 pools + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*4) // bar-baz pl.CreatePool(barPath, bazPath, 100, common.TickMathGetSqrtRatioAtTick(29960)) // 1:20 @@ -51,10 +49,10 @@ func TestPoolCreatePools(t *testing.T) { pl.CreatePool(bazPath, fooPath, 100, common.TickMathGetSqrtRatioAtTick(-23030)) // 1:0.1 // foo-wugnot - pl.CreatePool(fooPath, wugnotPath, 100, common.TickMathGetSqrtRatioAtTick(-29960)) // 1:0.05 + pl.CreatePool(fooPath, consts.WRAPPED_WUGNOT, 100, common.TickMathGetSqrtRatioAtTick(-29960)) // 1:0.05 // gns-wugnot - pl.CreatePool(gnsPath, wugnotPath, 500, common.TickMathGetSqrtRatioAtTick(0)) // 1:1 + pl.CreatePool(consts.GNS_PATH, consts.WRAPPED_WUGNOT, 500, common.TickMathGetSqrtRatioAtTick(0)) // 1:1 std.TestSkipHeights(5) } @@ -62,23 +60,23 @@ func TestPoolCreatePools(t *testing.T) { func TestFaucetLP01(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 0) - shouldEQ(t, balanceOf(bazObj, lp01), 0) - shouldEQ(t, balanceOf(fooObj, lp01), 0) - shouldEQ(t, balanceOf(quxObj, lp01), 0) - shouldEQ(t, balanceOf(gnsObj, lp01), 0) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, qux.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, gns.BalanceOf(a2u(lp01)), 0) + foo.Faucet(lp01) bar.Faucet(lp01) baz.Faucet(lp01) - foo.Faucet(lp01) qux.Faucet(lp01) gns.Faucet(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 100000000) - shouldEQ(t, balanceOf(bazObj, lp01), 100000000) - shouldEQ(t, balanceOf(fooObj, lp01), 100000000) - shouldEQ(t, balanceOf(quxObj, lp01), 100000000) - shouldEQ(t, balanceOf(gnsObj, lp01), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, qux.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, gns.BalanceOf(a2u(lp01)), 100000000) std.TestSkipHeights(5) } @@ -100,13 +98,13 @@ func TestPositionMintBarBazInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(1)) - shouldEQ(t, liquidity, bigint(4473213901)) + shouldEQ(t, liquidity, bigint(4473213900)) shouldEQ(t, amount0, bigint(499941)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -129,13 +127,13 @@ func TestPositionMintBarBazLowerRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(2)) - shouldEQ(t, liquidity, bigint(4484410365)) + shouldEQ(t, liquidity, bigint(4484410364)) shouldEQ(t, amount0, bigint(0)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -158,12 +156,12 @@ func TestPositionMintBarBazUpperRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(3)) - shouldEQ(t, liquidity, bigint(470937835)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(470937834)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(0)) std.TestSkipHeights(3) @@ -186,12 +184,12 @@ func TestPositionMintBazFooInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(4)) - shouldEQ(t, liquidity, bigint(3163542979)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(3163542978)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(999700)) std.TestSkipHeights(3) @@ -214,21 +212,21 @@ func TestPositionMintFooGnotInRange(t *testing.T) { wugnot.Approve(a2u(consts.POOL_ADDR), 10000000) tokenId, liquidity, amount0, amoutn1 := pn.Mint( - fooPath, // token0 - wugnotPath, // token1 - 100, // fee - -30960, // tickLower - -28960, // tickUpper - 10000000, // amount0Desired - 10000000, // amount1Desired - 0, // amount0Min - 0, // amount1Min - MAX_TIMEOUT, // deadline + fooPath, // token0 + consts.WRAPPED_WUGNOT, // token1 + 100, // fee + -30960, // tickLower + -28960, // tickUpper + 10000000, // amount0Desired + 10000000, // amount1Desired + 0, // amount0Min + 0, // amount1Min + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(5)) - shouldEQ(t, liquidity, bigint(45848242)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(45848241)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(499941)) std.TestSkipHeights(4) @@ -252,22 +250,22 @@ func TestPositionMintGnsGnotInRange(t *testing.T) { wugnot.Approve(a2u(consts.POOL_ADDR), 10000000) tokenId, liquidity, amount0, amoutn1 := pn.Mint( - gnsPath, // token0 - wugnotPath, // token1 - 500, // fee - -1000, // tickLower - 1000, // tickUpper - 10000000, // amount0Desired - 10000000, // amount1Desired - 0, // amount0Min - 0, // amount1Min - MAX_TIMEOUT, // deadline + consts.GNS_PATH, // token0 + consts.WRAPPED_WUGNOT, // token1 + 500, // fee + -1000, // tickLower + 1000, // tickUpper + 10000000, // amount0Desired + 10000000, // amount1Desired + 0, // amount0Min + 0, // amount1Min + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(6)) - shouldEQ(t, liquidity, bigint(205051663)) - shouldEQ(t, amount0, bigint(10000000)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, liquidity, bigint(205051662)) + shouldEQ(t, amount0, bigint(9999999)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(4) } @@ -312,16 +310,22 @@ func TestStakerStakeTokenForExternalReward(t *testing.T) { std.TestSkipHeights(2) } +func TestApproveGNS(t *testing.T) { + std.TestSetOrigCaller(consts.INTERNAL_REWARD_ACCOUNT) + gns.Approve(a2u(consts.STAKER_ADDR), uint64(consts.MAX_UINT64)) // internal reward distribution + std.TestSkipHeights(1) +} + func TestStakerCollectInternalReward(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(gnsObj, lp01), 90000000) - shouldEQ(t, balanceOf(oblObj, lp01), 0) + shouldEQ(t, gns.BalanceOf(a2u(lp01)), 90000001) + shouldEQ(t, obl.BalanceOf(a2u(lp01)), 0) sr.CollectReward(6) - shouldEQ(t, balanceOf(gnsObj, lp01), 90003300) - shouldEQ(t, balanceOf(oblObj, lp01), 0) + shouldEQ(t, gns.BalanceOf(a2u(lp01)), 90003268) + shouldEQ(t, obl.BalanceOf(a2u(lp01)), 0) std.TestSkipHeights(1) } @@ -329,13 +333,13 @@ func TestStakerCollectInternalReward(t *testing.T) { func TestStakerCollectExternalReward(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(gnsObj, lp01), 90003300) - shouldEQ(t, balanceOf(oblObj, lp01), 0) + shouldEQ(t, gns.BalanceOf(a2u(lp01)), 90003268) + shouldEQ(t, obl.BalanceOf(a2u(lp01)), 0) sr.CollectReward(1) - shouldEQ(t, balanceOf(gnsObj, lp01), 90003300) - shouldEQ(t, balanceOf(oblObj, lp01), 21) + shouldEQ(t, gns.BalanceOf(a2u(lp01)), 90003268) + shouldEQ(t, obl.BalanceOf(a2u(lp01)), 21) std.TestSkipHeights(1) } @@ -343,32 +347,49 @@ func TestStakerCollectExternalReward(t *testing.T) { func TestFaucetTR01(t *testing.T) { std.TestSetOrigCaller(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 0) - shouldEQ(t, balanceOf(bazObj, tr01), 0) - shouldEQ(t, balanceOf(fooObj, tr01), 0) - shouldEQ(t, balanceOf(quxObj, tr01), 0) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, qux.BalanceOf(a2u(tr01)), 0) bar.Faucet(tr01) baz.Faucet(tr01) foo.Faucet(tr01) qux.Faucet(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 100000000) - shouldEQ(t, balanceOf(bazObj, tr01), 100000000) - shouldEQ(t, balanceOf(fooObj, tr01), 100000000) - shouldEQ(t, balanceOf(quxObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, qux.BalanceOf(a2u(tr01)), 100000000) std.TestSkipHeights(5) } +func TestRouterDrySwapRouteBarBazExactIn(t *testing.T) { + std.TestSetOrigCaller(tr01) + + dryResult := rr.DrySwapRoute( + barPath, // inputToken + bazPath, // outputToken + 100000, // amountSpecified + "EXACT_IN", // swapType + "gno.land/r/demo/bar:gno.land/r/demo/baz:100", // strRouteArr + "100", // quoteArr + ) + shouldEQ(t, dryResult, bigint(1999835)) + + std.TestSkipHeights(1) +} + func TestRouterSwapRouteBarBazExactIn(t *testing.T) { std.TestSetOrigCaller(tr01) // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 100000) + baz.Approve(a2u(consts.ROUTER_ADDR), 3000) // 0.15% of 1999835 - shouldEQ(t, balanceOf(barObj, tr01), 100000000) - shouldEQ(t, balanceOf(bazObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 100000000) swapResult := rr.SwapRoute( barPath, // inputToken @@ -379,10 +400,10 @@ func TestRouterSwapRouteBarBazExactIn(t *testing.T) { "100", // quoteArr 1, // tokenAmountLimit ) - shouldEQ(t, swapResult, bigint(1999835)) + shouldEQ(t, swapResult, bigint(1996836)) - shouldEQ(t, balanceOf(barObj, tr01), 99900000) - shouldEQ(t, balanceOf(bazObj, tr01), 101999835) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99900000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 101996836) std.TestSkipHeights(2) } @@ -392,9 +413,10 @@ func TestRouterSwapRouteBarBazExactOut(t *testing.T) { // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 100000) + baz.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) - shouldEQ(t, balanceOf(barObj, tr01), 99900000) - shouldEQ(t, balanceOf(bazObj, tr01), 101999835) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99900000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 101996836) swapResult := rr.SwapRoute( barPath, // inputToken @@ -407,8 +429,8 @@ func TestRouterSwapRouteBarBazExactOut(t *testing.T) { ) shouldEQ(t, swapResult, bigint(5000)) - shouldEQ(t, balanceOf(barObj, tr01), 99895000) - shouldEQ(t, balanceOf(bazObj, tr01), 102099835) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99895000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 102096686) std.TestSkipHeights(2) } @@ -418,23 +440,24 @@ func TestRouterSwapRouteBarBazFooWgnotExactIn(t *testing.T) { // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 100000) + wugnot.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) - shouldEQ(t, balanceOf(barObj, tr01), 99895000) - shouldEQ(t, wugnotBalanceOf(tr01), 0) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99895000) + shouldEQ(t, wugnot.BalanceOf(a2u(tr01)), 0) swapResult := rr.SwapRoute( - barPath, // inputToken - wugnotPath, // outputToken - 100000, // amountSpecified - "EXACT_IN", // swapType + barPath, // inputToken + consts.WRAPPED_WUGNOT, // outputToken + 100000, // amountSpecified + "EXACT_IN", // swapType "gno.land/r/demo/bar:gno.land/r/demo/baz:100*POOL*gno.land/r/demo/baz:gno.land/r/demo/foo:100*POOL*gno.land/r/demo/foo:gno.land/r/demo/wugnot:100", // strRouteArr "100", // quoteArr 1, // tokenAmountLimit ) - shouldEQ(t, swapResult, bigint(9979)) + shouldEQ(t, swapResult, bigint(9965)) - shouldEQ(t, balanceOf(barObj, tr01), 99795000) - shouldEQ(t, wugnotBalanceOf(tr01), 9979) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99795000) + shouldEQ(t, wugnot.BalanceOf(a2u(tr01)), 9965) std.TestSkipHeights(2) } @@ -453,23 +476,24 @@ func TestRouterSwapRouteWgnotFooBazBarExactIn(t *testing.T) { // approve wugnot to pool wugnot.Approve(a2u(consts.POOL_ADDR), 100000) + bar.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) - shouldEQ(t, wugnotBalanceOf(tr01), 109979) - shouldEQ(t, balanceOf(barObj, tr01), 99795000) + shouldEQ(t, wugnot.BalanceOf(a2u(tr01)), 109965) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99795000) swapResult := rr.SwapRoute( - wugnotPath, // inputToken - barPath, // outputToken - 100000, // amountSpecified - "EXACT_OUT", // swapType + consts.WRAPPED_WUGNOT, // inputToken + barPath, // outputToken + 100000, // amountSpecified + "EXACT_OUT", // swapType "gno.land/r/demo/wugnot:gno.land/r/demo/foo:100*POOL*gno.land/r/demo/foo:gno.land/r/demo/baz:100*POOL*gno.land/r/demo/baz:gno.land/r/demo/bar:100", // strRouteArr "100", // quoteArr 300000, // tokenAmountLimit ) shouldEQ(t, swapResult, bigint(9958)) - shouldEQ(t, balanceOf(barObj, tr01), 99894938) - shouldEQ(t, wugnotBalanceOf(tr01), 100021) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99894789) + shouldEQ(t, wugnot.BalanceOf(a2u(tr01)), 100007) std.TestSkipHeights(3) } @@ -480,7 +504,7 @@ func TestPositionCollectFeeLpTokenId_1(t *testing.T) { tokenId, amount0, amount1, poolPath := pn.CollectFee(1) shouldEQ(t, tokenId, uint64(1)) shouldEQ(t, amount0, bigint(19)) - shouldEQ(t, amount1, bigint(200)) + shouldEQ(t, amount1, bigint(198)) shouldEQ(t, poolPath, "gno.land/r/demo/bar:gno.land/r/demo/baz:100") std.TestSkipHeights(1) @@ -493,7 +517,7 @@ func TestPositionCollectFeeLpTokenId_4(t *testing.T) { tokenId, amount0, amount1, poolPath := pn.CollectFee(4) shouldEQ(t, tokenId, uint64(4)) - shouldEQ(t, amount0, bigint(199)) + shouldEQ(t, amount0, bigint(198)) shouldEQ(t, amount1, bigint(20)) shouldEQ(t, poolPath, "gno.land/r/demo/baz:gno.land/r/demo/foo:100") @@ -512,10 +536,18 @@ func TestPositionCollectFeeLpTokenId_5(t *testing.T) { std.TestSkipHeights(1) } -func TestPositionBurnStakedPosition(t *testing.T) { +func TestPositionDecreaseLiquidityStakedPosition(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldPanic(t, func() { pn.Burn(1) }) - // can not burn staked position ( unstake first) + shouldPanic(t, func() { + pn.DecreaseLiquidity( + 1, + consts.MAX_UINT256, + 0, + 0, + max_timeout, + ) + }) + // can not decrase liquidity at staked position (unstake first) std.TestSkipHeights(1) } @@ -532,10 +564,16 @@ func TestStakerUnstake(t *testing.T) { std.TestSkipHeights(1) } -func TestPositionBurnUnstakedPosition(t *testing.T) { - tokenId, liquidity, amount0, amount1, poolPath := pn.Burn(1) +func TestPositionDecreaseLiquidityUnstakedPosition(t *testing.T) { + tokenId, liquidity, amount0, amount1, poolPath := pn.DecreaseLiquidity( + 1, + consts.MAX_UINT256, + 0, + 0, + max_timeout, + ) shouldEQ(t, tokenId, uint64(1)) - shouldEQ(t, liquidity, bigint(4473213901)) + shouldEQ(t, liquidity, bigint(4473213900)) shouldEQ(t, amount0, bigint(604982)) shouldEQ(t, amount1, bigint(7899135)) shouldEQ(t, poolPath, "gno.land/r/demo/bar:gno.land/r/demo/baz:100") @@ -547,15 +585,15 @@ func TestStakerEndExternalIncentive(t *testing.T) { std.TestSetOrigCaller(test1) std.TestSkipHeights(1382371) - shouldEQ(t, balanceOf(oblObj, test1), 499999900000000) + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499999900000000) shouldPanic(t, func() { - sr.EndExternalIncentive(string(test1), "gno.land/r/demo/bar:gno.land/r/demo/baz:100", "gno.land/r/demo/obl") + sr.EndExternalIncentive(test1, "gno.land/r/demo/bar:gno.land/r/demo/baz:100", "gno.land/r/demo/obl") }) std.TestSkipHeights(1234567) - sr.EndExternalIncentive(string(test1), "gno.land/r/demo/bar:gno.land/r/demo/baz:100", "gno.land/r/demo/obl") + sr.EndExternalIncentive(test1, "gno.land/r/demo/bar:gno.land/r/demo/baz:100", "gno.land/r/demo/obl") - shouldEQ(t, balanceOf(oblObj, test1), 499999999999979) + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499999999999979) } diff --git a/_test/_TEST_scenario_02_FAIL_too_small_amount_test.gnoa b/_test/_TEST_scenario_02_FAIL_too_small_amount_test.gnoa index d23a0bb8..471ad089 100644 --- a/_test/_TEST_scenario_02_FAIL_too_small_amount_test.gnoa +++ b/_test/_TEST_scenario_02_FAIL_too_small_amount_test.gnoa @@ -28,17 +28,15 @@ var ( ) func TestPoolInitByAdmin(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetOrigCaller(gsa) pl.InitManual() + std.TestSkipHeights(1) } func TestPoolCreatePools(t *testing.T) { - std.TestSetOrigCaller(test1) - - // approve gns to CreatePool ( 500 gns for 1 pool) - gns.Approve(a2u(consts.POOL_ADDR), 5000) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*2) // bar-baz pl.CreatePool(barPath, bazPath, 100, 354340008410679467268648495215) // tick 29960 ≈ 1:20 @@ -46,23 +44,23 @@ func TestPoolCreatePools(t *testing.T) { // baz-foo pl.CreatePool(bazPath, fooPath, 100, 79228162514264337593543950337) // tick 0 ≈ 1:1 - std.TestSkipHeights(4) + std.TestSkipHeights(2) } func TestFaucetLP01(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 0) - shouldEQ(t, balanceOf(bazObj, lp01), 0) - shouldEQ(t, balanceOf(fooObj, lp01), 0) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 0) bar.Faucet(lp01) baz.Faucet(lp01) foo.Faucet(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 100000000) - shouldEQ(t, balanceOf(bazObj, lp01), 100000000) - shouldEQ(t, balanceOf(fooObj, lp01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 100000000) std.TestSkipHeights(5) } @@ -84,13 +82,13 @@ func TestPositionMintBarBazInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(1)) - shouldEQ(t, liquidity, bigint(4473213901)) + shouldEQ(t, liquidity, bigint(4473213900)) shouldEQ(t, amount0, bigint(499941)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -112,13 +110,13 @@ func TestPositionMintBazFooInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(2)) - shouldEQ(t, liquidity, bigint(205051663)) - shouldEQ(t, amount0, bigint(10000000)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, liquidity, bigint(205051662)) + shouldEQ(t, amount0, bigint(9999999)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -126,14 +124,14 @@ func TestPositionMintBazFooInRange(t *testing.T) { func TestFaucetTR01(t *testing.T) { std.TestSetOrigCaller(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 0) - shouldEQ(t, balanceOf(bazObj, tr01), 0) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 0) bar.Faucet(tr01) baz.Faucet(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 100000000) - shouldEQ(t, balanceOf(bazObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 100000000) std.TestSkipHeights(5) } diff --git a/_test/_TEST_scenario_03_FAIL_too_small_liquidity_test.gnoa b/_test/_TEST_scenario_03_FAIL_too_small_liquidity_test.gnoa index 90c3aee2..d2074742 100644 --- a/_test/_TEST_scenario_03_FAIL_too_small_liquidity_test.gnoa +++ b/_test/_TEST_scenario_03_FAIL_too_small_liquidity_test.gnoa @@ -27,17 +27,15 @@ var ( ) func TestPoolInitByAdmin(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetOrigCaller(gsa) pl.InitManual() + std.TestSkipHeights(1) } func TestPoolCreatePools(t *testing.T) { - std.TestSetOrigCaller(test1) - - // approve gns to CreatePool ( 500 gns for 1 pool) - gns.Approve(a2u(consts.POOL_ADDR), 5000) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*2) // bar-baz pl.CreatePool(barPath, bazPath, 100, 354340008410679467268648495215) // tick 29960 ≈ 1:20 @@ -45,23 +43,23 @@ func TestPoolCreatePools(t *testing.T) { // baz-foo pl.CreatePool(bazPath, fooPath, 100, 79228162514264337593543950337) // tick 0 ≈ 1:1 - std.TestSkipHeights(4) + std.TestSkipHeights(2) } func TestFaucetLP01(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 0) - shouldEQ(t, balanceOf(bazObj, lp01), 0) - shouldEQ(t, balanceOf(fooObj, lp01), 0) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 0) bar.Faucet(lp01) baz.Faucet(lp01) foo.Faucet(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 100000000) - shouldEQ(t, balanceOf(bazObj, lp01), 100000000) - shouldEQ(t, balanceOf(fooObj, lp01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 100000000) std.TestSkipHeights(5) } @@ -83,13 +81,13 @@ func TestPositionMintBarBazInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(1)) - shouldEQ(t, liquidity, bigint(4473213901)) + shouldEQ(t, liquidity, bigint(4473213900)) shouldEQ(t, amount0, bigint(499941)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -111,13 +109,13 @@ func TestPositionMintBazFooInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(2)) - shouldEQ(t, liquidity, bigint(205051663)) - shouldEQ(t, amount0, bigint(10000000)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, liquidity, bigint(205051662)) + shouldEQ(t, amount0, bigint(9999999)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -125,16 +123,16 @@ func TestPositionMintBazFooInRange(t *testing.T) { func TestFaucetTR01(t *testing.T) { std.TestSetOrigCaller(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 0) - shouldEQ(t, balanceOf(bazObj, tr01), 0) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 0) bar.Faucet(tr01) baz.Faucet(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 100000000) - shouldEQ(t, balanceOf(bazObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 100000000) - std.TestSkipHeights(5) + std.TestSkipHeights(2) } func TestRouterDrySwapBarBazExactIn(t *testing.T) { diff --git a/_test/_TEST_scenario_04_router_one_route_one_hop_test.gnoa b/_test/_TEST_scenario_04_router_one_route_one_hop_test.gnoa index a88d438e..752134ec 100644 --- a/_test/_TEST_scenario_04_router_one_route_one_hop_test.gnoa +++ b/_test/_TEST_scenario_04_router_one_route_one_hop_test.gnoa @@ -33,17 +33,15 @@ var ( ) func TestPoolInitByAdmin(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetOrigCaller(gsa) pl.InitManual() + std.TestSkipHeights(1) } func TestPoolCreatePools(t *testing.T) { - std.TestSetOrigCaller(test1) - - // approve gns to CreatePool ( 500 gns for 1 pool) - gns.Approve(a2u(consts.POOL_ADDR), 5000) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*3) // bar-baz pl.CreatePool(barPath, bazPath, 100, 354340008410679467268648495215) // tick 29960 ≈ 1:20 @@ -52,30 +50,30 @@ func TestPoolCreatePools(t *testing.T) { pl.CreatePool(bazPath, fooPath, 100, 25050389945027294416741547334) // tick -23030 ≈ 1:0.1 // foo-wugnot - pl.CreatePool(fooPath, wugnotPath, 100, 17714911063927984461157312042) // tick -29960 ≈ 1:0.05 + pl.CreatePool(fooPath, consts.WRAPPED_WUGNOT, 100, 17714911063927984461157312042) // tick -29960 ≈ 1:0.05 - std.TestSkipHeights(4) + std.TestSkipHeights(3) } func TestFaucetLP01(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 0) - shouldEQ(t, balanceOf(bazObj, lp01), 0) - shouldEQ(t, balanceOf(fooObj, lp01), 0) - shouldEQ(t, balanceOf(quxObj, lp01), 0) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, qux.BalanceOf(a2u(lp01)), 0) bar.Faucet(lp01) baz.Faucet(lp01) foo.Faucet(lp01) qux.Faucet(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 100000000) - shouldEQ(t, balanceOf(bazObj, lp01), 100000000) - shouldEQ(t, balanceOf(fooObj, lp01), 100000000) - shouldEQ(t, balanceOf(quxObj, lp01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, qux.BalanceOf(a2u(lp01)), 100000000) - std.TestSkipHeights(5) + std.TestSkipHeights(4) } func TestpnitionMintBarBazInRange(t *testing.T) { @@ -95,13 +93,13 @@ func TestpnitionMintBarBazInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(1)) - shouldEQ(t, liquidity, bigint(4473213901)) + shouldEQ(t, liquidity, bigint(4473213900)) shouldEQ(t, amount0, bigint(499941)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -124,13 +122,13 @@ func TestpnitionMintBarBazLowerRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(2)) - shouldEQ(t, liquidity, bigint(4484410365)) + shouldEQ(t, liquidity, bigint(4484410364)) shouldEQ(t, amount0, bigint(0)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -153,12 +151,12 @@ func TestpnitionMintBarBazUpperRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(3)) - shouldEQ(t, liquidity, bigint(470937835)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(470937834)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(0)) std.TestSkipHeights(3) @@ -181,12 +179,12 @@ func TestpnitionMintBazFooInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(4)) - shouldEQ(t, liquidity, bigint(3163542979)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(3163542978)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(999700)) std.TestSkipHeights(3) @@ -209,21 +207,21 @@ func TestpnitionMintFooGnotInRange(t *testing.T) { wugnot.Approve(a2u(consts.POOL_ADDR), 10000000) tokenId, liquidity, amount0, amoutn1 := pn.Mint( - fooPath, // token0 - wugnotPath, // token1 - 100, // fee - -30960, // tickLower - -28960, // tickUpper - 10000000, // amount0Desired - 10000000, // amount1Desired - 0, // amount0Min - 0, // amount1Min - MAX_TIMEOUT, // deadline + fooPath, // token0 + consts.WRAPPED_WUGNOT, // token1 + 100, // fee + -30960, // tickLower + -28960, // tickUpper + 10000000, // amount0Desired + 10000000, // amount1Desired + 0, // amount0Min + 0, // amount1Min + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(5)) - shouldEQ(t, liquidity, bigint(45848242)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(45848241)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(499941)) std.TestSkipHeights(4) @@ -262,42 +260,52 @@ func TestStakerStakeToken(t *testing.T) { // stake tokenId 1 sr.StakeToken(1) std.TestSkipHeights(3) + + // spend some time + std.TestSkipHeights(100) +} + +func TestApproveGNS(t *testing.T) { + std.TestSetOrigCaller(consts.INTERNAL_REWARD_ACCOUNT) + gns.Approve(a2u(consts.STAKER_ADDR), uint64(consts.MAX_UINT64)) // internal reward distribution + std.TestSkipHeights(1) } func TestStakerCollectReward(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(gnsObj, lp01), 0) - shouldEQ(t, balanceOf(oblObj, lp01), 0) + shouldEQ(t, gns.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, obl.BalanceOf(a2u(lp01)), 0) + obl.Approve(a2u(consts.STAKER_ADDR), uint64(consts.MAX_UINT64)) sr.CollectReward(1) - shouldEQ(t, balanceOf(gnsObj, lp01), 0) // not internal reward pool - shouldEQ(t, balanceOf(oblObj, lp01), 21) + shouldEQ(t, gns.BalanceOf(a2u(lp01)), 0) // not internal reward pool + shouldEQ(t, obl.BalanceOf(a2u(lp01)), 21) } func TestFaucetTR01(t *testing.T) { std.TestSetOrigCaller(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 0) - shouldEQ(t, balanceOf(bazObj, tr01), 0) - shouldEQ(t, balanceOf(fooObj, tr01), 0) - shouldEQ(t, balanceOf(quxObj, tr01), 0) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, qux.BalanceOf(a2u(tr01)), 0) bar.Faucet(tr01) baz.Faucet(tr01) foo.Faucet(tr01) qux.Faucet(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 100000000) - shouldEQ(t, balanceOf(bazObj, tr01), 100000000) - shouldEQ(t, balanceOf(fooObj, tr01), 100000000) - shouldEQ(t, balanceOf(quxObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, qux.BalanceOf(a2u(tr01)), 100000000) std.TestSkipHeights(5) } -func TestrrterDrySwapRouteBarBazExactIn(t *testing.T) { +func TestRouterDrySwapRouteBarBazExactIn(t *testing.T) { std.TestSetOrigCaller(tr01) dryResult := rr.DrySwapRoute( @@ -312,14 +320,15 @@ func TestrrterDrySwapRouteBarBazExactIn(t *testing.T) { std.TestSkipHeights(2) } -func TestrrterSwapRouteBarBazExactIn(t *testing.T) { +func TestRouterSwapRouteBarBazExactIn(t *testing.T) { std.TestSetOrigCaller(tr01) // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 100000) + baz.Approve(a2u(consts.ROUTER_ADDR), 3000) // 0.15% of 1999835 - shouldEQ(t, balanceOf(barObj, tr01), 100000000) - shouldEQ(t, balanceOf(bazObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 100000000) swapResult := rr.SwapRoute( barPath, // inputToken @@ -330,15 +339,15 @@ func TestrrterSwapRouteBarBazExactIn(t *testing.T) { "100", // quoteArr 1, // tokenAmountLimit (minRecv) ) - shouldEQ(t, swapResult, bigint(1999835)) + shouldEQ(t, swapResult, bigint(1996836)) - shouldEQ(t, balanceOf(barObj, tr01), 99900000) - shouldEQ(t, balanceOf(bazObj, tr01), 101999835) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99900000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 101996836) std.TestSkipHeights(2) } -func TestrrterDrySwapRouteBarBazExactOutAfterSwap(t *testing.T) { +func TestRouterDrySwapRouteBarBazExactOutAfterSwap(t *testing.T) { std.TestSetOrigCaller(tr01) dryResult := rr.DrySwapRoute( @@ -353,14 +362,15 @@ func TestrrterDrySwapRouteBarBazExactOutAfterSwap(t *testing.T) { std.TestSkipHeights(2) } -func TestrrterSwapRouteBarBazExactOutAfterSwap(t *testing.T) { +func TestRouterSwapRouteBarBazExactOutAfterSwap(t *testing.T) { std.TestSetOrigCaller(tr01) // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 100000) + baz.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) - shouldEQ(t, balanceOf(barObj, tr01), 99900000) - shouldEQ(t, balanceOf(bazObj, tr01), 101999835) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99900000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 101996836) swapResult := rr.SwapRoute( barPath, // inputToken @@ -373,8 +383,8 @@ func TestrrterSwapRouteBarBazExactOutAfterSwap(t *testing.T) { ) shouldEQ(t, swapResult, bigint(5000)) - shouldEQ(t, balanceOf(barObj, tr01), 99895000) - shouldEQ(t, balanceOf(bazObj, tr01), 102099835) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99895000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 102096686) std.TestSkipHeights(2) } diff --git a/_test/_TEST_scenario_05_router_one_route_two_hop_test.gnoa b/_test/_TEST_scenario_05_router_one_route_two_hop_test.gnoa index d161cb26..3ed64caf 100644 --- a/_test/_TEST_scenario_05_router_one_route_two_hop_test.gnoa +++ b/_test/_TEST_scenario_05_router_one_route_two_hop_test.gnoa @@ -33,17 +33,15 @@ var ( ) func TestPoolInitByAdmin(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetOrigCaller(gsa) pl.InitManual() + std.TestSkipHeights(1) } func TestPoolCreatePools(t *testing.T) { - std.TestSetOrigCaller(test1) - - // approve gns to CreatePool ( 500 gns for 1 pool) - gns.Approve(a2u(consts.POOL_ADDR), 5000) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*3) // bar-baz pl.CreatePool(barPath, bazPath, 100, 354340008410679467268648495215) // tick 29960 ≈ 1:20 @@ -52,7 +50,7 @@ func TestPoolCreatePools(t *testing.T) { pl.CreatePool(bazPath, fooPath, 100, 25050389945027294416741547334) // tick -23030 ≈ 1:0.1 // foo-wugnot - pl.CreatePool(fooPath, wugnotPath, 100, 17714911063927984461157312042) // tick -29960 ≈ 1:0.05 + pl.CreatePool(fooPath, consts.WRAPPED_WUGNOT, 100, 17714911063927984461157312042) // tick -29960 ≈ 1:0.05 std.TestSkipHeights(4) } @@ -60,20 +58,20 @@ func TestPoolCreatePools(t *testing.T) { func TestFaucetLP01(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 0) - shouldEQ(t, balanceOf(bazObj, lp01), 0) - shouldEQ(t, balanceOf(fooObj, lp01), 0) - shouldEQ(t, balanceOf(quxObj, lp01), 0) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, qux.BalanceOf(a2u(lp01)), 0) bar.Faucet(lp01) baz.Faucet(lp01) foo.Faucet(lp01) qux.Faucet(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 100000000) - shouldEQ(t, balanceOf(bazObj, lp01), 100000000) - shouldEQ(t, balanceOf(fooObj, lp01), 100000000) - shouldEQ(t, balanceOf(quxObj, lp01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, qux.BalanceOf(a2u(lp01)), 100000000) std.TestSkipHeights(5) } @@ -95,13 +93,13 @@ func TestPositionMintBarBazInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(1)) - shouldEQ(t, liquidity, bigint(4473213901)) + shouldEQ(t, liquidity, bigint(4473213900)) shouldEQ(t, amount0, bigint(499941)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -124,13 +122,13 @@ func TestPositionMintBarBazLowerRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(2)) - shouldEQ(t, liquidity, bigint(4484410365)) + shouldEQ(t, liquidity, bigint(4484410364)) shouldEQ(t, amount0, bigint(0)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -153,12 +151,12 @@ func TestPositionMintBarBazUpperRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(3)) - shouldEQ(t, liquidity, bigint(470937835)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(470937834)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(0)) std.TestSkipHeights(3) @@ -181,12 +179,12 @@ func TestPositionMintBazFooInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(4)) - shouldEQ(t, liquidity, bigint(3163542979)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(3163542978)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(999700)) std.TestSkipHeights(3) @@ -209,21 +207,21 @@ func TestPositionMintFooGnotInRange(t *testing.T) { wugnot.Approve(a2u(consts.POOL_ADDR), 10000000) tokenId, liquidity, amount0, amoutn1 := pn.Mint( - fooPath, // token0 - wugnotPath, // token1 - 100, // fee - -30960, // tickLower - -28960, // tickUpper - 10000000, // amount0Desired - 10000000, // amount1Desired - 0, // amount0Min - 0, // amount1Min - MAX_TIMEOUT, // deadline + fooPath, // token0 + consts.WRAPPED_WUGNOT, // token1 + 100, // fee + -30960, // tickLower + -28960, // tickUpper + 10000000, // amount0Desired + 10000000, // amount1Desired + 0, // amount0Min + 0, // amount1Min + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(5)) - shouldEQ(t, liquidity, bigint(45848242)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(45848241)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(499941)) std.TestSkipHeights(4) @@ -267,32 +265,32 @@ func TestStakerStakeToken(t *testing.T) { func TestStakerCollectReward(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(gnsObj, lp01), 0) - shouldEQ(t, balanceOf(oblObj, lp01), 0) + shouldEQ(t, gns.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, obl.BalanceOf(a2u(lp01)), 0) sr.CollectReward(1) - shouldEQ(t, balanceOf(gnsObj, lp01), 0) - shouldEQ(t, balanceOf(oblObj, lp01), 21) + shouldEQ(t, gns.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, obl.BalanceOf(a2u(lp01)), 21) } func TestFaucetTR01(t *testing.T) { std.TestSetOrigCaller(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 0) - shouldEQ(t, balanceOf(bazObj, tr01), 0) - shouldEQ(t, balanceOf(fooObj, tr01), 0) - shouldEQ(t, balanceOf(quxObj, tr01), 0) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, qux.BalanceOf(a2u(tr01)), 0) bar.Faucet(tr01) baz.Faucet(tr01) foo.Faucet(tr01) qux.Faucet(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 100000000) - shouldEQ(t, balanceOf(bazObj, tr01), 100000000) - shouldEQ(t, balanceOf(fooObj, tr01), 100000000) - shouldEQ(t, balanceOf(quxObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, qux.BalanceOf(a2u(tr01)), 100000000) std.TestSkipHeights(5) } @@ -317,9 +315,10 @@ func TestRouterSwapRouteBarFooExactIn(t *testing.T) { // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 100000) + foo.Approve(a2u(consts.ROUTER_ADDR), 300) // 0.15% of 199863 - shouldEQ(t, balanceOf(barObj, tr01), 100000000) - shouldEQ(t, balanceOf(fooObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 100000000) swapResult := rr.SwapRoute( barPath, // inputToken @@ -330,10 +329,10 @@ func TestRouterSwapRouteBarFooExactIn(t *testing.T) { "100", // quoteArr "1", // tokenAmountLimit (minRecv) ) - shouldEQ(t, swapResult, bigint(199863)) + shouldEQ(t, swapResult, bigint(199564)) - shouldEQ(t, balanceOf(barObj, tr01), 99900000) - shouldEQ(t, balanceOf(fooObj, tr01), 100199863) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99900000) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 100199564) std.TestSkipHeights(2) } @@ -358,23 +357,24 @@ func TestRouterSwapRouteBarFooExactOutAfterSwap(t *testing.T) { // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 100000) + foo.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) - shouldEQ(t, balanceOf(barObj, tr01), 99900000) - shouldEQ(t, balanceOf(fooObj, tr01), 100199863) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99900000) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 100199564) swapResult := rr.SwapRoute( - barPath, // inputToken - fooPath, // outputToken - 100000, // amountSpecified - "EXACT_IN", // swapType + barPath, // inputToken + fooPath, // outputToken + 100000, // amountSpecified + "EXACT_OUT", // swapType "gno.land/r/demo/bar:gno.land/r/demo/baz:100*POOL*gno.land/r/demo/baz:gno.land/r/demo/foo:100", // strRouteArr - "100", // quoteArr - "1", // tokenAmountLimit (minRecv) + "100", // quoteArr + "50056", // maxSpent ) - shouldEQ(t, swapResult, bigint(199743)) + shouldEQ(t, swapResult, bigint(50056)) - shouldEQ(t, balanceOf(barObj, tr01), 99800000) - shouldEQ(t, balanceOf(fooObj, tr01), 100399606) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 99849944) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 100299414) std.TestSkipHeights(2) } diff --git a/_test/_TEST_scenario_06_router_one_route_three_hop_println_test.gnoa b/_test/_TEST_scenario_06_router_one_route_three_hop_println_test.gnoa index 2ac787af..d7645453 100644 --- a/_test/_TEST_scenario_06_router_one_route_three_hop_println_test.gnoa +++ b/_test/_TEST_scenario_06_router_one_route_three_hop_println_test.gnoa @@ -27,17 +27,15 @@ var ( ) func TestPoolInitByAdmin(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetOrigCaller(gsa) pl.InitManual() + std.TestSkipHeights(1) } func TestPoolCreatePools(t *testing.T) { - std.TestSetOrigCaller(test1) - - // approve gns to CreatePool ( 500 gns for 1 pool) - gns.Approve(a2u(consts.POOL_ADDR), 5000) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*3) // bar-baz pl.CreatePool(barPath, bazPath, 100, 354340008410679467268648495215) // tick 29960 ≈ 1:20 @@ -48,26 +46,26 @@ func TestPoolCreatePools(t *testing.T) { // foo-qux pl.CreatePool(fooPath, quxPath, 100, 17714911063927984461157312042) // tick -29960 ≈ 1:0.05 - std.TestSkipHeights(4) + std.TestSkipHeights(3) } func TestFaucetLP01(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 0) - shouldEQ(t, balanceOf(bazObj, lp01), 0) - shouldEQ(t, balanceOf(fooObj, lp01), 0) - shouldEQ(t, balanceOf(quxObj, lp01), 0) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, qux.BalanceOf(a2u(lp01)), 0) bar.Faucet(lp01) baz.Faucet(lp01) foo.Faucet(lp01) qux.Faucet(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 100000000) - shouldEQ(t, balanceOf(bazObj, lp01), 100000000) - shouldEQ(t, balanceOf(fooObj, lp01), 100000000) - shouldEQ(t, balanceOf(quxObj, lp01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, qux.BalanceOf(a2u(lp01)), 100000000) std.TestSkipHeights(5) } @@ -89,13 +87,13 @@ func TestPositionMintBarBazInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(1)) - shouldEQ(t, liquidity, bigint(4473213901)) + shouldEQ(t, liquidity, bigint(4473213900)) shouldEQ(t, amount0, bigint(499941)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -117,12 +115,12 @@ func TestPositionMintBazFooInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(2)) - shouldEQ(t, liquidity, bigint(3163542979)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(3163542978)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(999700)) std.TestSkipHeights(3) @@ -145,12 +143,12 @@ func TestPositionMintFooQuxInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(3)) - shouldEQ(t, liquidity, bigint(2237166074)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(2237166073)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(499941)) std.TestSkipHeights(3) @@ -159,20 +157,20 @@ func TestPositionMintFooQuxInRange(t *testing.T) { func TestFaucetTR01(t *testing.T) { std.TestSetOrigCaller(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 0) - shouldEQ(t, balanceOf(bazObj, tr01), 0) - shouldEQ(t, balanceOf(fooObj, tr01), 0) - shouldEQ(t, balanceOf(quxObj, tr01), 0) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, qux.BalanceOf(a2u(tr01)), 0) bar.Faucet(tr01) baz.Faucet(tr01) foo.Faucet(tr01) qux.Faucet(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 100000000) - shouldEQ(t, balanceOf(bazObj, tr01), 100000000) - shouldEQ(t, balanceOf(fooObj, tr01), 100000000) - shouldEQ(t, balanceOf(quxObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, qux.BalanceOf(a2u(tr01)), 100000000) std.TestSkipHeights(5) } @@ -188,7 +186,7 @@ func TestRouterDrySwapRouteBarQuxExactIn(t *testing.T) { "gno.land/r/demo/bar:gno.land/r/demo/baz:100*POOL*gno.land/r/demo/baz:gno.land/r/demo/foo:100*POOL*gno.land/r/demo/foo:gno.land/r/demo/qux:100", // strRouteArr "100", // quoteArr ) - println("EXACT_IN_dryResult:", dryResult) + println("EXACT_IN_dryResult:", dryResult) // 9990 std.TestSkipHeights(2) } @@ -197,9 +195,10 @@ func TestRouterSwapRouteBarQuxExactIn(t *testing.T) { // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 100000) + qux.Approve(a2u(consts.ROUTER_ADDR), 15) // 0.15% of 9990 - oldBar := balanceOf(barObj, tr01) - oldQux := balanceOf(quxObj, tr01) + oldBar := bar.BalanceOf(a2u(tr01)) + oldQux := qux.BalanceOf(a2u(tr01)) swapResult := rr.SwapRoute( barPath, // inputToken @@ -212,8 +211,8 @@ func TestRouterSwapRouteBarQuxExactIn(t *testing.T) { ) println("EXACT_IN_swapResult:", swapResult) - newBar := balanceOf(barObj, tr01) - newQux := balanceOf(quxObj, tr01) + newBar := bar.BalanceOf(a2u(tr01)) + newQux := qux.BalanceOf(a2u(tr01)) println("sentBar:", oldBar-newBar) println("R recvQux:", newQux-oldQux) @@ -241,9 +240,10 @@ func TestRouterSwapRouteBarQuxExactOutAfterSwap(t *testing.T) { // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 500000) + qux.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) - oldBar := balanceOf(barObj, tr01) - oldQux := balanceOf(quxObj, tr01) + oldBar := bar.BalanceOf(a2u(tr01)) + oldQux := qux.BalanceOf(a2u(tr01)) swapResult := rr.SwapRoute( barPath, // inputToken @@ -256,8 +256,8 @@ func TestRouterSwapRouteBarQuxExactOutAfterSwap(t *testing.T) { ) println("EXACT_OUT_swapResult:", swapResult) - newBar := balanceOf(barObj, tr01) - newQux := balanceOf(quxObj, tr01) + newBar := bar.BalanceOf(a2u(tr01)) + newQux := qux.BalanceOf(a2u(tr01)) println("R sentBar:", oldBar-newBar) println("recvQux:", newQux-oldQux) diff --git a/_test/_TEST_scenario_07_FAIL_router_one_route_three_hop_large_amount_println_test.gnoa b/_test/_TEST_scenario_07_FAIL_router_one_route_three_hop_large_amount_println_test.gnoa index 7f96753d..fe857d25 100644 --- a/_test/_TEST_scenario_07_FAIL_router_one_route_three_hop_large_amount_println_test.gnoa +++ b/_test/_TEST_scenario_07_FAIL_router_one_route_three_hop_large_amount_println_test.gnoa @@ -28,17 +28,15 @@ var ( ) func TestPoolInitByAdmin(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetOrigCaller(gsa) pl.InitManual() + std.TestSkipHeights(1) } func TestPoolCreatePools(t *testing.T) { - std.TestSetOrigCaller(test1) - - // approve gns to CreatePool ( 500 gns for 1 pool) - gns.Approve(a2u(consts.POOL_ADDR), 5000) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*3) // bar-baz pl.CreatePool(barPath, bazPath, 100, 354340008410679467268648495215) // tick 29960 ≈ 1:20 @@ -49,26 +47,26 @@ func TestPoolCreatePools(t *testing.T) { // foo-qux pl.CreatePool(fooPath, quxPath, 100, 17714911063927984461157312042) // tick -29960 ≈ 1:0.05 - std.TestSkipHeights(4) + std.TestSkipHeights(3) } func TestFaucetLP01(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 0) - shouldEQ(t, balanceOf(bazObj, lp01), 0) - shouldEQ(t, balanceOf(fooObj, lp01), 0) - shouldEQ(t, balanceOf(quxObj, lp01), 0) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, qux.BalanceOf(a2u(lp01)), 0) bar.Faucet(lp01) baz.Faucet(lp01) foo.Faucet(lp01) qux.Faucet(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 100000000) - shouldEQ(t, balanceOf(bazObj, lp01), 100000000) - shouldEQ(t, balanceOf(fooObj, lp01), 100000000) - shouldEQ(t, balanceOf(quxObj, lp01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, qux.BalanceOf(a2u(lp01)), 100000000) std.TestSkipHeights(5) } @@ -90,13 +88,13 @@ func TestPositionMintBarBazInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(1)) - shouldEQ(t, liquidity, bigint(4473213901)) + shouldEQ(t, liquidity, bigint(4473213900)) shouldEQ(t, amount0, bigint(499941)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -118,12 +116,12 @@ func TestPositionMintBazFooInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(2)) - shouldEQ(t, liquidity, bigint(3163542979)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(3163542978)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(999700)) std.TestSkipHeights(3) @@ -146,12 +144,12 @@ func TestPositionMintFooQuxInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(3)) - shouldEQ(t, liquidity, bigint(2237166074)) - shouldEQ(t, amount0, bigint(10000000)) + shouldEQ(t, liquidity, bigint(2237166073)) + shouldEQ(t, amount0, bigint(9999999)) shouldEQ(t, amoutn1, bigint(499941)) std.TestSkipHeights(3) @@ -160,20 +158,20 @@ func TestPositionMintFooQuxInRange(t *testing.T) { func TestFaucetTR01(t *testing.T) { std.TestSetOrigCaller(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 0) - shouldEQ(t, balanceOf(bazObj, tr01), 0) - shouldEQ(t, balanceOf(fooObj, tr01), 0) - shouldEQ(t, balanceOf(quxObj, tr01), 0) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, qux.BalanceOf(a2u(tr01)), 0) bar.Faucet(tr01) baz.Faucet(tr01) foo.Faucet(tr01) qux.Faucet(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 100000000) - shouldEQ(t, balanceOf(bazObj, tr01), 100000000) - shouldEQ(t, balanceOf(fooObj, tr01), 100000000) - shouldEQ(t, balanceOf(quxObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, qux.BalanceOf(a2u(tr01)), 100000000) std.TestSkipHeights(5) } @@ -189,7 +187,7 @@ func TestRouterDrySwapRouteBarQuxExactIn(t *testing.T) { "gno.land/r/demo/bar:gno.land/r/demo/baz:100*POOL*gno.land/r/demo/baz:gno.land/r/demo/foo:100*POOL*gno.land/r/demo/foo:gno.land/r/demo/qux:100", // strRouteArr "100", // quoteArr ) - println("EXACT_IN_dryResult:", dryResult) + println("EXACT_IN_dryResult:", dryResult) // 9990 std.TestSkipHeights(2) } @@ -198,9 +196,10 @@ func TestRouterSwapRouteBarQuxExactIn(t *testing.T) { // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 100000) + qux.Approve(a2u(consts.ROUTER_ADDR), 15) // 0.15 % of 9990 - oldBar := balanceOf(barObj, tr01) - oldQux := balanceOf(quxObj, tr01) + oldBar := bar.BalanceOf(a2u(tr01)) + oldQux := qux.BalanceOf(a2u(tr01)) swapResult := rr.SwapRoute( barPath, // inputToken @@ -213,8 +212,8 @@ func TestRouterSwapRouteBarQuxExactIn(t *testing.T) { ) println("EXACT_IN_swapResult:", swapResult) - newBar := balanceOf(barObj, tr01) - newQux := balanceOf(quxObj, tr01) + newBar := bar.BalanceOf(a2u(tr01)) + newQux := qux.BalanceOf(a2u(tr01)) println("sentBar:", oldBar-newBar) println("R recvQux:", newQux-oldQux) @@ -243,8 +242,8 @@ func TestRouterSwapRouteBarQuxExactOutAfterSwap(t *testing.T) { // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 500000) - oldBar := balanceOf(barObj, tr01) - oldQux := balanceOf(quxObj, tr01) + oldBar := bar.BalanceOf(a2u(tr01)) + oldQux := qux.BalanceOf(a2u(tr01)) shouldPanicWithMsg(t, func() { rr.SwapRoute( diff --git a/_test/_TEST_scenario_08_router_two_position_one_route_one_hop_println_test.gnoa b/_test/_TEST_scenario_08_router_two_position_one_route_one_hop_println_test.gnoa index 2c229ed6..e2c9dfb8 100644 --- a/_test/_TEST_scenario_08_router_two_position_one_route_one_hop_println_test.gnoa +++ b/_test/_TEST_scenario_08_router_two_position_one_route_one_hop_println_test.gnoa @@ -25,17 +25,15 @@ var ( ) func TestPoolInitByAdmin(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetOrigCaller(gsa) pl.InitManual() + std.TestSkipHeights(1) } func TestPoolCreatePools(t *testing.T) { - std.TestSetOrigCaller(test1) - - // approve gns to CreatePool ( 500 gns for 1 pool) - gns.Approve(a2u(consts.POOL_ADDR), 5000) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) // bar-baz pl.CreatePool(barPath, bazPath, 100, 354340008410679467268648495215) // tick 29960 ≈ 1:20 @@ -46,14 +44,14 @@ func TestPoolCreatePools(t *testing.T) { func TestFaucetLP01(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 0) - shouldEQ(t, balanceOf(bazObj, lp01), 0) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 0) bar.Faucet(lp01) baz.Faucet(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 100000000) - shouldEQ(t, balanceOf(bazObj, lp01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 100000000) std.TestSkipHeights(5) } @@ -75,12 +73,12 @@ func TestPositionMintBarBazInRange(t *testing.T) { 1000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(1)) - shouldEQ(t, liquidity, bigint(447322)) + shouldEQ(t, liquidity, bigint(447321)) shouldEQ(t, amount0, bigint(49)) - shouldEQ(t, amoutn1, bigint(1000)) + shouldEQ(t, amoutn1, bigint(999)) std.TestSkipHeights(3) } @@ -102,31 +100,31 @@ func TestPositionMintBarBazInRangeMore(t *testing.T) { 1000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(2)) - shouldEQ(t, liquidity, bigint(447322)) + shouldEQ(t, liquidity, bigint(447321)) shouldEQ(t, amount0, bigint(49)) - shouldEQ(t, amoutn1, bigint(1000)) + shouldEQ(t, amoutn1, bigint(999)) std.TestSkipHeights(3) - poolBar, _ := barObj.BalanceOf(consts.POOL_ADDR) - poolBaz, _ := bazObj.BalanceOf(consts.POOL_ADDR) + poolBar := bar.BalanceOf(a2u(consts.POOL_ADDR)) + poolBaz := baz.BalanceOf(a2u(consts.POOL_ADDR)) } func TestFaucetTR01(t *testing.T) { std.TestSetOrigCaller(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 0) - shouldEQ(t, balanceOf(bazObj, tr01), 0) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 0) bar.Faucet(tr01) baz.Faucet(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 100000000) - shouldEQ(t, balanceOf(bazObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 100000000) std.TestSkipHeights(5) } @@ -151,9 +149,10 @@ func TestRouterSwapRouteBarBazExactOut(t *testing.T) { // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 100000) + baz.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) - oldBar := balanceOf(barObj, tr01) - oldBaz := balanceOf(bazObj, tr01) + oldBar := bar.BalanceOf(a2u(tr01)) + oldBaz := baz.BalanceOf(a2u(tr01)) swapResult := rr.SwapRoute( barPath, // inputToken @@ -166,8 +165,8 @@ func TestRouterSwapRouteBarBazExactOut(t *testing.T) { ) println("EXACT_OUT_swapResult:", swapResult) - newBar := balanceOf(barObj, tr01) - newBaz := balanceOf(bazObj, tr01) + newBar := bar.BalanceOf(a2u(tr01)) + newBaz := baz.BalanceOf(a2u(tr01)) println("R sentBar:", oldBar-newBar) println("recvBaz:", newBaz-oldBaz) diff --git a/_test/_TEST_scenario_98_router_only_upper_position_println_test.gnoa b/_test/_TEST_scenario_98_router_only_upper_position_println_test.gnoa index ebe708a5..2fa14ac5 100644 --- a/_test/_TEST_scenario_98_router_only_upper_position_println_test.gnoa +++ b/_test/_TEST_scenario_98_router_only_upper_position_println_test.gnoa @@ -25,17 +25,15 @@ var ( ) func TestPoolInitByAdmin(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetOrigCaller(gsa) pl.InitManual() + std.TestSkipHeights(1) } func TestPoolCreatePools(t *testing.T) { - std.TestSetOrigCaller(test1) - - // approve gns to CreatePool ( 500 gns for 1 pool) - gns.Approve(a2u(consts.POOL_ADDR), 5000) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) // bar-baz pl.CreatePool(barPath, bazPath, 100, 354340008410679467268648495215) // tick 29960 ≈ 1:20 @@ -46,14 +44,14 @@ func TestPoolCreatePools(t *testing.T) { func TestFaucetLP01(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 0) - shouldEQ(t, balanceOf(bazObj, lp01), 0) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 0) bar.Faucet(lp01) baz.Faucet(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 100000000) - shouldEQ(t, balanceOf(bazObj, lp01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 100000000) std.TestSkipHeights(5) } @@ -75,15 +73,15 @@ func TestFaucetLP01(t *testing.T) { // 1000, // amount1Desired // 0, // amount0Min // 0, // amount1Min -// MAX_TIMEOUT, // deadline +// max_timeout, // deadline // ) // // shouldEQ(t, tokenId, bigint(1)) // shouldEQ(t, liquidity, bigint(223717)) // shouldEQ(t, amount0, bigint(49)) // shouldEQ(t, amoutn1, bigint(1000)) -// poolBar, _ := barObj.BalanceOf(consts.POOL_ADDR) -// poolBaz, _ := bazObj.BalanceOf(consts.POOL_ADDR) +// poolBar := bar.BalanceOf(a2u(consts.POOL_ADDR)) +// poolBaz := baz.BalanceOf(a2u(consts.POOL_ADDR)) // println("Pool Token0(BAR) Balance:", poolBar) // println("Pool Token1(BAZ) Balance:", poolBaz) @@ -107,29 +105,29 @@ func TestPositionMintBarBazUpperRange(t *testing.T) { 1000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) // shouldEQ(t, tokenId, bigint(2)) - shouldEQ(t, liquidity, bigint(24724)) - shouldEQ(t, amount0, bigint(1000)) + shouldEQ(t, liquidity, bigint(24723)) + shouldEQ(t, amount0, bigint(999)) shouldEQ(t, amoutn1, bigint(0)) - poolBar, _ := barObj.BalanceOf(consts.POOL_ADDR) - poolBaz, _ := bazObj.BalanceOf(consts.POOL_ADDR) + poolBar := bar.BalanceOf(a2u(consts.POOL_ADDR)) + poolBaz := baz.BalanceOf(a2u(consts.POOL_ADDR)) std.TestSkipHeights(3) } func TestFaucetTR01(t *testing.T) { std.TestSetOrigCaller(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 0) - shouldEQ(t, balanceOf(bazObj, tr01), 0) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 0) bar.Faucet(tr01) baz.Faucet(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 100000000) - shouldEQ(t, balanceOf(bazObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(tr01)), 100000000) std.TestSkipHeights(5) } @@ -157,8 +155,8 @@ func TestRouterSwapRouteBazBarExactIn(t *testing.T) { // approve bar to pool baz.Approve(a2u(consts.POOL_ADDR), 100000) - oldBar := balanceOf(barObj, tr01) - oldBaz := balanceOf(bazObj, tr01) + oldBar := bar.BalanceOf(a2u(tr01)) + oldBaz := baz.BalanceOf(a2u(tr01)) swapResult := rr.SwapRoute( bazPath, // inputToken @@ -171,8 +169,8 @@ func TestRouterSwapRouteBazBarExactIn(t *testing.T) { ) println("EXACT_IN_swapResult:", swapResult) - newBar := balanceOf(barObj, tr01) - newBaz := balanceOf(bazObj, tr01) + newBar := bar.BalanceOf(a2u(tr01)) + newBaz := baz.BalanceOf(a2u(tr01)) println("sentBaz:", oldBaz-newBaz) println("R recvBar:", newBar-oldBar) @@ -200,9 +198,10 @@ func TestRouterSwapRouteBazBarExactInTooMuch(t *testing.T) { // approve bar to pool baz.Approve(a2u(consts.POOL_ADDR), 100000) + bar.Approve(a2u(consts.ROUTER_ADDR), uint64(100000000)) - oldBar := balanceOf(barObj, tr01) - oldBaz := balanceOf(bazObj, tr01) + oldBar := bar.BalanceOf(a2u(tr01)) + oldBaz := baz.BalanceOf(a2u(tr01)) shouldPanicWithMsg(t, func() { rr.SwapRoute( @@ -215,6 +214,6 @@ func TestRouterSwapRouteBazBarExactInTooMuch(t *testing.T) { "10000000", // tokenAmountLimit (minReceived) ) }, - "[ROUTER] router.gno__SwapRoute() || too few received (expected minimum output:10000000, actual output:947)", + "[ROUTER] router.gno__SwapRoute() || too few received (expected minimum output:10000000, actual output:946)", ) } diff --git a/_test/_TEST_scenario_99_router_uniswap_sdk_test.gno b/_test/_TEST_scenario_99_router_uniswap_sdk_test.gnoa similarity index 80% rename from _test/_TEST_scenario_99_router_uniswap_sdk_test.gno rename to _test/_TEST_scenario_99_router_uniswap_sdk_test.gnoa index 4c7f5978..c296740e 100644 --- a/_test/_TEST_scenario_99_router_uniswap_sdk_test.gno +++ b/_test/_TEST_scenario_99_router_uniswap_sdk_test.gnoa @@ -44,17 +44,15 @@ var ( ) func TestPoolInitByAdmin(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetOrigCaller(gsa) pl.InitManual() + std.TestSkipHeights(1) } func TestPoolCreatePools(t *testing.T) { - std.TestSetOrigCaller(test1) - - // approve gns to CreatePool ( 500 gns for 1 pool) - gns.Approve(a2u(consts.POOL_ADDR), 5000) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*2) // bar-baz pl.CreatePool(barPath, bazPath, 100, 79228162514264337593543950337) // tick 0 ≈ 1:1 @@ -68,17 +66,17 @@ func TestPoolCreatePools(t *testing.T) { func TestFaucetLP01(t *testing.T) { std.TestSetOrigCaller(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 0) - shouldEQ(t, balanceOf(bazObj, lp01), 0) - shouldEQ(t, balanceOf(fooObj, lp01), 0) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 0) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 0) bar.Faucet(lp01) baz.Faucet(lp01) foo.Faucet(lp01) - shouldEQ(t, balanceOf(barObj, lp01), 100000000) - shouldEQ(t, balanceOf(bazObj, lp01), 100000000) - shouldEQ(t, balanceOf(fooObj, lp01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, baz.BalanceOf(a2u(lp01)), 100000000) + shouldEQ(t, foo.BalanceOf(a2u(lp01)), 100000000) std.TestSkipHeights(5) } @@ -100,13 +98,13 @@ func TestPositionMintBarBazInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(1)) - shouldEQ(t, liquidity, bigint(10000001)) - shouldEQ(t, amount0, bigint(10000000)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, liquidity, bigint(10000000)) + shouldEQ(t, amount0, bigint(9999999)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -129,13 +127,13 @@ func TestPositionMintBazFooInRange(t *testing.T) { 10000000, // amount1Desired 0, // amount0Min 0, // amount1Min - MAX_TIMEOUT, // deadline + max_timeout, // deadline ) shouldEQ(t, tokenId, bigint(2)) - shouldEQ(t, liquidity, bigint(10000001)) - shouldEQ(t, amount0, bigint(10000000)) - shouldEQ(t, amoutn1, bigint(10000000)) + shouldEQ(t, liquidity, bigint(10000000)) + shouldEQ(t, amount0, bigint(9999999)) + shouldEQ(t, amoutn1, bigint(9999999)) std.TestSkipHeights(3) } @@ -143,11 +141,11 @@ func TestPositionMintBazFooInRange(t *testing.T) { func TestFaucetTR01(t *testing.T) { std.TestSetOrigCaller(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 0) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 0) bar.Faucet(tr01) - shouldEQ(t, balanceOf(barObj, tr01), 100000000) + shouldEQ(t, bar.BalanceOf(a2u(tr01)), 100000000) std.TestSkipHeights(5) } @@ -172,9 +170,10 @@ func TestRouterSwapRouteBarFooExactIn(t *testing.T) { // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 100000) + foo.Approve(a2u(consts.ROUTER_ADDR), 148) // 0.15% of 98019 - barOld := balanceOf(barObj, tr01) - fooOld := balanceOf(fooObj, tr01) + barOld := bar.BalanceOf(a2u(tr01)) + fooOld := foo.BalanceOf(a2u(tr01)) shouldEQ(t, barOld, 100000000) shouldEQ(t, fooOld, 0) @@ -187,13 +186,13 @@ func TestRouterSwapRouteBarFooExactIn(t *testing.T) { "100", // quoteArr "1", // tokenAmountLimit (minRecv) ) - shouldEQ(t, swapResult, bigint(98019)) + shouldEQ(t, swapResult, bigint(97872)) - barNew := balanceOf(barObj, tr01) - fooNew := balanceOf(fooObj, tr01) + barNew := bar.BalanceOf(a2u(tr01)) + fooNew := foo.BalanceOf(a2u(tr01)) shouldEQ(t, barOld-barNew, 100000) - shouldEQ(t, fooNew-fooOld, 98019) + shouldEQ(t, fooNew-fooOld, 97872) std.TestSkipHeights(2) } @@ -218,11 +217,12 @@ func TestRouterSwapRouteBarFooExactOutAfterSwap(t *testing.T) { // approve bar to pool bar.Approve(a2u(consts.POOL_ADDR), 106226) + foo.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) - barOld := balanceOf(barObj, tr01) - fooOld := balanceOf(fooObj, tr01) + barOld := bar.BalanceOf(a2u(tr01)) + fooOld := foo.BalanceOf(a2u(tr01)) shouldEQ(t, barOld, 99900000) - shouldEQ(t, fooOld, 98019) + shouldEQ(t, fooOld, 97872) swapResult := rr.SwapRoute( barPath, // inputToken @@ -235,12 +235,11 @@ func TestRouterSwapRouteBarFooExactOutAfterSwap(t *testing.T) { ) shouldEQ(t, swapResult, bigint(106226)) - barNew := balanceOf(barObj, tr01) - fooNew := balanceOf(fooObj, tr01) + barNew := bar.BalanceOf(a2u(tr01)) + fooNew := foo.BalanceOf(a2u(tr01)) shouldEQ(t, barOld-barNew, 106226) - // shouldEQ(t, fooNew-fooOld, 100000) - shouldEQ(t, fooNew-fooOld, 100000-2) // tolerance + shouldEQ(t, fooNew-fooOld, 99849) std.TestSkipHeights(2) } diff --git a/pool/_RPC_api.gno b/pool/_RPC_api.gno index a00fbf33..6f03346a 100644 --- a/pool/_RPC_api.gno +++ b/pool/_RPC_api.gno @@ -5,6 +5,9 @@ import ( "encoding/json" "strings" + "std" + "time" + "gno.land/p/demo/ufmt" ) @@ -98,8 +101,8 @@ func ApiGetPools() string { r := ResponseApiGetPools{ Stat: ResponseQueryBase{ - Height: GetHeight(), - Timestamp: GetTimestamp(), + Height: std.GetHeight(), + Timestamp: time.Now().Unix(), }, Response: rpcPools, } diff --git a/pool/_TEST_INIT_register_tokens_test.gno b/pool/_TEST_0_INIT_TOKEN_REGISTER_test.gno similarity index 100% rename from pool/_TEST_INIT_register_tokens_test.gno rename to pool/_TEST_0_INIT_TOKEN_REGISTER_test.gno diff --git a/pool/_TEST_INIT_basic_test.gno b/pool/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno similarity index 53% rename from pool/_TEST_INIT_basic_test.gno rename to pool/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno index 841e23a3..8f949c60 100644 --- a/pool/_TEST_INIT_basic_test.gno +++ b/pool/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno @@ -4,46 +4,26 @@ import ( "std" "testing" - "gno.land/r/demo/gns" - - "gno.land/r/demo/bar" - "gno.land/r/demo/baz" - "gno.land/r/demo/foo" - - "gno.land/r/demo/wugnot" - "gno.land/r/demo/consts" ) var ( - test1 std.Address - - barPath = "gno.land/r/demo/bar" - bazPath = "gno.land/r/demo/baz" - fooPath = "gno.land/r/demo/foo" - - fee100 = uint16(100) - fee500 = uint16(500) - fee3000 = uint16(3000) -) + gsa std.Address = consts.GNOSWAP_ADMIN + test1 std.Address = std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") -func init() { - test1 = std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") - // prepare ugnot - testBanker := std.GetBanker(std.BankerTypeRealmIssue) - testBanker.IssueCoin(test1, "ugnot", 500_000_000_000_000) - - std.TestSetPrevAddr(test1) - - gns.Approve(a2u(consts.POOL_ADDR), 500_000_000_000_000) + fooPath string = "gno.land/r/demo/foo" + barPath string = "gno.land/r/demo/bar" + bazPath string = "gno.land/r/demo/baz" + quxPath string = "gno.land/r/demo/qux" - 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) + oblPath string = "gno.land/r/demo/obl" + // wugnotPath string = "gno.land/r/demo/wugnot" // from consts + // gnsPath string = "gno.land/r/demo/gns" // from consts - wugnot.Approve(a2u(consts.POOL_ADDR), 500_000_000_000_000) - -} + fee100 uint16 = 100 + fee500 uint16 = 500 + fee3000 uint16 = 3000 +) /* HELPER */ func shouldEQ(t *testing.T, got, expected interface{}) { diff --git a/pool/_TEST_rpc_get_test.gno b/pool/_TEST_get_test.gno similarity index 88% rename from pool/_TEST_rpc_get_test.gno rename to pool/_TEST_get_test.gno index 3a050992..86755ecf 100644 --- a/pool/_TEST_rpc_get_test.gno +++ b/pool/_TEST_get_test.gno @@ -5,43 +5,53 @@ import ( "testing" "gno.land/r/demo/consts" + + "gno.land/r/demo/bar" + "gno.land/r/demo/baz" + "gno.land/r/demo/foo" + + "gno.land/r/demo/gns" ) var ( test_tickLower = int32(9000) test_tickUpper = int32(11000) test_liquidityExpect = bigint(100_000_000) - - test_tickLower2 = int32(50000) - test_tickUpper2 = int32(100000) ) // 1. Init Pool func TestInit(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(gsa) InitManual() } // 2. Create Foo:Bar Pool func TestCreateFooBarPool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + CreatePool(fooPath, barPath, fee500, 130621891405341611593710811006) shouldEQ(t, len(pools), 1) } // 3. Create Bar:Baz Pool func TestCreateBarBazPool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + CreatePool(barPath, bazPath, fee500, 130621891405341611593710811006) shouldEQ(t, len(pools), 2) } // 4. Mint Foo:Bar Liquidity by test1 func TestMintFooBarLiquidity(t *testing.T) { + std.TestSetPrevAddr(test1) + foo.Approve(a2u(consts.POOL_ADDR), 2958014) + bar.Approve(a2u(consts.POOL_ADDR), 8040315) + std.TestSetPrevRealm(consts.POSITION_PATH) std.TestSetOrigCaller(test1) - - Mint( + amount0, amount1 := Mint( fooPath, barPath, fee500, @@ -50,14 +60,19 @@ func TestMintFooBarLiquidity(t *testing.T) { -test_tickLower, test_liquidityExpect, ) + shouldEQ(t, amount0, bigint(8040315)) + shouldEQ(t, amount1, bigint(2958014)) } // 5. Mint Bar:Baz Liquidity by test1 func TestMintBarBazLiquidity(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 2958014) + baz.Approve(a2u(consts.POOL_ADDR), 8040315) + std.TestSetPrevRealm(consts.POSITION_PATH) std.TestSetOrigCaller(test1) - - Mint( + amount0, amount1 := Mint( barPath, bazPath, fee500, @@ -66,6 +81,8 @@ func TestMintBarBazLiquidity(t *testing.T) { test_tickUpper, test_liquidityExpect, ) + shouldEQ(t, amount0, bigint(2958014)) + shouldEQ(t, amount1, bigint(8040315)) } // RPC GET TESTS diff --git a/pool/_TEST_pool_dryswap_and_swap_test.gnoa b/pool/_TEST_pool_dryswap_and_swap_test.gnoa index b139d3ce..61eaebfb 100644 --- a/pool/_TEST_pool_dryswap_and_swap_test.gnoa +++ b/pool/_TEST_pool_dryswap_and_swap_test.gnoa @@ -5,6 +5,11 @@ import ( "testing" "gno.land/r/demo/consts" + + "gno.land/r/demo/bar" + "gno.land/r/demo/foo" + + "gno.land/r/demo/gns" ) var ( @@ -18,10 +23,14 @@ var ( ) func TestInitManual(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(gsa) InitManual() + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + CreatePool(fooPath, barPath, fee500, sqrtPrice) + shouldEQ(t, len(pools), 1) } func TestDrySwap_ZeroForOneTrue_AmountSpecified_Positive_16000(t *testing.T) { @@ -33,10 +42,22 @@ func TestDrySwap_ZeroForOneTrue_AmountSpecified_Positive_16000(t *testing.T) { shouldEQ(t, ok, false) // not enough mint == swap will fail + std.TestSetPrevAddr(test1) + foo.Approve(a2u(consts.POOL_ADDR), uint64(0)) + bar.Approve(a2u(consts.POOL_ADDR), uint64(0)) + + std.TestSetPrevRealm(consts.POSITION_PATH) + std.TestSetOrigCaller(test1) Mint(fooPath, barPath, fee500, consts.POSITION_ADDR, -tickUpper, -tickLower, 10) _, _, ok = DrySwap(fooPath, barPath, fee500, "_", true, 16000, consts.MIN_PRICE) shouldEQ(t, ok, false) + std.TestSetPrevAddr(test1) + foo.Approve(a2u(consts.POOL_ADDR), 2958014649) + bar.Approve(a2u(consts.POOL_ADDR), 8040315471) + + std.TestSetPrevRealm(consts.POSITION_PATH) + std.TestSetOrigCaller(test1) Mint(fooPath, barPath, fee500, consts.POSITION_ADDR, -tickUpper, -tickLower, liquidityExpect) // -11000 ~ -9000 // zeroForOne true diff --git a/pool/_TEST_pool_multi_token_test.gnoa b/pool/_TEST_pool_multi_token_test.gnoa index 9a3149cd..dd0d030d 100644 --- a/pool/_TEST_pool_multi_token_test.gnoa +++ b/pool/_TEST_pool_multi_token_test.gnoa @@ -5,43 +5,53 @@ import ( "testing" "gno.land/r/demo/consts" + + "gno.land/r/demo/bar" + "gno.land/r/demo/baz" + "gno.land/r/demo/foo" + + "gno.land/r/demo/gns" ) var ( test_tickLower = int32(9000) test_tickUpper = int32(11000) test_liquidityExpect = bigint(100_000_000) - - test_tickLower2 = int32(50000) - test_tickUpper2 = int32(100000) ) // 1. Init Pool func TestInit(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(gsa) InitManual() } // 2. Create Foo:Bar Pool func TestCreateFooBarPool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + CreatePool(fooPath, barPath, fee500, 130621891405341611593710811006) shouldEQ(t, len(pools), 1) } // 3. Create Bar:Baz Pool func TestCreateBarBazPool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + CreatePool(barPath, bazPath, fee500, 130621891405341611593710811006) shouldEQ(t, len(pools), 2) } // 4. Mint Foo:Bar Liquidity by test1 func TestMintFooBarLiquidity(t *testing.T) { + std.TestSetPrevAddr(test1) + foo.Approve(a2u(consts.POOL_ADDR), 2958014) + bar.Approve(a2u(consts.POOL_ADDR), 8040315) + std.TestSetPrevRealm(consts.POSITION_PATH) std.TestSetOrigCaller(test1) - - Mint( + amount0, amount1 := Mint( fooPath, barPath, fee500, @@ -50,14 +60,19 @@ func TestMintFooBarLiquidity(t *testing.T) { -test_tickLower, test_liquidityExpect, ) + shouldEQ(t, amount0, bigint(8040315)) + shouldEQ(t, amount1, bigint(2958014)) } // 5. Mint Bar:Baz Liquidity by test1 func TestMintBarBazLiquidity(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 2958014) + baz.Approve(a2u(consts.POOL_ADDR), 8040315) + std.TestSetPrevRealm(consts.POSITION_PATH) std.TestSetOrigCaller(test1) - - Mint( + amount0, amount1 := Mint( barPath, bazPath, fee500, @@ -66,21 +81,26 @@ func TestMintBarBazLiquidity(t *testing.T) { test_tickUpper, test_liquidityExpect, ) + shouldEQ(t, amount0, bigint(2958014)) + shouldEQ(t, amount1, bigint(8040315)) } // 6. Swap Foo:Bar Foo > Bar by test1 func TestSwapFooBarFooToBar(t *testing.T) { - std.TestSetPrevRealm(consts.ROUTER_PATH) - std.TestSetOrigCaller(test1) + oldTest1Bar := balanceOfByRegisterCall(barPath, test1) + oldTest1Foo := balanceOfByRegisterCall(fooPath, test1) - oldtest1Token1Balance := balanceOfByRegisterCall(fooPath, test1) - oldtest1Token0Balance := balanceOfByRegisterCall(barPath, test1) - oldPoolToken1Balance := balanceOfByRegisterCall(fooPath, consts.POOL_ADDR) - oldPoolToken0Balance := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) + oldPoolBar := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) + oldPoolFoo := balanceOfByRegisterCall(fooPath, consts.POOL_ADDR) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 16000) + + std.TestSetPrevRealm(consts.ROUTER_PATH) + std.TestSetOrigCaller(test1) poolIn, poolOut := Swap( - fooPath, barPath, + fooPath, fee500, test1, true, @@ -91,27 +111,31 @@ func TestSwapFooBarFooToBar(t *testing.T) { shouldEQ(t, poolIn, bigint(16000)) shouldEQ(t, poolOut, bigint(-5882)) - newtest1Token1Balance := balanceOfByRegisterCall(fooPath, test1) - newtest1Token0Balance := balanceOfByRegisterCall(barPath, test1) - newPoolToken1Balance := balanceOfByRegisterCall(fooPath, consts.POOL_ADDR) - newPoolToken0Balance := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) + newTest1Bar := balanceOfByRegisterCall(barPath, test1) + newTest1Foo := balanceOfByRegisterCall(fooPath, test1) - shouldEQ(t, oldtest1Token0Balance-newtest1Token0Balance, 16000) - shouldEQ(t, newtest1Token1Balance-oldtest1Token1Balance, 5882) - shouldEQ(t, newPoolToken0Balance-oldPoolToken0Balance, 16000) - shouldEQ(t, oldPoolToken1Balance-newPoolToken1Balance, 5882) + newPoolBar := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) + newPoolFoo := balanceOfByRegisterCall(fooPath, consts.POOL_ADDR) + + shouldEQ(t, oldTest1Bar-newTest1Bar, 16000) + shouldEQ(t, newTest1Foo-oldTest1Foo, 5882) + + shouldEQ(t, newPoolBar-oldPoolBar, 16000) + shouldEQ(t, oldPoolFoo-newPoolFoo, 5882) } // 7. Swap Bar:Baz Bar > Baz by test1 func TestSwapBarBazBarToBaz(t *testing.T) { - std.TestSetPrevRealm(consts.ROUTER_PATH) - std.TestSetOrigCaller(test1) - - oldtest1Token0Balance := balanceOfByRegisterCall(barPath, test1) + oldTest1Token0Balance := balanceOfByRegisterCall(barPath, test1) oldtest1BazBalance := balanceOfByRegisterCall(bazPath, test1) oldPoolToken0Balance := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) oldPoolBazBalance := balanceOfByRegisterCall(bazPath, consts.POOL_ADDR) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 16000) + + std.TestSetPrevRealm(consts.ROUTER_PATH) + std.TestSetOrigCaller(test1) poolIn, poolOut := Swap( barPath, bazPath, @@ -125,12 +149,12 @@ func TestSwapBarBazBarToBaz(t *testing.T) { shouldEQ(t, poolIn, bigint(16000)) shouldEQ(t, poolOut, bigint(-43457)) - newtest1Token0Balance := balanceOfByRegisterCall(barPath, test1) + newTest1Token0Balance := balanceOfByRegisterCall(barPath, test1) newtest1BazBalance := balanceOfByRegisterCall(bazPath, test1) newPoolToken0Balance := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) newPoolBazBalance := balanceOfByRegisterCall(bazPath, consts.POOL_ADDR) - shouldEQ(t, oldtest1Token0Balance-newtest1Token0Balance, 16000) + shouldEQ(t, oldTest1Token0Balance-newTest1Token0Balance, 16000) shouldEQ(t, newtest1BazBalance-oldtest1BazBalance, 43457) shouldEQ(t, newPoolToken0Balance-oldPoolToken0Balance, 16000) shouldEQ(t, oldPoolBazBalance-newPoolBazBalance, 43457) @@ -141,8 +165,8 @@ func TestCollectFooBarFees(t *testing.T) { std.TestSetPrevRealm(consts.POSITION_PATH) std.TestSetOrigCaller(test1) - oldtest1Token1Balance := balanceOfByRegisterCall(fooPath, test1) - oldtest1Token0Balance := balanceOfByRegisterCall(barPath, test1) + oldTest1Token1Balance := balanceOfByRegisterCall(fooPath, test1) + oldTest1Token0Balance := balanceOfByRegisterCall(barPath, test1) oldPoolToken1Balance := balanceOfByRegisterCall(fooPath, consts.POOL_ADDR) oldPoolToken0Balance := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) @@ -163,13 +187,13 @@ func TestCollectFooBarFees(t *testing.T) { shouldNEQ(t, c0, bigint(0)) // swap was foo > bar, so only foo has fees shouldEQ(t, c1, bigint(0)) // swap was foo > bar, so bar has no fees - newtest1Token1Balance := balanceOfByRegisterCall(fooPath, test1) - newtest1Token0Balance := balanceOfByRegisterCall(barPath, test1) + newTest1Token1Balance := balanceOfByRegisterCall(fooPath, test1) + newTest1Token0Balance := balanceOfByRegisterCall(barPath, test1) newPoolToken1Balance := balanceOfByRegisterCall(fooPath, consts.POOL_ADDR) newPoolToken0Balance := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) - shouldEQ(t, newtest1Token1Balance-oldtest1Token1Balance, uint64(c1)) - shouldEQ(t, newtest1Token0Balance-oldtest1Token0Balance, uint64(c0)) + shouldEQ(t, newTest1Token1Balance-oldTest1Token1Balance, uint64(c1)) + shouldEQ(t, newTest1Token0Balance-oldTest1Token0Balance, uint64(c0)) shouldEQ(t, oldPoolToken1Balance-newPoolToken1Balance, uint64(c1)) shouldEQ(t, oldPoolToken0Balance-newPoolToken0Balance, uint64(c0)) } @@ -179,7 +203,7 @@ func TestCollectBarBazFees(t *testing.T) { std.TestSetPrevRealm(consts.POSITION_PATH) std.TestSetOrigCaller(test1) - oldtest1Token0Balance := balanceOfByRegisterCall(barPath, test1) + oldTest1Token0Balance := balanceOfByRegisterCall(barPath, test1) oldtest1BazBalance := balanceOfByRegisterCall(bazPath, test1) oldPoolToken0Balance := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) oldPoolBazBalance := balanceOfByRegisterCall(bazPath, consts.POOL_ADDR) @@ -201,12 +225,12 @@ func TestCollectBarBazFees(t *testing.T) { shouldNEQ(t, c0, bigint(0)) // swap was foo > bar, so only foo has fees shouldEQ(t, c1, bigint(0)) // swap was foo > bar, so bar has no fees - newtest1Token0Balance := balanceOfByRegisterCall(barPath, test1) + newTest1Token0Balance := balanceOfByRegisterCall(barPath, test1) newtest1BazBalance := balanceOfByRegisterCall(bazPath, test1) newPoolToken0Balance := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) newPoolBazBalance := balanceOfByRegisterCall(bazPath, consts.POOL_ADDR) - shouldEQ(t, newtest1Token0Balance-oldtest1Token0Balance, uint64(c0)) + shouldEQ(t, newTest1Token0Balance-oldTest1Token0Balance, uint64(c0)) shouldEQ(t, newtest1BazBalance-oldtest1BazBalance, uint64(c1)) shouldEQ(t, oldPoolToken0Balance-newPoolToken0Balance, uint64(c0)) shouldEQ(t, oldPoolBazBalance-newPoolBazBalance, uint64(c1)) @@ -267,8 +291,8 @@ func TestCollectFooBarLiquidity(t *testing.T) { std.TestSetOrigCaller(test1) std.TestSetPrevRealm(consts.POSITION_PATH) - oldtest1Token1Balance := balanceOfByRegisterCall(fooPath, test1) - oldtest1Token0Balance := balanceOfByRegisterCall(barPath, test1) + oldTest1Token1Balance := balanceOfByRegisterCall(fooPath, test1) + oldTest1Token0Balance := balanceOfByRegisterCall(barPath, test1) oldPoolToken1Balance := balanceOfByRegisterCall(fooPath, consts.POOL_ADDR) oldPoolToken0Balance := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) @@ -286,13 +310,13 @@ func TestCollectFooBarLiquidity(t *testing.T) { shouldNEQ(t, c0, bigint(0)) shouldNEQ(t, c1, bigint(0)) - newtest1Token1Balance := balanceOfByRegisterCall(fooPath, test1) - newtest1Token0Balance := balanceOfByRegisterCall(barPath, test1) + newTest1Token1Balance := balanceOfByRegisterCall(fooPath, test1) + newTest1Token0Balance := balanceOfByRegisterCall(barPath, test1) newPoolToken1Balance := balanceOfByRegisterCall(fooPath, consts.POOL_ADDR) newPoolToken0Balance := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) - shouldEQ(t, newtest1Token1Balance-oldtest1Token1Balance, uint64(c0)) - shouldEQ(t, newtest1Token0Balance-oldtest1Token0Balance, uint64(c1)) + shouldEQ(t, newTest1Token1Balance-oldTest1Token1Balance, uint64(c0)) + shouldEQ(t, newTest1Token0Balance-oldTest1Token0Balance, uint64(c1)) shouldEQ(t, oldPoolToken1Balance-newPoolToken1Balance, uint64(c0)) shouldEQ(t, oldPoolToken0Balance-newPoolToken0Balance, uint64(c1)) } @@ -302,7 +326,7 @@ func TestCollectBarBazLiquidity(t *testing.T) { std.TestSetOrigCaller(test1) std.TestSetPrevRealm(consts.POSITION_PATH) - oldtest1Token0Balance := balanceOfByRegisterCall(barPath, test1) + oldTest1Token0Balance := balanceOfByRegisterCall(barPath, test1) oldtest1BazBalance := balanceOfByRegisterCall(bazPath, test1) oldPoolToken0Balance := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) oldPoolBazBalance := balanceOfByRegisterCall(bazPath, consts.POOL_ADDR) @@ -321,12 +345,12 @@ func TestCollectBarBazLiquidity(t *testing.T) { shouldNEQ(t, c0, bigint(0)) shouldNEQ(t, c1, bigint(0)) - newtest1Token0Balance := balanceOfByRegisterCall(barPath, test1) + newTest1Token0Balance := balanceOfByRegisterCall(barPath, test1) newtest1BazBalance := balanceOfByRegisterCall(bazPath, test1) newPoolToken0Balance := balanceOfByRegisterCall(barPath, consts.POOL_ADDR) newPoolBazBalance := balanceOfByRegisterCall(bazPath, consts.POOL_ADDR) - shouldEQ(t, newtest1Token0Balance-oldtest1Token0Balance, uint64(c0)) + shouldEQ(t, newTest1Token0Balance-oldTest1Token0Balance, uint64(c0)) shouldEQ(t, newtest1BazBalance-oldtest1BazBalance, uint64(c1)) shouldEQ(t, oldPoolToken0Balance-newPoolToken0Balance, uint64(c0)) shouldEQ(t, oldPoolBazBalance-newPoolBazBalance, uint64(c1)) diff --git a/pool/_TEST_pool_native_swap_test.gnoa b/pool/_TEST_pool_native_swap_test.gnoa index f127c064..4ef5fd67 100644 --- a/pool/_TEST_pool_native_swap_test.gnoa +++ b/pool/_TEST_pool_native_swap_test.gnoa @@ -4,25 +4,28 @@ import ( "std" "testing" - "gno.land/r/demo/wugnot" - "gno.land/r/demo/consts" + + "gno.land/r/demo/gns" + + "gno.land/r/demo/foo" + "gno.land/r/demo/wugnot" ) var ( test_tickLower = int32(9000) test_tickUpper = int32(11000) - test_liquidityExpect = bigint(1000) + test_liquidityExpect = bigint(100_000_000) ) // 1. Init & Create Pool func TestPoolInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(gsa) InitManual() + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) CreatePool(fooPath, consts.WRAPPED_WUGNOT, fee500, 130621891405341611593710811006) // x2.7 - - shouldPanic(t, func() { CreatePool(fooPath, consts.WRAPPED_WUGNOT, fee500, 130621891405341611593710811006) }) } // 2. Mint LP and Get GNFT @@ -32,15 +35,22 @@ func TestMint(t *testing.T) { token0, token1 = token1, token0 } + // prepare ugnot + testBanker := std.GetBanker(std.BankerTypeRealmIssue) + testBanker.IssueCoin(test1, "ugnot", 804_031) + // simulate transfer & decrase std.TestSetOrigSend(std.Coins{{"ugnot", 804_031}}, nil) - testBanker := std.GetBanker(std.BankerTypeRealmIssue) testBanker.RemoveCoin(std.GetOrigCaller(), "ugnot", 804_031) // Deposit(wrap) std.TestSetPrevAddr(test1) wugnot.Deposit() + std.TestSetPrevAddr(test1) + foo.Approve(a2u(consts.POOL_ADDR), 295801) + wugnot.Approve(a2u(consts.POOL_ADDR), 804031) + // Mint std.TestSetPrevRealm(consts.POSITION_PATH) amount0, amount1 := Mint( @@ -65,6 +75,9 @@ func TestSwapBuyNative(t *testing.T) { shouldEQ(t, test1OldT0Bal, 499999999704199) // foo shouldEQ(t, test1OldT1Bal, bigint(0)) // wugnot + std.TestSetPrevAddr(test1) + foo.Approve(a2u(consts.POOL_ADDR), 10000) + std.TestSetPrevRealm(consts.ROUTER_PATH) std.TestSetOrigCaller(test1) amount0, amount1 := Swap( @@ -94,10 +107,11 @@ func TestSwapSellNative(t *testing.T) { shouldEQ(t, test1OldT0Bal, 499999999694199) shouldEQ(t, test1OldT1Bal, 27123) - // test1 has 27131 wugnot from previous swap - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + wugnot.Approve(a2u(consts.POOL_ADDR), 10000) std.TestSetPrevRealm(consts.ROUTER_PATH) + std.TestSetOrigCaller(test1) amount0, amount1 := Swap( // ugnot 10_000 > foo ?? fooPath, // token0 consts.WRAPPED_WUGNOT, // token1 diff --git a/pool/_TEST_pool_single_lp_test.gnoa b/pool/_TEST_pool_single_lp_test.gnoa index 04164cdd..27560c78 100644 --- a/pool/_TEST_pool_single_lp_test.gnoa +++ b/pool/_TEST_pool_single_lp_test.gnoa @@ -1,9 +1,15 @@ package pool import ( - "encoding/gjson" "std" "testing" + "time" + + "encoding/gjson" + + "gno.land/r/demo/bar" + "gno.land/r/demo/foo" + "gno.land/r/demo/gns" "gno.land/r/demo/consts" ) @@ -19,23 +25,23 @@ var ( // 1. Init & Create Pool using Factory Contract by Gnoswap Admin func TestInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(gsa) InitManual() - std.TestSetOrigCaller(test1) - CreatePool(barPath, fooPath, fee500, 130621891405341611593710811006) - - // sqrtPrice - // 130621891405341611593710811006 // tick = 10000 - shouldPanic(t, func() { CreatePool(barPath, fooPath, 500, 130621891405341611593710811006) }) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + CreatePool(barPath, fooPath, fee500, 130621891405341611593710811006) // x2.7 } // 2. Mint by test1 func TestMint(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + foo.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + std.TestSetPrevRealm(consts.POSITION_PATH) std.TestSetOrigCaller(test1) - - Mint( + amount0, amount1 := Mint( fooPath, barPath, fee500, @@ -44,6 +50,8 @@ func TestMint(t *testing.T) { test_tickUpper, test_liquidityExpect, ) + shouldEQ(t, amount0, bigint(29)) + shouldEQ(t, amount1, bigint(80)) pool := GetPool(barPath, fooPath, fee500) test_liquidity := pool.PoolGetLiquidity() @@ -289,11 +297,11 @@ func TestSwap(t *testing.T) { // 6. SetFeeProtocol by Gnoswap Admin func TestSetFeeProtocol(t *testing.T) { // non admin call - std.TestSetOrigCaller(test1) + std.TestSetOrigCaller(gsa) shouldPanic(t, func() { SetFeeProtocol(2, 2) }) // admin call - std.TestSetOrigCaller(test1) + std.TestSetOrigCaller(gsa) SetFeeProtocol(6, 8) for _, pool := range pools { @@ -303,8 +311,7 @@ func TestSetFeeProtocol(t *testing.T) { // 7. CollectProtocol by Gnoswap Admin func TestCollectProtocol(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetOrigCaller(gsa) SetFeeProtocol(6, 8) pool := GetPool(barPath, fooPath, fee500) test_slot0 := pool.PoolGetSlot0() @@ -321,7 +328,7 @@ func TestCollectProtocol(t *testing.T) { test1OldToken0Bal := balanceOfByRegisterCall(pool.token0Path, test1) test1OldToken1Bal := balanceOfByRegisterCall(pool.token1Path, test1) - std.TestSetPrevAddr(test1) + std.TestSetPrevAddr(gsa) amount0, amount1 := CollectProtocol(barPath, fooPath, fee500, test1, 100000, 100000) test1NewToken0Bal := balanceOfByRegisterCall(pool.token0Path, test1) @@ -340,7 +347,7 @@ func TestCollectProtocol(t *testing.T) { test1OldToken0Bal := balanceOfByRegisterCall(pool.token0Path, test1) test1OldToken1Bal := balanceOfByRegisterCall(pool.token1Path, test1) - std.TestSetPrevAddr(test1) + std.TestSetPrevAddr(gsa) amount0, amount1 := CollectProtocol(barPath, fooPath, fee500, test1, 100000, 100000) test1NewToken0Bal := balanceOfByRegisterCall(pool.token0Path, test1) @@ -353,8 +360,8 @@ func TestApiGetPools(t *testing.T) { gpls := ApiGetPools() jsonStr := gjson.Parse(gpls) - shouldEQ(t, jsonStr.Get("stat.height").Int(), GetHeight()) - shouldEQ(t, jsonStr.Get("stat.timestamp").Int(), GetTimestamp()) + shouldEQ(t, jsonStr.Get("stat.height").Int(), std.GetHeight()) + shouldEQ(t, jsonStr.Get("stat.timestamp").Int(), time.Now().Unix()) shouldEQ(t, len(jsonStr.Get("response").Array()), 1) } diff --git a/pool/_TEST_rpc_test.gnoa b/pool/_TEST_rpc_test.gnoa index d9fe797a..9f22ce44 100644 --- a/pool/_TEST_rpc_test.gnoa +++ b/pool/_TEST_rpc_test.gnoa @@ -7,43 +7,59 @@ import ( "encoding/gjson" "gno.land/r/demo/consts" + + "gno.land/r/demo/bar" + "gno.land/r/demo/baz" + "gno.land/r/demo/foo" + + "gno.land/r/demo/gns" ) var ( test_tickLower = int32(9000) test_tickUpper = int32(11000) test_liquidityExpect = bigint(100_000_000) - - test_tickLower2 = int32(50000) - test_tickUpper2 = int32(100000) ) // 1. Init Pool func TestInit(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(gsa) InitManual() + std.TestSkipHeights(1) } // 2. Create Foo:Bar Pool func TestCreateFooBarPool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + std.TestSkipHeights(1) + CreatePool(fooPath, barPath, fee500, 130621891405341611593710811006) shouldEQ(t, len(pools), 1) + std.TestSkipHeights(1) } // 3. Create Bar:Baz Pool func TestCreateBarBazPool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + std.TestSkipHeights(1) + CreatePool(barPath, bazPath, fee500, 130621891405341611593710811006) shouldEQ(t, len(pools), 2) + std.TestSkipHeights(1) } // 4. Mint Foo:Bar Liquidity by test1 func TestMintFooBarLiquidity(t *testing.T) { + std.TestSetPrevAddr(test1) + foo.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + bar.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + std.TestSkipHeights(2) + std.TestSetPrevRealm(consts.POSITION_PATH) std.TestSetOrigCaller(test1) - - Mint( + amount0, amount1 := Mint( fooPath, barPath, fee500, @@ -52,14 +68,21 @@ func TestMintFooBarLiquidity(t *testing.T) { -test_tickLower, test_liquidityExpect, ) + shouldEQ(t, amount0, bigint(8040315)) + shouldEQ(t, amount1, bigint(2958014)) + std.TestSkipHeights(1) } // 5. Mint Bar:Baz Liquidity by test1 func TestMintBarBazLiquidity(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + baz.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + std.TestSkipHeights(2) + std.TestSetPrevRealm(consts.POSITION_PATH) std.TestSetOrigCaller(test1) - - Mint( + amount0, amount1 := Mint( barPath, bazPath, fee500, @@ -68,6 +91,9 @@ func TestMintBarBazLiquidity(t *testing.T) { test_tickUpper, test_liquidityExpect, ) + shouldEQ(t, amount0, bigint(2958014)) + shouldEQ(t, amount1, bigint(8040315)) + std.TestSkipHeights(1) } // API TESTS diff --git a/pool/emergency_halt.gno b/pool/emergency_halt.gno index ac488ffa..ce76dd10 100644 --- a/pool/emergency_halt.gno +++ b/pool/emergency_halt.gno @@ -1,6 +1,8 @@ package pool import ( + "std" + "gno.land/p/demo/ufmt" "gno.land/r/demo/consts" ) @@ -23,7 +25,7 @@ func assertCalledByGovRealm() { consts.GOV_PATH, ufmt.Sprintf( "[POOL] emergency_halt.gno__assertCalledByGovRealm() || only gov(%s) can call, but called from(%s)", - consts.GOV_PATH, PrevRealmPath(), + consts.GOV_PATH, std.PrevRealm().PkgPath(), ), ) } diff --git a/pool/gno_helper.gno b/pool/gno_helper.gno index efa19b33..ffc3c637 100644 --- a/pool/gno_helper.gno +++ b/pool/gno_helper.gno @@ -2,40 +2,10 @@ package pool import ( "std" - "time" "gno.land/r/demo/consts" ) -func GetHeight() int64 { - return std.GetHeight() -} - -func GetTimestamp() int64 { - return time.Now().Unix() -} - -func GetChainID() string { - return std.GetChainID() -} - func GetOrigPkgAddr() std.Address { return consts.POOL_ADDR - // return std.GetOrigPkgAddr() -} - -func GetOrigCaller() std.Address { - return std.GetOrigCaller() -} - -func PrevRealmAddr() std.Address { - return std.PrevRealm().Addr() -} - -func PrevRealmPath() string { - return std.PrevRealm().PkgPath() -} - -func PrevRealm() std.Realm { - return std.PrevRealm() } diff --git a/pool/pool.gno b/pool/pool.gno index 29ee3cd2..8aea42b1 100644 --- a/pool/pool.gno +++ b/pool/pool.gno @@ -8,7 +8,7 @@ import ( "gno.land/r/demo/consts" - g "gno.land/r/demo/gov" + gv "gno.land/r/demo/gov" ) // only position contract can call this function @@ -21,7 +21,7 @@ func Mint( tickUpper int32, liquidityAmount bigint, ) (bigint, bigint) { - requirePrevRealmPath(consts.POSITION_PATH, ufmt.Sprintf("[POOL] pool.gno__Mint() || expected PrevRealmPath(%s), got %s", consts.POSITION_PATH, PrevRealmPath())) + requirePrevRealmPath(consts.POSITION_PATH, ufmt.Sprintf("[POOL] pool.gno__Mint() || expected std.PrevRealm().PkgPath()(%s), got %s", consts.POSITION_PATH, std.PrevRealm().PkgPath())) requirePositive(liquidityAmount, ufmt.Sprintf("[POOL] pool.gno__Mint() || expected liquidityAmount(%d) > 0", liquidityAmount)) @@ -44,7 +44,7 @@ func Mint( if amount0 > 0 { balance0Before := bigint(balanceOfByRegisterCall(pool.token0Path, GetOrigPkgAddr())) - from := GetOrigCaller() // token should be transferred from actual user(GetOrigCaller), not from the realm(PrevRealm) + from := std.GetOrigCaller() // token should be transferred from actual user(std.GetOrigCaller), not from the realm(PrevRealm) to := GetOrigPkgAddr() ok := transferFromByRegisterCall(pool.token0Path, from, to, uint64(amount0)) @@ -68,7 +68,7 @@ func Mint( if amount1 > 0 { balance1Before = bigint(balanceOfByRegisterCall(pool.token1Path, GetOrigPkgAddr())) - from := GetOrigCaller() // token should be transferred from actual user(GetOrigCaller), not from the realm(PrevRealm) + from := std.GetOrigCaller() // token should be transferred from actual user(std.GetOrigCaller), not from the realm(PrevRealm) to := GetOrigPkgAddr() ok := transferFromByRegisterCall(pool.token1Path, from, to, uint64(amount1)) @@ -104,7 +104,7 @@ func Burn( tickUpper int32, amount bigint, ) (bigint, bigint) { - requirePrevRealmPath(consts.POSITION_PATH, ufmt.Sprintf("[POOL] pool.gno__Burn() || expected PrevRealmPath(%s), got %s", consts.POSITION_PATH, PrevRealmPath())) + requirePrevRealmPath(consts.POSITION_PATH, ufmt.Sprintf("[POOL] pool.gno__Burn() || expected PrevRealmPath(%s), got %s", consts.POSITION_PATH, std.PrevRealm().PkgPath())) requireUnsigned(amount, ufmt.Sprintf("[POOL] pool.gno__Burn() || amount(%d) >= 0", amount)) @@ -112,7 +112,7 @@ func Burn( position, amount0Int, amount1Int := pool.modifyPosition( ModifyPositionParams{ - PrevRealmAddr(), // msg.sender + std.PrevRealm().Addr(), // msg.sender tickLower, tickUpper, -amount, @@ -128,7 +128,7 @@ func Burn( position.tokensOwed1 += amount1 } - positionKey := positionGetKey(PrevRealmAddr(), tickLower, tickUpper) + positionKey := positionGetKey(std.PrevRealm().Addr(), tickLower, tickUpper) pool.positions[positionKey] = position // actual token transfer happens in Collect() @@ -146,14 +146,14 @@ func Collect( amount0Requested bigint, amount1Requested bigint, ) (bigint, bigint) { - requirePrevRealmPath(consts.POSITION_PATH, ufmt.Sprintf("[POOL] pool.gno__Collect() || expected PrevRealmPath(%s), got %s", consts.POSITION_PATH, PrevRealmPath())) + requirePrevRealmPath(consts.POSITION_PATH, ufmt.Sprintf("[POOL] pool.gno__Collect() || expected PrevRealmPath(%s), got %s", consts.POSITION_PATH, std.PrevRealm().PkgPath())) requireUnsigned(amount0Requested, ufmt.Sprintf("[POOL] pool.gno__Collect() || amount0Requested(%d) >= 0", amount0Requested)) requireUnsigned(amount1Requested, ufmt.Sprintf("[POOL] pool.gno__Collect() || amount1Requested(%d) >= 0", amount1Requested)) pool := GetPool(token0Path, token1Path, fee) - positionKey := positionGetKey(PrevRealmAddr(), tickLower, tickUpper) + positionKey := positionGetKey(std.PrevRealm().Addr(), tickLower, tickUpper) position, exist := pool.positions[positionKey] requireExist(exist, ufmt.Sprintf("[POOL] pool.gno__Collect() || position(%s) does not exist", positionKey)) @@ -194,7 +194,7 @@ func Swap( sqrtPriceLimitX96 bigint, payer std.Address, // router ) (bigint, bigint) { - requirePrevRealmPath(consts.ROUTER_PATH, ufmt.Sprintf("[POOL] pool.gno__Swap() || expected PrevRealmPath(%s), got %s", consts.ROUTER_PATH, PrevRealmPath())) + requirePrevRealmPath(consts.ROUTER_PATH, ufmt.Sprintf("[POOL] pool.gno__Swap() || expected PrevRealmPath(%s), got %s", consts.ROUTER_PATH, std.PrevRealm().PkgPath())) // early panic require(amountSpecified != 0, ufmt.Sprintf("[POOL] pool.gno__Swap() || amountSpecified(%d) != 0", amountSpecified)) @@ -471,7 +471,7 @@ func SetFeeProtocol( feeProtocol0 uint8, feeProtocol1 uint8, ) { - require(isAdmin(PrevRealmAddr()), ufmt.Sprintf("[POOL] pool.gno__SetFeeProtocol() || caller(%s) must be admin", PrevRealmAddr())) + require(isAdmin(std.PrevRealm().Addr()), ufmt.Sprintf("[POOL] pool.gno__SetFeeProtocol() || caller(%s) must be admin", std.PrevRealm().Addr())) require( (feeProtocol0 == 0 || (feeProtocol0 >= 4 && feeProtocol0 <= 10)) && (feeProtocol1 == 0 || (feeProtocol1 >= 4 && feeProtocol1 <= 10)), @@ -487,7 +487,7 @@ func SetFeeProtocol( } // update governace value - g.SetGovParameter("protocoL_fees", feeProtocol0+(feeProtocol1<<4)) + gv.SetGovParameter("protocoL_fees", feeProtocol0+(feeProtocol1<<4)) } // ADMIN @@ -501,7 +501,7 @@ func CollectProtocol( ) (bigint, bigint) { requireUnsigned(amount0Requested, ufmt.Sprintf("[POOL] pool.gno__CollectProtocol() || amount0Requested(%d) >= 0", amount0Requested)) requireUnsigned(amount1Requested, ufmt.Sprintf("[POOL] pool.gno__CollectProtocol() || amount1Requested(%d) >= 0", amount1Requested)) - require(isAdmin(PrevRealmAddr()), ufmt.Sprintf("[POOL] pool.gno__CollectProtocol() || caller(%s) must be admin", PrevRealmAddr())) + require(isAdmin(std.PrevRealm().Addr()), ufmt.Sprintf("[POOL] pool.gno__CollectProtocol() || caller(%s) must be admin", std.PrevRealm().Addr())) pool := GetPool(token0Path, token1Path, fee) diff --git a/pool/pool_manager.gno b/pool/pool_manager.gno index 315a91f6..fab50b43 100644 --- a/pool/pool_manager.gno +++ b/pool/pool_manager.gno @@ -21,12 +21,15 @@ var ( ) func InitManual() { + // MUST BE ORIGIN CALLER + std.AssertOriginCall() require(!initialized, ufmt.Sprintf("[POOl] pool_manager.gno__InitManual() || expected initialized(%t) == false", initialized)) + require(std.GetOrigCaller() == consts.GNOSWAP_ADMIN, ufmt.Sprintf("[POOl] pool_manager.gno__InitManual() || expected std.GetOrigCaller(%s) == consts.GNOSWAP_ADMIN(%s)", std.GetOrigCaller().String(), consts.GNOSWAP_ADMIN.String())) feeAmountTickSpacing[100] = 2 // 0.01% feeAmountTickSpacing[500] = 10 // 0.05% feeAmountTickSpacing[3000] = 60 // 0.3% feeAmountTickSpacing[10000] = 200 // 1% - admins = append(admins, PrevRealmAddr()) + admins = append(admins, std.PrevRealm().Addr()) initialized = true } @@ -90,7 +93,7 @@ func GetPoolPath(token0Path, token1Path string, fee uint16) string { } func AddAdmin(addr std.Address) { - caller := PrevRealmAddr() + caller := std.PrevRealm().Addr() if isAdmin(caller) { admins = append(admins, addr) } else { @@ -99,7 +102,7 @@ func AddAdmin(addr std.Address) { } func RemoveAdmin(addr std.Address) { - caller := PrevRealmAddr() + caller := std.PrevRealm().Addr() if isAdmin(caller) { if len(admins) == 1 { diff --git a/pool/pool_register.gno b/pool/token_register.gno similarity index 100% rename from pool/pool_register.gno rename to pool/token_register.gno diff --git a/pool/utils.gno b/pool/utils.gno index a6397828..e67104e3 100644 --- a/pool/utils.gno +++ b/pool/utils.gno @@ -74,7 +74,7 @@ func requireExist(exist bool, msg string) { } func requirePrevRealmPath(prevRealmPath, msg string) { - if PrevRealmPath() != prevRealmPath { + if std.PrevRealm().PkgPath() != prevRealmPath { panic(msg) } } diff --git a/position/_RPC_api.gno b/position/_RPC_api.gno index 3f2cd277..86bbd0ef 100644 --- a/position/_RPC_api.gno +++ b/position/_RPC_api.gno @@ -2,6 +2,8 @@ package position import ( "encoding/json" + "std" + "time" "gno.land/p/demo/common" "gno.land/p/demo/ufmt" @@ -49,8 +51,8 @@ func ApiGetPositions() string { r := ResponseApiGetPositions{ Stat: ResponseQueryBase{ - Height: GetHeight(), - Timestamp: GetTimestamp(), + Height: std.GetHeight(), + Timestamp: time.Now().Unix(), }, Response: rpcPositions, } diff --git a/position/_TEST_INIT_register_tokens_test.gno b/position/_TEST_0_INIT_TOKEN_REGISTER_test.gno similarity index 99% rename from position/_TEST_INIT_register_tokens_test.gno rename to position/_TEST_0_INIT_TOKEN_REGISTER_test.gno index a5e471c1..412cd3a0 100644 --- a/position/_TEST_INIT_register_tokens_test.gno +++ b/position/_TEST_0_INIT_TOKEN_REGISTER_test.gno @@ -18,6 +18,7 @@ import ( "gno.land/r/demo/gns" "gno.land/r/demo/consts" + "gno.land/r/demo/users" pl "gno.land/r/demo/pool" // only for position `testcase`` to call grc20 by register diff --git a/position/_TEST_INIT_basic_test.gno b/position/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno similarity index 56% rename from position/_TEST_INIT_basic_test.gno rename to position/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno index 28ebabc8..e6737eae 100644 --- a/position/_TEST_INIT_basic_test.gno +++ b/position/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno @@ -4,13 +4,7 @@ import ( "std" "testing" - "gno.land/r/demo/gns" - - "gno.land/r/demo/bar" - "gno.land/r/demo/baz" - "gno.land/r/demo/foo" - - "gno.land/r/demo/wugnot" + "gno.land/r/demo/consts" "gno.land/r/demo/gnft" @@ -18,43 +12,25 @@ import ( ) var ( - test1 std.Address - poolAddr, posAddr std.Address + gsa std.Address = consts.GNOSWAP_ADMIN + test1 std.Address = std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") - barPath = "gno.land/r/demo/bar" - bazPath = "gno.land/r/demo/baz" - fooPath = "gno.land/r/demo/foo" + fooPath string = "gno.land/r/demo/foo" + barPath string = "gno.land/r/demo/bar" + bazPath string = "gno.land/r/demo/baz" + quxPath string = "gno.land/r/demo/qux" - wgnotPath = "gno.land/r/demo/wugnot" + oblPath string = "gno.land/r/demo/obl" + // wugnotPath string = "gno.land/r/demo/wugnot" // from consts + // gnsPath string = "gno.land/r/demo/gns" // from consts - fee100 = uint16(100) - fee500 = uint16(500) - fee3000 = uint16(3000) + fee100 uint16 = 100 + fee500 uint16 = 500 + fee3000 uint16 = 3000 - max_timeout = bigint(9999999999) + max_timeout bigint = 9999999999 ) -func init() { - test1 = std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") - // prepare ugnot - 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") - - std.TestSetPrevAddr(test1) - - gns.Approve(a2u(poolAddr), 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) - - wugnot.Approve(a2u(poolAddr), 500_000_000_000_000) - -} - /* HELPER */ func shouldEQ(t *testing.T, got, expected interface{}) { if got != expected { diff --git a/position/_TEST_position_api_test.gnoa b/position/_TEST_position_api_test.gno similarity index 78% rename from position/_TEST_position_api_test.gnoa rename to position/_TEST_position_api_test.gno index 4d90d864..7d3b238e 100644 --- a/position/_TEST_position_api_test.gnoa +++ b/position/_TEST_position_api_test.gno @@ -8,6 +8,10 @@ import ( "gno.land/r/demo/consts" + "gno.land/r/demo/bar" + "gno.land/r/demo/foo" + "gno.land/r/demo/gns" + pl "gno.land/r/demo/pool" ) @@ -19,24 +23,21 @@ var ( // 1. Init & Create Pool func TestPoolInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(gsa) pl.InitManual() - std.TestSetOrigCaller(test1) - pl.CreatePool(fooPath, barPath, fee500, 130621891405341611593710811006) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) - // fee - // 500 = 0.05% // USv3 default - // 3000 = 0.3% // USv3 default - // 10000 = 1% // USv3 default - - // sqrtPrice - // 130621891405341611593710811006 // tick = 10000 - shouldPanic(t, func() { pl.CreatePool(fooPath, barPath, 500, 130621891405341611593710811006) }) + pl.CreatePool(fooPath, barPath, fee500, 130621891405341611593710811006) // tick = 10000 } // 2. Mint LP and Get GNFT func TestMint(t *testing.T) { + std.TestSetPrevAddr(test1) + foo.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) // COLLECT_FEE + bar.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) // COLLECT_FEE + // test1 mints => will get tid 1 nft std.TestSetOrigCaller(test1) Mint(fooPath, barPath, fee500, int32(9000), int32(11000), bigint(1_000_000), bigint(1_000_000), bigint(1), bigint(1), bigint(1234567890)) @@ -48,7 +49,7 @@ func TestMint(t *testing.T) { // 3. Swap to make position fee func TestSwap(t *testing.T) { - std.TestSetPrevRealm("gno.land/r/demo/router") + std.TestSetPrevRealm(consts.ROUTER_PATH) std.TestSetOrigCaller(test1) pl.Swap( fooPath, diff --git a/position/_TEST_position_increase_decrease_test.gno b/position/_TEST_position_increase_decrease_test.gnoa similarity index 67% rename from position/_TEST_position_increase_decrease_test.gno rename to position/_TEST_position_increase_decrease_test.gnoa index 745f8a8a..f935dfd6 100644 --- a/position/_TEST_position_increase_decrease_test.gno +++ b/position/_TEST_position_increase_decrease_test.gnoa @@ -8,23 +8,27 @@ import ( "gno.land/r/demo/consts" + "gno.land/r/demo/bar" + "gno.land/r/demo/foo" + "gno.land/r/demo/gns" + pl "gno.land/r/demo/pool" ) // 1. Init & Create Pool func TestPoolInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(gsa) pl.InitManual() - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) pl.CreatePool(barPath, fooPath, fee500, common.TickMathGetSqrtRatioAtTick(10000)) // x2.71814592682522526700950038502924144268035888671875 - - // sqrtPrice - shouldPanic(t, func() { pl.CreatePool(fooPath, barPath, fee500, common.TickMathGetSqrtRatioAtTick(10000)) }) } func TestMintPosition(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 18394891) + foo.Approve(a2u(consts.POOL_ADDR), 49999999) // r3v4_xxx: liquidity_management.gno #26 tokenId, liquidity, amount0, amount1 := Mint( barPath, @@ -41,16 +45,18 @@ func TestMintPosition(t *testing.T) { shouldEQ(t, tokenId, 1) shouldEQ(t, getNextId(), 2) shouldEQ(t, amount0, bigint(18394891)) - shouldEQ(t, amount1, bigint(50000000)) + shouldEQ(t, amount1, bigint(49999999)) // r3v4_xxx: liquidity_management.gno #26 } func TestIncreaseLiquidity(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 3678978) + foo.Approve(a2u(consts.POOL_ADDR), 9999999) // r3v4_xxx: liquidity_management.gno #26 pool := getPoolFromLpTokenId(uint64(1)) oldLiquidity := pool.PoolGetLiquidity() - IncreaseLiquidity( + _, _, m0, m1 := IncreaseLiquidity( uint64(1), // tokenId bigint(10_000_000), // amount0Desired bigint(10_000_000), // amount1Desired @@ -58,6 +64,8 @@ func TestIncreaseLiquidity(t *testing.T) { bigint(0), // amount1Min max_timeout, // deadline ) + shouldEQ(t, m0, bigint(3678978)) + shouldEQ(t, m1, bigint(9999999)) // r3v4_xxx: liquidity_management.gno #26 newLiquidity := pool.PoolGetLiquidity() @@ -65,6 +73,8 @@ func TestIncreaseLiquidity(t *testing.T) { } func TestCollectFeeBeforeSwap(t *testing.T) { + std.TestSetPrevAddr(test1) + tokenId, fee0, fee1, poolPath := CollectFee(1) shouldEQ(t, tokenId, uint64(1)) shouldEQ(t, fee0, bigint(0)) @@ -73,6 +83,9 @@ func TestCollectFeeBeforeSwap(t *testing.T) { } func TestSwap(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 1_234_567) + std.TestSetPrevRealm(consts.ROUTER_PATH) std.TestSetOrigCaller(test1) amount0, amount1 := pl.Swap( @@ -88,8 +101,10 @@ func TestSwap(t *testing.T) { } func TestCollectFeeAfterSwap(t *testing.T) { - std.TestSetPrevRealm("") - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + + bar.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + foo.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) tokenId, fee0, fee1, poolPath := CollectFee(1) shouldEQ(t, tokenId, uint64(1)) @@ -108,7 +123,9 @@ func TestCollectFee2(t *testing.T) { shouldEQ(t, fee1, bigint(0)) // this it output token shouldEQ(t, poolPath, "gno.land/r/demo/bar:gno.land/r/demo/foo:500") - // println(unclaimedFee(uint64(1))) // should be 0, 0 + fee0, fee1 = unclaimedFee(uint64(1)) + shouldEQ(t, fee0, bigint(0)) + shouldEQ(t, fee1, bigint(0)) } func TestSwap2(t *testing.T) { @@ -129,10 +146,15 @@ func TestSwap2(t *testing.T) { std.TestSetPrevRealm("") std.TestSetOrigCaller(test1) - // println(unclaimedFee(uint64(1))) // 499 0 - // tokenId, fee0, fee1, poolPath := CollectFee(1) - // println("fee0", fee0) // 495 ( 1% of fee differ ) - // println("fee1", fee1) // 0 + fee0, fee1 := unclaimedFee(uint64(1)) + shouldEQ(t, fee0, bigint(499)) + shouldEQ(t, fee1, bigint(0)) + + tokenId, fee0, fee1, poolPath := CollectFee(1) + shouldEQ(t, tokenId, uint64(1)) + shouldEQ(t, fee0, bigint(495)) // 499 -> 495 ≈ cause of protocol fee + shouldEQ(t, fee1, bigint(0)) + shouldEQ(t, poolPath, "gno.land/r/demo/bar:gno.land/r/demo/foo:500") } func TestDecreaseLiquidity(t *testing.T) { @@ -141,7 +163,7 @@ func TestDecreaseLiquidity(t *testing.T) { oldLiquidity := getPoolFromLpTokenId(uint64(1)).PoolGetLiquidity() - tokenId, liquidity, amount0, amount1 := DecreaseLiquidity( + tokenId, liquidity, amount0, amount1, targetPoolPath := DecreaseLiquidity( uint64(1), // tokenId bigint(10_000_000), // liquidity bigint(0), // amount0Min diff --git a/position/_TEST_position_test.gnoa b/position/_TEST_position_test.gnoa index b516c1cd..16e73c77 100644 --- a/position/_TEST_position_test.gnoa +++ b/position/_TEST_position_test.gnoa @@ -1,32 +1,37 @@ package position import ( - "encoding/gjson" "std" "testing" - "gno.land/p/demo/common" + "encoding/gjson" + "gno.land/r/demo/consts" pl "gno.land/r/demo/pool" + "gno.land/r/demo/bar" + "gno.land/r/demo/foo" + + "gno.land/r/demo/gns" + "gno.land/r/demo/gnft" ) -// 1. Init & Create Pool func TestPoolInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetOrigCaller(gsa) pl.InitManual() - std.TestSetOrigCaller(test1) - pl.CreatePool(barPath, fooPath, fee500, common.TickMathGetSqrtRatioAtTick(10000)) // x2.71814592682522526700950038502924144268035888671875 + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) - // sqrtPrice - shouldPanic(t, func() { pl.CreatePool(fooPath, barPath, fee500, common.TickMathGetSqrtRatioAtTick(10000)) }) + pl.CreatePool(barPath, fooPath, fee500, 130621891405341611593710811006) // tick = 10000 } func TestMintPosition01InRange(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 18394891) + foo.Approve(a2u(consts.POOL_ADDR), 49999999) tokenId, liquidity, amount0, amount1 := Mint( barPath, @@ -43,11 +48,13 @@ func TestMintPosition01InRange(t *testing.T) { shouldEQ(t, tokenId, 1) shouldEQ(t, getNextId(), 2) shouldEQ(t, amount0, bigint(18394891)) - shouldEQ(t, amount1, bigint(50000000)) + shouldEQ(t, amount1, bigint(49999999)) } func TestMintPosition02LowerRange(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 0) + foo.Approve(a2u(consts.POOL_ADDR), 49999999) tokenId, liquidity, amount0, amount1 := Mint( barPath, @@ -64,11 +71,13 @@ func TestMintPosition02LowerRange(t *testing.T) { shouldEQ(t, tokenId, 2) shouldEQ(t, getNextId(), 3) shouldEQ(t, amount0, bigint(0)) - shouldEQ(t, amount1, bigint(50000000)) + shouldEQ(t, amount1, bigint(49999999)) } func TestMintPosition03UpperRange(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 49999999) + foo.Approve(a2u(consts.POOL_ADDR), 0) tokenId, liquidity, amount0, amount1 := Mint( barPath, @@ -84,7 +93,7 @@ func TestMintPosition03UpperRange(t *testing.T) { ) shouldEQ(t, tokenId, 3) shouldEQ(t, getNextId(), 4) - shouldEQ(t, amount0, bigint(50000000)) + shouldEQ(t, amount0, bigint(49999999)) shouldEQ(t, amount1, bigint(0)) } @@ -97,6 +106,9 @@ func TestCollectFeeBeforeSwap(t *testing.T) { } func TestSwap(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 1234567) + std.TestSetPrevRealm(consts.ROUTER_PATH) std.TestSetOrigCaller(test1) amount0, amount1 := pl.Swap( @@ -112,6 +124,10 @@ func TestSwap(t *testing.T) { } func TestCollectFeeAfterSwap(t *testing.T) { + std.TestSetPrevAddr(test1) + foo.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) // COLLECT_FEE + bar.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) // COLLECT_FEE + tokenId, fee0, fee1, poolPath := CollectFee(1) shouldEQ(t, tokenId, uint64(1)) shouldNEQ(t, fee0, bigint(0)) // this is input token @@ -120,19 +136,19 @@ func TestCollectFeeAfterSwap(t *testing.T) { } -func TestBurnUpperPosition(t *testing.T) { +func TestDecreaseLiquidityUpperPosition(t *testing.T) { std.TestSetOrigCaller(test1) ownerOfPosition := gnft.OwnerOf(tid(3)) - shouldEQ(t, ownerOfPosition, GetOrigCaller()) + shouldEQ(t, ownerOfPosition, std.GetOrigCaller()) - tokenId, liquidity, amount0, amount1, poolPath := Burn(3) + tokenId, liquidity, amount0, amount1, poolPath := DecreaseLiquidity(uint64(3), consts.MAX_UINT256, 0, 0, max_timeout) shouldEQ(t, tokenId, uint64(3)) - shouldEQ(t, amount0, bigint(50000000)) + shouldEQ(t, amount0, bigint(49999999)) shouldEQ(t, amount1, bigint(0)) ownerOfPosition = gnft.OwnerOf(tid(3)) - shouldEQ(t, ownerOfPosition, GetOrigCaller()) + shouldEQ(t, ownerOfPosition, std.GetOrigCaller()) } func TestApiGetPositions(t *testing.T) { diff --git a/position/_TEST_position_test_two_position_used_single_swap_test.gnoa b/position/_TEST_position_test_two_position_used_single_swap_test.gnoa index 4fce12a5..2cb345f4 100644 --- a/position/_TEST_position_test_two_position_used_single_swap_test.gnoa +++ b/position/_TEST_position_test_two_position_used_single_swap_test.gnoa @@ -4,26 +4,30 @@ import ( "std" "testing" - "gno.land/p/demo/common" "gno.land/r/demo/consts" pl "gno.land/r/demo/pool" + + "gno.land/r/demo/bar" + "gno.land/r/demo/foo" + "gno.land/r/demo/gns" ) -// 1. Init & Create Pool + func TestPoolInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetOrigCaller(gsa) pl.InitManual() - std.TestSetOrigCaller(test1) - pl.CreatePool(barPath, fooPath, fee500, common.TickMathGetSqrtRatioAtTick(10000)) // x2.71814592682522526700950038502924144268035888671875 + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) - // sqrtPrice - shouldPanic(t, func() { pl.CreatePool(fooPath, barPath, fee500, common.TickMathGetSqrtRatioAtTick(10000)) }) + pl.CreatePool(barPath, fooPath, fee500, 130621891405341611593710811006) // tick = 10000 } func TestMintPosition01WideInRange(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 18394891) + foo.Approve(a2u(consts.POOL_ADDR), 49999999) tokenId, liquidity, amount0, amount1 := Mint( barPath, @@ -39,13 +43,15 @@ func TestMintPosition01WideInRange(t *testing.T) { ) shouldEQ(t, tokenId, 1) shouldEQ(t, getNextId(), 2) - shouldEQ(t, liquidity, bigint(318704394)) + shouldEQ(t, liquidity, bigint(318704392)) shouldEQ(t, amount0, bigint(18394891)) - shouldEQ(t, amount1, bigint(50000000)) + shouldEQ(t, amount1, bigint(49999999)) } func TestMintPositionTightInRange(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 18394891) + foo.Approve(a2u(consts.POOL_ADDR), 49999999) tokenId, liquidity, amount0, amount1 := Mint( barPath, @@ -61,9 +67,9 @@ func TestMintPositionTightInRange(t *testing.T) { ) shouldEQ(t, tokenId, 2) shouldEQ(t, getNextId(), 3) - shouldEQ(t, liquidity, bigint(1228379123)) + shouldEQ(t, liquidity, bigint(1228379121)) shouldEQ(t, amount0, bigint(18394891)) - shouldEQ(t, amount1, bigint(50000000)) + shouldEQ(t, amount1, bigint(49999999)) } func TestCollectFeeBeforeSwapPos1(t *testing.T) { @@ -83,6 +89,9 @@ func TestCollectFeeBeforeSwapPos2(t *testing.T) { } func TestSwap(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 1234567) + std.TestSetPrevRealm(consts.ROUTER_PATH) std.TestSetOrigCaller(test1) amount0, amount1 := pl.Swap( @@ -99,6 +108,10 @@ func TestSwap(t *testing.T) { // IF POSITION 2 DOESN'T EXIST, POSITION 1 WILL EARN '617' as fee func TestCollectFeeAfterSwapPos1(t *testing.T) { + std.TestSetPrevAddr(test1) + foo.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) // COLLECT_FEE + bar.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) // COLLECT_FEE + tokenId, fee0, fee1, poolPath := CollectFee(1) shouldEQ(t, tokenId, uint64(1)) // shouldEQ(t, fee0, bigint(617)) diff --git a/position/gno_helper.gno b/position/gno_helper.gno index 4958d681..3b94ea16 100644 --- a/position/gno_helper.gno +++ b/position/gno_helper.gno @@ -2,32 +2,10 @@ package position import ( "std" - "time" "gno.land/r/demo/consts" ) -func GetChainID() string { - return std.GetChainID() -} - -func GetHeight() int64 { - return std.GetHeight() -} - -func GetTimestamp() int64 { - return time.Now().Unix() -} - func GetOrigPkgAddr() std.Address { return consts.POSITION_ADDR - // return std.GetOrigPkgAddr() -} - -func GetOrigCaller() std.Address { - return std.GetOrigCaller() -} - -func PrevRealmAddr() std.Address { - return std.PrevRealm().Addr() } diff --git a/position/liquidity_management.gno b/position/liquidity_management.gno index 35c28790..697c1776 100644 --- a/position/liquidity_management.gno +++ b/position/liquidity_management.gno @@ -22,7 +22,8 @@ func addLiquidity(params AddLiquidityParams) (bigint, bigint, bigint) { params.amount0Desired, params.amount1Desired, ) - liquidity += 2 // r3v4_xxx: adjust for rounding errors + // r3v4_xxx: adjust for rounding errors + // liquidity += 2 pToken0, pToken1, pFee := poolKeyDivide(params.poolKey) amount0, amount1 := pl.Mint( diff --git a/position/position.gno b/position/position.gno index 7f55c911..d87e08c3 100644 --- a/position/position.gno +++ b/position/position.gno @@ -1,6 +1,8 @@ package position import ( + "std" + "gno.land/p/demo/ufmt" "gno.land/r/demo/consts" @@ -69,14 +71,14 @@ func mint(params MintParams) (uint64, bigint, bigint, bigint) { tokenId := nextId nextId++ // nextId = nextId + 1 - gnft.Mint(a2u(GetOrigCaller()), tid(tokenId)) // owner, tokenId + gnft.Mint(a2u(std.GetOrigCaller()), tid(tokenId)) // owner, tokenId positionKey := positionKeyCompute(GetOrigPkgAddr(), params.tickLower, params.tickUpper) feeGrowthInside0LastX128, feeGrowthInside1LastX128 := pool.PoolGetPositionFeeGrowthInside0LastX128(positionKey), pool.PoolGetPositionFeeGrowthInside1LastX128(positionKey) position := Position{ nonce: 0, - operator: PrevRealmAddr(), + operator: std.PrevRealm().Addr(), poolKey: pl.GetPoolPath(params.token0, params.token1, params.fee), tickLower: params.tickLower, tickUpper: params.tickUpper, @@ -115,10 +117,10 @@ func increaseLiquidity(params IncreaseLiquidityParams) (uint64, bigint, bigint, // verify tokenId exists require(exists(params.tokenId), ufmt.Sprintf("[POSITION] position.gno__increaseLiquidity() || tokenId(%d) doesn't exist", params.tokenId)) - // MUST BE OWNER TO DECREASE LIQUIDITY + // MUST BE OWNER TO INCREASE LIQUIDITY // can not be approved address > staked position can be modified owner := gnft.OwnerOf(tid(params.tokenId)) - require(owner == GetOrigCaller(), ufmt.Sprintf("[POSITION] position.gno__decreaseLiquidity() || only owner can decrease liquidity__owner(%s) == GetOrigCaller(%s)", owner, GetOrigCaller())) + require(owner == std.GetOrigCaller(), ufmt.Sprintf("[POSITION] position.gno__increaseLiquidity() || only owner can increase liquidity__owner(%s) == std.GetOrigCaller(%s)", owner, std.GetOrigCaller())) checkDeadline(params.deadline) @@ -162,7 +164,7 @@ func DecreaseLiquidity( amount0Min bigint, amount1Min bigint, deadline bigint, -) (uint64, bigint, bigint, bigint) { // tokenId, liquidity, amount0, amount1 +) (uint64, bigint, bigint, bigint, string) { // tokenId, liquidity, amount0, amount1, poolPath decreaseLiquidityParams := DecreaseLiquidityParams{ tokenId: tokenId, liquidity: liquidity, @@ -174,13 +176,13 @@ func DecreaseLiquidity( return decreaseLiquidity(decreaseLiquidityParams) } -func decreaseLiquidity(params DecreaseLiquidityParams) (uint64, bigint, bigint, bigint) { +func decreaseLiquidity(params DecreaseLiquidityParams) (uint64, bigint, bigint, bigint, string) { // verify tokenId require(exists(params.tokenId), ufmt.Sprintf("[POSITION] position.gno__decreaseLiquidity() || tokenId(%d) doesn't exist", params.tokenId)) // MUST BE OWNER TO DECREASE LIQUIDITY ( can not be approved address ) owner := gnft.OwnerOf(tid(params.tokenId)) - require(owner == GetOrigCaller(), ufmt.Sprintf("[POSITION] position.gno__decreaseLiquidity() || only owner can decrease liquidity__owner(%s) == GetOrigCaller(%s)", owner, GetOrigCaller())) + require(owner == std.GetOrigCaller(), ufmt.Sprintf("[POSITION] position.gno__decreaseLiquidity() || only owner can decrease liquidity__owner(%s) == std.GetOrigCaller(%s)", owner, std.GetOrigCaller())) checkDeadline(params.deadline) @@ -221,7 +223,7 @@ func decreaseLiquidity(params DecreaseLiquidityParams) (uint64, bigint, bigint, pToken0, pToken1, pFee, - GetOrigCaller(), + std.GetOrigCaller(), position.tickLower, position.tickUpper, burnedAmount0, @@ -238,7 +240,7 @@ func decreaseLiquidity(params DecreaseLiquidityParams) (uint64, bigint, bigint, burnPosition(params.tokenId) // just update flag } - return params.tokenId, params.liquidity, amount0, amount1 + return params.tokenId, params.liquidity, amount0, amount1, position.poolKey } func CollectFee(tokenId uint64) (uint64, bigint, bigint, string) { // tokenId, tokensOwed0, tokensOwed1, poolPath @@ -275,7 +277,7 @@ func CollectFee(tokenId uint64) (uint64, bigint, bigint, string) { // tokenId, t token0, token1, fee, - GetOrigCaller(), + std.GetOrigCaller(), position.tickLower, position.tickUpper, consts.MAX_UINT64, // r3v4_xxx: current grc20 handles amount by `uint64` @@ -311,7 +313,7 @@ func burnPosition(tokenId uint64) { } func isAuthorizedForToken(tokenId uint64) { - require(isApprovedOrOwner(PrevRealmAddr(), tokenId), ufmt.Sprintf("[POSITION] position.gno__isAuthorizedForToken() || caller(%s) is not approved or owner of tokenId(%d)", PrevRealmAddr(), tokenId)) + require(isApprovedOrOwner(std.PrevRealm().Addr(), tokenId), ufmt.Sprintf("[POSITION] position.gno__isAuthorizedForToken() || caller(%s) is not approved or owner of tokenId(%d)", std.PrevRealm().Addr(), tokenId)) } func deleteFromPositions(m map[uint64]Position, key uint64) map[uint64]Position { diff --git a/position/util.gno b/position/util.gno index b65acaba..575ea2fc 100644 --- a/position/util.gno +++ b/position/util.gno @@ -4,6 +4,7 @@ import ( "std" "strconv" "strings" + "time" "gno.land/p/demo/ufmt" @@ -17,7 +18,7 @@ func require(condition bool, message string) { } func checkDeadline(deadline bigint) { - require(bigint(GetTimestamp()) <= deadline, ufmt.Sprintf("[POSITION] util.gno__checkDeadline() || transaction too old__GetTimestamp()(%d) <= deadline(%d)", GetTimestamp(), deadline)) + require(bigint(time.Now().Unix()) <= deadline, ufmt.Sprintf("[POSITION] util.gno__checkDeadline() || transaction too old__time.Now().Unix()(%d) <= deadline(%d)", time.Now().Unix(), deadline)) } func a2u(addr std.Address) users.AddressOrName { diff --git a/router/_RPC_api.gno b/router/_RPC_api.gno index 45c3bf2a..0eec3b76 100644 --- a/router/_RPC_api.gno +++ b/router/_RPC_api.gno @@ -2,8 +2,10 @@ package router import ( "encoding/json" + "std" "strconv" "strings" + "time" "gno.land/p/demo/common" "gno.land/p/demo/ufmt" @@ -29,8 +31,8 @@ type ResponseGetRatiosFromBase struct { func ApiGetRatiosFromBase() string { qb := ResponseQueryBase{ - Height: GetHeight(), - Timestamp: GetTimestamp(), + Height: std.GetHeight(), + Timestamp: time.Now().Unix(), } ratios := findRatios(3) diff --git a/router/_TEST_INIT_register_tokens_test.gno b/router/_TEST_0_INIT_TOKEN_REGISTER_test.gno similarity index 99% rename from router/_TEST_INIT_register_tokens_test.gno rename to router/_TEST_0_INIT_TOKEN_REGISTER_test.gno index 715304b1..74590ea2 100644 --- a/router/_TEST_INIT_register_tokens_test.gno +++ b/router/_TEST_0_INIT_TOKEN_REGISTER_test.gno @@ -18,6 +18,7 @@ import ( "gno.land/r/demo/gns" "gno.land/r/demo/consts" + "gno.land/r/demo/users" pl "gno.land/r/demo/pool" // only for position `testcase`` to call grc20 by register diff --git a/router/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno b/router/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno new file mode 100644 index 00000000..ea302b7c --- /dev/null +++ b/router/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno @@ -0,0 +1,62 @@ +package router + +import ( + "std" + "testing" + + "gno.land/r/demo/consts" +) + +var ( + gsa std.Address = consts.GNOSWAP_ADMIN + test1 std.Address = std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") + + fooPath string = "gno.land/r/demo/foo" + barPath string = "gno.land/r/demo/bar" + bazPath string = "gno.land/r/demo/baz" + quxPath string = "gno.land/r/demo/qux" + + oblPath string = "gno.land/r/demo/obl" + // wugnotPath string = "gno.land/r/demo/wugnot" // from consts + // gnsPath string = "gno.land/r/demo/gns" // from consts + + fee100 uint16 = 100 + fee500 uint16 = 500 + fee3000 uint16 = 3000 + + max_timeout bigint = 9999999999 +) + +/* HELPER */ +func shouldEQ(t *testing.T, got, expected interface{}) { + if got != expected { + t.Errorf("got %v, expected %v", got, expected) + } +} + +func shouldNEQ(t *testing.T, got, expected interface{}) { + if got == expected { + t.Errorf("got %v, didn't expected %v", got, expected) + } +} + +func shouldGT(t *testing.T, l, r interface{}) { + if !(l < r) { + t.Errorf("expected %v < %v", l, r) + } +} + +func shouldLT(t *testing.T, l, r interface{}) { + if !(l > r) { + t.Errorf("expected %v > %v", l, r) + } +} + +func shouldPanic(t *testing.T, f func()) { + defer func() { + if r := recover(); r == nil { + t.Errorf("expected panic") + } + }() + f() +} diff --git a/router/_TEST_INIT_basic_test.gno b/router/_TEST_INIT_basic_test.gno deleted file mode 100644 index 546df60a..00000000 --- a/router/_TEST_INIT_basic_test.gno +++ /dev/null @@ -1,106 +0,0 @@ -package router - -import ( - "std" - "testing" - - "gno.land/r/demo/gns" - - "gno.land/r/demo/bar" - "gno.land/r/demo/baz" - "gno.land/r/demo/foo" - "gno.land/r/demo/qux" - - "gno.land/r/demo/obl" - - "gno.land/r/demo/wugnot" - - "gno.land/r/demo/consts" -) - -var ( - test1 std.Address - - barPath = "gno.land/r/demo/bar" - bazPath = "gno.land/r/demo/baz" - fooPath = "gno.land/r/demo/foo" - gnsPath = "gno.land/r/demo/gns" - oblPath = "gno.land/r/demo/obl" - quxPath = "gno.land/r/demo/qux" - wgnotPath = "gno.land/r/demo/wugnot" - - fee100 = uint16(100) - fee500 = uint16(500) - fee3000 = uint16(3000) - - max_timeout = bigint(9999999999) -) - -func init() { - test1 = std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") - - // prepare ugnot - testBanker := std.GetBanker(std.BankerTypeRealmIssue) - testBanker.IssueCoin(test1, "ugnot", 500_000_000_000_000) - - std.TestSetPrevAddr(test1) - gns.Approve(a2u(consts.POOL_ADDR), 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(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(consts.POOL_ADDR), 500_000_000_000_000) - - std.TestSetPrevAddr(consts.INTERNAL_REWARD_ACCOUNT) - gns.Approve(a2u(consts.STAKER_ADDR), 500_000_000_000_000) // to create internal incentive -} - -/* HELPER */ -func shouldEQ(t *testing.T, got, expected interface{}) { - if got != expected { - t.Errorf("got %v, expected %v", got, expected) - } -} - -func shouldNEQ(t *testing.T, got, expected interface{}) { - if got == expected { - t.Errorf("got %v, didn't expected %v", got, expected) - } -} - -func shouldGT(t *testing.T, l, r interface{}) { - if !(l < r) { - t.Errorf("expected %v < %v", l, r) - } -} - -func shouldLT(t *testing.T, l, r interface{}) { - if !(l > r) { - t.Errorf("expected %v > %v", l, r) - } -} - -func shouldPanic(t *testing.T, f func()) { - defer func() { - if r := recover(); r == nil { - t.Errorf("expected panic") - } - }() - f() -} - -func ugnotBalanceOf(addr std.Address) uint64 { - testBanker := std.GetBanker(std.BankerTypeRealmIssue) - - coins := testBanker.GetCoins(addr) - if len(coins) == 0 { - return 0 - } - - return uint64(testBanker.GetCoins(addr)[0].Amount) -} diff --git a/router/_TEST_router_ratio_test.gnoa b/router/_TEST_router_ratio_test.gnoa index e1542e24..cd4abfcc 100644 --- a/router/_TEST_router_ratio_test.gnoa +++ b/router/_TEST_router_ratio_test.gnoa @@ -9,23 +9,28 @@ import ( pn "gno.land/r/demo/position" "gno.land/p/demo/common" + "gno.land/r/demo/consts" + "gno.land/r/demo/bar" + "gno.land/r/demo/foo" + "gno.land/r/demo/gns" + "gno.land/r/demo/qux" "gno.land/r/demo/wugnot" ) func TestInitManual(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(gsa) pl.InitManual() - std.TestSkipHeights(1) } func TestPoolCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*(3+4+3)) // 1 HOPS - pl.CreatePool(barPath, wgnotPath, fee100, common.TickMathGetSqrtRatioAtTick(10_000)) - pl.CreatePool(barPath, wgnotPath, fee500, common.TickMathGetSqrtRatioAtTick(20_000)) - pl.CreatePool(barPath, wgnotPath, fee3000, common.TickMathGetSqrtRatioAtTick(60_000)) // NOT USED BY SMALL LIQ + pl.CreatePool(barPath, consts.WRAPPED_WUGNOT, fee100, common.TickMathGetSqrtRatioAtTick(10_000)) + pl.CreatePool(barPath, consts.WRAPPED_WUGNOT, fee500, common.TickMathGetSqrtRatioAtTick(20_000)) + pl.CreatePool(barPath, consts.WRAPPED_WUGNOT, fee3000, common.TickMathGetSqrtRatioAtTick(60_000)) // NOT USED BY SMALL LIQ // -10_000 0.367897 // -20_000 0.135348 // 0.367897 + 0.135348 = 0.503245 @@ -33,7 +38,7 @@ func TestPoolCreatePool(t *testing.T) { // 1 WGNOT = 0.2516225 BAR // 2 HOPS - pl.CreatePool(wgnotPath, quxPath, fee100, common.TickMathGetSqrtRatioAtTick(0)) // 1:1 + pl.CreatePool(consts.WRAPPED_WUGNOT, quxPath, fee100, common.TickMathGetSqrtRatioAtTick(0)) // 1:1 pl.CreatePool(quxPath, fooPath, fee100, common.TickMathGetSqrtRatioAtTick(50_000)) pl.CreatePool(quxPath, fooPath, fee500, common.TickMathGetSqrtRatioAtTick(60_000)) pl.CreatePool(quxPath, fooPath, fee3000, common.TickMathGetSqrtRatioAtTick(100_000)) // NOT USED BY SMALL LIQ @@ -44,33 +49,39 @@ func TestPoolCreatePool(t *testing.T) { // 1 WGNOT = 275.8419265 BAR // 3 HOPS - pl.CreatePool(wgnotPath, bazPath, fee100, common.TickMathGetSqrtRatioAtTick(6932)) // 1:2 - pl.CreatePool(bazPath, oblPath, fee100, common.TickMathGetSqrtRatioAtTick(6932)) // 1:2 - pl.CreatePool(oblPath, gnsPath, fee100, common.TickMathGetSqrtRatioAtTick(6932)) // 1:2 + pl.CreatePool(consts.WRAPPED_WUGNOT, bazPath, fee100, common.TickMathGetSqrtRatioAtTick(6932)) // 1:2 + pl.CreatePool(bazPath, oblPath, fee100, common.TickMathGetSqrtRatioAtTick(6932)) // 1:2 + pl.CreatePool(oblPath, consts.GNS_PATH, fee100, common.TickMathGetSqrtRatioAtTick(6932)) // 1:2 // 1 GNOT = 8 GNS } func TestPositionMint(t *testing.T) { std.TestSetOrigCaller(test1) - // wugnot prepare - std.TestSetOrigSend(std.Coins{{"ugnot", 100_000_000_000}}, nil) + // prepare ugnot testBanker := std.GetBanker(std.BankerTypeRealmIssue) + testBanker.IssueCoin(test1, "ugnot", 100_000_000_000) + std.TestSetOrigSend(std.Coins{{"ugnot", 100_000_000_000}}, nil) testBanker.RemoveCoin(std.GetOrigCaller(), "ugnot", 100_000_000_000) // Deposit(wrap) std.TestSetPrevAddr(test1) wugnot.Deposit() - pn.Mint(barPath, wgnotPath, fee100, 8000, 12000, 100_000_000, 100_000_000, 0, 0, max_timeout) - pn.Mint(barPath, wgnotPath, fee500, 18000, 22000, 80_000_000, 80_000_000, 0, 0, max_timeout) - pn.Mint(barPath, wgnotPath, fee3000, 58020, 62040, 10_000_000, 10_000_000, 0, 0, max_timeout) + bar.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + wugnot.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + qux.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + foo.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + + pn.Mint(barPath, consts.WRAPPED_WUGNOT, fee100, 8000, 12000, 100_000_000, 100_000_000, 0, 0, max_timeout) + pn.Mint(barPath, consts.WRAPPED_WUGNOT, fee500, 18000, 22000, 80_000_000, 80_000_000, 0, 0, max_timeout) + pn.Mint(barPath, consts.WRAPPED_WUGNOT, fee3000, 58020, 62040, 10_000_000, 10_000_000, 0, 0, max_timeout) pn.Mint(quxPath, fooPath, fee100, 48000, 52000, 100_000_000, 100_000_000, 0, 0, max_timeout) pn.Mint(quxPath, fooPath, fee500, 58000, 62000, 80_000_000, 80_000_000, 0, 0, max_timeout) pn.Mint(quxPath, fooPath, fee3000, 98040, 10020, 10_000_000, 10_000_000, 0, 0, max_timeout) - // pn.Mint(fooPath, gnsPath, fee100, 48000, 52000, 100_000_000, 100_000_000, 0, 0, max_timeout) + // pn.Mint(fooPath, consts.GNS_PATH, fee100, 48000, 52000, 100_000_000, 100_000_000, 0, 0, max_timeout) } func TestApiGetRatiosFromBase(t *testing.T) { diff --git a/router/_TEST_router_swap_route_1route_1hop_out_range_test.gnoa b/router/_TEST_router_swap_route_1route_1hop_out_range_test.gnoa index 49b67c7e..fc20ced7 100644 --- a/router/_TEST_router_swap_route_1route_1hop_out_range_test.gnoa +++ b/router/_TEST_router_swap_route_1route_1hop_out_range_test.gnoa @@ -5,19 +5,25 @@ import ( "std" "testing" + "gno.land/r/demo/consts" + pl "gno.land/r/demo/pool" pn "gno.land/r/demo/position" + + "gno.land/r/demo/bar" + "gno.land/r/demo/baz" + + "gno.land/r/demo/gns" ) func TestInitManual(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(gsa) pl.InitManual() - std.TestSkipHeights(1) } func TestCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) pl.CreatePool(barPath, bazPath, fee500, 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 jsonOutput := pl.ApiGetPools() @@ -27,14 +33,16 @@ func TestCreatePool(t *testing.T) { func TestPositionMint(t *testing.T) { // bar_baz_500 by test1 - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + baz.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) // Mint tokenId, liquidity, amount0, amount1 := pn.Mint(barPath, bazPath, fee500, int32(12000), int32(15000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) shouldEQ(t, tokenId, uint64(1)) - shouldEQ(t, liquidity, bigint(1308151)) - shouldEQ(t, amount0, bigint(100000)) // ONLY BAR - shouldEQ(t, amount1, bigint(0)) // NO BAZ + // shouldEQ(t, liquidity, bigint(1308151)) + shouldEQ(t, amount0, bigint(99999)) // ONLY BAR + shouldEQ(t, amount1, bigint(0)) // NO BAZ } func TestDrySwapRouteBarBazExactIn(t *testing.T) { @@ -65,7 +73,7 @@ func TestSwapRouteBarBazExactIn(t *testing.T) { "EXACT_IN", // swapType "gno.land/r/demo/baz:gno.land/r/demo/bar:500", // strRouteArr "100", // quoteArr - 2710, // tokenAmountLimit + 2710, // tokenAmountLimit ( too few recieved (expected 2710, got 300)) ) }) } diff --git a/router/_TEST_router_swap_route_1route_1hop_test.gno b/router/_TEST_router_swap_route_1route_1hop_test.gno deleted file mode 100644 index b5022dd5..00000000 --- a/router/_TEST_router_swap_route_1route_1hop_test.gno +++ /dev/null @@ -1,165 +0,0 @@ -package router - -import ( - "encoding/gjson" - "std" - "testing" - - "gno.land/r/demo/consts" - - "gno.land/r/demo/bar" - "gno.land/r/demo/baz" - - pl "gno.land/r/demo/pool" - pn "gno.land/r/demo/position" -) - -func TestInitManual(t *testing.T) { - std.TestSetOrigCaller(test1) - pl.InitManual() - std.TestSkipHeights(1) -} - -func TestCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) - - pl.CreatePool(barPath, bazPath, uint16(500), 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 - - jsonOutput := pl.ApiGetPools() - jsonStr := gjson.Parse(jsonOutput) - shouldEQ(t, len(jsonStr.Get("response").Array()), 1) -} - -func TestPositionMint(t *testing.T) { - // bar_baz_500 by test1 - std.TestSetOrigCaller(test1) - - // Mint - pn.Mint(barPath, bazPath, uint16(500), int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) -} - -func TestDrySwapRouteBarBazExactIn(t *testing.T) { - std.TestSetOrigCaller(test1) - - dryResult := DrySwapRoute( - barPath, // inputToken - bazPath, // outputToken - bigint(1000), // amountSpecified - "EXACT_IN", // swapType - "gno.land/r/demo/bar:gno.land/r/demo/baz:500", // strRouteArr - "100", // quoteArr - ) - - shouldEQ(t, dryResult, bigint(2707)) -} - -func TestSwapRouteBarBazExactIn(t *testing.T) { - std.TestSetPrevAddr(test1) - baz.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) - - swapResult := SwapRoute( - barPath, // inputToken - bazPath, // outputToken - bigint(1000), // amountSpecified - "EXACT_IN", // swapType - "gno.land/r/demo/bar:gno.land/r/demo/baz:500", // strRouteArr - "100", // quoteArr - 2700, // tokenAmountLimit - ) - shouldEQ(t, swapResult, bigint(2707)) -} - -func TestDrySwapRouteBarBazExactOut(t *testing.T) { - std.TestSetOrigCaller(test1) - - dryResult := DrySwapRoute( - barPath, // inputToken - bazPath, // outputToken - bigint(1000), // amountSpecified - "EXACT_OUT", // swapType - "gno.land/r/demo/bar:gno.land/r/demo/baz:500", // strRouteArr - "100", // quoteArr - ) - - shouldEQ(t, dryResult, bigint(369)) -} - -func TestSwapRouteBarBazExactOut(t *testing.T) { - std.TestSetPrevAddr(test1) - baz.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) - - swapResult := SwapRoute( - barPath, // inputToken - bazPath, // outputToken - bigint(1000), // amountSpecified - "EXACT_OUT", // swapType - "gno.land/r/demo/bar:gno.land/r/demo/baz:500", // strRouteArr - "100", // quoteArr - 370, // tokenAmountLimit - ) - - shouldEQ(t, swapResult, bigint(369)) -} - -func TestDrySwapRouteBazBarExactIn(t *testing.T) { - std.TestSetOrigCaller(test1) - - dryResult := DrySwapRoute( - bazPath, // inputToken - barPath, // outputToken - bigint(1000), // amountSpecified - "EXACT_IN", // swapType - "gno.land/r/demo/baz:gno.land/r/demo/bar:500", // strRouteArr - "100", // quoteArr - ) - - shouldEQ(t, dryResult, bigint(368)) -} - -func TestSwapRouteBazBarExactIn(t *testing.T) { - std.TestSetOrigCaller(test1) - - swapResult := SwapRoute( - bazPath, // inputToken - barPath, // outputToken - bigint(1000), // amountSpecified - "EXACT_IN", // swapType - "gno.land/r/demo/baz:gno.land/r/demo/bar:500", // strRouteArr - "100", // quoteArr - 360, // tokenAmountLimit - ) - - shouldEQ(t, swapResult, bigint(368)) -} - -func TestDrySwapRouteBazBarExactOut(t *testing.T) { - std.TestSetOrigCaller(test1) - - dryResult := DrySwapRoute( - bazPath, // inputToken - barPath, // outputToken - bigint(3000), // amountSpecified - "EXACT_IN", // swapType - "gno.land/r/demo/baz:gno.land/r/demo/bar:500", // strRouteArr - "100", // quoteArr - ) - - shouldEQ(t, dryResult, bigint(1103)) -} - -func TestSwapRouteBazBarExactOut(t *testing.T) { - std.TestSetPrevAddr(test1) - bar.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) - - swapResult := SwapRoute( - bazPath, // inputToken - barPath, // outputToken - bigint(3000), // amountSpecified - "EXACT_IN", // swapType - "gno.land/r/demo/baz:gno.land/r/demo/bar:500", // strRouteArr - "100", // quoteArr - 1100, // tokenAmountLimit - ) - - shouldEQ(t, swapResult, bigint(1103)) -} diff --git a/router/_TEST_router_swap_route_1route_1hop_test.gnoa b/router/_TEST_router_swap_route_1route_1hop_test.gnoa new file mode 100644 index 00000000..b2c25784 --- /dev/null +++ b/router/_TEST_router_swap_route_1route_1hop_test.gnoa @@ -0,0 +1,172 @@ +package router + +import ( + "encoding/gjson" + "std" + "testing" + + "gno.land/r/demo/consts" + + pl "gno.land/r/demo/pool" + pn "gno.land/r/demo/position" + + "gno.land/r/demo/bar" + "gno.land/r/demo/baz" + + "gno.land/r/demo/gns" +) + +func TestInitManual(t *testing.T) { + std.TestSetPrevAddr(gsa) + pl.InitManual() +} + +func TestCreatePool(t *testing.T) { + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + pl.CreatePool(barPath, bazPath, fee500, 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 + + jsonOutput := pl.ApiGetPools() + jsonStr := gjson.Parse(jsonOutput) + shouldEQ(t, len(jsonStr.Get("response").Array()), 1) +} + +func TestPositionMint(t *testing.T) { + // bar_baz_500 by test1 + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 36789) + baz.Approve(a2u(consts.POOL_ADDR), 99999) + + // Mint + tokenId, liquidity, amount0, amount1 := pn.Mint(barPath, bazPath, fee500, int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) + shouldEQ(t, tokenId, uint64(1)) + shouldEQ(t, amount0, bigint(36789)) + shouldEQ(t, amount1, bigint(99999)) +} + +func TestDrySwapRouteBarBazExactIn(t *testing.T) { + std.TestSetPrevAddr(test1) + + dryResult := DrySwapRoute( + barPath, // inputToken + bazPath, // outputToken + bigint(1000), // amountSpecified + "EXACT_IN", // swapType + "gno.land/r/demo/bar:gno.land/r/demo/baz:500", // strRouteArr + "100", // quoteArr + ) + + shouldEQ(t, dryResult, bigint(2711)) +} + +func TestSwapRouteBarBazExactIn(t *testing.T) { + std.TestSetPrevAddr(test1) + + bar.Approve(a2u(consts.POOL_ADDR), uint64(1000)) + baz.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) // ITS FOR 0.15% fee + + swapResult := SwapRoute( + barPath, // inputToken + bazPath, // outputToken + bigint(1000), // amountSpecified + "EXACT_IN", // swapType + "gno.land/r/demo/bar:gno.land/r/demo/baz:500", // strRouteArr + "100", // quoteArr + 2700, // tokenAmountLimit + ) + shouldEQ(t, swapResult, bigint(2707)) +} + +// func TestDrySwapRouteBarBazExactOut(t *testing.T) { +// std.TestSetPrevAddr(test1) + +// dryResult := DrySwapRoute( +// barPath, // inputToken +// bazPath, // outputToken +// bigint(1000), // amountSpecified +// "EXACT_OUT", // swapType +// "gno.land/r/demo/bar:gno.land/r/demo/baz:500", // strRouteArr +// "100", // quoteArr +// ) + +// shouldEQ(t, dryResult, bigint(369)) +// } + +// func TestSwapRouteBarBazExactOut(t *testing.T) { +// std.TestSetPrevAddr(test1) + +// swapResult := SwapRoute( +// barPath, // inputToken +// bazPath, // outputToken +// bigint(1000), // amountSpecified +// "EXACT_OUT", // swapType +// "gno.land/r/demo/bar:gno.land/r/demo/baz:500", // strRouteArr +// "100", // quoteArr +// 370, // tokenAmountLimit +// ) + +// shouldEQ(t, swapResult, bigint(369)) +// } + +// func TestDrySwapRouteBazBarExactIn(t *testing.T) { +// std.TestSetOrigCaller(test1) + +// dryResult := DrySwapRoute( +// bazPath, // inputToken +// barPath, // outputToken +// bigint(1000), // amountSpecified +// "EXACT_IN", // swapType +// "gno.land/r/demo/baz:gno.land/r/demo/bar:500", // strRouteArr +// "100", // quoteArr +// ) + +// shouldEQ(t, dryResult, bigint(368)) +// } + +// func TestSwapRouteBazBarExactIn(t *testing.T) { +// std.TestSetOrigCaller(test1) + +// swapResult := SwapRoute( +// bazPath, // inputToken +// barPath, // outputToken +// bigint(1000), // amountSpecified +// "EXACT_IN", // swapType +// "gno.land/r/demo/baz:gno.land/r/demo/bar:500", // strRouteArr +// "100", // quoteArr +// 360, // tokenAmountLimit +// ) + +// shouldEQ(t, swapResult, bigint(368)) +// } + +// func TestDrySwapRouteBazBarExactOut(t *testing.T) { +// std.TestSetOrigCaller(test1) + +// dryResult := DrySwapRoute( +// bazPath, // inputToken +// barPath, // outputToken +// bigint(3000), // amountSpecified +// "EXACT_IN", // swapType +// "gno.land/r/demo/baz:gno.land/r/demo/bar:500", // strRouteArr +// "100", // quoteArr +// ) + +// shouldEQ(t, dryResult, bigint(1103)) +// } + +// func TestSwapRouteBazBarExactOut(t *testing.T) { +// std.TestSetPrevAddr(test1) +// bar.Approve(a2u(consts.ROUTER_ADDR), uint64(consts.MAX_UINT64)) + +// swapResult := SwapRoute( +// bazPath, // inputToken +// barPath, // outputToken +// bigint(3000), // amountSpecified +// "EXACT_IN", // swapType +// "gno.land/r/demo/baz:gno.land/r/demo/bar:500", // strRouteArr +// "100", // quoteArr +// 1100, // tokenAmountLimit +// ) + +// shouldEQ(t, swapResult, bigint(1103)) +// } diff --git a/router/_TEST_router_swap_route_1route_2hop_native_in_out_test.gnoa b/router/_TEST_router_swap_route_1route_2hop_native_in_out_test.gnoa index c99f049c..62375868 100644 --- a/router/_TEST_router_swap_route_1route_2hop_native_in_out_test.gnoa +++ b/router/_TEST_router_swap_route_1route_2hop_native_in_out_test.gnoa @@ -5,24 +5,30 @@ import ( "std" "testing" + "gno.land/r/demo/consts" + pl "gno.land/r/demo/pool" - pos "gno.land/r/demo/position" + pn "gno.land/r/demo/position" + "gno.land/r/demo/bar" + "gno.land/r/demo/baz" + "gno.land/r/demo/gns" + "gno.land/r/demo/qux" "gno.land/r/demo/wugnot" ) func TestInitManual(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(gsa) pl.InitManual() - std.TestSkipHeights(1) } func TestCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*3) - pl.CreatePool(barPath, bazPath, fee500, 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 - pl.CreatePool(bazPath, quxPath, fee500, 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 - pl.CreatePool(quxPath, wgnotPath, fee500, 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 + pl.CreatePool(barPath, bazPath, fee500, 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 + pl.CreatePool(bazPath, quxPath, fee500, 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 + pl.CreatePool(quxPath, consts.WRAPPED_WUGNOT, fee500, 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 // 1 bar ≈ 19.683 gnot jsonOutput := pl.ApiGetPools() @@ -31,27 +37,33 @@ func TestCreatePool(t *testing.T) { } func TestPositionMintBarBaz(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 36789) + baz.Approve(a2u(consts.POOL_ADDR), 99999) - tokenId, liquidity, amount0, amount1 := pos.Mint(barPath, bazPath, fee500, int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) + tokenId, liquidity, amount0, amount1 := pn.Mint(barPath, bazPath, fee500, int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) shouldEQ(t, tokenId, uint64(1)) - shouldEQ(t, amount0 > 0, true) // 36789 bar - shouldEQ(t, amount1 > 0, true) // 99999 baz + shouldEQ(t, amount0, bigint(36789)) // bar + shouldEQ(t, amount1, bigint(99999)) // baz } func TestPositionMintBazQux(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + baz.Approve(a2u(consts.POOL_ADDR), 36789) + qux.Approve(a2u(consts.POOL_ADDR), 99999) - tokenId, liquidity, amount0, amount1 := pos.Mint(bazPath, quxPath, fee500, int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) + tokenId, liquidity, amount0, amount1 := pn.Mint(bazPath, quxPath, fee500, int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) shouldEQ(t, tokenId, uint64(2)) - shouldEQ(t, amount0 > 0, true) // 36789 baz - shouldEQ(t, amount1 > 0, true) // 99999 qux + shouldEQ(t, amount0, bigint(36789)) + shouldEQ(t, amount1, bigint(99999)) + } func TestPositionMintQuxGnot(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) // send + std.TestIssueCoins(test1, std.Coins{{"ugnot", 999999}}) std.TestSetOrigSend(std.Coins{{"ugnot", 999999}}, nil) testBanker := std.GetBanker(std.BankerTypeRealmIssue) testBanker.RemoveCoin(std.GetOrigCaller(), "ugnot", 999999) @@ -60,20 +72,23 @@ func TestPositionMintQuxGnot(t *testing.T) { std.TestSetPrevAddr(test1) wugnot.Deposit() - tokenId, liquidity, amount0, amount1 := pos.Mint(quxPath, wgnotPath, fee500, int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) + qux.Approve(a2u(consts.POOL_ADDR), 36789) + wugnot.Approve(a2u(consts.POOL_ADDR), 99999) + + tokenId, liquidity, amount0, amount1 := pn.Mint(quxPath, consts.WRAPPED_WUGNOT, fee500, int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) shouldEQ(t, tokenId, uint64(3)) - shouldEQ(t, amount0 > 0, true) // 36789 qux - shouldEQ(t, amount1 > 0, true) // 99999 gnot + shouldEQ(t, amount0, bigint(36789)) + shouldEQ(t, amount1, bigint(99999)) } func TestDrySwapRouteBarGnotExactIn(t *testing.T) { std.TestSetOrigCaller(test1) dryResult := DrySwapRoute( - barPath, // inputToken - wgnotPath, // outputToken - bigint(1000), // amountSpecified - "EXACT_IN", // swapType + barPath, // inputToken + consts.WRAPPED_WUGNOT, // outputToken + bigint(1000), // amountSpecified + "EXACT_IN", // swapType "gno.land/r/demo/bar:gno.land/r/demo/baz:500*POOL*gno.land/r/demo/baz:gno.land/r/demo/qux:500*POOL*gno.land/r/demo/qux:gno.land/r/demo/wugnot:500", // strRouteArr "100", // quoteArr ) @@ -84,10 +99,10 @@ func TestDrySwapRouteBarGnotExactOut(t *testing.T) { std.TestSetOrigCaller(test1) dryResult := DrySwapRoute( - barPath, // inputToken - wgnotPath, // outputToken - bigint(20000), // amountSpecified - "EXACT_OUT", // swapType + barPath, // inputToken + consts.WRAPPED_WUGNOT, // outputToken + bigint(20000), // amountSpecified + "EXACT_OUT", // swapType "gno.land/r/demo/bar:gno.land/r/demo/baz:500*POOL*gno.land/r/demo/baz:gno.land/r/demo/qux:500*POOL*gno.land/r/demo/qux:gno.land/r/demo/wugnot:500", // strRouteArr "100", // quoteArr ) @@ -98,10 +113,10 @@ func TestDrySwapRouteGnotBarExactIn(t *testing.T) { std.TestSetOrigCaller(test1) dryResult := DrySwapRoute( - wgnotPath, // intputToken - barPath, // outputToken - bigint(5000), // amountSpecified - "EXACT_IN", // swapType + consts.WRAPPED_WUGNOT, // intputToken + barPath, // outputToken + bigint(5000), // amountSpecified + "EXACT_IN", // swapType "gno.land/r/demo/wugnot:gno.land/r/demo/qux:500*POOL*gno.land/r/demo/qux:gno.land/r/demo/baz:500*POOL*gno.land/r/demo/baz:gno.land/r/demo/bar:500", // strRouteArr "100", // quoteArr ) @@ -112,12 +127,12 @@ func TestDrySwapRouteGnotBarExactOut(t *testing.T) { std.TestSetOrigCaller(test1) dryResult := DrySwapRoute( - wgnotPath, // intputToken - barPath, // outputToken - bigint(100), // amountSpecified - "EXACT_OUT", // swapType + consts.WRAPPED_WUGNOT, // intputToken + barPath, // outputToken + bigint(100), // amountSpecified + "EXACT_OUT", // swapType "gno.land/r/demo/wugnot:gno.land/r/demo/qux:500*POOL*gno.land/r/demo/qux:gno.land/r/demo/baz:500*POOL*gno.land/r/demo/baz:gno.land/r/demo/bar:500", // strRouteArr "100", // quoteArr ) - shouldEQ(t, dryResult, bigint(1977)) + shouldEQ(t, dryResult, bigint(1986)) } diff --git a/router/_TEST_router_swap_route_1route_3hop_native_middle_test.gnoa b/router/_TEST_router_swap_route_1route_3hop_native_middle_test.gnoa index f4e25f86..cee5bc07 100644 --- a/router/_TEST_router_swap_route_1route_3hop_native_middle_test.gnoa +++ b/router/_TEST_router_swap_route_1route_3hop_native_middle_test.gnoa @@ -5,23 +5,27 @@ import ( "std" "testing" + "gno.land/r/demo/consts" + pl "gno.land/r/demo/pool" - pos "gno.land/r/demo/position" + pn "gno.land/r/demo/position" - wugnot "gno.land/r/demo/wugnot" + "gno.land/r/demo/bar" + "gno.land/r/demo/gns" + "gno.land/r/demo/wugnot" ) func TestInitManual(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetOrigCaller(gsa) pl.InitManual() - std.TestSkipHeights(1) } func TestCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*2) - pl.CreatePool(gnsPath, wgnotPath, fee100, 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 - pl.CreatePool(wgnotPath, barPath, fee100, 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 + pl.CreatePool(consts.GNS_PATH, consts.WRAPPED_WUGNOT, fee100, 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 + pl.CreatePool(consts.WRAPPED_WUGNOT, barPath, fee100, 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 // 1 gns ≈ 7.29 bar jsonOutput := pl.ApiGetPools() @@ -33,6 +37,7 @@ func TestPositionMintGnsGnot(t *testing.T) { std.TestSetOrigCaller(test1) // send + std.TestIssueCoins(test1, std.Coins{{"ugnot", 999999}}) std.TestSetOrigSend(std.Coins{{"ugnot", 999999}}, nil) testBanker := std.GetBanker(std.BankerTypeRealmIssue) testBanker.RemoveCoin(std.GetOrigCaller(), "ugnot", 999999) @@ -41,7 +46,10 @@ func TestPositionMintGnsGnot(t *testing.T) { std.TestSetPrevAddr(test1) wugnot.Deposit() - tokenId, liquidity, amount0, amount1 := pos.Mint(gnsPath, wgnotPath, fee100, int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) + gns.Approve(a2u(consts.POOL_ADDR), 36789) + wugnot.Approve(a2u(consts.POOL_ADDR), 99999) + + tokenId, liquidity, amount0, amount1 := pn.Mint(consts.GNS_PATH, consts.WRAPPED_WUGNOT, fee100, int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) shouldEQ(t, tokenId, uint64(1)) shouldEQ(t, amount0 > 0, true) // 36789 shouldEQ(t, amount1 > 0, true) // 99999 @@ -51,6 +59,7 @@ func TestPositionMintGnotBar(t *testing.T) { std.TestSetOrigCaller(test1) // send + std.TestIssueCoins(test1, std.Coins{{"ugnot", 999999}}) std.TestSetOrigSend(std.Coins{{"ugnot", 999999}}, nil) testBanker := std.GetBanker(std.BankerTypeRealmIssue) testBanker.RemoveCoin(std.GetOrigCaller(), "ugnot", 999999) @@ -59,38 +68,43 @@ func TestPositionMintGnotBar(t *testing.T) { std.TestSetPrevAddr(test1) wugnot.Deposit() - tokenId, liquidity, amount0, amount1 := pos.Mint(wgnotPath, barPath, fee100, int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) + wugnot.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + bar.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + + tokenId, liquidity, amount0, amount1 := pn.Mint(consts.WRAPPED_WUGNOT, barPath, fee100, int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) shouldEQ(t, tokenId, uint64(2)) shouldEQ(t, amount0 > 0, true) // 99999 shouldEQ(t, amount1 > 0, true) // 36865 } -func TestDrySwapRouteBarGnotExactIn(t *testing.T) { +func TestDrySwapRouteGnsBarExactIn(t *testing.T) { std.TestSetOrigCaller(test1) dryResult := DrySwapRoute( - gnsPath, // inputToken - barPath, // outputToken - bigint(1000), // amountSpecified - "EXACT_IN", // swapType + consts.GNS_PATH, // inputToken + barPath, // outputToken + bigint(1000), // amountSpecified + "EXACT_IN", // swapType "gno.land/r/demo/gns:gno.land/r/demo/wugnot:100*POOL*gno.land/r/demo/wugnot:gno.land/r/demo/bar:100", // strRouteArr "100", // quoteArr ) shouldEQ(t, dryResult, bigint(7339)) } -func TestSwapRouteBarGnotExactIn(t *testing.T) { - std.TestSetOrigCaller(test1) +func TestSwapRouteGnsBarExactIn(t *testing.T) { + std.TestSetPrevAddr(test1) + + gns.Approve(a2u(consts.POOL_ADDR), 1000) // swap input amount + bar.Approve(a2u(consts.ROUTER_ADDR), 7328) // 0.15% fee - std.TestSetOrigSend(std.Coins{{"", 0}}, nil) swapResult := SwapRoute( - gnsPath, // inputToken - barPath, // outputToken - bigint(1000), // amountSpecified - "EXACT_IN", // swapType + consts.GNS_PATH, // inputToken + barPath, // outputToken + bigint(1000), // amountSpecified + "EXACT_IN", // swapType "gno.land/r/demo/gns:gno.land/r/demo/wugnot:100*POOL*gno.land/r/demo/wugnot:gno.land/r/demo/bar:100", // strRouteArr "100", // quoteArr "0", // tokenAmountLimit ) - shouldEQ(t, swapResult, bigint(7339)) + shouldEQ(t, swapResult, bigint(7328)) } diff --git a/router/_TEST_router_swap_route_2route_2hop_test.gnoa b/router/_TEST_router_swap_route_2route_2hop_test.gno similarity index 78% rename from router/_TEST_router_swap_route_2route_2hop_test.gnoa rename to router/_TEST_router_swap_route_2route_2hop_test.gno index e60b0134..be56562e 100644 --- a/router/_TEST_router_swap_route_2route_2hop_test.gnoa +++ b/router/_TEST_router_swap_route_2route_2hop_test.gno @@ -5,18 +5,25 @@ import ( "std" "testing" + "gno.land/r/demo/consts" + pl "gno.land/r/demo/pool" - pos "gno.land/r/demo/position" + pn "gno.land/r/demo/position" + + "gno.land/r/demo/bar" + "gno.land/r/demo/baz" + "gno.land/r/demo/gns" + "gno.land/r/demo/qux" ) func TestInitManual(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetOrigCaller(gsa) pl.InitManual() - std.TestSkipHeights(1) } func TestCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*2) pl.CreatePool(barPath, bazPath, uint16(500), 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 pl.CreatePool(bazPath, quxPath, uint16(500), 130621891405341611593710811006) // tick = 10_000, ratio = 2.71814592682522526700950038502924144268035888671875 @@ -28,11 +35,15 @@ func TestCreatePool(t *testing.T) { func TestPositionMint(t *testing.T) { // bar_baz_500 by test1 - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + + bar.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + baz.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + qux.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) // Mint - pos.Mint(barPath, bazPath, uint16(500), int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) - pos.Mint(bazPath, quxPath, uint16(500), int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) + pn.Mint(barPath, bazPath, uint16(500), int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) + pn.Mint(bazPath, quxPath, uint16(500), int32(9000), int32(11000), bigint(100_000), bigint(100_000), 0, 0, max_timeout) } func TestDrySwapRouteBarQuxExactIn(t *testing.T) { @@ -51,7 +62,10 @@ func TestDrySwapRouteBarQuxExactIn(t *testing.T) { } func TestSwapRouteBarQuxExactIn(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + + bar.Approve(a2u(consts.POOL_ADDR), 10000) + qux.Approve(a2u(consts.ROUTER_ADDR), 10000) swapResult := SwapRoute( barPath, // inputToken @@ -63,11 +77,11 @@ func TestSwapRouteBarQuxExactIn(t *testing.T) { 1, // tokenAmountLimit ) - shouldEQ(t, swapResult, bigint(7328)) + shouldEQ(t, swapResult, bigint(7318)) } func TestDrySwapRouteBarQuxExactOut(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) dryResult := DrySwapRoute( barPath, // inputToken @@ -82,7 +96,7 @@ func TestDrySwapRouteBarQuxExactOut(t *testing.T) { } func TestSwapRouteBarQuxExactOut(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) swapResult := SwapRoute( barPath, // inputToken @@ -98,7 +112,7 @@ func TestSwapRouteBarQuxExactOut(t *testing.T) { } func TestDrySwapRouteQuxBarExactIn(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) dryResult := DrySwapRoute( quxPath, // inputToken @@ -113,7 +127,7 @@ func TestDrySwapRouteQuxBarExactIn(t *testing.T) { } func TestSwapRouteQuxBarExactIn(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) swapResult := SwapRoute( quxPath, // inputToken @@ -129,7 +143,7 @@ func TestSwapRouteQuxBarExactIn(t *testing.T) { } func TestDrySwapRouteQuxBarExactOut(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) dryResult := DrySwapRoute( quxPath, // inputToken @@ -140,11 +154,14 @@ func TestDrySwapRouteQuxBarExactOut(t *testing.T) { "30,70", // quoteArr ) - shouldEQ(t, dryResult, bigint(7278)) + shouldEQ(t, dryResult, bigint(7285)) } func TestwapRouteQuxBarExactOut(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + + qux.Approve(a2u(consts.POOL_ADDR), 10000) + bar.Approve(a2u(consts.ROUTER_ADDR), 10000) swapResult := SwapRoute( quxPath, // inputToken @@ -156,5 +173,5 @@ func TestwapRouteQuxBarExactOut(t *testing.T) { 99999, // tokenAmountLimit ) - shouldEQ(t, swapResult, bigint(7277)) + shouldEQ(t, swapResult, bigint(7278)) } diff --git a/router/_TEST_routes_find_swap_path_test.gnoa b/router/_TEST_routes_find_swap_path_test.gnoa index a27d07f4..97495a71 100644 --- a/router/_TEST_routes_find_swap_path_test.gnoa +++ b/router/_TEST_routes_find_swap_path_test.gnoa @@ -4,27 +4,32 @@ import ( "std" "testing" + "gno.land/p/demo/common" + "gno.land/r/demo/consts" + pl "gno.land/r/demo/pool" pn "gno.land/r/demo/position" - "gno.land/p/demo/common" - + "gno.land/r/demo/bar" + "gno.land/r/demo/foo" + "gno.land/r/demo/gns" + "gno.land/r/demo/qux" "gno.land/r/demo/wugnot" ) func TestInitManual(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(gsa) pl.InitManual() - std.TestSkipHeights(1) } func TestPoolCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*(3+4+3)) // 1 HOPS - pl.CreatePool(barPath, wgnotPath, fee100, common.TickMathGetSqrtRatioAtTick(10_000)) - pl.CreatePool(barPath, wgnotPath, fee500, common.TickMathGetSqrtRatioAtTick(20_000)) - pl.CreatePool(barPath, wgnotPath, fee3000, common.TickMathGetSqrtRatioAtTick(60_000)) // NOT USED BY SMALL LIQ + pl.CreatePool(barPath, consts.WRAPPED_WUGNOT, fee100, common.TickMathGetSqrtRatioAtTick(10_000)) + pl.CreatePool(barPath, consts.WRAPPED_WUGNOT, fee500, common.TickMathGetSqrtRatioAtTick(20_000)) + pl.CreatePool(barPath, consts.WRAPPED_WUGNOT, fee3000, common.TickMathGetSqrtRatioAtTick(60_000)) // NOT USED BY SMALL LIQ // -10_000 0.367897 // -20_000 0.135348 // 0.367897 + 0.135348 = 0.503245 @@ -32,7 +37,7 @@ func TestPoolCreatePool(t *testing.T) { // 1 WGNOT = 0.2516225 BAR // 2 HOPS - pl.CreatePool(wgnotPath, quxPath, fee100, common.TickMathGetSqrtRatioAtTick(0)) // 1:1 + pl.CreatePool(consts.WRAPPED_WUGNOT, quxPath, fee100, common.TickMathGetSqrtRatioAtTick(0)) // 1:1 pl.CreatePool(quxPath, fooPath, fee100, common.TickMathGetSqrtRatioAtTick(50_000)) pl.CreatePool(quxPath, fooPath, fee500, common.TickMathGetSqrtRatioAtTick(60_000)) pl.CreatePool(quxPath, fooPath, fee3000, common.TickMathGetSqrtRatioAtTick(100_000)) // NOT USED BY SMALL LIQ @@ -43,16 +48,17 @@ func TestPoolCreatePool(t *testing.T) { // 1 WGNOT = 275.8419265 BAR // 3 HOPS - pl.CreatePool(wgnotPath, bazPath, fee100, common.TickMathGetSqrtRatioAtTick(6932)) // 1:2 - pl.CreatePool(bazPath, oblPath, fee100, common.TickMathGetSqrtRatioAtTick(6932)) // 1:2 - pl.CreatePool(oblPath, gnsPath, fee100, common.TickMathGetSqrtRatioAtTick(6932)) // 1:2 + pl.CreatePool(consts.WRAPPED_WUGNOT, bazPath, fee100, common.TickMathGetSqrtRatioAtTick(6932)) // 1:2 + pl.CreatePool(bazPath, oblPath, fee100, common.TickMathGetSqrtRatioAtTick(6932)) // 1:2 + pl.CreatePool(oblPath, consts.GNS_PATH, fee100, common.TickMathGetSqrtRatioAtTick(6932)) // 1:2 // 1 GNOT = 8 GNS } func TestPositionMint(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) // wugnot prepare + std.TestIssueCoins(test1, std.Coins{{"ugnot", 100_000_000_000}}) std.TestSetOrigSend(std.Coins{{"ugnot", 100_000_000_000}}, nil) testBanker := std.GetBanker(std.BankerTypeRealmIssue) testBanker.RemoveCoin(std.GetOrigCaller(), "ugnot", 100_000_000_000) @@ -61,23 +67,28 @@ func TestPositionMint(t *testing.T) { std.TestSetPrevAddr(test1) wugnot.Deposit() - pn.Mint(barPath, wgnotPath, fee100, 8000, 12000, 100_000_000, 100_000_000, 0, 0, max_timeout) - pn.Mint(barPath, wgnotPath, fee500, 18000, 22000, 80_000_000, 80_000_000, 0, 0, max_timeout) - pn.Mint(barPath, wgnotPath, fee3000, 58020, 62040, 10_000_000, 10_000_000, 0, 0, max_timeout) + bar.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + wugnot.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + qux.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + foo.Approve(a2u(consts.POOL_ADDR), uint64(consts.MAX_UINT64)) + + pn.Mint(barPath, consts.WRAPPED_WUGNOT, fee100, 8000, 12000, 100_000_000, 100_000_000, 0, 0, max_timeout) + pn.Mint(barPath, consts.WRAPPED_WUGNOT, fee500, 18000, 22000, 80_000_000, 80_000_000, 0, 0, max_timeout) + pn.Mint(barPath, consts.WRAPPED_WUGNOT, fee3000, 58020, 62040, 10_000_000, 10_000_000, 0, 0, max_timeout) pn.Mint(quxPath, fooPath, fee100, 48000, 52000, 100_000_000, 100_000_000, 0, 0, max_timeout) pn.Mint(quxPath, fooPath, fee500, 58000, 62000, 80_000_000, 80_000_000, 0, 0, max_timeout) pn.Mint(quxPath, fooPath, fee3000, 98040, 10020, 10_000_000, 10_000_000, 0, 0, max_timeout) - // pn.Mint(fooPath, gnsPath, fee100, 48000, 52000, 100_000_000, 100_000_000, 0, 0, max_timeout) + // pn.Mint(fooPath, consts.GNS_PATH, fee100, 48000, 52000, 100_000_000, 100_000_000, 0, 0, max_timeout) } func TestFindRoutes1(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) pools := findCandidatePools() - inputTokenPath := "gno.land/r/demo/wugnot" // FIXED + inputTokenPath := consts.WRAPPED_WUGNOT // FIXED outputTokenPath := "gno.land/r/demo/bar" maxHops := 3 routes := computeAllRoutes( @@ -90,11 +101,11 @@ func TestFindRoutes1(t *testing.T) { } func TestFindRoutes2(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) pools := findCandidatePools() - inputTokenPath := "gno.land/r/demo/wugnot" // FIXED + inputTokenPath := consts.WRAPPED_WUGNOT // FIXED outputTokenPath := "gno.land/r/demo/foo" maxHops := 3 routes := computeAllRoutes( @@ -107,11 +118,11 @@ func TestFindRoutes2(t *testing.T) { } func TestFindRoutes3(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) pools := findCandidatePools() - inputTokenPath := "gno.land/r/demo/wugnot" // FIXED + inputTokenPath := consts.WRAPPED_WUGNOT // FIXED outputTokenPath := "gno.land/r/demo/gns" maxHops := 3 routes := computeAllRoutes( diff --git a/router/gno_helper.gno b/router/gno_helper.gno index c9a8296d..25d34e5c 100644 --- a/router/gno_helper.gno +++ b/router/gno_helper.gno @@ -2,19 +2,10 @@ package router import ( "std" - "time" "gno.land/r/demo/consts" ) -func GetHeight() int64 { - return std.GetHeight() -} - -func GetTimestamp() int64 { - return time.Now().Unix() -} - func GetOrigPkgAddr() std.Address { return consts.ROUTER_ADDR } diff --git a/router/router.gno b/router/router.gno index 3dd0645d..7bd7029b 100644 --- a/router/router.gno +++ b/router/router.gno @@ -10,82 +10,6 @@ import ( "gno.land/r/demo/consts" ) -func DrySwapRoute( - inputToken string, - outputToken string, - amountSpecified bigint, - swapType SwapType, - strRouteArr string, // []string - quoteArr string, // []int -) bigint { - require(amountSpecified != 0, "[ROUTER] router.gno__DrySwapRoute() || amountSpecified == 0") - - switch swapType { - case ExactIn: - amountSpecified = amountSpecified - case ExactOut: - amountSpecified = -amountSpecified - default: - panic("[ROUTER] router.gno__DrySwapRoute() || unknown swapType") - } - - // check route length ( should be 1 ~ 7 ) - routes := strings.Split(strRouteArr, ",") - require(1 <= len(routes) && len(routes) <= 7, ufmt.Sprintf("[ROUTER] router.gno__DrySwapRoute() || len(routes) should be 1 ~ 7 (len(routes)[%d])", len(routes))) - - // check if routes length and quotes length are same - quotes := strings.Split(quoteArr, ",") - require(len(routes) == len(quotes), ufmt.Sprintf("[ROUTER] router.gno__DrySwapRoute() || len(routes[%d]) != len(quotes[%d])", len(routes), len(quotes))) - - // check if quotes are up to 100% - quotesSum := 0 - for _, quote := range quotes { - intQuote, _ := strconv.Atoi(quote) - quotesSum += intQuote - } - require(quotesSum == 100, "[ROUTER] router.gno__DrySwapRoute() || quotesSum != 100") - - var resultAmountIn, resultAmountOut bigint - for i, route := range routes { - numHops := strings.Count(route, "*POOL*") + 1 - quote, _ := strconv.Atoi(quotes[i]) - - // check if route hop is up to 3 - require(numHops <= 3, "[ROUTER] router.gno__DrySwapRoute() || numHops > 3") - - toSwap := amountSpecified * bigint(quote) / bigint(100) - - if numHops == 1 { // SINGLE - amountIn, amountOut := handleSingleSwap(route, toSwap, true) - resultAmountIn += amountIn - resultAmountOut += amountOut - } else if 2 <= numHops && numHops <= 3 { // MULTI - amountIn, amountOut := handleMultiSwap(swapType, route, numHops, toSwap, true) - resultAmountIn += amountIn - resultAmountOut += amountOut - } else { - panic("[ROUTER] router.gno__DrySwapRoute() || numHops should be 1 ~ 3") - } - } - - // PROTOCOL FEE - resultAmountOut = handleProtocolFee(outputToken, resultAmountOut, true) - - if swapType == ExactIn { - if resultAmountIn != amountSpecified { - return -1 // if pool doesn't have enough output token amount to swap against input token amount - } - return resultAmountOut - } - - if swapType == ExactOut { - if resultAmountOut < amountSpecified { // if pool doesn't user wanted amount of output token - return -1 - } - return resultAmountIn - } -} - func SwapRoute( inputToken string, outputToken string, diff --git a/router/router_dry.gno b/router/router_dry.gno new file mode 100644 index 00000000..9647906c --- /dev/null +++ b/router/router_dry.gno @@ -0,0 +1,86 @@ +package router + +import ( + "strconv" + "strings" + + "gno.land/p/demo/ufmt" +) + +func DrySwapRoute( + inputToken string, + outputToken string, + amountSpecified bigint, + swapType SwapType, + strRouteArr string, // []string + quoteArr string, // []int +) bigint { + require(amountSpecified != 0, "[ROUTER] router.gno__DrySwapRoute() || amountSpecified == 0") + + switch swapType { + case ExactIn: + amountSpecified = amountSpecified + case ExactOut: + amountSpecified = -amountSpecified + default: + panic("[ROUTER] router.gno__DrySwapRoute() || unknown swapType") + } + + // check route length ( should be 1 ~ 7 ) + routes := strings.Split(strRouteArr, ",") + require(1 <= len(routes) && len(routes) <= 7, ufmt.Sprintf("[ROUTER] router.gno__DrySwapRoute() || len(routes) should be 1 ~ 7 (len(routes)[%d])", len(routes))) + + // check if routes length and quotes length are same + quotes := strings.Split(quoteArr, ",") + require(len(routes) == len(quotes), ufmt.Sprintf("[ROUTER] router.gno__DrySwapRoute() || len(routes[%d]) != len(quotes[%d])", len(routes), len(quotes))) + + // check if quotes are up to 100% + quotesSum := 0 + for _, quote := range quotes { + intQuote, _ := strconv.Atoi(quote) + quotesSum += intQuote + } + require(quotesSum == 100, "[ROUTER] router.gno__DrySwapRoute() || quotesSum != 100") + + var resultAmountIn, resultAmountOut bigint + for i, route := range routes { + numHops := strings.Count(route, "*POOL*") + 1 + quote, _ := strconv.Atoi(quotes[i]) + + // check if route hop is up to 3 + require(numHops <= 3, "[ROUTER] router.gno__DrySwapRoute() || numHops > 3") + + toSwap := amountSpecified * bigint(quote) / bigint(100) + + if numHops == 1 { // SINGLE + amountIn, amountOut := handleSingleSwap(route, toSwap, true) + resultAmountIn += amountIn + resultAmountOut += amountOut + } else if 2 <= numHops && numHops <= 3 { // MULTI + amountIn, amountOut := handleMultiSwap(swapType, route, numHops, toSwap, true) + resultAmountIn += amountIn + resultAmountOut += amountOut + } else { + panic("[ROUTER] router.gno__DrySwapRoute() || numHops should be 1 ~ 3") + } + } + + // PROTOCOL FEE + // resultAmountOut = handleProtocolFee(outputToken, resultAmountOut, true) + // DrySwap should return raw resultAmountOut( ≈ with protocol fee ) + // Interface needs to calculate 0.15 protocol fee + + if swapType == ExactIn { + if resultAmountIn != amountSpecified { + return -1 // if pool doesn't have enough output token amount to swap against input token amount + } + return resultAmountOut + } + + if swapType == ExactOut { + if resultAmountOut < amountSpecified { // if pool doesn't user wanted amount of output token + return -1 + } + return resultAmountIn + } +} diff --git a/router/router_register.gno b/router/token_register.gno similarity index 100% rename from router/router_register.gno rename to router/token_register.gno diff --git a/staker/_RPC_api_incentive.gno b/staker/_RPC_api_incentive.gno index d1691e66..3ab27913 100644 --- a/staker/_RPC_api_incentive.gno +++ b/staker/_RPC_api_incentive.gno @@ -2,6 +2,9 @@ package staker import ( "encoding/json" + "time" + + "std" pl "gno.land/r/demo/pool" @@ -46,8 +49,8 @@ func ApiGetRewardTokens() string { // JSON qb := ResponseQueryBase{ - Height: GetHeight(), - Timestamp: int64(GetTimestamp()), + Height: std.GetHeight(), + Timestamp: time.Now().Unix(), } r := ResponseRewardTokens{ diff --git a/staker/_RPC_api_stake.gno b/staker/_RPC_api_stake.gno index 51ed551d..f65f79d1 100644 --- a/staker/_RPC_api_stake.gno +++ b/staker/_RPC_api_stake.gno @@ -3,6 +3,7 @@ package staker import ( "encoding/json" "std" + "time" "gno.land/p/demo/ufmt" ) @@ -85,8 +86,8 @@ func ApiGetRewards() string { } qb := ResponseQueryBase{ - Height: GetHeight(), - Timestamp: int64(GetTimestamp()), + Height: std.GetHeight(), + Timestamp: time.Now().Unix(), } r := ResponseApiGetRewards{ @@ -137,8 +138,8 @@ func ApiGetRewardByLpTokenId(lpTokenId uint64) string { } qb := ResponseQueryBase{ - Height: GetHeight(), - Timestamp: int64(GetTimestamp()), + Height: std.GetHeight(), + Timestamp: time.Now().Unix(), } r := ResponseApiGetRewardByLpTokenId{ @@ -167,8 +168,8 @@ func ApiGetStakes() string { } qb := ResponseQueryBase{ - Height: GetHeight(), - Timestamp: int64(GetTimestamp()), + Height: std.GetHeight(), + Timestamp: time.Now().Unix(), } r := ResponseApiGetStakes{ diff --git a/staker/_TEST_INIT_register_tokens_test.gno b/staker/_TEST_0_INIT_TOKEN_REGISTER_test.gno similarity index 99% rename from staker/_TEST_INIT_register_tokens_test.gno rename to staker/_TEST_0_INIT_TOKEN_REGISTER_test.gno index c743ad42..2b05ea06 100644 --- a/staker/_TEST_INIT_register_tokens_test.gno +++ b/staker/_TEST_0_INIT_TOKEN_REGISTER_test.gno @@ -18,6 +18,7 @@ import ( "gno.land/r/demo/gns" "gno.land/r/demo/consts" + "gno.land/r/demo/users" pl "gno.land/r/demo/pool" // only for position `testcase`` to call grc20 by register diff --git a/staker/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno b/staker/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno new file mode 100644 index 00000000..3cdc1086 --- /dev/null +++ b/staker/_TEST_0_INIT_VARIABLE_AND_HELPER_test.gno @@ -0,0 +1,75 @@ +package staker + +import ( + "std" + "testing" + + "gno.land/r/demo/consts" +) + +var ( + gsa std.Address = consts.GNOSWAP_ADMIN + test1 std.Address = std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") + + fooPath string = "gno.land/r/demo/foo" + barPath string = "gno.land/r/demo/bar" + bazPath string = "gno.land/r/demo/baz" + quxPath string = "gno.land/r/demo/qux" + + oblPath string = "gno.land/r/demo/obl" + // wugnotPath string = "gno.land/r/demo/wugnot" // from consts + // gnsPath string = "gno.land/r/demo/gns" // from consts + + fee100 uint16 = 100 + fee500 uint16 = 500 + fee3000 uint16 = 3000 + + max_timeout bigint = 9999999999 +) + +/* HELPER */ +func shouldEQ(t *testing.T, got, expected interface{}) { + if got != expected { + t.Errorf("got %v, expected %v", got, expected) + } +} + +func shouldNEQ(t *testing.T, got, expected interface{}) { + if got == expected { + t.Errorf("got %v, didn't expected %v", got, expected) + } +} + +func shouldGT(t *testing.T, l, r interface{}) { + if !(l < r) { + t.Errorf("expected %v < %v", l, r) + } +} + +func shouldLT(t *testing.T, l, r interface{}) { + if !(l > r) { + t.Errorf("expected %v > %v", l, r) + } +} + +func shouldPanic(t *testing.T, f func()) { + defer func() { + if r := recover(); r == nil { + t.Errorf("expected panic") + } + }() + f() +} + +func shouldPanicWithMsg(t *testing.T, f func(), msg string) { + defer func() { + if r := recover(); r == nil { + t.Errorf("The code did not panic") + } else { + if r != msg { + t.Errorf("excepted panic(%v), got(%v)", msg, r) + } + } + }() + f() +} diff --git a/staker/_TEST_INIT_basic_test.gno b/staker/_TEST_INIT_basic_test.gno deleted file mode 100644 index 1635619d..00000000 --- a/staker/_TEST_INIT_basic_test.gno +++ /dev/null @@ -1,131 +0,0 @@ -package staker - -import ( - "std" - "testing" - - "gno.land/r/demo/consts" - - "gno.land/r/demo/gns" - - "gno.land/r/demo/bar" - "gno.land/r/demo/baz" - "gno.land/r/demo/foo" - "gno.land/r/demo/qux" - - "gno.land/r/demo/obl" - - "gno.land/r/demo/wugnot" - - nft "gno.land/r/demo/gnft" -) - -var ( - test1 std.Address - - barPath = "gno.land/r/demo/bar" - bazPath = "gno.land/r/demo/baz" - fooPath = "gno.land/r/demo/foo" - quxPath = "gno.land/r/demo/qux" - - wgnotPath = "gno.land/r/demo/wugnot" - - fee100 = uint16(100) - fee500 = uint16(500) - fee3000 = uint16(3000) - - max_timeout = bigint(9999999999) -) - -func init() { - test1 = std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") - // prepare ugnot - testBanker := std.GetBanker(std.BankerTypeRealmIssue) - testBanker.IssueCoin(test1, "ugnot", 500_000_000_000_000) - - std.TestSetPrevAddr(test1) - - gns.Approve(a2u(consts.POOL_ADDR), 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(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(consts.POOL_ADDR), 500_000_000_000_000) - - std.TestSetPrevAddr(consts.INTERNAL_REWARD_ACCOUNT) - gns.Approve(a2u(consts.STAKER_ADDR), 500_000_000_000_000) // to create internal incentive -} - -/* HELPER */ -func shouldEQ(t *testing.T, got, expected interface{}) { - if got != expected { - t.Errorf("got %v, expected %v", got, expected) - } -} - -func shouldNEQ(t *testing.T, got, expected interface{}) { - if got == expected { - t.Errorf("got %v, didn't expected %v", got, expected) - } -} - -func shouldGT(t *testing.T, l, r interface{}) { - if !(l < r) { - t.Errorf("expected %v < %v", l, r) - } -} - -func shouldLT(t *testing.T, l, r interface{}) { - if !(l > r) { - t.Errorf("expected %v > %v", l, r) - } -} - -func shouldPanic(t *testing.T, f func()) { - defer func() { - if r := recover(); r == nil { - t.Errorf("expected panic") - } - }() - f() -} - -func shouldPanicWithMsg(t *testing.T, f func(), msg string) { - defer func() { - if r := recover(); r == nil { - t.Errorf("The code did not panic") - } else { - if r != msg { - t.Errorf("excepted panic(%v), got(%v)", msg, r) - } - } - }() - f() -} - -func ugnotBalanceOf(addr std.Address) uint64 { - testBanker := std.GetBanker(std.BankerTypeRealmIssue) - - coins := testBanker.GetCoins(addr) - if len(coins) == 0 { - return 0 - } - - return uint64(testBanker.GetCoins(addr)[0].Amount) -} - -func isOwner(t *testing.T, tokenId uint64, addr std.Address) bool { - owner := nft.OwnerOf(tid(tokenId)) - - if owner == addr { - return true - } - - t.Errorf("expected owner %v, got %v", addr, owner) - return false -} diff --git a/staker/_TEST_staker_collect_reward_test.gno b/staker/_TEST_staker_collect_reward_test.gno index d15271e7..685f0b84 100644 --- a/staker/_TEST_staker_collect_reward_test.gno +++ b/staker/_TEST_staker_collect_reward_test.gno @@ -3,6 +3,7 @@ package staker import ( "std" "testing" + "time" "gno.land/r/demo/consts" @@ -11,6 +12,9 @@ import ( "gno.land/r/demo/gnft" + "gno.land/r/demo/bar" + "gno.land/r/demo/qux" + "gno.land/r/demo/gns" "gno.land/r/demo/obl" ) @@ -31,148 +35,167 @@ func init() { } func TestPoolInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetPrevAddr(gsa) pl.InitManual() std.TestSkipHeights(1) - pl.CreatePool(barPath, quxPath, 500, 130621891405341611593710811006) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + std.TestSkipHeights(1) + + pl.CreatePool(barPath, quxPath, 500, 130621891405341611593710811006) // tick 10_000 ≈ x2.7 + std.TestSkipHeights(1) +} + +func TestPositionMint01(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 367) + qux.Approve(a2u(consts.POOL_ADDR), 999) + std.TestSkipHeights(2) + + lpTokenId, liquidity, amount0, amount1 := pn.Mint( + barPath, // token0 + quxPath, // token1 + uint16(500), // fee + int32(9000), // tickLower + int32(11000), // tickUpper + bigint(1000), // amount0Desired + bigint(1000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + bigint(2345678901), // deadline + ) + std.TestSkipHeights(1) + + shouldEQ(t, lpTokenId, 1) + shouldEQ(t, gnft.OwnerOf(tid(lpTokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(367)) + shouldEQ(t, amount1, bigint(999)) + + // approve nft to staker + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(lpTokenId)) std.TestSkipHeights(1) } -func TestPositionMint(t *testing.T) { - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - barPath, // token0 - quxPath, // token1 - uint16(500), // fee - int32(9000), // tickLower - int32(11000), // tickUpper - bigint(1000), // amount0Desired - bigint(1000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 1) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } - - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - barPath, // token0 - quxPath, // token1 - uint16(500), // fee - int32(9100), // tickLower - int32(12000), // tickUpper - bigint(5000), // amount0Desired - bigint(5000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 2) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } +func TestPositionMint02(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 3978) + qux.Approve(a2u(consts.POOL_ADDR), 4999) + std.TestSkipHeights(2) + + lpTokenId, liquidity, amount0, amount1 := pn.Mint( + barPath, // token0 + quxPath, // token1 + uint16(500), // fee + int32(9100), // tickLower + int32(12000), // tickUpper + bigint(5000), // amount0Desired + bigint(5000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + bigint(2345678901), // deadline + ) + std.TestSkipHeights(1) + + shouldEQ(t, lpTokenId, 2) + shouldEQ(t, gnft.OwnerOf(tid(lpTokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(3978)) + shouldEQ(t, amount1, bigint(4999)) + + // approve nft to staker + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(lpTokenId)) + std.TestSkipHeights(1) } func TestCreateExternalIncentive(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + obl.Approve(a2u(consts.STAKER_ADDR), uint64(10_000_000_000)) + std.TestSkipHeights(1) CreateExternalIncentive( "gno.land/r/demo/bar:gno.land/r/demo/qux:500", // targetPoolPath "gno.land/r/demo/obl", // rewardToken 10_000_000_000, // rewardAmount - GetTimestamp(), // startTimestamp - GetTimestamp()+TIMESTAMP_90DAYS, // endTimestamp + time.Now().Unix(), // startTimestamp + time.Now().Unix()+TIMESTAMP_90DAYS, // endTimestamp ) - CreateExternalIncentive("gno.land/r/demo/bar:gno.land/r/demo/qux:500", "gno.land/r/demo/obl", 10_000_000_000, GetTimestamp(), GetTimestamp()+TIMESTAMP_90DAYS) - std.TestSkipHeights(5) -} + std.TestSkipHeights(1) -func TestStakeToken(t *testing.T) { - { - std.TestSetOrigCaller(test1) - StakeToken(1) // GNFT tokenId - std.TestSkipHeights(2) + obl.Approve(a2u(consts.STAKER_ADDR), uint64(10_000_000_000)) + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) // staker - shouldEQ(t, len(deposits), 1) - } + CreateExternalIncentive("gno.land/r/demo/bar:gno.land/r/demo/qux:500", "gno.land/r/demo/obl", 10_000_000_000, time.Now().Unix(), time.Now().Unix()+TIMESTAMP_90DAYS) + std.TestSkipHeights(1) +} - { - std.TestSetOrigCaller(test1) - StakeToken(2) // GNFT tokenId - std.TestSkipHeights(2) +func TestStakeToken01(t *testing.T) { + std.TestSetPrevAddr(test1) + StakeToken(1) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) // staker - shouldEQ(t, len(deposits), 2) - } + shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) // staker + shouldEQ(t, len(deposits), 1) } -func TestCollectReward(t *testing.T) { +func TestStakeToken02(t *testing.T) { std.TestSetPrevAddr(test1) + StakeToken(2) // GNFT tokenId + std.TestSkipHeights(1) + + shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) // staker + shouldEQ(t, len(deposits), 2) +} - // CALLING ApiGetRewardByLpTokenId(1) will return token_path list to approve - gns.Approve(a2u(consts.STAKER_ADDR), uint64(consts.MAX_UINT64)) - obl.Approve(a2u(consts.STAKER_ADDR), uint64(consts.MAX_UINT64)) +func TestCollectReward(t *testing.T) { + std.TestSetPrevAddr(consts.INTERNAL_REWARD_ACCOUNT) + gns.Approve(a2u(consts.STAKER_ADDR), uint64(consts.MAX_UINT64)) // internal reward distribution + std.TestSkipHeights(1) // before claim gnsOld := gns.BalanceOf(a2u(test1)) + std.TestSkipHeights(1) shouldEQ(t, gnsOld, 99500000000) + std.TestSetPrevRealm(consts.STAKER_PATH) + std.TestSetOrigCaller(test1) CollectReward(1) // GNFT tokenId - gnsNew := gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsNew, 99500000124) + std.TestSkipHeights(1) + gnsNew := gns.BalanceOf(a2u(test1)) + std.TestSkipHeights(1) + shouldEQ(t, gnsNew, 99500000125) } -func TestUnstakeToken(t *testing.T) { - { - std.TestSetOrigCaller(test1) - UnstakeToken(1) // GNFT tokenId - std.TestSkipHeights(1) +func TestUnstakeToken01(t *testing.T) { + std.TestSetPrevAddr(test1) + UnstakeToken(1) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(1)), test1) + shouldEQ(t, gnft.OwnerOf(tid(1)), test1) - // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 99500000124) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000000636) // external - } + // check reward + shouldEQ(t, gns.BalanceOf(a2u(test1)), 99500000125) // internal + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000000642) // external +} - { - std.TestSetOrigCaller(test1) - UnstakeToken(2) // GNFT tokenId - std.TestSkipHeights(1) +func TestUnstakeToken02(t *testing.T) { + std.TestSetPrevAddr(test1) + UnstakeToken(2) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(2)), test1) + shouldEQ(t, gnft.OwnerOf(tid(2)), test1) - // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 99500000933) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004795) // external - } + // check reward + shouldEQ(t, gns.BalanceOf(a2u(test1)), 99500000942) // internal + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004843) // external } func TestEndExternalIncentive(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) std.TestSkipHeights(9999999) - EndExternalIncentive(GetOrigCaller().String(), "gno.land/r/demo/bar:gno.land/r/demo/qux:500", "gno.land/r/demo/obl") // use same parameter as CreateExternalIncentive() + EndExternalIncentive(std.GetOrigCaller(), "gno.land/r/demo/bar:gno.land/r/demo/qux:500", "gno.land/r/demo/obl") // use same parameter as CreateExternalIncentive() std.TestSkipHeights(1) shouldEQ(t, len(incentives), 0) diff --git a/staker/_TEST_staker_get_test.gnoa b/staker/_TEST_staker_get_test.gnoa index 51bb49cf..2506b65e 100644 --- a/staker/_TEST_staker_get_test.gnoa +++ b/staker/_TEST_staker_get_test.gnoa @@ -3,101 +3,136 @@ package staker import ( "std" "testing" + "time" + + "gno.land/r/demo/consts" pl "gno.land/r/demo/pool" pn "gno.land/r/demo/position" "gno.land/r/demo/gnft" + + "gno.land/r/demo/bar" + "gno.land/r/demo/qux" + + "gno.land/r/demo/gns" + "gno.land/r/demo/obl" ) func TestPoolInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetPrevAddr(gsa) pl.InitManual() std.TestSkipHeights(1) - pl.CreatePool(fooPath, barPath, 500, 130621891405341611593710811006) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + std.TestSkipHeights(1) + + pl.CreatePool(barPath, quxPath, 500, 130621891405341611593710811006) // tick 10_000 ≈ x2.7 + std.TestSkipHeights(1) +} + +func TestPositionMint01(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 367) + qux.Approve(a2u(consts.POOL_ADDR), 999) + std.TestSkipHeights(2) + + lpTokenId, liquidity, amount0, amount1 := pn.Mint( + barPath, // token0 + quxPath, // token1 + uint16(500), // fee + int32(9000), // tickLower + int32(11000), // tickUpper + bigint(1000), // amount0Desired + bigint(1000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + bigint(2345678901), // deadline + ) + std.TestSkipHeights(1) + + shouldEQ(t, lpTokenId, 1) + shouldEQ(t, gnft.OwnerOf(tid(lpTokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(367)) + shouldEQ(t, amount1, bigint(999)) + + // approve nft to staker + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(lpTokenId)) std.TestSkipHeights(1) } -func TestPositionMint(t *testing.T) { - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - fooPath, // token0 - barPath, // token1 - uint16(500), // fee - int32(9000), // tickLower - int32(11000), // tickUpper - bigint(1000), // amount0Desired - bigint(1000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 1) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } - - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - fooPath, // token0 - barPath, // token1 - uint16(500), // fee - int32(9100), // tickLower - int32(12000), // tickUpper - bigint(5000), // amount0Desired - bigint(5000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 2) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } +func TestPositionMint02(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 3978) + qux.Approve(a2u(consts.POOL_ADDR), 4999) + std.TestSkipHeights(2) + + lpTokenId, liquidity, amount0, amount1 := pn.Mint( + barPath, // token0 + quxPath, // token1 + uint16(500), // fee + int32(9100), // tickLower + int32(12000), // tickUpper + bigint(5000), // amount0Desired + bigint(5000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + bigint(2345678901), // deadline + ) + std.TestSkipHeights(1) + + shouldEQ(t, lpTokenId, 2) + shouldEQ(t, gnft.OwnerOf(tid(lpTokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(3978)) + shouldEQ(t, amount1, bigint(4999)) + + // approve nft to staker + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(lpTokenId)) + std.TestSkipHeights(1) } func TestCreateExternalIncentive(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + obl.Approve(a2u(consts.STAKER_ADDR), uint64(10_000_000_000)) + std.TestSkipHeights(1) CreateExternalIncentive( - "gno.land/r/demo/bar:gno.land/r/demo/foo:500", // targetPoolPath + "gno.land/r/demo/bar:gno.land/r/demo/qux:500", // targetPoolPath "gno.land/r/demo/obl", // rewardToken 10_000_000_000, // rewardAmount - GetTimestamp(), // startTimestamp - GetTimestamp()+TIMESTAMP_90DAYS, // endTimestamp + time.Now().Unix(), // startTimestamp + time.Now().Unix()+TIMESTAMP_90DAYS, // endTimestamp ) - std.TestSkipHeights(5) + std.TestSkipHeights(1) - shouldPanic(t, func() { - CreateExternalIncentive("gno.land/r/demo/bar:gno.land/r/demo/foo:500", "OBL", 10_000_000_000, GetTimestamp(), GetTimestamp()+TIMESTAMP_90DAYS) - }) + obl.Approve(a2u(consts.STAKER_ADDR), uint64(10_000_000_000)) + std.TestSkipHeights(1) + + CreateExternalIncentive("gno.land/r/demo/bar:gno.land/r/demo/qux:500", "gno.land/r/demo/obl", 10_000_000_000, time.Now().Unix(), time.Now().Unix()+TIMESTAMP_90DAYS) + std.TestSkipHeights(1) } -func TestStakeToken(t *testing.T) { - std.TestSetOrigCaller(test1) - StakeToken(1) +func TestStakeToken01(t *testing.T) { + std.TestSetPrevAddr(test1) + StakeToken(1) // GNFT tokenId + std.TestSkipHeights(1) - // don't stake - // std.TestSetOrigCaller(test1) - // StakeToken(2) + shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) // staker + shouldEQ(t, len(deposits), 1) } +// func TestStakeToken02(t *testing.T) { +// std.TestSetPrevAddr(test1) +// StakeToken(2) // GNFT tokenId +// std.TestSkipHeights(1) + +// shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) // staker +// shouldEQ(t, len(deposits), 2) +// } + func TestIsStaked(t *testing.T) { shouldEQ(t, IsStaked(1), true) shouldEQ(t, IsStaked(2), false) diff --git a/staker/_TEST_staker_internal_external_test.gnoa b/staker/_TEST_staker_internal_external_test.gnoa index 3b842cf2..fdcd0301 100644 --- a/staker/_TEST_staker_internal_external_test.gnoa +++ b/staker/_TEST_staker_internal_external_test.gnoa @@ -2,16 +2,22 @@ package staker import ( "std" - "testing" + "time" + + "gno.land/r/demo/consts" pl "gno.land/r/demo/pool" pn "gno.land/r/demo/position" "gno.land/r/demo/gnft" + "gno.land/r/demo/bar" + "gno.land/r/demo/baz" + "gno.land/r/demo/foo" "gno.land/r/demo/gns" "gno.land/r/demo/obl" + "gno.land/r/demo/qux" ) func init() { @@ -30,19 +36,26 @@ func init() { } func TestPoolInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetPrevAddr(gsa) 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.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE*3) + std.TestSkipHeights(1) + + pl.CreatePool(barPath, quxPath, 500, 130621891405341611593710811006) // internal, tier 1 // tick 10_000 ≈ x2.7 + pl.CreatePool(barPath, bazPath, 100, 79228162514264337593543950337) // internal, tier 2 // tick 0 ≈ x1 + pl.CreatePool(fooPath, quxPath, 500, 79228162514264337593543950337) // external // tick 0 ≈ x1 std.TestSkipHeights(3) } func TestMintBarQux500(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 36789) + qux.Approve(a2u(consts.POOL_ADDR), 99999) + std.TestSkipHeights(2) + tokenId, liquidity, amount0, amount1 := pn.Mint( barPath, // token0 quxPath, // token1 @@ -58,11 +71,17 @@ func TestMintBarQux500(t *testing.T) { std.TestSkipHeights(1) shouldEQ(t, tokenId, 1) - shouldEQ(t, gnft.OwnerOf(tid(tokenId)), GetOrigCaller()) // test1 + shouldEQ(t, gnft.OwnerOf(tid(tokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(36789)) + shouldEQ(t, amount1, bigint(99999)) } func TestMintBarBaz100(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 99999) + baz.Approve(a2u(consts.POOL_ADDR), 99999) + std.TestSkipHeights(2) + tokenId, liquidity, amount0, amount1 := pn.Mint( barPath, // token0 bazPath, // token1 @@ -78,11 +97,17 @@ func TestMintBarBaz100(t *testing.T) { std.TestSkipHeights(1) shouldEQ(t, tokenId, 2) - shouldEQ(t, gnft.OwnerOf(tid(tokenId)), GetOrigCaller()) // test1 + shouldEQ(t, gnft.OwnerOf(tid(tokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(99999)) + shouldEQ(t, amount1, bigint(99999)) } func TestMintFooQux500(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + foo.Approve(a2u(consts.POOL_ADDR), 99999) + qux.Approve(a2u(consts.POOL_ADDR), 99999) + std.TestSkipHeights(2) + tokenId, liquidity, amount0, amount1 := pn.Mint( fooPath, // token0 quxPath, // token1 @@ -98,20 +123,23 @@ func TestMintFooQux500(t *testing.T) { std.TestSkipHeights(1) shouldEQ(t, tokenId, 3) - shouldEQ(t, gnft.OwnerOf(tid(tokenId)), GetOrigCaller()) // test1 + shouldEQ(t, gnft.OwnerOf(tid(tokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(99999)) + shouldEQ(t, amount1, bigint(99999)) } func TestCreateExternalIncentive(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + obl.Approve(a2u(consts.STAKER_ADDR), uint64(100_000_000)) + std.TestSkipHeights(1) 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 + time.Now().Unix(), // startTimestamp + time.Now().Unix()+TIMESTAMP_90DAYS, // endTimestamp ) - std.TestSkipHeights(1) } @@ -146,17 +174,20 @@ func TestStakeExternal(t *testing.T) { } func TestCollectRewardToken1(t *testing.T) { - std.TestSetPrevAddr(test1) + std.TestSetPrevAddr(consts.INTERNAL_REWARD_ACCOUNT) + gns.Approve(a2u(consts.STAKER_ADDR), uint64(consts.MAX_UINT64)) // internal reward distribution + std.TestSkipHeights(1) // before claim gnsOld := gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsOld, 99999998500) + shouldEQ(t, gnsOld, 98500000000) + std.TestSetPrevAddr(test1) CollectReward(1) std.TestSkipHeights(1) gnsNew := gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsNew, 99999999325) + shouldEQ(t, gnsNew, 98500000817) } func TestCollectRewardToken2(t *testing.T) { @@ -164,13 +195,13 @@ func TestCollectRewardToken2(t *testing.T) { // before claim gnsOld := gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsOld, 99999999325) + shouldEQ(t, gnsOld, 98500000817) CollectReward(2) std.TestSkipHeights(1) gnsNew := gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsNew, 99999999820) + shouldEQ(t, gnsNew, 98500001308) } func TestCollectRewardToken1Again(t *testing.T) { @@ -178,7 +209,7 @@ func TestCollectRewardToken1Again(t *testing.T) { // before claim gnsOld := gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsOld, 99999999820) + shouldEQ(t, gnsOld, 98500001308) // ACCELERATE TIME std.TestSkipHeights(100000) @@ -187,7 +218,7 @@ func TestCollectRewardToken1Again(t *testing.T) { std.TestSkipHeights(1) gnsNew := gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsNew, 100000000370) + shouldEQ(t, gnsNew, 98500001853) } func TestCollectExternalReward(t *testing.T) { @@ -219,17 +250,17 @@ func TestUnstakeToken1(t *testing.T) { std.TestSetPrevAddr(test1) gnsOld := gns.BalanceOf(a2u(test1)) oblOld := obl.BalanceOf(a2u(test1)) - shouldEQ(t, gnsOld, 100000000700) + shouldEQ(t, gnsOld, 98500002180) shouldEQ(t, oblOld, 499999900000035) std.TestSkipHeights(100000) UnstakeToken(1) gnsNew := gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsNew, 100000001250) + shouldEQ(t, gnsNew, 98500002725) UnstakeToken(2) gnsNew = gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsNew, 100000001580) + shouldEQ(t, gnsNew, 98500003052) UnstakeToken(3) oblNew := obl.BalanceOf(a2u(test1)) diff --git a/staker/_TEST_staker_one_external_native_test.gnoa b/staker/_TEST_staker_one_external_native_test.gnoa index c6567079..79ef04a7 100644 --- a/staker/_TEST_staker_one_external_native_test.gnoa +++ b/staker/_TEST_staker_one_external_native_test.gnoa @@ -3,14 +3,19 @@ package staker import ( "std" "testing" + "time" pl "gno.land/r/demo/pool" pn "gno.land/r/demo/position" - "gno.land/r/demo/gnft" + "gno.land/r/demo/bar" + "gno.land/r/demo/foo" "gno.land/r/demo/gns" - "gno.land/r/demo/wugnot" + + "gno.land/r/demo/gnft" + + "gno.land/r/demo/consts" ) func init() { @@ -26,143 +31,159 @@ func init() { poolTiers["ATOM/GNOT_500"] = 3 poolTiers["ATOM/USDT_500"] = 3 poolTiers["ATOM/WETH_500"] = 3 - } func TestPoolInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetPrevAddr(gsa) pl.InitManual() std.TestSkipHeights(1) - pl.CreatePool(barPath, fooPath, 500, 130621891405341611593710811006) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + std.TestSkipHeights(1) + + pl.CreatePool(barPath, fooPath, 500, 130621891405341611593710811006) // tick 10_000 ≈ x2.7 std.TestSkipHeights(1) } -func TestPositionMint(t *testing.T) { - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - barPath, // token0 - fooPath, // token1 - uint16(500), // fee - int32(9000), // tickLower - int32(11000), // tickUpper - bigint(1000), // amount0Desired - bigint(1000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 1) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } - - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - barPath, // token10 - fooPath, // token1 - uint16(500), // fee - int32(9100), // tickLower - int32(12000), // tickUpper - bigint(5000), // amount0Desired - bigint(5000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 2) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } +func TestPositionMint01(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 367) + foo.Approve(a2u(consts.POOL_ADDR), 999) + std.TestSkipHeights(2) + + lpTokenId, liquidity, amount0, amount1 := pn.Mint( + barPath, // token0 + fooPath, // token1 + uint16(500), // fee + int32(9000), // tickLower + int32(11000), // tickUpper + bigint(1000), // amount0Desired + bigint(1000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + bigint(2345678901), // deadline + ) + std.TestSkipHeights(1) + + shouldEQ(t, lpTokenId, 1) + shouldEQ(t, gnft.OwnerOf(tid(lpTokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(367)) + shouldEQ(t, amount1, bigint(999)) + + // approve nft to staker for staking + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(lpTokenId)) + std.TestSkipHeights(1) +} + +func TestPositionMint02(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 3978) + foo.Approve(a2u(consts.POOL_ADDR), 4999) + std.TestSkipHeights(2) + + lpTokenId, liquidity, amount0, amount1 := pn.Mint( + barPath, // token0 + fooPath, // token1 + uint16(500), // fee + int32(9100), // tickLower + int32(12000), // tickUpper + bigint(5000), // amount0Desired + bigint(5000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + bigint(2345678901), // deadline + ) + std.TestSkipHeights(1) + + shouldEQ(t, lpTokenId, 2) + shouldEQ(t, gnft.OwnerOf(tid(lpTokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(3978)) + shouldEQ(t, amount1, bigint(4999)) + + // approve nft to staker + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(lpTokenId)) + std.TestSkipHeights(1) } func TestCreateExternalIncentive(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) // send - std.TestSetOrigSend(std.Coins{{"ugnot", 10_000_000_000}}, nil) testBanker := std.GetBanker(std.BankerTypeRealmIssue) + testBanker.IssueCoin(test1, "ugnot", 10_000_000_000) + std.TestSetOrigSend(std.Coins{{"ugnot", 10_000_000_000}}, nil) testBanker.RemoveCoin(std.GetOrigCaller(), "ugnot", 10_000_000_000) // Deposit(wrap) - std.TestSetPrevAddr(test1) wugnot.Deposit() + std.TestSkipHeights(1) + + wugnot.Approve(a2u(consts.STAKER_ADDR), 10_000_000_000) + std.TestSkipHeights(1) CreateExternalIncentive( "gno.land/r/demo/bar:gno.land/r/demo/foo:500", // targetPoolPath - wgnotPath, // rewardToken - 10_000_000_000, // rewardAmount - GetTimestamp(), // startTimestamp - GetTimestamp()+TIMESTAMP_90DAYS, // endTimestamp + consts.WRAPPED_WUGNOT, // rewardToken + 10_000_000_000, // rewardAmount + time.Now().Unix(), // startTimestamp + time.Now().Unix()+TIMESTAMP_90DAYS, // endTimestamp ) std.TestSkipHeights(1) } -func TestStakeToken(t *testing.T) { - { - std.TestSetOrigCaller(test1) - StakeToken(1) // GNFT tokenId - std.TestSkipHeights(2) +func TestStakeToken01(t *testing.T) { + std.TestSetPrevAddr(test1) + StakeToken(1) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) // staker - shouldEQ(t, len(deposits), 1) - } + shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) // staker + shouldEQ(t, len(deposits), 1) +} - { - std.TestSetOrigCaller(test1) - StakeToken(2) // GNFT tokenId - std.TestSkipHeights(2) +func TestStakeToken02(t *testing.T) { + std.TestSetPrevAddr(test1) + StakeToken(2) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) // staker - shouldEQ(t, len(deposits), 2) - } + shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) // staker + shouldEQ(t, len(deposits), 2) } -func TestUnstakeToken(t *testing.T) { - { - std.TestSetOrigCaller(test1) - UnstakeToken(1) // GNFT tokenId - std.TestSkipHeights(1) +func TestUnstakeToken01(t *testing.T) { + std.TestSetPrevAddr(consts.INTERNAL_REWARD_ACCOUNT) + gns.Approve(a2u(consts.STAKER_ADDR), uint64(consts.MAX_UINT64)) // internal reward distribution + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(1)), test1) + std.TestSetPrevAddr(test1) + UnstakeToken(1) // GNFT tokenId + std.TestSkipHeights(1) + + shouldEQ(t, gnft.OwnerOf(tid(1)), test1) - // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 99999999626) // internal - shouldEQ(t, wugnot.BalanceOf(a2u(test1)), 324) // external - } + // check reward + shouldEQ(t, gns.BalanceOf(a2u(test1)), 99500000125) // internal + shouldEQ(t, wugnot.BalanceOf(a2u(test1)), 321) // external +} - { - std.TestSetOrigCaller(test1) - UnstakeToken(2) // GNFT tokenId - std.TestSkipHeights(1) +func TestUnstakeToken02(t *testing.T) { + std.TestSetPrevAddr(test1) + UnstakeToken(2) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(2)), test1) + shouldEQ(t, gnft.OwnerOf(tid(2)), test1) - // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000451) // internal - shouldEQ(t, wugnot.BalanceOf(a2u(test1)), 2445) // external - } + // check reward + shouldEQ(t, gns.BalanceOf(a2u(test1)), 99500000942) // internal + shouldEQ(t, wugnot.BalanceOf(a2u(test1)), 2421) // external } func TestEndExternalIncentive(t *testing.T) { std.TestSetOrigCaller(test1) std.TestSkipHeights(9999999) - EndExternalIncentive(GetOrigCaller().String(), "gno.land/r/demo/bar:gno.land/r/demo/foo:500", wgnotPath) // use same parameter as CreateExternalIncentive() + EndExternalIncentive(std.GetOrigCaller(), "gno.land/r/demo/bar:gno.land/r/demo/foo:500", consts.WRAPPED_WUGNOT) // use same parameter as CreateExternalIncentive() std.TestSkipHeights(1) shouldEQ(t, len(incentives), 0) diff --git a/staker/_TEST_staker_one_external_test.gnoa b/staker/_TEST_staker_one_external_test.gnoa index fa2fd4ff..1524274f 100644 --- a/staker/_TEST_staker_one_external_test.gnoa +++ b/staker/_TEST_staker_one_external_test.gnoa @@ -3,15 +3,21 @@ package staker import ( "std" "testing" + "time" "encoding/gjson" pl "gno.land/r/demo/pool" pn "gno.land/r/demo/position" - "gno.land/r/demo/gnft" + "gno.land/r/demo/bar" + "gno.land/r/demo/foo" "gno.land/r/demo/gns" "gno.land/r/demo/obl" + + "gno.land/r/demo/gnft" + + "gno.land/r/demo/consts" ) func init() { @@ -30,102 +36,111 @@ func init() { } func TestPoolInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetPrevAddr(gsa) pl.InitManual() std.TestSkipHeights(1) - pl.CreatePool(fooPath, barPath, 500, 130621891405341611593710811006) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + std.TestSkipHeights(1) + + pl.CreatePool(fooPath, barPath, 500, 130621891405341611593710811006) // tick 10_000 ≈ x2.7 std.TestSkipHeights(1) } -func TestPositionMint(t *testing.T) { - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - fooPath, // token0 - barPath, // token1 - uint16(500), // fee - int32(9000), // tickLower - int32(11000), // tickUpper - bigint(1000), // amount0Desired - bigint(1000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 1) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } - - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - fooPath, // token0 - barPath, // token1 - uint16(500), // fee - int32(9100), // tickLower - int32(12000), // tickUpper - bigint(5000), // amount0Desired - bigint(5000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 2) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } +func TestPositionMint01(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 999) + foo.Approve(a2u(consts.POOL_ADDR), 367) + std.TestSkipHeights(2) + + lpTokenId, liquidity, amount0, amount1 := pn.Mint( + fooPath, // token0 + barPath, // token1 + uint16(500), // fee + int32(9000), // tickLower + int32(11000), // tickUpper + bigint(1000), // amount0Desired + bigint(1000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + bigint(2345678901), // deadline + ) + std.TestSkipHeights(1) + + shouldEQ(t, lpTokenId, 1) + shouldEQ(t, gnft.OwnerOf(tid(lpTokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(999)) + shouldEQ(t, amount1, bigint(367)) + + // approve nft to staker for staking + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(lpTokenId)) + std.TestSkipHeights(1) +} + +func TestPositionMint02(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 4999) + foo.Approve(a2u(consts.POOL_ADDR), 3978) + std.TestSkipHeights(2) + + lpTokenId, liquidity, amount0, amount1 := pn.Mint( + fooPath, // token0 + barPath, // token1 + uint16(500), // fee + int32(9100), // tickLower + int32(12000), // tickUpper + bigint(5000), // amount0Desired + bigint(5000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + bigint(2345678901), // deadline + ) + std.TestSkipHeights(1) + + shouldEQ(t, lpTokenId, 2) + shouldEQ(t, gnft.OwnerOf(tid(lpTokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(4999)) + shouldEQ(t, amount1, bigint(3978)) + + // approve nft to staker + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(lpTokenId)) + std.TestSkipHeights(1) } func TestCreateExternalIncentive(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + obl.Approve(a2u(consts.STAKER_ADDR), 10_000_000_000) + std.TestSkipHeights(1) CreateExternalIncentive( "gno.land/r/demo/bar:gno.land/r/demo/foo:500", // targetPoolPath - "gno.land/r/demo/obl", // rewardToken - 10_000_000_000, // rewardAmount - GetTimestamp(), // startTimestamp - GetTimestamp()+TIMESTAMP_90DAYS, // endTimestamp + oblPath, // rewardToken + 10_000_000_000, // rewardAmount + time.Now().Unix(), // startTimestamp + time.Now().Unix()+TIMESTAMP_90DAYS, // endTimestamp ) - std.TestSkipHeights(5) - - shouldPanic(t, func() { - CreateExternalIncentive("gno.land/r/demo/bar:gno.land/r/demo/foo:500", "OBL", 10_000_000_000, GetTimestamp(), GetTimestamp()+TIMESTAMP_90DAYS) - }) + std.TestSkipHeights(1) } -func TestStakeToken(t *testing.T) { - { - std.TestSetOrigCaller(test1) - StakeToken(1) // GNFT tokenId - std.TestSkipHeights(2) +func TestStakeToken01(t *testing.T) { + std.TestSetPrevAddr(test1) + StakeToken(1) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) // staker - shouldEQ(t, len(deposits), 1) - } + shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) // staker + shouldEQ(t, len(deposits), 1) +} - { - std.TestSetOrigCaller(test1) - StakeToken(2) // GNFT tokenId - std.TestSkipHeights(2) +func TestStakeToken02(t *testing.T) { + std.TestSetPrevAddr(test1) + StakeToken(2) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) // staker - shouldEQ(t, len(deposits), 2) - } + shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) // staker + shouldEQ(t, len(deposits), 2) } func TestApiGetStakes(t *testing.T) { @@ -140,36 +155,38 @@ func TestApiGetRewardTokens(t *testing.T) { shouldEQ(t, len(jsonStr.Get("response").Array()), 1) } -func TestUnstakeToken(t *testing.T) { - { - std.TestSetOrigCaller(test1) - UnstakeToken(1) // GNFT tokenId - std.TestSkipHeights(1) +func TestUnstakeToken01(t *testing.T) { + std.TestSetPrevAddr(consts.INTERNAL_REWARD_ACCOUNT) + gns.Approve(a2u(consts.STAKER_ADDR), uint64(consts.MAX_UINT64)) // internal reward distribution + std.TestSkipHeights(1) + + std.TestSetPrevAddr(test1) + UnstakeToken(1) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(1)), test1) + shouldEQ(t, gnft.OwnerOf(tid(1)), test1) - // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 99999999626) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499990000000324) // external - } + // check reward + shouldEQ(t, gns.BalanceOf(a2u(test1)), 99500000125) // internal + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499990000000321) // external +} - { - std.TestSetOrigCaller(test1) - UnstakeToken(2) // GNFT tokenId - std.TestSkipHeights(1) +func TestUnstakeToken02(t *testing.T) { + std.TestSetPrevAddr(test1) + UnstakeToken(2) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(2)), test1) + shouldEQ(t, gnft.OwnerOf(tid(2)), test1) - // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000451) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499990000002445) // external - } + // check reward + shouldEQ(t, gns.BalanceOf(a2u(test1)), 99500000942) // internal + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499990000002421) // external } func TestEndExternalIncentive(t *testing.T) { std.TestSetOrigCaller(test1) std.TestSkipHeights(9999999) - EndExternalIncentive(GetOrigCaller().String(), "gno.land/r/demo/bar:gno.land/r/demo/foo:500", "gno.land/r/demo/obl") // use same parameter as CreateExternalIncentive() + EndExternalIncentive(std.GetOrigCaller(), "gno.land/r/demo/bar:gno.land/r/demo/foo:500", "gno.land/r/demo/obl") // use same parameter as CreateExternalIncentive() std.TestSkipHeights(1) shouldEQ(t, len(incentives), 0) diff --git a/staker/_TEST_staker_one_increase_external_test.gnoa b/staker/_TEST_staker_one_increase_external_test.gnoa index de151280..48629318 100644 --- a/staker/_TEST_staker_one_increase_external_test.gnoa +++ b/staker/_TEST_staker_one_increase_external_test.gnoa @@ -3,13 +3,21 @@ package staker import ( "std" "testing" + "time" + + "encoding/gjson" pl "gno.land/r/demo/pool" pn "gno.land/r/demo/position" - "gno.land/r/demo/gnft" + "gno.land/r/demo/bar" + "gno.land/r/demo/foo" "gno.land/r/demo/gns" "gno.land/r/demo/obl" + + "gno.land/r/demo/gnft" + + "gno.land/r/demo/consts" ) func init() { @@ -28,125 +36,156 @@ func init() { } func TestPoolInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetPrevAddr(gsa) pl.InitManual() std.TestSkipHeights(1) - pl.CreatePool(fooPath, barPath, 500, 130621891405341611593710811006) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + std.TestSkipHeights(1) + + pl.CreatePool(fooPath, barPath, 500, 130621891405341611593710811006) // tick 10_000 ≈ x2.7 + std.TestSkipHeights(1) +} + +func TestPositionMint01(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 999) + foo.Approve(a2u(consts.POOL_ADDR), 367) + std.TestSkipHeights(2) + + lpTokenId, liquidity, amount0, amount1 := pn.Mint( + fooPath, // token0 + barPath, // token1 + uint16(500), // fee + int32(9000), // tickLower + int32(11000), // tickUpper + bigint(1000), // amount0Desired + bigint(1000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + bigint(2345678901), // deadline + ) + std.TestSkipHeights(1) + + shouldEQ(t, lpTokenId, 1) + shouldEQ(t, gnft.OwnerOf(tid(lpTokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(999)) + shouldEQ(t, amount1, bigint(367)) + + // approve nft to staker for staking + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(lpTokenId)) std.TestSkipHeights(1) } -func TestPositionMint(t *testing.T) { - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - fooPath, // token0 - barPath, // token1 - uint16(500), // fee - int32(9000), // tickLower - int32(11000), // tickUpper - bigint(1000), // amount0Desired - bigint(1000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 1) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } - - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - fooPath, // token0 - barPath, // token1 - uint16(500), // fee - int32(9100), // tickLower - int32(12000), // tickUpper - bigint(5000), // amount0Desired - bigint(5000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 2) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } +func TestPositionMint02(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 4999) + foo.Approve(a2u(consts.POOL_ADDR), 3978) + std.TestSkipHeights(2) + + lpTokenId, liquidity, amount0, amount1 := pn.Mint( + fooPath, // token0 + barPath, // token1 + uint16(500), // fee + int32(9100), // tickLower + int32(12000), // tickUpper + bigint(5000), // amount0Desired + bigint(5000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + bigint(2345678901), // deadline + ) + std.TestSkipHeights(1) + + shouldEQ(t, lpTokenId, 2) + shouldEQ(t, gnft.OwnerOf(tid(lpTokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(4999)) + shouldEQ(t, amount1, bigint(3978)) + + // approve nft to staker + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(lpTokenId)) + std.TestSkipHeights(1) } func TestCreateExternalIncentive(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + obl.Approve(a2u(consts.STAKER_ADDR), 10_000_000_000) + std.TestSkipHeights(1) CreateExternalIncentive( "gno.land/r/demo/bar:gno.land/r/demo/foo:500", // targetPoolPath - "gno.land/r/demo/obl", // rewardToken - 10_000_000_000, // rewardAmount - GetTimestamp(), // startTimestamp - GetTimestamp()+TIMESTAMP_90DAYS, // endTimestamp + oblPath, // rewardToken + 10_000_000_000, // rewardAmount + time.Now().Unix(), // startTimestamp + time.Now().Unix()+TIMESTAMP_90DAYS, // endTimestamp ) - CreateExternalIncentive("gno.land/r/demo/bar:gno.land/r/demo/foo:500", "gno.land/r/demo/obl", 10_000_000_000, GetTimestamp(), GetTimestamp()+TIMESTAMP_90DAYS) - std.TestSkipHeights(5) + std.TestSkipHeights(1) + + obl.Approve(a2u(consts.STAKER_ADDR), 10_000_000_000) + std.TestSkipHeights(1) + CreateExternalIncentive("gno.land/r/demo/bar:gno.land/r/demo/foo:500", oblPath, 10_000_000_000, time.Now().Unix(), time.Now().Unix()+TIMESTAMP_90DAYS) + std.TestSkipHeights(1) +} + +func TestStakeToken01(t *testing.T) { + std.TestSetPrevAddr(test1) + StakeToken(1) // GNFT tokenId + std.TestSkipHeights(1) + + shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) // staker + shouldEQ(t, len(deposits), 1) } -func TestStakeToken(t *testing.T) { - { - std.TestSetOrigCaller(test1) - StakeToken(1) // GNFT tokenId - std.TestSkipHeights(2) +func TestStakeToken02(t *testing.T) { + std.TestSetPrevAddr(test1) + StakeToken(2) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) // staker - shouldEQ(t, len(deposits), 1) - } + shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) // staker + shouldEQ(t, len(deposits), 2) +} - { - std.TestSetOrigCaller(test1) - StakeToken(2) // GNFT tokenId - std.TestSkipHeights(2) +func TestApiGetStakes(t *testing.T) { + gss := ApiGetStakes() + jsonStr := gjson.Parse(gss) + shouldEQ(t, len(jsonStr.Get("response").Array()), 2) +} - shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) // staker - shouldEQ(t, len(deposits), 2) - } +func TestApiGetRewardTokens(t *testing.T) { + grt := ApiGetRewardTokens() + jsonStr := gjson.Parse(grt) + shouldEQ(t, len(jsonStr.Get("response").Array()), 1) } -func TestUnstakeToken(t *testing.T) { - { - std.TestSetOrigCaller(test1) - UnstakeToken(1) // GNFT tokenId - std.TestSkipHeights(1) +func TestUnstakeToken01(t *testing.T) { + std.TestSetPrevAddr(consts.INTERNAL_REWARD_ACCOUNT) + gns.Approve(a2u(consts.STAKER_ADDR), uint64(consts.MAX_UINT64)) // internal reward distribution + std.TestSkipHeights(1) + + std.TestSetPrevAddr(test1) + UnstakeToken(1) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(1)), test1) + shouldEQ(t, gnft.OwnerOf(tid(1)), test1) - // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 99999999626) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000000648) // external - } + // check reward + shouldEQ(t, gns.BalanceOf(a2u(test1)), 99500000125) // internal + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000000642) // external +} - { - std.TestSetOrigCaller(test1) - UnstakeToken(2) // GNFT tokenId - std.TestSkipHeights(1) +func TestUnstakeToken02(t *testing.T) { + std.TestSetPrevAddr(test1) + UnstakeToken(2) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(2)), test1) + shouldEQ(t, gnft.OwnerOf(tid(2)), test1) - // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000451) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004891) // external - } + // check reward + shouldEQ(t, gns.BalanceOf(a2u(test1)), 99500000942) // internal + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004843) // external } func TestEndExternalIncentive(t *testing.T) { @@ -156,13 +195,12 @@ func TestEndExternalIncentive(t *testing.T) { // incentive time isn't over yet shouldPanicWithMsg(t, func() { - EndExternalIncentive(string(test1), "gno.land/r/demo/bar:gno.land/r/demo/foo:500", "gno.land/r/demo/obl") - }, "[STAKER] staker.gno__EndExternalIncentive() || cannot end incentive before endTimestamp(1242343920), current(1234567975)") + EndExternalIncentive(test1, "gno.land/r/demo/bar:gno.land/r/demo/foo:500", "gno.land/r/demo/obl") + }, "[STAKER] staker.gno__EndExternalIncentive() || cannot end incentive before endTimestamp(1242343950), current(1234567990)") - std.TestSkipHeights(1555188) // not yet, one more should be good to end incentive - std.TestSkipHeights(1) + std.TestSkipHeights(9999999) // not yet, one more should be good to end incentive - EndExternalIncentive(string(test1), "gno.land/r/demo/bar:gno.land/r/demo/foo:500", "gno.land/r/demo/obl") // use same parameter as CreateExternalIncentive() + EndExternalIncentive(test1, "gno.land/r/demo/bar:gno.land/r/demo/foo:500", "gno.land/r/demo/obl") // use same parameter as CreateExternalIncentive() std.TestSkipHeights(1) shouldEQ(t, len(incentives), 0) diff --git a/staker/_TEST_staker_rpc_get_test.gnoa b/staker/_TEST_staker_rpc_get_test.gnoa index 87920dba..a813d657 100644 --- a/staker/_TEST_staker_rpc_get_test.gnoa +++ b/staker/_TEST_staker_rpc_get_test.gnoa @@ -3,15 +3,21 @@ package staker import ( "std" "testing" + "time" "encoding/gjson" pl "gno.land/r/demo/pool" pn "gno.land/r/demo/position" - "gno.land/r/demo/gnft" + "gno.land/r/demo/bar" "gno.land/r/demo/gns" "gno.land/r/demo/obl" + "gno.land/r/demo/qux" + + "gno.land/r/demo/gnft" + + "gno.land/r/demo/consts" ) func init() { @@ -30,99 +36,115 @@ func init() { } func TestPoolInitCreatePool(t *testing.T) { - std.TestSetOrigCaller(test1) - + std.TestSetPrevAddr(gsa) pl.InitManual() std.TestSkipHeights(1) - pl.CreatePool(barPath, quxPath, 500, 130621891405341611593710811006) + std.TestSetPrevAddr(test1) + gns.Approve(a2u(consts.POOL_ADDR), consts.POOL_CREATION_FEE) + std.TestSkipHeights(1) + + pl.CreatePool(barPath, quxPath, 500, 130621891405341611593710811006) // tick 10_000 ≈ x2.7 std.TestSkipHeights(1) } +func TestPositionMint01(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 367) + qux.Approve(a2u(consts.POOL_ADDR), 999) + std.TestSkipHeights(2) + + lpTokenId, liquidity, amount0, amount1 := pn.Mint( + barPath, // token0 + quxPath, // token1 + uint16(500), // fee + int32(9000), // tickLower + int32(11000), // tickUpper + bigint(1000), // amount0Desired + bigint(1000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + bigint(2345678901), // deadline + ) + std.TestSkipHeights(1) + + shouldEQ(t, lpTokenId, 1) + shouldEQ(t, gnft.OwnerOf(tid(lpTokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(367)) + shouldEQ(t, amount1, bigint(999)) -func TestPositionMint(t *testing.T) { - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - barPath, // token0 - quxPath, // token1 - uint16(500), // fee - int32(9000), // tickLower - int32(11000), // tickUpper - bigint(1000), // amount0Desired - bigint(1000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 1) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } - - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - barPath, // token0 - quxPath, // token1 - uint16(500), // fee - int32(9100), // tickLower - int32(12000), // tickUpper - bigint(5000), // amount0Desired - bigint(5000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 2) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } + // approve nft to staker for staking + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(lpTokenId)) + std.TestSkipHeights(1) +} + +func TestPositionMint02(t *testing.T) { + std.TestSetPrevAddr(test1) + bar.Approve(a2u(consts.POOL_ADDR), 3978) + qux.Approve(a2u(consts.POOL_ADDR), 4999) + std.TestSkipHeights(2) + + lpTokenId, liquidity, amount0, amount1 := pn.Mint( + barPath, // token0 + quxPath, // token1 + uint16(500), // fee + int32(9100), // tickLower + int32(12000), // tickUpper + bigint(5000), // amount0Desired + bigint(5000), // amount1Desired + bigint(1), // amount0Min + bigint(1), // amount1Min + bigint(2345678901), // deadline + ) + std.TestSkipHeights(1) + + shouldEQ(t, lpTokenId, 2) + shouldEQ(t, gnft.OwnerOf(tid(lpTokenId)), std.GetOrigCaller()) // test1 + shouldEQ(t, amount0, bigint(3978)) + shouldEQ(t, amount1, bigint(4999)) + + // approve nft to staker + std.TestSetPrevAddr(test1) + gnft.Approve(a2u(GetOrigPkgAddr()), tid(lpTokenId)) + std.TestSkipHeights(1) } func TestCreateExternalIncentive(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(test1) + obl.Approve(a2u(consts.STAKER_ADDR), 10_000_000_000) + std.TestSkipHeights(1) CreateExternalIncentive( "gno.land/r/demo/bar:gno.land/r/demo/qux:500", // targetPoolPath - "gno.land/r/demo/obl", // rewardToken - 10_000_000_000, // rewardAmount - GetTimestamp(), // startTimestamp - GetTimestamp()+TIMESTAMP_90DAYS, // endTimestamp + oblPath, // rewardToken + 10_000_000_000, // rewardAmount + time.Now().Unix(), // startTimestamp + time.Now().Unix()+TIMESTAMP_90DAYS, // endTimestamp ) - CreateExternalIncentive("gno.land/r/demo/bar:gno.land/r/demo/qux:500", "gno.land/r/demo/obl", 10_000_000_000, GetTimestamp(), GetTimestamp()+TIMESTAMP_90DAYS) - std.TestSkipHeights(5) + std.TestSkipHeights(1) + + obl.Approve(a2u(consts.STAKER_ADDR), 10_000_000_000) + std.TestSkipHeights(1) + CreateExternalIncentive("gno.land/r/demo/bar:gno.land/r/demo/qux:500", oblPath, 10_000_000_000, time.Now().Unix(), time.Now().Unix()+TIMESTAMP_90DAYS) + std.TestSkipHeights(1) } -func TestStakeToken(t *testing.T) { - { - std.TestSetOrigCaller(test1) - StakeToken(1) // GNFT tokenId - std.TestSkipHeights(2) +func TestStakeToken01(t *testing.T) { + std.TestSetPrevAddr(test1) + StakeToken(1) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) // staker - shouldEQ(t, len(deposits), 1) - } + shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) // staker + shouldEQ(t, len(deposits), 1) +} - { - std.TestSetOrigCaller(test1) - StakeToken(2) // GNFT tokenId - std.TestSkipHeights(2) +func TestStakeToken02(t *testing.T) { + std.TestSetPrevAddr(test1) + StakeToken(2) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) // staker - shouldEQ(t, len(deposits), 2) - } + shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) // staker + shouldEQ(t, len(deposits), 2) } func TestApiGetRewards(t *testing.T) { @@ -140,48 +162,52 @@ func TestApiGetStakes(t *testing.T) { } func TestCollectReward(t *testing.T) { - std.TestSetOrigCaller(test1) + std.TestSetPrevAddr(consts.INTERNAL_REWARD_ACCOUNT) + gns.Approve(a2u(consts.STAKER_ADDR), uint64(consts.MAX_UINT64)) // internal reward distribution + std.TestSkipHeights(1) // before claim gnsOld := gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsOld, 99999999500) + shouldEQ(t, gnsOld, 99500000000) + std.TestSetPrevAddr(test1) CollectReward(1) // GNFT tokenId + std.TestSkipHeights(1) + gnsNew := gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsNew, 99999999626) + shouldEQ(t, gnsNew, 99500000125) } -func TestUnstakeToken(t *testing.T) { - { - std.TestSetOrigCaller(test1) - UnstakeToken(1) // GNFT tokenId - std.TestSkipHeights(1) +func TestUnstakeToken01(t *testing.T) { + std.TestSetPrevAddr(test1) + UnstakeToken(1) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(1)), test1) + shouldEQ(t, gnft.OwnerOf(tid(1)), test1) - // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 99999999626) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000000648) // external - } + // check reward + shouldEQ(t, gns.BalanceOf(a2u(test1)), 99500000125) // internal + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000000642) // external +} - { - std.TestSetOrigCaller(test1) - UnstakeToken(2) // GNFT tokenId - std.TestSkipHeights(1) +func TestUnstakeToken02(t *testing.T) { + std.TestSetPrevAddr(test1) + UnstakeToken(2) // GNFT tokenId + std.TestSkipHeights(1) - shouldEQ(t, gnft.OwnerOf(tid(2)), test1) + shouldEQ(t, gnft.OwnerOf(tid(2)), test1) - // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000451) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004891) // external - } + // check reward + shouldEQ(t, gns.BalanceOf(a2u(test1)), 99500000942) + // internal + shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004843) // external } func TestEndExternalIncentive(t *testing.T) { std.TestSetOrigCaller(test1) std.TestSkipHeights(9999999) - EndExternalIncentive(GetOrigCaller().String(), "gno.land/r/demo/bar:gno.land/r/demo/qux:500", "gno.land/r/demo/obl") // use same parameter as CreateExternalIncentive() + EndExternalIncentive(std.GetOrigCaller(), "gno.land/r/demo/bar:gno.land/r/demo/qux:500", "gno.land/r/demo/obl") // use same parameter as CreateExternalIncentive() std.TestSkipHeights(1) shouldEQ(t, len(incentives), 0) diff --git a/staker/_TEST_staker_rpc_test.gnoa b/staker/_TEST_staker_rpc_test.gnoa deleted file mode 100644 index 87920dba..00000000 --- a/staker/_TEST_staker_rpc_test.gnoa +++ /dev/null @@ -1,189 +0,0 @@ -package staker - -import ( - "std" - "testing" - - "encoding/gjson" - - 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 // DEV - - // tier 2 - poolTiers["GNS/USDT_500"] = 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) - std.TestSkipHeights(1) -} - -func TestPositionMint(t *testing.T) { - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - barPath, // token0 - quxPath, // token1 - uint16(500), // fee - int32(9000), // tickLower - int32(11000), // tickUpper - bigint(1000), // amount0Desired - bigint(1000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 1) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } - - { - std.TestSetOrigCaller(test1) - tPosTokenId, tPosLiquidity, tPosAmount0, tPosAmount1 := pn.Mint( - barPath, // token0 - quxPath, // token1 - uint16(500), // fee - int32(9100), // tickLower - int32(12000), // tickUpper - bigint(5000), // amount0Desired - bigint(5000), // amount1Desired - bigint(1), // amount0Min - bigint(1), // amount1Min - bigint(2345678901), // deadline - ) - std.TestSkipHeights(1) - - shouldEQ(t, tPosTokenId, 2) - shouldEQ(t, gnft.OwnerOf(tid(tPosTokenId)), GetOrigCaller()) // test1 - - // approve nft to staker - std.TestSetPrevAddr(test1) - gnft.Approve(a2u(GetOrigPkgAddr()), tid(tPosTokenId)) - std.TestSkipHeights(1) - } -} - -func TestCreateExternalIncentive(t *testing.T) { - std.TestSetOrigCaller(test1) - - CreateExternalIncentive( - "gno.land/r/demo/bar:gno.land/r/demo/qux:500", // targetPoolPath - "gno.land/r/demo/obl", // rewardToken - 10_000_000_000, // rewardAmount - GetTimestamp(), // startTimestamp - GetTimestamp()+TIMESTAMP_90DAYS, // endTimestamp - ) - CreateExternalIncentive("gno.land/r/demo/bar:gno.land/r/demo/qux:500", "gno.land/r/demo/obl", 10_000_000_000, GetTimestamp(), GetTimestamp()+TIMESTAMP_90DAYS) - std.TestSkipHeights(5) -} - -func TestStakeToken(t *testing.T) { - { - std.TestSetOrigCaller(test1) - StakeToken(1) // GNFT tokenId - std.TestSkipHeights(2) - - shouldEQ(t, gnft.OwnerOf(tid(1)), GetOrigPkgAddr()) // staker - shouldEQ(t, len(deposits), 1) - } - - { - std.TestSetOrigCaller(test1) - StakeToken(2) // GNFT tokenId - std.TestSkipHeights(2) - - shouldEQ(t, gnft.OwnerOf(tid(2)), GetOrigPkgAddr()) // staker - shouldEQ(t, len(deposits), 2) - } -} - -func TestApiGetRewards(t *testing.T) { - agrs := ApiGetRewards() - jsonStr := gjson.Parse(agrs) - jsonArr := jsonStr.Get("response").Array() - shouldEQ(t, len(jsonArr), 2) // lpTokenId 1, 2 -} - -func TestApiGetStakes(t *testing.T) { - ags := ApiGetStakes() - jsonStr := gjson.Parse(ags) - jsonArr := jsonStr.Get("response").Array() - shouldEQ(t, len(jsonArr), 2) // lpTokenId 1, 2 -} - -func TestCollectReward(t *testing.T) { - std.TestSetOrigCaller(test1) - - // before claim - gnsOld := gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsOld, 99999999500) - - CollectReward(1) // GNFT tokenId - gnsNew := gns.BalanceOf(a2u(test1)) - shouldEQ(t, gnsNew, 99999999626) - -} - -func TestUnstakeToken(t *testing.T) { - { - std.TestSetOrigCaller(test1) - UnstakeToken(1) // GNFT tokenId - std.TestSkipHeights(1) - - shouldEQ(t, gnft.OwnerOf(tid(1)), test1) - - // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 99999999626) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000000648) // external - } - - { - std.TestSetOrigCaller(test1) - UnstakeToken(2) // GNFT tokenId - std.TestSkipHeights(1) - - shouldEQ(t, gnft.OwnerOf(tid(2)), test1) - - // check reward - shouldEQ(t, gns.BalanceOf(a2u(test1)), 100000000451) // internal - shouldEQ(t, obl.BalanceOf(a2u(test1)), 499980000004891) // external - } -} - -func TestEndExternalIncentive(t *testing.T) { - std.TestSetOrigCaller(test1) - std.TestSkipHeights(9999999) - EndExternalIncentive(GetOrigCaller().String(), "gno.land/r/demo/bar:gno.land/r/demo/qux:500", "gno.land/r/demo/obl") // use same parameter as CreateExternalIncentive() - std.TestSkipHeights(1) - - shouldEQ(t, len(incentives), 0) - shouldEQ(t, len(poolIncentives["gno.land/r/demo/bar:gno.land/r/demo/qux:500"]), 0) -} diff --git a/staker/gno_helper.gno b/staker/gno_helper.gno index e3fff7ae..9e3aa049 100644 --- a/staker/gno_helper.gno +++ b/staker/gno_helper.gno @@ -2,36 +2,10 @@ package staker import ( "std" - "time" "gno.land/r/demo/consts" ) -func GetTimestamp() int64 { - return time.Now().Unix() -} - -func GetHeight() int64 { - return std.GetHeight() -} - func GetOrigPkgAddr() std.Address { return consts.STAKER_ADDR - // return std.GetOrigPkgAddr() -} - -func GetOrigCaller() std.Address { - return std.GetOrigCaller() -} - -func PrevRealmAddr() std.Address { - return std.PrevRealm().Addr() -} - -func PrevRealmPath() string { - return std.PrevRealm().PkgPath() -} - -func PrevRealm() std.Realm { - return std.PrevRealm() } diff --git a/staker/incentive_id.gno b/staker/incentive_id.gno index fb2b0fb2..9d7c16d4 100644 --- a/staker/incentive_id.gno +++ b/staker/incentive_id.gno @@ -3,11 +3,13 @@ package staker import ( "encoding/base64" + "std" + "gno.land/p/demo/ufmt" ) -func incentiveIdCompute(caller, targetPoolPath, rewardToken string) string { - key := ufmt.Sprintf("%s:%s:%s", caller, targetPoolPath, rewardToken) +func incentiveIdCompute(caller std.Address, targetPoolPath, rewardToken string) string { + key := ufmt.Sprintf("%s:%s:%s", caller.String(), targetPoolPath, rewardToken) encoded := base64.StdEncoding.EncodeToString([]byte(key)) return encoded diff --git a/staker/reward_math.gno b/staker/reward_math.gno index 41ea3d1d..e97063c3 100644 --- a/staker/reward_math.gno +++ b/staker/reward_math.gno @@ -2,6 +2,7 @@ package staker import ( "std" + "time" "gno.land/r/demo/consts" @@ -82,7 +83,7 @@ func rewardMathComputeInternalRewardAmount(tokenId uint64, deposit Deposit) bigi // so there is no need to consider start/end time of reward program // start time is staked time, end time is current time startTime := deposit.stakeTimestamp - endTime := GetTimestamp() + endTime := time.Now().Unix() stakedDuration := endTime - startTime rewardRatio := getRewardRatio(stakedDuration) @@ -137,7 +138,7 @@ func rewardMathComputeExternalRewardAmount(tokenId uint64, deposit Deposit, ince // stake start time ( largest value between incentive start time and deposit stake time ) // stake end time ( smallest value between incentive end time and current time) startTime := max(incentive.startTimestamp, deposit.stakeTimestamp) - endTime := min(incentive.endTimestamp, GetTimestamp()) + endTime := min(incentive.endTimestamp, time.Now().Unix()) stakedDuration := endTime - startTime rewardRatio := getRewardRatio(stakedDuration) diff --git a/staker/staker.gno b/staker/staker.gno index c093b78d..e775bb8b 100644 --- a/staker/staker.gno +++ b/staker/staker.gno @@ -2,6 +2,7 @@ package staker import ( "std" + "time" "gno.land/p/demo/common" "gno.land/p/demo/ufmt" @@ -46,30 +47,30 @@ func CreateExternalIncentive( startTimestamp int64, endTimestamp int64, ) { - require(GetTimestamp() <= startTimestamp, ufmt.Sprintf("[STAKER] staker.gno__CreateExternalIncentive() || startTimestamp must be in the future__GetTimestamp(%d) <= startTimestamp(%d)", GetTimestamp(), startTimestamp)) + require(time.Now().Unix() <= startTimestamp, ufmt.Sprintf("[STAKER] staker.gno__CreateExternalIncentive() || startTimestamp must be in the future__time.Now().Unix(%d) <= startTimestamp(%d)", time.Now().Unix(), startTimestamp)) externalDuration := uint64(endTimestamp - startTimestamp) if !(externalDuration == TIMESTAMP_90DAYS || externalDuration == TIMESTAMP_180DAYS || externalDuration == TIMESTAMP_360DAYS) { panic(ufmt.Sprintf("[STAKER] staker.gno__CreateExternalIncentive() || externalDuration(%d) must be 90, 180, 360 days)", externalDuration)) } - fromBalanceBefore := balanceOfByRegisterCall(rewardToken, GetOrigCaller()) + fromBalanceBefore := balanceOfByRegisterCall(rewardToken, std.GetOrigCaller()) require(fromBalanceBefore >= uint64(rewardAmount), ufmt.Sprintf("[STAKER] staker.gno__CreateExternalIncentive() || not enough rewardAmount(%d) to create incentive(%d)", fromBalanceBefore, rewardAmount)) poolRewardBalanceBefore := balanceOfByRegisterCall(rewardToken, GetOrigPkgAddr()) - incentiveId := incentiveIdCompute(GetOrigCaller().String(), targetPoolPath, rewardToken) + incentiveId := incentiveIdCompute(std.GetOrigCaller(), targetPoolPath, rewardToken) // if same incentiveId exists => increase rewardTokenAmount for _, v := range poolIncentives[targetPoolPath] { if v == incentiveId { - transferFromByRegisterCall(rewardToken, GetOrigCaller(), GetOrigPkgAddr(), uint64(rewardAmount)) + transferFromByRegisterCall(rewardToken, std.GetOrigCaller(), GetOrigPkgAddr(), uint64(rewardAmount)) incentives[v].rewardAmount += rewardAmount return } } - transferFromByRegisterCall(rewardToken, GetOrigCaller(), GetOrigPkgAddr(), uint64(rewardAmount)) + transferFromByRegisterCall(rewardToken, std.GetOrigCaller(), GetOrigPkgAddr(), uint64(rewardAmount)) poolRewardBalanceAfter := balanceOfByRegisterCall(rewardToken, GetOrigPkgAddr()) require(poolRewardBalanceAfter-poolRewardBalanceBefore == uint64(rewardAmount), ufmt.Sprintf("[STAKER] staker.gno__CreateExternalIncentive() || pool reward balance not updated correctly(before:%d, added:%d, final:%d)", poolRewardBalanceBefore, rewardAmount, poolRewardBalanceAfter)) @@ -80,7 +81,7 @@ func CreateExternalIncentive( rewardAmount: rewardAmount, startTimestamp: startTimestamp, endTimestamp: endTimestamp, - refundee: GetOrigCaller(), + refundee: std.GetOrigCaller(), } poolIncentives[targetPoolPath] = append(poolIncentives[targetPoolPath], incentiveId) @@ -93,10 +94,10 @@ func StakeToken(tokenId uint64) (string, bigint, bigint) { // poolPath, token0Am // check tokenId owner require( - gnft.OwnerOf(tid(tokenId)) == GetOrigCaller(), + gnft.OwnerOf(tid(tokenId)) == std.GetOrigCaller(), ufmt.Sprintf( - "[STAKER] staker.gno__StakeToken() || only owner can stake their token tokenId(%d), owner(%s) == GetOrigCaller(%s)", - tokenId, gnft.OwnerOf(tid(tokenId)), GetOrigCaller(), + "[STAKER] staker.gno__StakeToken() || only owner can stake their token tokenId(%d), owner(%s) == std.GetOrigCaller(%s)", + tokenId, gnft.OwnerOf(tid(tokenId)), std.GetOrigCaller(), ), ) @@ -110,7 +111,7 @@ func StakeToken(tokenId uint64) (string, bigint, bigint) { // poolPath, token0Am // staked status deposit := deposits[tokenId] deposit.numberOfStakes++ - deposit.stakeTimestamp = GetTimestamp() + deposit.stakeTimestamp = time.Now().Unix() deposit.targetPoolPath = poolKey deposits[tokenId] = deposit @@ -125,7 +126,7 @@ func CollectReward(tokenId uint64) { deposit, exist := deposits[tokenId] require(exist, ufmt.Sprintf("[STAKER] staker.gno__CollectReward() || tokenId(%d) not staked", tokenId)) - 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())) + require(std.PrevRealm().Addr() == deposit.owner, ufmt.Sprintf("[STAKER] staker.gno__CollectReward() || only owner(%s) can collect reward from tokenId(%d), std.PrevRealm().Addr()(%s)", deposit.owner, tokenId, std.PrevRealm().Addr())) // poolPath to collect reward poolPath := pn.PositionGetPositionPoolKey(tokenId) @@ -138,7 +139,7 @@ func CollectReward(tokenId uint64) { if externalReward > 0 { // protocol fee - toUser := handleRewardFee(incentive.rewardToken, externalReward) + toUser := handleRewardFee(incentive.rewardToken, externalReward, false) // then transfer rest transferByRegisterCall(incentive.rewardToken, deposit.owner, uint64(toUser)) @@ -154,7 +155,7 @@ func CollectReward(tokenId uint64) { if internalGNS > 0 { // protocol fee - toUser := handleRewardFee(consts.GNS_PATH, internalGNS) + toUser := handleRewardFee(consts.GNS_PATH, internalGNS, true) // then transfer rest gns.TransferFrom(a2u(consts.INTERNAL_REWARD_ACCOUNT), a2u(deposit.owner), uint64(toUser)) @@ -179,16 +180,16 @@ func UnstakeToken(tokenId uint64) (string, bigint, bigint) { return poolPath, token0Amount, token1Amount } -func EndExternalIncentive(refundee, targetPoolPath, rewardToken string) { +func EndExternalIncentive(refundee std.Address, targetPoolPath, rewardToken string) { incentiveId := incentiveIdCompute(refundee, targetPoolPath, rewardToken) incentive, exist := incentives[incentiveId] require(exist, ufmt.Sprintf("[STAKER] staker.gno__EndExternalIncentive() || cannot end non existent incentive(%s)", incentiveId)) - require(GetTimestamp() >= incentive.endTimestamp, ufmt.Sprintf("[STAKER] staker.gno__EndExternalIncentive() || cannot end incentive before endTimestamp(%d), current(%d)", incentive.endTimestamp, GetTimestamp())) + require(time.Now().Unix() >= incentive.endTimestamp, ufmt.Sprintf("[STAKER] staker.gno__EndExternalIncentive() || cannot end incentive before endTimestamp(%d), current(%d)", incentive.endTimestamp, time.Now().Unix())) // when incentive is ended // 1. admin can end incentive without refund // 2. refundee can end incentive with refund - switch GetOrigCaller() { + switch std.GetOrigCaller() { case consts.GNOSWAP_ADMIN: // admin can end incentive without refund incentives = deleteFromIncentives(incentives, incentiveId) @@ -217,7 +218,7 @@ func EndExternalIncentive(refundee, targetPoolPath, rewardToken string) { func transferDeposit(tokenId uint64, to std.Address) { owner := gnft.OwnerOf(tid(tokenId)) - require(owner == GetOrigCaller(), ufmt.Sprintf("[STAKER] staker.gno__transferDeposit() || only owner(%s) can transfer tokenId(%d), GetOrigCaller()(%s)", owner, tokenId, PrevRealmAddr())) + require(owner == std.GetOrigCaller(), ufmt.Sprintf("[STAKER] staker.gno__transferDeposit() || only owner(%s) can transfer tokenId(%d), std.GetOrigCaller()(%s)", owner, tokenId, std.GetOrigCaller())) deposits[tokenId].owner = owner diff --git a/staker/staker_register.gno b/staker/token_register.gno similarity index 100% rename from staker/staker_register.gno rename to staker/token_register.gno diff --git a/staker/utils.gno b/staker/utils.gno index 1abbd0bc..8a01800b 100644 --- a/staker/utils.gno +++ b/staker/utils.gno @@ -87,7 +87,7 @@ func requireExist(exist bool, msg string) { } func requirePrevRealmPath(prevRealmPath, msg string) { - if PrevRealmPath() != prevRealmPath { + if std.PrevRealm().PkgPath() != prevRealmPath { panic(msg) } }