From 064ba86c1e1ef5684a6488dcf451b6b822353643 Mon Sep 17 00:00:00 2001 From: 0xTopaz <60733299+onlyhyde@users.noreply.github.com> Date: Tue, 10 Dec 2024 19:19:49 +0900 Subject: [PATCH] GSW-1839 refactor: helper test code integration and update gno.mod (#427) - remove require in gno.mod - integrated helper test code --- position/_helper_test.gno | 472 +++++++++++++++++- position/gno.mod | 16 - position/position.gno | 16 +- .../__TEST_0_INIT_TOKEN_REGISTER_test.gno | 176 ------- .../__TEST_0_INIT_TOKEN_REGISTER_test.gnoA} | 0 .../tests/__TEST_0_INIT_VARS_HELPERS_test.gno | 69 --- .../__TEST_0_INIT_VARS_HELPERS_test.gnoA} | 0 7 files changed, 474 insertions(+), 275 deletions(-) delete mode 100644 position/tests/__TEST_0_INIT_TOKEN_REGISTER_test.gno rename position/{__TEST_0_INIT_TOKEN_REGISTER_test.gno => tests/__TEST_0_INIT_TOKEN_REGISTER_test.gnoA} (100%) delete mode 100644 position/tests/__TEST_0_INIT_VARS_HELPERS_test.gno rename position/{__TEST_0_INIT_VARS_HELPERS_test.gno => tests/__TEST_0_INIT_VARS_HELPERS_test.gnoA} (100%) diff --git a/position/_helper_test.gno b/position/_helper_test.gno index 4d87113fd..be52f83be 100644 --- a/position/_helper_test.gno +++ b/position/_helper_test.gno @@ -4,17 +4,477 @@ import ( "std" "testing" + "gno.land/p/demo/testutils" "gno.land/p/demo/uassert" - "gno.land/r/onbloc/bar" - "gno.land/r/onbloc/foo" - + pusers "gno.land/p/demo/users" + "gno.land/r/demo/users" + "gno.land/r/demo/wugnot" "gno.land/r/gnoswap/v1/common" "gno.land/r/gnoswap/v1/consts" "gno.land/r/gnoswap/v1/gnft" - + "gno.land/r/gnoswap/v1/gns" pl "gno.land/r/gnoswap/v1/pool" + "gno.land/r/onbloc/bar" + "gno.land/r/onbloc/baz" + "gno.land/r/onbloc/foo" + "gno.land/r/onbloc/obl" + "gno.land/r/onbloc/qux" +) + +const ( + ugnotDenom string = "ugnot" + ugnotPath string = "gno.land/r/gnoswap/v1/pool:ugnot" + wugnotPath string = "gno.land/r/demo/wugnot" + gnsPath string = "gno.land/r/gnoswap/v1/gns" + barPath string = "gno.land/r/onbloc/bar" + bazPath string = "gno.land/r/onbloc/baz" + fooPath string = "gno.land/r/onbloc/foo" + oblPath string = "gno.land/r/onbloc/obl" + quxPath string = "gno.land/r/onbloc/qux" + + fee100 uint32 = 100 + fee500 uint32 = 500 + fee3000 uint32 = 3000 + maxApprove uint64 = 18446744073709551615 + max_timeout int64 = 9999999999 +) + +const ( + // define addresses to use in tests + addr01 = testutils.TestAddress("addr01") + addr02 = testutils.TestAddress("addr02") ) +type WugnotToken struct{} + +func (WugnotToken) Transfer() func(to pusers.AddressOrName, amount uint64) { + return wugnot.Transfer +} +func (WugnotToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { + return wugnot.TransferFrom +} +func (WugnotToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { + return wugnot.BalanceOf +} +func (WugnotToken) Approve() func(spender pusers.AddressOrName, amount uint64) { + return wugnot.Approve +} + +type GNSToken struct{} + +func (GNSToken) Transfer() func(to pusers.AddressOrName, amount uint64) { + return gns.Transfer +} +func (GNSToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { + return gns.TransferFrom +} +func (GNSToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { + return gns.BalanceOf +} +func (GNSToken) Approve() func(spender pusers.AddressOrName, amount uint64) { + return gns.Approve +} + +type BarToken struct{} + +func (BarToken) Transfer() func(to pusers.AddressOrName, amount uint64) { + return bar.Transfer +} +func (BarToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { + return bar.TransferFrom +} +func (BarToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { + return bar.BalanceOf +} +func (BarToken) Approve() func(spender pusers.AddressOrName, amount uint64) { + return bar.Approve +} + +type BazToken struct{} + +func (BazToken) Transfer() func(to pusers.AddressOrName, amount uint64) { + return baz.Transfer +} +func (BazToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { + return baz.TransferFrom +} +func (BazToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { + return baz.BalanceOf +} +func (BazToken) Approve() func(spender pusers.AddressOrName, amount uint64) { + return baz.Approve +} + +type FooToken struct{} + +func (FooToken) Transfer() func(to pusers.AddressOrName, amount uint64) { + return foo.Transfer +} +func (FooToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { + return foo.TransferFrom +} +func (FooToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { + return foo.BalanceOf +} +func (FooToken) Approve() func(spender pusers.AddressOrName, amount uint64) { + return foo.Approve +} + +type OBLToken struct{} + +func (OBLToken) Transfer() func(to pusers.AddressOrName, amount uint64) { + return obl.Transfer +} +func (OBLToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { + return obl.TransferFrom +} +func (OBLToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { + return obl.BalanceOf +} +func (OBLToken) Approve() func(spender pusers.AddressOrName, amount uint64) { + return obl.Approve +} + +type QuxToken struct{} + +func (QuxToken) Transfer() func(to pusers.AddressOrName, amount uint64) { + return qux.Transfer +} +func (QuxToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { + return qux.TransferFrom +} +func (QuxToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { + return qux.BalanceOf +} +func (QuxToken) Approve() func(spender pusers.AddressOrName, amount uint64) { + return qux.Approve +} + +func init() { + std.TestSetRealm(std.NewUserRealm(consts.TOKEN_REGISTER)) + + pl.RegisterGRC20Interface(wugnotPath, WugnotToken{}) + pl.RegisterGRC20Interface(gnsPath, GNSToken{}) + pl.RegisterGRC20Interface(barPath, BarToken{}) + pl.RegisterGRC20Interface(bazPath, BazToken{}) + pl.RegisterGRC20Interface(fooPath, FooToken{}) + pl.RegisterGRC20Interface(oblPath, OBLToken{}) + pl.RegisterGRC20Interface(quxPath, QuxToken{}) +} + +var ( + admin = pusers.AddressOrName(consts.ADMIN) + alice = pusers.AddressOrName(testutils.TestAddress("alice")) + pool = pusers.AddressOrName(consts.POOL_ADDR) + protocolFee = pusers.AddressOrName(consts.PROTOCOL_FEE_ADDR) + adminRealm = std.NewUserRealm(users.Resolve(admin)) + posRealm = std.NewCodeRealm(consts.POSITION_PATH) + + // addresses used in tests + addrUsedInTest = []std.Address{addr01, addr02} +) + +func InitialisePoolTest(t *testing.T) { + t.Helper() + + ugnotFaucet(t, users.Resolve(admin), 100_000_000_000_000) + ugnotDeposit(t, users.Resolve(admin), 100_000_000_000_000) + + std.TestSetOrigCaller(users.Resolve(admin)) + TokenApprove(t, gnsPath, admin, pool, maxApprove) + poolPath := pl.GetPoolPath(wugnotPath, gnsPath, fee3000) + if !pl.DoesPoolPathExist(poolPath) { + pl.CreatePool(wugnotPath, gnsPath, fee3000, "79228162514264337593543950336") + } + + //2. create position + std.TestSetOrigCaller(users.Resolve(alice)) + TokenFaucet(t, wugnotPath, alice) + TokenFaucet(t, gnsPath, alice) + TokenApprove(t, wugnotPath, alice, pool, uint64(1000)) + TokenApprove(t, gnsPath, alice, pool, uint64(1000)) + MintPosition(t, + wugnotPath, + gnsPath, + fee3000, + int32(1020), + int32(5040), + "1000", + "1000", + "0", + "0", + max_timeout, + users.Resolve(alice), + users.Resolve(alice), + ) +} + +func TokenFaucet(t *testing.T, tokenPath string, to pusers.AddressOrName) { + t.Helper() + std.TestSetOrigCaller(users.Resolve(admin)) + defaultAmount := uint64(5_000_000_000) + + switch tokenPath { + case wugnotPath: + wugnotTransfer(t, to, defaultAmount) + case gnsPath: + gnsTransfer(t, to, defaultAmount) + case barPath: + barTransfer(t, to, defaultAmount) + case bazPath: + bazTransfer(t, to, defaultAmount) + case fooPath: + fooTransfer(t, to, defaultAmount) + case oblPath: + oblTransfer(t, to, defaultAmount) + case quxPath: + quxTransfer(t, to, defaultAmount) + default: + panic("token not found") + } +} + +func TokenBalance(t *testing.T, tokenPath string, owner pusers.AddressOrName) uint64 { + t.Helper() + switch tokenPath { + case wugnotPath: + return wugnot.BalanceOf(owner) + case gnsPath: + return gns.BalanceOf(owner) + case barPath: + return bar.BalanceOf(owner) + case bazPath: + return baz.BalanceOf(owner) + case fooPath: + return foo.BalanceOf(owner) + case oblPath: + return obl.BalanceOf(owner) + case quxPath: + return qux.BalanceOf(owner) + default: + panic("token not found") + } +} + +func TokenAllowance(t *testing.T, tokenPath string, owner, spender pusers.AddressOrName) uint64 { + t.Helper() + switch tokenPath { + case wugnotPath: + return wugnot.Allowance(owner, spender) + case gnsPath: + return gns.Allowance(owner, spender) + case barPath: + return bar.Allowance(owner, spender) + case bazPath: + return baz.Allowance(owner, spender) + case fooPath: + return foo.Allowance(owner, spender) + case oblPath: + return obl.Allowance(owner, spender) + case quxPath: + return qux.Allowance(owner, spender) + default: + panic("token not found") + } +} + +func TokenApprove(t *testing.T, tokenPath string, owner, spender pusers.AddressOrName, amount uint64) { + t.Helper() + switch tokenPath { + case wugnotPath: + wugnotApprove(t, owner, spender, amount) + case gnsPath: + gnsApprove(t, owner, spender, amount) + case barPath: + barApprove(t, owner, spender, amount) + case bazPath: + bazApprove(t, owner, spender, amount) + case fooPath: + fooApprove(t, owner, spender, amount) + case oblPath: + oblApprove(t, owner, spender, amount) + case quxPath: + quxApprove(t, owner, spender, amount) + default: + panic("token not found") + } +} + +func MintPosition(t *testing.T, + token0 string, + token1 string, + fee uint32, + tickLower int32, + tickUpper int32, + amount0Desired string, // *u256.Uint + amount1Desired string, // *u256.Uint + amount0Min string, // *u256.Uint + amount1Min string, // *u256.Uint + deadline int64, + mintTo std.Address, + caller std.Address, +) (uint64, string, string, string) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(caller)) + + return Mint( + token0, + token1, + fee, + tickLower, + tickUpper, + amount0Desired, + amount1Desired, + amount0Min, + amount1Min, + deadline, + mintTo, + caller) +} + +func wugnotApprove(t *testing.T, owner, spender pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(owner))) + wugnot.Approve(spender, amount) +} + +func gnsApprove(t *testing.T, owner, spender pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(owner))) + gns.Approve(spender, amount) +} + +func barApprove(t *testing.T, owner, spender pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(owner))) + bar.Approve(spender, amount) +} + +func bazApprove(t *testing.T, owner, spender pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(owner))) + baz.Approve(spender, amount) +} + +func fooApprove(t *testing.T, owner, spender pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(owner))) + foo.Approve(spender, amount) +} + +func oblApprove(t *testing.T, owner, spender pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(owner))) + obl.Approve(spender, amount) +} + +func quxApprove(t *testing.T, owner, spender pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(owner))) + qux.Approve(spender, amount) +} + +func wugnotTransfer(t *testing.T, to pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(admin))) + wugnot.Transfer(to, amount) +} + +func gnsTransfer(t *testing.T, to pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(admin))) + gns.Transfer(to, amount) +} + +func barTransfer(t *testing.T, to pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(admin))) + bar.Transfer(to, amount) +} + +func bazTransfer(t *testing.T, to pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(admin))) + baz.Transfer(to, amount) +} + +func fooTransfer(t *testing.T, to pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(admin))) + foo.Transfer(to, amount) +} + +func oblTransfer(t *testing.T, to pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(admin))) + obl.Transfer(to, amount) +} + +func quxTransfer(t *testing.T, to pusers.AddressOrName, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(users.Resolve(admin))) + qux.Transfer(to, amount) +} + +// ---------------------------------------------------------------------------- +// ugnot + +func ugnotTransfer(t *testing.T, from, to std.Address, amount uint64) { + t.Helper() + + std.TestSetRealm(std.NewUserRealm(from)) + std.TestSetOrigSend(std.Coins{{ugnotDenom, int64(amount)}}, nil) + banker := std.GetBanker(std.BankerTypeRealmSend) + banker.SendCoins(from, to, std.Coins{{ugnotDenom, int64(amount)}}) +} + +func ugnotBalanceOf(t *testing.T, addr std.Address) uint64 { + t.Helper() + + banker := std.GetBanker(std.BankerTypeRealmIssue) + coins := banker.GetCoins(addr) + if len(coins) == 0 { + return 0 + } + + return uint64(coins.AmountOf(ugnotDenom)) +} + +func ugnotMint(t *testing.T, addr std.Address, denom string, amount int64) { + t.Helper() + banker := std.GetBanker(std.BankerTypeRealmIssue) + banker.IssueCoin(addr, denom, amount) + std.TestIssueCoins(addr, std.Coins{{denom, int64(amount)}}) +} + +func ugnotBurn(t *testing.T, addr std.Address, denom string, amount int64) { + t.Helper() + banker := std.GetBanker(std.BankerTypeRealmIssue) + banker.RemoveCoin(addr, denom, amount) +} + +func ugnotFaucet(t *testing.T, to std.Address, amount uint64) { + t.Helper() + faucetAddress := users.Resolve(admin) + std.TestSetOrigCaller(faucetAddress) + + if ugnotBalanceOf(t, faucetAddress) < amount { + newCoins := std.Coins{{ugnotDenom, int64(amount)}} + ugnotMint(t, faucetAddress, newCoins[0].Denom, newCoins[0].Amount) + std.TestSetOrigSend(newCoins, nil) + } + ugnotTransfer(t, faucetAddress, to, amount) +} + +func ugnotDeposit(t *testing.T, addr std.Address, amount uint64) { + t.Helper() + std.TestSetRealm(std.NewUserRealm(addr)) + wugnotAddr := consts.WUGNOT_ADDR + banker := std.GetBanker(std.BankerTypeRealmSend) + banker.SendCoins(addr, wugnotAddr, std.Coins{{ugnotDenom, int64(amount)}}) + wugnot.Deposit() +} + // resetObject resets the object state(clear or make it default values) func resetObject(t *testing.T) { positions = make(map[uint64]Position) @@ -54,8 +514,8 @@ func TestBeforeResetObject(t *testing.T) { "0", "0", max_timeout, - admin, - admin, + users.Resolve(admin), + users.Resolve(admin), ) uassert.Equal(t, tokenId, uint64(1), "tokenId should be 1") diff --git a/position/gno.mod b/position/gno.mod index ca6175e65..7278afb2f 100644 --- a/position/gno.mod +++ b/position/gno.mod @@ -1,17 +1 @@ module gno.land/r/gnoswap/v1/position - -require ( - gno.land/p/demo/grc/grc721 v0.0.0-latest - gno.land/p/demo/json v0.0.0-latest - gno.land/p/demo/ufmt v0.0.0-latest - gno.land/p/demo/users v0.0.0-latest - gno.land/p/gnoswap/int256 v0.0.0-latest - gno.land/p/gnoswap/pool v0.0.0-latest - gno.land/p/gnoswap/uint256 v0.0.0-latest - gno.land/r/demo/wugnot v0.0.0-latest - gno.land/r/gnoswap/v1/common v0.0.0-latest - gno.land/r/gnoswap/v1/consts v0.0.0-latest - gno.land/r/gnoswap/v1/emission v0.0.0-latest - gno.land/r/gnoswap/v1/gnft v0.0.0-latest - gno.land/r/gnoswap/v1/pool v0.0.0-latest -) diff --git a/position/position.gno b/position/position.gno index 2aa8ad5c6..7e5e37a2b 100644 --- a/position/position.gno +++ b/position/position.gno @@ -103,7 +103,7 @@ func Mint( handleLeftoverNativeToken(token0IsNative, token1IsNative, userWugnotBalance, caller) - poolSqrtPriceX96 := pl.PoolGetSqrtPriceX96(poolPath) + poolSqrtPriceX96 := pl.PoolGetSlot0SqrtPriceX96(poolPath) prevAddr, prevRealm := getPrev() @@ -120,7 +120,7 @@ func Mint( "internal_liquidity", liquidity.ToString(), "internal_amount0", amount0.ToString(), "internal_amount1", amount1.ToString(), - "internal_sqrtPriceX96", poolSqrtPriceX96.ToString(), + "internal_sqrtPriceX96", poolSqrtPriceX96, ) return tokenId, liquidity.ToString(), amount0.ToString(), amount1.ToString() @@ -263,7 +263,7 @@ func IncreaseLiquidity( unwrap(leftOver, std.PrevRealm().Addr()) } - poolSqrtPriceX96 := pl.PoolGetSqrtPriceX96(poolPath) + poolSqrtPriceX96 := pl.PoolGetSlot0SqrtPriceX96(poolPath) prevAddr, prevRealm := getPrev() @@ -276,7 +276,7 @@ func IncreaseLiquidity( "internal_liquidity", liquidity.ToString(), "internal_amount0", amount0.ToString(), "internal_amount1", amount1.ToString(), - "internal_sqrtPriceX96", poolSqrtPriceX96.ToString(), + "internal_sqrtPriceX96", poolSqrtPriceX96, ) return tokenId, liquidity.ToString(), amount0.ToString(), amount1.ToString(), poolPath @@ -384,7 +384,7 @@ func DecreaseLiquidity( tokenId, liquidity, fee0, fee1, amount0, amount1, poolPath := decreaseLiquidity(decreaseLiquidityParams) - poolSqrtPriceX96 := pl.PoolGetSqrtPriceX96(poolPath) + poolSqrtPriceX96 := pl.PoolGetSlot0SqrtPriceX96(poolPath) prevAddr, prevRealm := getPrev() @@ -401,7 +401,7 @@ func DecreaseLiquidity( "internal_amount0", amount0.ToString(), "internal_amount1", amount1.ToString(), "internal_unwrapResult", ufmt.Sprintf("%t", unwrapResult), - "internal_sqrtPriceX96", poolSqrtPriceX96.ToString(), + "internal_sqrtPriceX96", poolSqrtPriceX96, ) return tokenId, liquidity.ToString(), fee0.ToString(), fee1.ToString(), amount0.ToString(), amount1.ToString(), poolPath @@ -613,7 +613,7 @@ func Reposition( positions[tokenId] = position - poolSqrtPriceX96 := pl.PoolGetSqrtPriceX96(position.poolKey) + poolSqrtPriceX96 := pl.PoolGetSlot0SqrtPriceX96(position.poolKey) prevAddr, prevRealm := getPrev() @@ -630,7 +630,7 @@ func Reposition( "internal_oldTickLower", ufmt.Sprintf("%d", oldTickLower), "internal_oldTickUpper", ufmt.Sprintf("%d", oldTickUpper), "internal_poolPath", position.poolKey, - "internal_sqrtPriceX96", poolSqrtPriceX96.ToString(), + "internal_sqrtPriceX96", poolSqrtPriceX96, ) return tokenId, liquidity.ToString(), tickLower, tickUpper, amount0.ToString(), amount1.ToString() diff --git a/position/tests/__TEST_0_INIT_TOKEN_REGISTER_test.gno b/position/tests/__TEST_0_INIT_TOKEN_REGISTER_test.gno deleted file mode 100644 index 8da3b3790..000000000 --- a/position/tests/__TEST_0_INIT_TOKEN_REGISTER_test.gno +++ /dev/null @@ -1,176 +0,0 @@ -package position - -import ( - "std" - - "gno.land/r/onbloc/foo" - - "gno.land/r/onbloc/bar" - - "gno.land/r/onbloc/baz" - - "gno.land/r/onbloc/qux" - - "gno.land/r/demo/wugnot" - - "gno.land/r/onbloc/obl" - - "gno.land/r/gnoswap/v1/gns" - - "gno.land/r/onbloc/usdc" - - "gno.land/r/gnoswap/v1/consts" - - pusers "gno.land/p/demo/users" - - pl "gno.land/r/gnoswap/v1/pool" - rr "gno.land/r/gnoswap/v1/router" -) - -type FooToken struct{} - -func (FooToken) Transfer() func(to pusers.AddressOrName, amount uint64) { - return foo.Transfer -} -func (FooToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { - return foo.TransferFrom -} -func (FooToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { - return foo.BalanceOf -} -func (FooToken) Approve() func(spender pusers.AddressOrName, amount uint64) { - return foo.Approve -} - -type BarToken struct{} - -func (BarToken) Transfer() func(to pusers.AddressOrName, amount uint64) { - return bar.Transfer -} -func (BarToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { - return bar.TransferFrom -} -func (BarToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { - return bar.BalanceOf -} -func (BarToken) Approve() func(spender pusers.AddressOrName, amount uint64) { - return bar.Approve -} - -type BazToken struct{} - -func (BazToken) Transfer() func(to pusers.AddressOrName, amount uint64) { - return baz.Transfer -} -func (BazToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { - return baz.TransferFrom -} -func (BazToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { - return baz.BalanceOf -} -func (BazToken) Approve() func(spender pusers.AddressOrName, amount uint64) { - return baz.Approve -} - -type QuxToken struct{} - -func (QuxToken) Transfer() func(to pusers.AddressOrName, amount uint64) { - return qux.Transfer -} -func (QuxToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { - return qux.TransferFrom -} -func (QuxToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { - return qux.BalanceOf -} -func (QuxToken) Approve() func(spender pusers.AddressOrName, amount uint64) { - return qux.Approve -} - -type WugnotToken struct{} - -func (WugnotToken) Transfer() func(to pusers.AddressOrName, amount uint64) { - return wugnot.Transfer -} -func (WugnotToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { - return wugnot.TransferFrom -} -func (WugnotToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { - return wugnot.BalanceOf -} -func (WugnotToken) Approve() func(spender pusers.AddressOrName, amount uint64) { - return wugnot.Approve -} - -type OBLToken struct{} - -func (OBLToken) Transfer() func(to pusers.AddressOrName, amount uint64) { - return obl.Transfer -} -func (OBLToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { - return obl.TransferFrom -} -func (OBLToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { - return obl.BalanceOf -} -func (OBLToken) Approve() func(spender pusers.AddressOrName, amount uint64) { - return obl.Approve -} - -type GNSToken struct{} - -func (GNSToken) Transfer() func(to pusers.AddressOrName, amount uint64) { - return gns.Transfer -} - -func (GNSToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { - return gns.TransferFrom -} - -func (GNSToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { - return gns.BalanceOf -} - -func (GNSToken) Approve() func(spender pusers.AddressOrName, amount uint64) { - return gns.Approve -} - -type USDCToken struct{} - -func (USDCToken) Transfer() func(to pusers.AddressOrName, amount uint64) { - return usdc.Transfer -} - -func (USDCToken) TransferFrom() func(from, to pusers.AddressOrName, amount uint64) { - return usdc.TransferFrom -} - -func (USDCToken) BalanceOf() func(owner pusers.AddressOrName) uint64 { - return usdc.BalanceOf -} - -func (USDCToken) Approve() func(spender pusers.AddressOrName, amount uint64) { - return usdc.Approve -} - -func init() { - std.TestSetRealm(std.NewUserRealm(consts.TOKEN_REGISTER)) - - pl.RegisterGRC20Interface("gno.land/r/onbloc/bar", BarToken{}) - pl.RegisterGRC20Interface("gno.land/r/onbloc/foo", FooToken{}) - pl.RegisterGRC20Interface("gno.land/r/onbloc/baz", BazToken{}) - pl.RegisterGRC20Interface("gno.land/r/onbloc/qux", QuxToken{}) - pl.RegisterGRC20Interface("gno.land/r/demo/wugnot", WugnotToken{}) - pl.RegisterGRC20Interface("gno.land/r/onbloc/obl", OBLToken{}) - pl.RegisterGRC20Interface("gno.land/r/gnoswap/v1/gns", GNSToken{}) - pl.RegisterGRC20Interface("gno.land/r/onbloc/usdc", USDCToken{}) - - rr.RegisterGRC20Interface("gno.land/r/onbloc/bar", BarToken{}) - rr.RegisterGRC20Interface("gno.land/r/onbloc/foo", FooToken{}) - rr.RegisterGRC20Interface("gno.land/r/onbloc/baz", BazToken{}) - rr.RegisterGRC20Interface("gno.land/r/onbloc/qux", QuxToken{}) - rr.RegisterGRC20Interface("gno.land/r/demo/wugnot", WugnotToken{}) - rr.RegisterGRC20Interface("gno.land/r/onbloc/obl", OBLToken{}) - rr.RegisterGRC20Interface("gno.land/r/gnoswap/v1/gns", GNSToken{}) - rr.RegisterGRC20Interface("gno.land/r/onbloc/usdc", USDCToken{}) -} diff --git a/position/__TEST_0_INIT_TOKEN_REGISTER_test.gno b/position/tests/__TEST_0_INIT_TOKEN_REGISTER_test.gnoA similarity index 100% rename from position/__TEST_0_INIT_TOKEN_REGISTER_test.gno rename to position/tests/__TEST_0_INIT_TOKEN_REGISTER_test.gnoA diff --git a/position/tests/__TEST_0_INIT_VARS_HELPERS_test.gno b/position/tests/__TEST_0_INIT_VARS_HELPERS_test.gno deleted file mode 100644 index f7972bb9a..000000000 --- a/position/tests/__TEST_0_INIT_VARS_HELPERS_test.gno +++ /dev/null @@ -1,69 +0,0 @@ -package position - -import ( - "std" - "testing" - - "gno.land/r/gnoswap/v1/consts" - - "gno.land/r/gnoswap/v1/gnft" - - pl "gno.land/r/gnoswap/v1/pool" -) - -var ( - admin std.Address = consts.ADMIN - test1 std.Address = std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") - - fooPath string = "gno.land/r/onbloc/foo" - barPath string = "gno.land/r/onbloc/bar" - bazPath string = "gno.land/r/onbloc/baz" - quxPath string = "gno.land/r/onbloc/qux" - - oblPath string = "gno.land/r/onbloc/obl" - // wugnotPath string = "gno.land/r/demo/wugnot" // from consts - // gnsPath string = "gno.land/r/gnoswap/v1/gns" // from consts - - fee100 uint32 = 100 - fee500 uint32 = 500 - fee3000 uint32 = 3000 - - max_timeout int64 = 9999999999 -) - -// Realms to mock frames -var ( - adminRealm = std.NewUserRealm(admin) - posRealm = std.NewCodeRealm(consts.POSITION_PATH) - rouRealm = std.NewCodeRealm(consts.ROUTER_PATH) - stkRealm = std.NewCodeRealm(consts.STAKER_PATH) -) - -/* HELPER */ -func ugnotBalanceOf(addr std.Address) uint64 { - testBanker := std.GetBanker(std.BankerTypeRealmIssue) - - coins := testBanker.GetCoins(addr) - if len(coins) == 0 { - return 0 - } - - return uint64(coins.AmountOf("ugnot")) -} - -func isOwner(t *testing.T, tokenId uint64, addr std.Address) bool { - owner := gnft.OwnerOf(tid(tokenId)) - - if owner == addr { - return true - } - - t.Errorf("expected owner %v, got %v", addr, owner) - return false -} - -func getPoolFromLpTokenId(lpTokenId uint64) *pl.Pool { - position := positions[lpTokenId] - - return pl.GetPoolFromPoolPath(position.poolKey) -} diff --git a/position/__TEST_0_INIT_VARS_HELPERS_test.gno b/position/tests/__TEST_0_INIT_VARS_HELPERS_test.gnoA similarity index 100% rename from position/__TEST_0_INIT_VARS_HELPERS_test.gno rename to position/tests/__TEST_0_INIT_VARS_HELPERS_test.gnoA