diff --git a/pool/_GET_no_receiver.gno b/pool/_GET_no_receiver.gno
new file mode 100644
index 000000000..57389a14e
--- /dev/null
+++ b/pool/_GET_no_receiver.gno
@@ -0,0 +1,250 @@
+package pool
+
+import (
+	"gno.land/p/demo/ufmt"
+)
+
+// Slot0
+func PoolGetSlot0SqrtPriceX96(poolPath string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetSlot0SqrtPriceX96() || pool(%s) does not exist", poolPath))
+
+	return pool.slot0.sqrtPriceX96
+}
+
+func PoolGetSlot0Tick(poolPath string) int32 {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetSlot0Tick() || pool(%s) does not exist", poolPath))
+
+	return pool.slot0.tick
+}
+
+func PoolGetSlot0FeeProtocol(poolPath string) uint8 {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetSlot0FeeProtocol() || pool(%s) does not exist", poolPath))
+
+	return pool.slot0.feeProtocol
+}
+
+// Balances
+func PoolGetToken0Balance(poolPath string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetToken0Balance() || pool(%s) does not exist", poolPath))
+
+	return pool.balances.token0
+}
+
+func PoolGetToken1Balance(poolPath string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetToken1Balance() || pool(%s) does not exist", poolPath))
+
+	return pool.balances.token1
+}
+
+// ProtocolFees
+func PoolGetToken0ProtocolFee(poolPath string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetToken0ProtocolFee() || pool(%s) does not exist", poolPath))
+
+	return pool.protocolFees.token0
+}
+
+func PoolGetToken1ProtocolFee(poolPath string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetToken1ProtocolFee() || pool(%s) does not exist", poolPath))
+
+	return pool.protocolFees.token1
+}
+
+// PositionInfo
+func PoolGetPositionLiquidity(poolPath, key string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionLiquidity() || pool(%s) does not exist", poolPath))
+
+	position, exist := pool.positions[key]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionLiquidity() || position(%s) does not exist", key))
+
+	return position.liquidity
+}
+
+func PoolGetPositionFeeGrowthInside0LastX128(poolPath, key string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionFeeGrowthInside0LastX128() || pool(%s) does not exist", poolPath))
+
+	position, exist := pool.positions[key]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionFeeGrowthInside0LastX128) || position(%s) does not exist", key))
+
+	return position.feeGrowthInside0LastX128
+}
+
+func PoolGetPositionFeeGrowthInside1LastX128(poolPath, key string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionFeeGrowthInside1LastX128() || pool(%s) does not exist", poolPath))
+
+	position, exist := pool.positions[key]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionFeeGrowthInside1LastX128() || position(%s) does not exist", key))
+
+	return position.feeGrowthInside1LastX128
+}
+
+func PoolGetPositionTokensOwed0(poolPath, key string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionTokensOwed0() || pool(%s) does not exist", poolPath))
+
+	position, exist := pool.positions[key]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionTokensOwed0() || position(%s) does not exist", key))
+
+	return position.tokensOwed0
+}
+
+func PoolGetPositionTokensOwed1(poolPath, key string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionTokensOwed1() || pool(%s) does not exist", poolPath))
+
+	position, exist := pool.positions[key]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionTokensOwed1() || position(%s) does not exist", key))
+
+	return position.tokensOwed1
+}
+
+// TickInfo
+func PoolGetTickLiquidityGross(poolPath string, x int32) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickLiquidityGross() || pool(%s) does not exist", poolPath))
+
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickLiquidityGross() || tick(%d) does not exist", x))
+
+	return tick.liquidityGross
+}
+
+func PoolGetTickLiquidityNet(poolPath string, x int32) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickLiquidityNet() || pool(%s) does not exist", poolPath))
+
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickLiquidityNet() || tick(%d) does not exist", x))
+
+	return tick.liquidityNet
+}
+
+func PoolGetTickFeeGrowthOutside0X128(poolPath string, x int32) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickFeeGrowthOutside0X128() || pool(%s) does not exist", poolPath))
+
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickFeeGrowthOutside0X128() || tick(%d) does not exist", x))
+
+	return tick.feeGrowthOutside0X128
+}
+
+func PoolGetTickFeeGrowthOutside1X128(poolPath string, x int32) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickFeeGrowthOutside1X128() || pool(%s) does not exist", poolPath))
+
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickFeeGrowthOutside1X128() || tick(%d) does not exist", x))
+
+	return tick.feeGrowthOutside1X128
+}
+
+func PoolGetTickTickCumulativeOutside(poolPath string, x int32) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickTickCumulativeOutside() || pool(%s) does not exist", poolPath))
+
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickTickCumulativeOutside() || tick(%d) does not exist", x))
+
+	return tick.tickCumulativeOutside
+}
+
+func PoolGetTickSecondsPerLiquidityOutsideX128(poolPath string, x int32) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickSecondsPerLiquidityOutsideX128() || pool(%s) does not exist", poolPath))
+
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickSecondsPerLiquidityOutsideX128() || tick(%d) does not exist", x))
+
+	return tick.secondsPerLiquidityOutsideX128
+}
+
+func PoolGetTickSecondsOutside(poolPath string, x int32) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickSecondsOutside() || pool(%s) does not exist", poolPath))
+
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickSecondsOutside() || tick(%d) does not exist", x))
+
+	return tick.secondsOutside
+}
+
+func PoolGetTickInitialized(poolPath string, x int32) bool {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickInitialized() || pool(%s) does not exist", poolPath))
+
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickInitialized() || tick(%d) does not exist", x))
+
+	return tick.initialized
+}
+
+// TickBitmaps
+func PoolGetTickBitmap(poolPath string, x int16) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickBitmap() || pool(%s) does not exist", poolPath))
+
+	tickBitmap, exist := pool.tickBitmaps[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickBitmap() || tickBitmap(%d) does not exist", x))
+
+	return tickBitmap
+}
+
+// Pool
+func PoolGetToken0Path(poolPath string) string {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetToken0Path() || pool(%s) does not exist", poolPath))
+
+	return pool.token0Path
+}
+
+func PoolGetToken1Path(poolPath string) string {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetToken1Path() || pool(%s) does not exist", poolPath))
+
+	return pool.token1Path
+}
+
+func PoolGetFee(poolPath string) uint16 {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetFee() || pool(%s) does not exist", poolPath))
+
+	return pool.fee
+}
+
+func PoolGetTickSpacing(poolPath string) int32 {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickSpacing() || pool(%s) does not exist", poolPath))
+
+	return pool.tickSpacing
+}
+
+func PoolGetFeeGrowthGlobal0X128(poolPath string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetFeeGrowthGlobal0X128() || pool(%s) does not exist", poolPath))
+
+	return pool.feeGrowthGlobal0X128
+}
+
+func PoolGetFeeGrowthGlobal1X128(poolPath string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetFeeGrowthGlobal1X128() || pool(%s) does not exist", poolPath))
+
+	return pool.feeGrowthGlobal1X128
+}
+
+func PoolGetLiquidity(poolPath string) bigint {
+	pool, exist := pools[poolPath]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetLiquidity() || pool(%s) does not exist", poolPath))
+
+	return pool.liquidity
+}
diff --git a/pool/_GET_pool.gno b/pool/_GET_receiver.gno
similarity index 54%
rename from pool/_GET_pool.gno
rename to pool/_GET_receiver.gno
index f0fd6650d..e4c25a5c3 100644
--- a/pool/_GET_pool.gno
+++ b/pool/_GET_receiver.gno
@@ -13,14 +13,24 @@ func PoolGetPoolList() []string {
 	return poolPaths
 }
 
-func (pool *Pool) PoolGetToken0Path() string {
-	return pool.token0Path
+// Slot0
+func (pool *Pool) PoolGetSlot0() Slot0 {
+	return pool.slot0
 }
 
-func (pool *Pool) PoolGetToken1Path() string {
-	return pool.token1Path
+func (pool *Pool) PoolGetSlot0SqrtPriceX96() bigint {
+	return pool.slot0.sqrtPriceX96
+}
+
+func (pool *Pool) PoolGetSlot0Tick() int32 {
+	return pool.slot0.tick
+}
+
+func (pool *Pool) PoolGetSlot0FeeProtocol() uint8 {
+	return pool.slot0.feeProtocol
 }
 
+// Balances
 func (pool *Pool) PoolGetToken0Balance() bigint {
 	return pool.balances.token0
 }
@@ -29,42 +39,63 @@ func (pool *Pool) PoolGetToken1Balance() bigint {
 	return pool.balances.token1
 }
 
-func (pool *Pool) PoolGetFee() uint16 {
-	return pool.fee
+// ProtocolFees
+func (pool *Pool) PoolGetToken0ProtocolFee() bigint {
+	return pool.protocolFees.token0
 }
 
-func (pool *Pool) PoolGetTickSpacing() int32 {
-	return pool.tickSpacing
+func (pool *Pool) PoolGetToken1ProtocolFee() bigint {
+	return pool.protocolFees.token1
 }
 
-func (pool *Pool) PoolGetSlot0() Slot0 {
-	return pool.slot0
+// PositionInfo
+func (pool *Pool) PoolGetPositions() Positions {
+	return pool.positions
 }
 
-func (pool *Pool) PoolGetSlot0SqrtPriceX96() bigint {
-	return pool.slot0.sqrtPriceX96
+func (pool *Pool) PoolGetPosition(key string) PositionInfo {
+	position, exist := pool.positions[key]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPosition() || position(%s) does not exist", key))
+
+	return position
 }
 
-func (pool *Pool) PoolGetSlot0Tick() int32 {
-	return pool.slot0.tick
+func (pool *Pool) PoolGetPositionLiquidity(key string) bigint {
+	position, exist := pool.positions[key]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionLiquidity() || position(%s) does not exist", key))
+
+	return position.liquidity
 }
 
-func (pool *Pool) PoolGetSlot0FeeProtocol() uint8 {
-	return pool.slot0.feeProtocol
+func (pool *Pool) PoolGetPositionFeeGrowthInside0LastX128(key string) bigint {
+	position, exist := pool.positions[key]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionFeeGrowthInside0LastX128) || position(%s) does not exist", key))
+
+	return position.feeGrowthInside0LastX128
 }
 
-func (pool *Pool) PoolGetFeeGrowthGlobal0X128() bigint {
-	return pool.feeGrowthGlobal0X128
+func (pool *Pool) PoolGetPositionFeeGrowthInside1LastX128(key string) bigint {
+	position, exist := pool.positions[key]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionFeeGrowthInside1LastX128() || position(%s) does not exist", key))
+
+	return position.feeGrowthInside1LastX128
 }
 
-func (pool *Pool) PoolGetFeeGrowthGlobal1X128() bigint {
-	return pool.feeGrowthGlobal1X128
+func (pool *Pool) PoolGetPositionTokensOwed0(key string) bigint {
+	position, exist := pool.positions[key]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionTokensOwed0() || position(%s) does not exist", key))
+
+	return position.tokensOwed0
 }
 
-func (pool *Pool) PoolGetLiquidity() bigint {
-	return pool.liquidity
+func (pool *Pool) PoolGetPositionTokensOwed1(key string) bigint {
+	position, exist := pool.positions[key]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionTokensOwed1() || position(%s) does not exist", key))
+
+	return position.tokensOwed1
 }
 
+// TickInfo
 func (pool *Pool) PoolGetTick(x int32) TickInfo {
 	tick, exist := pool.ticks[x]
 	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTick() || tick(%d) does not exist", x))
@@ -72,12 +103,23 @@ func (pool *Pool) PoolGetTick(x int32) TickInfo {
 	return tick
 }
 
+func (pool *Pool) PoolGetTickLiquidityGross(x int32) bigint {
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickLiquidityGross() || tick(%d) does not exist", x))
+
+	return tick.liquidityGross
+}
+
+func (pool *Pool) PoolGetTickLiquidityNet(x int32) bigint {
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickLiquidityNet() || tick(%d) does not exist", x))
+
+	return tick.liquidityNet
+}
+
 func (pool *Pool) PoolGetTickFeeGrowthOutside0X128(x int32) bigint {
 	tick, exist := pool.ticks[x]
 	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickFeeGrowthOutside0X128() || tick(%d) does not exist", x))
-	// if !exist {
-	// 	return 0
-	// }
 
 	return tick.feeGrowthOutside0X128
 }
@@ -85,44 +127,71 @@ func (pool *Pool) PoolGetTickFeeGrowthOutside0X128(x int32) bigint {
 func (pool *Pool) PoolGetTickFeeGrowthOutside1X128(x int32) bigint {
 	tick, exist := pool.ticks[x]
 	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickFeeGrowthOutside1X128() || tick(%d) does not exist", x))
-	// if !exist {
-	// 	return 0
-	// }
 
 	return tick.feeGrowthOutside1X128
 }
 
+func (pool *Pool) PoolGetTickTickCumulativeOutside(x int32) bigint {
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickTickCumulativeOutside() || tick(%d) does not exist", x))
+
+	return tick.tickCumulativeOutside
+}
+
+func (pool *Pool) PoolGetTickSecondsPerLiquidityOutsideX128(x int32) bigint {
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickSecondsPerLiquidityOutsideX128() || tick(%d) does not exist", x))
+
+	return tick.secondsPerLiquidityOutsideX128
+}
+
+func (pool *Pool) PoolGetTickSecondsOutside(x int32) bigint {
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickSecondsOutside() || tick(%d) does not exist", x))
+
+	return tick.secondsOutside
+}
+
+func (pool *Pool) PoolGetTickInitialized(x int32) bool {
+	tick, exist := pool.ticks[x]
+	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickInitialized() || tick(%d) does not exist", x))
+
+	return tick.initialized
+}
+
+// TickBitmaps
 func (pool *Pool) PoolGetTickBitmap(x int16) bigint {
 	tickBitmap, exist := pool.tickBitmaps[x]
 	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetTickBitmap() || tickBitmap(%d) does not exist", x))
-	// if !exist {
-	// 	return 0
-	// }
 
 	return tickBitmap
 }
 
-func (pool *Pool) PoolGetPositions() Positions {
-	return pool.positions
+// Pool
+func (pool *Pool) PoolGetToken0Path() string {
+	return pool.token0Path
 }
 
-func (pool *Pool) PoolGetPosition(key string) PositionInfo {
-	position, exist := pool.positions[key]
-	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPosition() || position(%s) does not exist", key))
+func (pool *Pool) PoolGetToken1Path() string {
+	return pool.token1Path
+}
 
-	return position
+func (pool *Pool) PoolGetFee() uint16 {
+	return pool.fee
 }
 
-func (pool *Pool) PoolGetPositionFeeGrowthInside0LastX128(key string) bigint {
-	position, exist := pool.positions[key]
-	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionFeeGrowthInside0LastX128) || position(%s) does not exist", key))
+func (pool *Pool) PoolGetTickSpacing() int32 {
+	return pool.tickSpacing
+}
 
-	return position.feeGrowthInside0LastX128
+func (pool *Pool) PoolGetFeeGrowthGlobal0X128() bigint {
+	return pool.feeGrowthGlobal0X128
 }
 
-func (pool *Pool) PoolGetPositionFeeGrowthInside1LastX128(key string) bigint {
-	position, exist := pool.positions[key]
-	requireExist(exist, ufmt.Sprintf("[POOL] _GET_pool.gno__PoolGetPositionFeeGrowthInside1LastX128() || position(%s) does not exist", key))
+func (pool *Pool) PoolGetFeeGrowthGlobal1X128() bigint {
+	return pool.feeGrowthGlobal1X128
+}
 
-	return position.feeGrowthInside1LastX128
+func (pool *Pool) PoolGetLiquidity() bigint {
+	return pool.liquidity
 }
diff --git a/pool/_TEST_pool_single_lp_test.gno b/pool/_TEST_pool_single_lp_test.gnoa
similarity index 100%
rename from pool/_TEST_pool_single_lp_test.gno
rename to pool/_TEST_pool_single_lp_test.gnoa
diff --git a/pool/_TEST_rpc_get_test.gno b/pool/_TEST_rpc_get_test.gno
new file mode 100644
index 000000000..3a050992f
--- /dev/null
+++ b/pool/_TEST_rpc_get_test.gno
@@ -0,0 +1,215 @@
+package pool
+
+import (
+	"std"
+	"testing"
+
+	"gno.land/r/demo/consts"
+)
+
+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)
+	InitManual()
+}
+
+// 2. Create Foo:Bar Pool
+func TestCreateFooBarPool(t *testing.T) {
+	std.TestSetOrigCaller(test1)
+	CreatePool(fooPath, barPath, fee500, 130621891405341611593710811006)
+	shouldEQ(t, len(pools), 1)
+}
+
+// 3. Create Bar:Baz Pool
+func TestCreateBarBazPool(t *testing.T) {
+	std.TestSetOrigCaller(test1)
+	CreatePool(barPath, bazPath, fee500, 130621891405341611593710811006)
+	shouldEQ(t, len(pools), 2)
+}
+
+// 4. Mint Foo:Bar Liquidity by test1
+func TestMintFooBarLiquidity(t *testing.T) {
+	std.TestSetPrevRealm(consts.POSITION_PATH)
+	std.TestSetOrigCaller(test1)
+
+	Mint(
+		fooPath,
+		barPath,
+		fee500,
+		consts.POSITION_ADDR,
+		-test_tickUpper,
+		-test_tickLower,
+		test_liquidityExpect,
+	)
+}
+
+// 5. Mint Bar:Baz Liquidity by test1
+func TestMintBarBazLiquidity(t *testing.T) {
+	std.TestSetPrevRealm(consts.POSITION_PATH)
+	std.TestSetOrigCaller(test1)
+
+	Mint(
+		barPath,
+		bazPath,
+		fee500,
+		consts.POSITION_ADDR,
+		test_tickLower,
+		test_tickUpper,
+		test_liquidityExpect,
+	)
+}
+
+// RPC GET TESTS
+var poolPath = "gno.land/r/demo/bar:gno.land/r/demo/foo:500"
+var positionKey = "ZzEwd3dhNTN4Z3U0Mzk3a3Z6ejdha3hhcjkzNzB6amRwd3V4NXRoOV9fLTExMDAwX18tOTAwMA=="
+var tick = int32(-11000)
+var tickBitmap = int16(-5)
+
+func TestPoolGetSlot0SqrtPriceX96(t *testing.T) {
+	sqrt := PoolGetSlot0SqrtPriceX96(poolPath)
+	shouldEQ(t, string(sqrt), "48055510970269007215549348797")
+}
+
+func TestPoolGetSlot0Tick(t *testing.T) {
+	tick := PoolGetSlot0Tick(poolPath)
+	shouldEQ(t, tick, int32(-10000))
+}
+
+func TestPoolGetSlot0FeeProtocol(t *testing.T) {
+	fee := PoolGetSlot0FeeProtocol(poolPath)
+	shouldEQ(t, fee, uint8(0))
+}
+
+func TestPoolGetToken0Balance(t *testing.T) {
+	balance := PoolGetToken0Balance(poolPath)
+	shouldEQ(t, balance, bigint(8040315))
+}
+
+func TestPoolGetToken1Balance(t *testing.T) {
+	balance := PoolGetToken1Balance(poolPath)
+	shouldEQ(t, balance, bigint(2958014))
+}
+
+func TestPoolGetToken0ProtocolFee(t *testing.T) {
+	protocolFee := PoolGetToken0ProtocolFee(poolPath)
+	shouldEQ(t, protocolFee, bigint(0))
+}
+
+func TestPoolGetToken1ProtocolFee(t *testing.T) {
+	protocolFee := PoolGetToken1ProtocolFee(poolPath)
+	shouldEQ(t, protocolFee, bigint(0))
+}
+
+func TestPoolGetPositionLiquidity(t *testing.T) {
+	liquidity := PoolGetPositionLiquidity(poolPath, positionKey)
+	shouldEQ(t, liquidity, test_liquidityExpect)
+}
+
+func TestPoolGetPositionFeeGrowthInside0LastX128(t *testing.T) {
+	feeGrowth := PoolGetPositionFeeGrowthInside0LastX128(poolPath, positionKey)
+	shouldEQ(t, feeGrowth, bigint(0))
+}
+
+func TestPoolGetPositionFeeGrowthInside1LastX128(t *testing.T) {
+	feeGrowth := PoolGetPositionFeeGrowthInside1LastX128(poolPath, positionKey)
+	shouldEQ(t, feeGrowth, bigint(0))
+}
+
+func TestPoolGetPositionTokensOwed0(t *testing.T) {
+	tokensOwed := PoolGetPositionTokensOwed0(poolPath, positionKey)
+	shouldEQ(t, tokensOwed, bigint(0))
+}
+
+func TestPoolGetPositionTokensOwed1(t *testing.T) {
+	tokensOwed := PoolGetPositionTokensOwed1(poolPath, positionKey)
+	shouldEQ(t, tokensOwed, bigint(0))
+}
+
+func TestPoolGetTickLiquidityGross(t *testing.T) {
+	liquidityGross := PoolGetTickLiquidityGross(poolPath, tick)
+	shouldEQ(t, liquidityGross, test_liquidityExpect)
+}
+
+func TestPoolGetTickLiquidityNet(t *testing.T) {
+	liquidityNet := PoolGetTickLiquidityNet(poolPath, tick)
+	shouldEQ(t, liquidityNet, test_liquidityExpect)
+}
+
+func TestPoolGetTickFeeGrowthOutside0X128(t *testing.T) {
+	feeGrowth := PoolGetTickFeeGrowthOutside0X128(poolPath, tick)
+	shouldEQ(t, feeGrowth, bigint(0))
+}
+
+func TestPoolGetTickFeeGrowthOutside1X128(t *testing.T) {
+	feeGrowth := PoolGetTickFeeGrowthOutside1X128(poolPath, tick)
+	shouldEQ(t, feeGrowth, bigint(0))
+}
+
+func TestPoolGetTickTickCumulativeOutside(t *testing.T) {
+	cumulative := PoolGetTickTickCumulativeOutside(poolPath, tick)
+	shouldEQ(t, cumulative, bigint(0))
+}
+
+func TestPoolGetTickSecondsPerLiquidityOutsideX128(t *testing.T) {
+	seconds := PoolGetTickSecondsPerLiquidityOutsideX128(poolPath, tick)
+	shouldEQ(t, seconds, bigint(0))
+}
+
+func TestPoolGetTickSecondsOutside(t *testing.T) {
+	liquidityGross := PoolGetTickSecondsOutside(poolPath, tick)
+	shouldEQ(t, liquidityGross, bigint(0))
+}
+
+func TestPoolGetTickInitialized(t *testing.T) {
+	initialized := PoolGetTickInitialized(poolPath, tick)
+	shouldEQ(t, initialized, true)
+}
+
+func TestPoolGetTickBitmap(t *testing.T) {
+	bitmap := PoolGetTickBitmap(poolPath, tickBitmap)
+	shouldEQ(t, string(bitmap), "1532495540865888858358347027150309183618739122183602176")
+}
+
+func TestPoolGetToken0Path(t *testing.T) {
+	token0Path := PoolGetToken0Path(poolPath)
+	shouldEQ(t, token0Path, barPath)
+}
+
+func TestPoolGetToken1Path(t *testing.T) {
+	token1Path := PoolGetToken1Path(poolPath)
+	shouldEQ(t, token1Path, fooPath)
+}
+
+func TestPoolGetFee(t *testing.T) {
+	fee := PoolGetFee(poolPath)
+	shouldEQ(t, fee, fee500)
+}
+
+func TestPoolGetTickSpacing(t *testing.T) {
+	spacing := PoolGetTickSpacing(poolPath)
+	shouldEQ(t, spacing, int32(10))
+}
+
+func TestPoolGetFeeGrowthGlobal0X128(t *testing.T) {
+	feeGrowth := PoolGetFeeGrowthGlobal0X128(poolPath)
+	shouldEQ(t, feeGrowth, bigint(0))
+}
+
+func TestPoolGetFeeGrowthGlobal1X128(t *testing.T) {
+	feeGrowth := PoolGetFeeGrowthGlobal1X128(poolPath)
+	shouldEQ(t, feeGrowth, bigint(0))
+}
+
+func TestPoolGetLiquidity(t *testing.T) {
+	liquidity := PoolGetLiquidity(poolPath)
+	shouldEQ(t, liquidity, test_liquidityExpect)
+}
diff --git a/pool/liquidity_math_test.gno b/pool/liquidity_math_test.gno
deleted file mode 100644
index 0fa080518..000000000
--- a/pool/liquidity_math_test.gno
+++ /dev/null
@@ -1,53 +0,0 @@
-package pool
-
-import (
-    "testing"
-    "gno.land/p/demo/ufmt"
-)
-
-func TestLiquidityMathAddDelta(t *testing.T) {
-    testCases := []struct {
-        x bigint
-        y bigint
-        expected bigint
-		isErr bool
-    }{
-		{-1000, -500, -1500, true},
-		{-1000, 500, -500, true},
-		{-200, -100, -300, true},
-		{-200, 100, -100, true},
-		{-100, -50, -150, true},
-		{-100, 50, -50, true},
-		{0, -100, -100, true},
-		{0, 0, 0, false},
-		{10, -5, 5, false},
-		{10, 5, 15, false},
-		{100, -50, 50, false},
-		{100, 50, 150, false},
-		{200, -100, 100, false},
-		{200, 100, 300, false},
-		{1000, -500, 500, false},
-		{1000, 500, 1500, false},
-	}
-
-    for i, tc := range testCases {
-        func() {
-            defer func() {
-                if r := recover(); r != nil {
-                    if !tc.isErr {
-                        t.Errorf("Test case %d failed: x=%d, y=%d, expected=%d, got panic but didn't expect one", i+1, tc.x, tc.y, tc.expected)
-                    }
-                } else {
-                    if tc.isErr {
-                        t.Errorf("Test case %d failed: x=%d, y=%d, expected panic but didn't get one", i+1, tc.x, tc.y)
-                    }
-                }
-            }()
-
-            result := liquidityMathAddDelta(tc.x, tc.y)
-            if result != tc.expected && !tc.isErr {
-                t.Errorf("Test case %d failed: x=%d, y=%d, expected=%d, got=%d", i+1, tc.x, tc.y, tc.expected, result)
-            }
-        }()
-    }
-}
\ No newline at end of file
diff --git a/position/_GET_position.gno b/position/_GET_no_receiver.gno.gno
similarity index 80%
rename from position/_GET_position.gno
rename to position/_GET_no_receiver.gno.gno
index cde46f145..193287fde 100644
--- a/position/_GET_position.gno
+++ b/position/_GET_no_receiver.gno.gno
@@ -1,15 +1,20 @@
 package position
 
 import (
-	"gno.land/p/demo/common"
+	"std"
 )
 
+// type Position
 func PositionGetPosition(tokenId uint64) Position {
 	return positions[tokenId]
 }
 
-func PositionGetPositionLiquidity(tokenId uint64) bigint {
-	return positions[tokenId].liquidity
+func PositionGetPositionNonce(tokenId uint64) bigint {
+	return positions[tokenId].nonce
+}
+
+func PositionGetPositionOperator(tokenId uint64) std.Address {
+	return positions[tokenId].operator
 }
 
 func PositionGetPositionPoolKey(tokenId uint64) string {
@@ -24,6 +29,10 @@ func PositionGetPositionTickUpper(tokenId uint64) int32 {
 	return positions[tokenId].tickUpper
 }
 
+func PositionGetPositionLiquidity(tokenId uint64) bigint {
+	return positions[tokenId].liquidity
+}
+
 func PositionGetPositionFeeGrowthInside0LastX128(tokenId uint64) bigint {
 	return positions[tokenId].feeGrowthInside0LastX128
 }
@@ -39,7 +48,3 @@ func PositionGetPositionTokensOwed0(tokenId uint64) bigint {
 func PositionGetPositionTokensOwed1(tokenId uint64) bigint {
 	return positions[tokenId].tokensOwed1
 }
-
-func PositionGetAmountsForLiquidity(sqrtRatioX96, sqrtRatioAX96, sqrtRatioBX96, liquidity bigint) (bigint, bigint) {
-	return common.GetAmountsForLiquidity(sqrtRatioX96, sqrtRatioAX96, sqrtRatioBX96, liquidity)
-}
diff --git a/staker/_GET_no_receiver.gno b/staker/_GET_no_receiver.gno
new file mode 100644
index 000000000..24fef0b9e
--- /dev/null
+++ b/staker/_GET_no_receiver.gno
@@ -0,0 +1,94 @@
+package staker
+
+import (
+	"std"
+
+	"gno.land/p/demo/ufmt"
+)
+
+// Incentive
+func StakerPoolIncentives(poolPath string) []string {
+	incentives, exist := poolIncentives[poolPath]
+	requireExist(exist, ufmt.Sprintf("[STAKER] _GET_staker.gno__StakerPoolIncentives() || poolPath(%s) incentives does not exist", poolPath))
+
+	return incentives
+}
+
+func StakerIncentiveTargetPoolPath(incentiveId string) string {
+	incentive, exist := incentives[incentiveId]
+	requireExist(exist, ufmt.Sprintf("[STAKER] _GET_staker.gno__StakerIncentiveTargetPoolPath() || incentiveId(%s) incentive does not exist", incentiveId))
+
+	return incentive.targetPoolPath
+}
+
+func StakerIncentiveRewardToken(incentiveId string) string {
+	incentive, exist := incentives[incentiveId]
+	requireExist(exist, ufmt.Sprintf("[STAKER] _GET_staker.gno__StakerIncentiveRewardToken() || incentiveId(%s) incentive does not exist", incentiveId))
+
+	return incentive.rewardToken
+}
+
+func StakerIncentiveRewardAmount(incentiveId string) bigint {
+	incentive, exist := incentives[incentiveId]
+	requireExist(exist, ufmt.Sprintf("[STAKER] _GET_staker.gno__StakerIncentiveRewardAmount() || incentiveId(%s) incentive does not exist", incentiveId))
+
+	return incentive.rewardAmount
+}
+
+func StakerIncentiveStartTimestamp(incentiveId string) int64 {
+	incentive, exist := incentives[incentiveId]
+	requireExist(exist, ufmt.Sprintf("[STAKER] _GET_staker.gno__StakerIncentiveStartTimestamp() || incentiveId(%s) incentive does not exist", incentiveId))
+
+	return incentive.startTimestamp
+}
+
+func StakerIncentiveEndTimestamp(incentiveId string) int64 {
+	incentive, exist := incentives[incentiveId]
+	requireExist(exist, ufmt.Sprintf("[STAKER] _GET_staker.gno__StakerIncentiveEndTimestamp() || incentiveId(%s) incentive does not exist", incentiveId))
+
+	return incentive.endTimestamp
+}
+
+func StakerIncentiveRefundee(incentiveId string) std.Address {
+	incentive, exist := incentives[incentiveId]
+	requireExist(exist, ufmt.Sprintf("[STAKER] _GET_staker.gno__StakerIncentiveRefundee() || incentiveId(%s) incentive does not exist", incentiveId))
+
+	return incentive.refundee
+}
+
+// Deposit
+func StakerDepositOwner(lpTokenId uint64) std.Address {
+	deposit, exist := deposits[lpTokenId]
+	requireExist(exist, ufmt.Sprintf("[STAKER] _GET_staker.gno__StakerDepositOwner() || tokenId(%d) deposit does not exist", lpTokenId))
+
+	return deposit.owner
+}
+
+func StakerDepositNumberOfStakes(lpTokenId uint64) uint64 {
+	deposit, exist := deposits[lpTokenId]
+	requireExist(exist, ufmt.Sprintf("[STAKER] _GET_staker.gno__StakerDepositNumberOfStakes() || tokenId(%d) deposit does not exist", lpTokenId))
+
+	return deposit.numberOfStakes
+}
+
+func StakerDepositStakeTimestamp(lpTokenId uint64) int64 {
+	deposit, exist := deposits[lpTokenId]
+	requireExist(exist, ufmt.Sprintf("[STAKER] _GET_staker.gno__StakerDepositStakeTimestamp() || tokenId(%d) deposit does not exist", lpTokenId))
+
+	return deposit.stakeTimestamp
+}
+
+func StakerDepositTargetPoolPath(lpTokenId uint64) string {
+	deposit, exist := deposits[lpTokenId]
+	requireExist(exist, ufmt.Sprintf("[STAKER] _GET_staker.gno__StakerDepositTargetPoolPath() || tokenId(%d) deposit does not exist", lpTokenId))
+
+	return deposit.targetPoolPath
+}
+
+// PoolTier
+func StakerPoolTier(poolPath string) uint8 {
+	tier, exist := poolTiers[poolPath]
+	requireExist(exist, ufmt.Sprintf("[STAKER] _GET_staker.gno__StakerPoolTier() || poolPath(%s) poolTier does not exist", poolPath))
+
+	return tier
+}
diff --git a/staker/_GET_staker.gno b/staker/_GET_staker.gno
deleted file mode 100644
index 39a1d9a01..000000000
--- a/staker/_GET_staker.gno
+++ /dev/null
@@ -1,6 +0,0 @@
-package staker
-
-func IsStaked(tokenId uint64) bool {
-	_, exist := deposits[tokenId]
-	return exist
-}
diff --git a/staker/_RPC_api_stake.gno b/staker/_RPC_api_stake.gno
index 5f38f7346..8ad72e860 100644
--- a/staker/_RPC_api_stake.gno
+++ b/staker/_RPC_api_stake.gno
@@ -126,3 +126,9 @@ func ApiGetStakes() string {
 
 	return string(rr)
 }
+
+// for off chain to check if lpTokenId is staked via RPC
+func IsStaked(tokenId uint64) bool {
+	_, exist := deposits[tokenId]
+	return exist
+}
diff --git a/staker/_TEST_staker_collect_reward_test.gno b/staker/_TEST_staker_collect_reward_test.gnoa
similarity index 100%
rename from staker/_TEST_staker_collect_reward_test.gno
rename to staker/_TEST_staker_collect_reward_test.gnoa
diff --git a/staker/_TEST_staker_rpc_get_test.gno b/staker/_TEST_staker_rpc_get_test.gno
new file mode 100644
index 000000000..dc092851c
--- /dev/null
+++ b/staker/_TEST_staker_rpc_get_test.gno
@@ -0,0 +1,186 @@
+package staker
+
+import (
+	"std"
+	"testing"
+
+	pl "gno.land/r/demo/pool"
+	pn "gno.land/r/demo/position"
+
+	"gno.land/r/demo/gnft"
+)
+
+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)
+	}
+}
+
+var poolPath = "gno.land/r/demo/bar:gno.land/r/demo/qux:500"
+var incentiveId = "ZzFqZzhtdHV0dTlraGhmd2M0bnhtdWhjcGZ0ZjBwYWpkaGZ2c3FmNTpnbm8ubGFuZC9yL2RlbW8vYmFyOmduby5sYW5kL3IvZGVtby9xdXg6NTAwOmduby5sYW5kL3IvZGVtby9vYmw="
+var lpTokenId = uint64(1)
+
+func TestStakerPoolIncentives(t *testing.T) {
+	incentives := StakerPoolIncentives(poolPath)
+	shouldEQ(t, incentives[0], incentiveId)
+}
+
+func TestStakerIncentiveTargetPoolPath(t *testing.T) {
+	targetPoolPath := StakerIncentiveTargetPoolPath(incentiveId)
+	shouldEQ(t, targetPoolPath, poolPath)
+}
+
+func TestStakerIncentiveRewardToken(t *testing.T) {
+	rewardToken := StakerIncentiveRewardToken(incentiveId)
+	shouldEQ(t, rewardToken, "gno.land/r/demo/obl")
+}
+
+func TestStakerIncentiveRewardAmount(t *testing.T) {
+	rewardAmount := StakerIncentiveRewardAmount(incentiveId)
+	shouldEQ(t, rewardAmount, bigint(20_000_000_000))
+}
+
+func TestStakerIncentiveStartTimestamp(t *testing.T) {
+	startTimestamp := StakerIncentiveStartTimestamp(incentiveId)
+	shouldEQ(t, startTimestamp, 1234567920)
+}
+
+func TestStakerIncentiveEndTimestamp(t *testing.T) {
+	endTimestamp := StakerIncentiveEndTimestamp(incentiveId)
+	shouldEQ(t, endTimestamp, 1242343920)
+}
+
+func TestStakerIncentiveRefundee(t *testing.T) {
+	refundee := StakerIncentiveRefundee(incentiveId)
+	shouldEQ(t, refundee, a2u(test1))
+}
+
+func TestStakerDepositOwner(t *testing.T) {
+	owner := StakerDepositOwner(lpTokenId)
+	shouldEQ(t, owner, a2u(test1))
+}
+
+func TestStakerDepositNumberOfStakes(t *testing.T) {
+	numberOfStakes := StakerDepositNumberOfStakes(lpTokenId)
+	shouldEQ(t, numberOfStakes, 1)
+}
+
+func TestStakerDepositStakeTimestamp(t *testing.T) {
+	stakeTimestamp := StakerDepositStakeTimestamp(lpTokenId)
+	shouldEQ(t, stakeTimestamp, 1234567945)
+}
+
+func TestStakerDepositTargetPoolPath(t *testing.T) {
+	targetPoolPath := StakerDepositTargetPoolPath(lpTokenId)
+	shouldEQ(t, targetPoolPath, poolPath)
+}
+
+func TestStakerPoolTier(t *testing.T) {
+	tier := StakerPoolTier(poolPath)
+	shouldEQ(t, tier, 1)
+}