chore: remove Pool prefix from pool's receiver getter (#423)

r3v4s · web-flow · commit ce2e2923ce5e · 2024-12-15T14:10:20.000+09:00
diff --git a/pool/getter.gno b/pool/getter.gno
@@ -11,119 +11,119 @@ func PoolGetPoolList() []string {
 }
 
 func PoolGetToken0Path(poolPath string) string {
-	return mustGetPool(poolPath).PoolGetToken0Path()
+	return mustGetPool(poolPath).GetToken0Path()
 }
 
 func PoolGetToken1Path(poolPath string) string {
-	return mustGetPool(poolPath).PoolGetToken1Path()
+	return mustGetPool(poolPath).GetToken1Path()
 }
 
 func PoolGetFee(poolPath string) uint32 {
-	return mustGetPool(poolPath).PoolGetFee()
+	return mustGetPool(poolPath).GetFee()
 }
 
 func PoolGetBalanceToken0(poolPath string) string {
-	return mustGetPool(poolPath).PoolGetBalanceToken0().ToString()
+	return mustGetPool(poolPath).GetBalanceToken0().ToString()
 }
 
 func PoolGetBalanceToken1(poolPath string) string {
-	return mustGetPool(poolPath).PoolGetBalanceToken1().ToString()
+	return mustGetPool(poolPath).GetBalanceToken1().ToString()
 }
 
 func PoolGetTickSpacing(poolPath string) int32 {
-	return mustGetPool(poolPath).PoolGetTickSpacing()
+	return mustGetPool(poolPath).GetTickSpacing()
 }
 
 func PoolGetMaxLiquidityPerTick(poolPath string) string {
-	return mustGetPool(poolPath).PoolGetMaxLiquidityPerTick().ToString()
+	return mustGetPool(poolPath).GetMaxLiquidityPerTick().ToString()
 }
 
 func PoolGetSlot0SqrtPriceX96(poolPath string) string {
-	return mustGetPool(poolPath).PoolGetSlot0SqrtPriceX96().ToString()
+	return mustGetPool(poolPath).GetSlot0SqrtPriceX96().ToString()
 }
 
 func PoolGetSlot0Tick(poolPath string) int32 {
-	return mustGetPool(poolPath).PoolGetSlot0Tick()
+	return mustGetPool(poolPath).GetSlot0Tick()
 }
 
 func PoolGetSlot0FeeProtocol(poolPath string) uint8 {
-	return mustGetPool(poolPath).PoolGetSlot0FeeProtocol()
+	return mustGetPool(poolPath).GetSlot0FeeProtocol()
 }
 
 func PoolGetSlot0Unlocked(poolPath string) bool {
-	return mustGetPool(poolPath).PoolGetSlot0Unlocked()
+	return mustGetPool(poolPath).GetSlot0Unlocked()
 }
 
 func PoolGetFeeGrowthGlobal0X128(poolPath string) string {
-	return mustGetPool(poolPath).PoolGetFeeGrowthGlobal0X128().ToString()
+	return mustGetPool(poolPath).GetFeeGrowthGlobal0X128().ToString()
 }
 
 func PoolGetFeeGrowthGlobal1X128(poolPath string) string {
-	return mustGetPool(poolPath).PoolGetFeeGrowthGlobal1X128().ToString()
+	return mustGetPool(poolPath).GetFeeGrowthGlobal1X128().ToString()
 }
 
 func PoolGetProtocolFeesToken0(poolPath string) string {
-	return mustGetPool(poolPath).PoolGetProtocolFeesToken0().ToString()
+	return mustGetPool(poolPath).GetProtocolFeesToken0().ToString()
 }
 
 func PoolGetProtocolFeesToken1(poolPath string) string {
-	return mustGetPool(poolPath).PoolGetProtocolFeesToken1().ToString()
+	return mustGetPool(poolPath).GetProtocolFeesToken1().ToString()
 }
 
 func PoolGetLiquidity(poolPath string) string {
-	return mustGetPool(poolPath).PoolGetLiquidity().ToString()
+	return mustGetPool(poolPath).GetLiquidity().ToString()
 }
 
 // position
 func PoolGetPositionLiquidity(poolPath, key string) string {
-	return mustGetPool(poolPath).PoolGetPositionLiquidity(key).ToString()
+	return mustGetPool(poolPath).GetPositionLiquidity(key).ToString()
 }
 
 func PoolGetPositionFeeGrowthInside0LastX128(poolPath, key string) string {
-	return mustGetPool(poolPath).PoolGetPositionFeeGrowthInside0LastX128(key).ToString()
+	return mustGetPool(poolPath).GetPositionFeeGrowthInside0LastX128(key).ToString()
 }
 
 func PoolGetPositionFeeGrowthInside1LastX128(poolPath, key string) string {
-	return mustGetPool(poolPath).PoolGetPositionFeeGrowthInside1LastX128(key).ToString()
+	return mustGetPool(poolPath).GetPositionFeeGrowthInside1LastX128(key).ToString()
 }
 
 func PoolGetPositionTokensOwed0(poolPath, key string) string {
-	return mustGetPool(poolPath).PoolGetPositionTokensOwed0(key).ToString()
+	return mustGetPool(poolPath).GetPositionTokensOwed0(key).ToString()
 }
 
 func PoolGetPositionTokensOwed1(poolPath, key string) string {
-	return mustGetPool(poolPath).PoolGetPositionTokensOwed1(key).ToString()
+	return mustGetPool(poolPath).GetPositionTokensOwed1(key).ToString()
 }
 
 // tick
 func PoolGetTickLiquidityGross(poolPath string, tick int32) string {
-	return mustGetPool(poolPath).PoolGetTickLiquidityGross(tick).ToString()
+	return mustGetPool(poolPath).GetTickLiquidityGross(tick).ToString()
 }
 
 func PoolGetTickLiquidityNet(poolPath string, tick int32) string {
-	return mustGetPool(poolPath).PoolGetTickLiquidityNet(tick).ToString()
+	return mustGetPool(poolPath).GetTickLiquidityNet(tick).ToString()
 }
 
 func PoolGetTickFeeGrowthOutside0X128(poolPath string, tick int32) string {
-	return mustGetPool(poolPath).PoolGetTickFeeGrowthOutside0X128(tick).ToString()
+	return mustGetPool(poolPath).GetTickFeeGrowthOutside0X128(tick).ToString()
 }
 
 func PoolGetTickFeeGrowthOutside1X128(poolPath string, tick int32) string {
-	return mustGetPool(poolPath).PoolGetTickFeeGrowthOutside1X128(tick).ToString()
+	return mustGetPool(poolPath).GetTickFeeGrowthOutside1X128(tick).ToString()
 }
 
 func PoolGetTickCumulativeOutside(poolPath string, tick int32) int64 {
-	return mustGetPool(poolPath).PoolGetTickCumulativeOutside(tick)
+	return mustGetPool(poolPath).GetTickCumulativeOutside(tick)
 }
 
 func PoolGetTickSecondsPerLiquidityOutsideX128(poolPath string, tick int32) string {
-	return mustGetPool(poolPath).PoolGetTickSecondsPerLiquidityOutsideX128(tick).ToString()
+	return mustGetPool(poolPath).GetTickSecondsPerLiquidityOutsideX128(tick).ToString()
 }
 
 func PoolGetTickSecondsOutside(poolPath string, tick int32) uint32 {
-	return mustGetPool(poolPath).PoolGetTickSecondsOutside(tick)
+	return mustGetPool(poolPath).GetTickSecondsOutside(tick)
 }
 
 func PoolGetTickInitialized(poolPath string, tick int32) bool {
-	return mustGetPool(poolPath).PoolGetTickInitialized(tick)
+	return mustGetPool(poolPath).GetTickInitialized(tick)
 }
diff --git a/pool/pool.gno b/pool/pool.gno
@@ -985,71 +985,71 @@ func checkAmountRange(amount *u256.Uint) (uint64, error) {
 }
 
 // receiver getters
-func (p *Pool) PoolGetToken0Path() string {
+func (p *Pool) GetToken0Path() string {
 	return p.token0Path
 }
 
-func (p *Pool) PoolGetToken1Path() string {
+func (p *Pool) GetToken1Path() string {
 	return p.token1Path
 }
 
-func (p *Pool) PoolGetFee() uint32 {
+func (p *Pool) GetFee() uint32 {
 	return p.fee
 }
 
-func (p *Pool) PoolGetBalanceToken0() *u256.Uint {
+func (p *Pool) GetBalanceToken0() *u256.Uint {
 	return p.balances.token0
 }
 
-func (p *Pool) PoolGetBalanceToken1() *u256.Uint {
+func (p *Pool) GetBalanceToken1() *u256.Uint {
 	return p.balances.token1
 }
 
-func (p *Pool) PoolGetTickSpacing() int32 {
+func (p *Pool) GetTickSpacing() int32 {
 	return p.tickSpacing
 }
 
-func (p *Pool) PoolGetMaxLiquidityPerTick() *u256.Uint {
+func (p *Pool) GetMaxLiquidityPerTick() *u256.Uint {
 	return p.maxLiquidityPerTick
 }
 
-func (p *Pool) PoolGetSlot0() Slot0 {
+func (p *Pool) GetSlot0() Slot0 {
 	return p.slot0
 }
 
-func (p *Pool) PoolGetSlot0SqrtPriceX96() *u256.Uint {
+func (p *Pool) GetSlot0SqrtPriceX96() *u256.Uint {
 	return p.slot0.sqrtPriceX96
 }
 
-func (p *Pool) PoolGetSlot0Tick() int32 {
+func (p *Pool) GetSlot0Tick() int32 {
 	return p.slot0.tick
 }
 
-func (p *Pool) PoolGetSlot0FeeProtocol() uint8 {
+func (p *Pool) GetSlot0FeeProtocol() uint8 {
 	return p.slot0.feeProtocol
 }
 
-func (p *Pool) PoolGetSlot0Unlocked() bool {
+func (p *Pool) GetSlot0Unlocked() bool {
 	return p.slot0.unlocked
 }
 
-func (p *Pool) PoolGetFeeGrowthGlobal0X128() *u256.Uint {
+func (p *Pool) GetFeeGrowthGlobal0X128() *u256.Uint {
 	return p.feeGrowthGlobal0X128
 }
 
-func (p *Pool) PoolGetFeeGrowthGlobal1X128() *u256.Uint {
+func (p *Pool) GetFeeGrowthGlobal1X128() *u256.Uint {
 	return p.feeGrowthGlobal1X128
 }
 
-func (p *Pool) PoolGetProtocolFeesToken0() *u256.Uint {
+func (p *Pool) GetProtocolFeesToken0() *u256.Uint {
 	return p.protocolFees.token0
 }
 
-func (p *Pool) PoolGetProtocolFeesToken1() *u256.Uint {
+func (p *Pool) GetProtocolFeesToken1() *u256.Uint {
 	return p.protocolFees.token1
 }
 
-func (p *Pool) PoolGetLiquidity() *u256.Uint {
+func (p *Pool) GetLiquidity() *u256.Uint {
 	return p.liquidity
 }
 
diff --git a/pool/position.gno b/pool/position.gno
@@ -107,23 +107,23 @@ func positionUpdate(
 
 // receiver getters
 
-func (p *Pool) PoolGetPositionLiquidity(key string) *u256.Uint {
+func (p *Pool) GetPositionLiquidity(key string) *u256.Uint {
 	return p.mustGetPosition(key).liquidity
 }
 
-func (p *Pool) PoolGetPositionFeeGrowthInside0LastX128(key string) *u256.Uint {
+func (p *Pool) GetPositionFeeGrowthInside0LastX128(key string) *u256.Uint {
 	return p.mustGetPosition(key).feeGrowthInside0LastX128
 }
 
-func (p *Pool) PoolGetPositionFeeGrowthInside1LastX128(key string) *u256.Uint {
+func (p *Pool) GetPositionFeeGrowthInside1LastX128(key string) *u256.Uint {
 	return p.mustGetPosition(key).feeGrowthInside1LastX128
 }
 
-func (p *Pool) PoolGetPositionTokensOwed0(key string) *u256.Uint {
+func (p *Pool) GetPositionTokensOwed0(key string) *u256.Uint {
 	return p.mustGetPosition(key).tokensOwed0
 }
 
-func (p *Pool) PoolGetPositionTokensOwed1(key string) *u256.Uint {
+func (p *Pool) GetPositionTokensOwed1(key string) *u256.Uint {
 	return p.mustGetPosition(key).tokensOwed1
 }
 
diff --git a/pool/tick.gno b/pool/tick.gno
@@ -144,35 +144,35 @@ func getFeeGrowthAboveX128(
 }
 
 // receiver getters
-func (p *Pool) PoolGetTickLiquidityGross(tick int32) *u256.Uint {
+func (p *Pool) GetTickLiquidityGross(tick int32) *u256.Uint {
 	return p.mustGetTick(tick).liquidityGross
 }
 
-func (p *Pool) PoolGetTickLiquidityNet(tick int32) *i256.Int {
+func (p *Pool) GetTickLiquidityNet(tick int32) *i256.Int {
 	return p.mustGetTick(tick).liquidityNet
 }
 
-func (p *Pool) PoolGetTickFeeGrowthOutside0X128(tick int32) *u256.Uint {
+func (p *Pool) GetTickFeeGrowthOutside0X128(tick int32) *u256.Uint {
 	return p.mustGetTick(tick).feeGrowthOutside0X128
 }
 
-func (p *Pool) PoolGetTickFeeGrowthOutside1X128(tick int32) *u256.Uint {
+func (p *Pool) GetTickFeeGrowthOutside1X128(tick int32) *u256.Uint {
 	return p.mustGetTick(tick).feeGrowthOutside1X128
 }
 
-func (p *Pool) PoolGetTickCumulativeOutside(tick int32) int64 {
+func (p *Pool) GetTickCumulativeOutside(tick int32) int64 {
 	return p.mustGetTick(tick).tickCumulativeOutside
 }
 
-func (p *Pool) PoolGetTickSecondsPerLiquidityOutsideX128(tick int32) *u256.Uint {
+func (p *Pool) GetTickSecondsPerLiquidityOutsideX128(tick int32) *u256.Uint {
 	return p.mustGetTick(tick).secondsPerLiquidityOutsideX128
 }
 
-func (p *Pool) PoolGetTickSecondsOutside(tick int32) uint32 {
+func (p *Pool) GetTickSecondsOutside(tick int32) uint32 {
 	return p.mustGetTick(tick).secondsOutside
 }
 
-func (p *Pool) PoolGetTickInitialized(tick int32) bool {
+func (p *Pool) GetTickInitialized(tick int32) bool {
 	return p.mustGetTick(tick).initialized
 }
 
diff --git a/position/_RPC_api.gno b/position/_RPC_api.gno
@@ -390,7 +390,7 @@ func rpcMakePosition(lpTokenId uint64) RpcPosition {
 	burned := isBurned(lpTokenId)
 
 	pool := pl.GetPoolFromPoolPath(position.poolKey)
-	currentX96 := pool.PoolGetSlot0SqrtPriceX96()
+	currentX96 := pool.GetSlot0SqrtPriceX96()
 	lowerX96 := common.TickMathGetSqrtRatioAtTick(position.tickLower)
 	upperX96 := common.TickMathGetSqrtRatioAtTick(position.tickUpper)
 
@@ -439,24 +439,24 @@ func unclaimedFee(tokenId uint64) (*i256.Int, *i256.Int) {
 	poolKey := positions[tokenId].poolKey
 	pool := pl.GetPoolFromPoolPath(poolKey)
 
-	currentTick := pool.PoolGetSlot0Tick()
+	currentTick := pool.GetSlot0Tick()
 
-	_feeGrowthGlobal0X128 := pool.PoolGetFeeGrowthGlobal0X128()     // u256
+	_feeGrowthGlobal0X128 := pool.GetFeeGrowthGlobal0X128()         // u256
 	feeGrowthGlobal0X128 := i256.FromUint256(_feeGrowthGlobal0X128) // i256
 
-	_feeGrowthGlobal1X128 := pool.PoolGetFeeGrowthGlobal1X128()     // u256
+	_feeGrowthGlobal1X128 := pool.GetFeeGrowthGlobal1X128()         // u256
 	feeGrowthGlobal1X128 := i256.FromUint256(_feeGrowthGlobal1X128) // i256
 
-	_tickUpperFeeGrowthOutside0X128 := pool.PoolGetTickFeeGrowthOutside0X128(tickUpper) // u256
+	_tickUpperFeeGrowthOutside0X128 := pool.GetTickFeeGrowthOutside0X128(tickUpper)     // u256
 	tickUpperFeeGrowthOutside0X128 := i256.FromUint256(_tickUpperFeeGrowthOutside0X128) // i256
 
-	_tickUpperFeeGrowthOutside1X128 := pool.PoolGetTickFeeGrowthOutside1X128(tickUpper) // u256
+	_tickUpperFeeGrowthOutside1X128 := pool.GetTickFeeGrowthOutside1X128(tickUpper)     // u256
 	tickUpperFeeGrowthOutside1X128 := i256.FromUint256(_tickUpperFeeGrowthOutside1X128) // i256
 
-	_tickLowerFeeGrowthOutside0X128 := pool.PoolGetTickFeeGrowthOutside0X128(tickLower) // u256
+	_tickLowerFeeGrowthOutside0X128 := pool.GetTickFeeGrowthOutside0X128(tickLower)     // u256
 	tickLowerFeeGrowthOutside0X128 := i256.FromUint256(_tickLowerFeeGrowthOutside0X128) // i256
 
-	_tickLowerFeeGrowthOutside1X128 := pool.PoolGetTickFeeGrowthOutside1X128(tickLower) // u256
+	_tickLowerFeeGrowthOutside1X128 := pool.GetTickFeeGrowthOutside1X128(tickLower)     // u256
 	tickLowerFeeGrowthOutside1X128 := i256.FromUint256(_tickLowerFeeGrowthOutside1X128) // i256
 
 	_feeGrowthInside0LastX128 := positions[tokenId].feeGrowthInside0LastX128 // u256
diff --git a/position/liquidity_management.gno b/position/liquidity_management.gno
@@ -16,7 +16,7 @@ import (
 func addLiquidity(params AddLiquidityParams) (*u256.Uint, *u256.Uint, *u256.Uint) {
 	pool := pl.GetPoolFromPoolPath(params.poolKey)
 
-	sqrtPriceX96 := pool.PoolGetSlot0SqrtPriceX96()
+	sqrtPriceX96 := pool.GetSlot0SqrtPriceX96()
 	sqrtRatioAX96 := common.TickMathGetSqrtRatioAtTick(params.tickLower)
 	sqrtRatioBX96 := common.TickMathGetSqrtRatioAtTick(params.tickUpper)
 
diff --git a/position/position.gno b/position/position.gno

Original file line number	Diff line number	Diff line change
`@@ -11,119 +11,119 @@ func PoolGetPoolList() []string {`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`func PoolGetToken0Path(poolPath string) string {`
`14`		`- return mustGetPool(poolPath).PoolGetToken0Path()`
	`14`	`+ return mustGetPool(poolPath).GetToken0Path()`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`func PoolGetToken1Path(poolPath string) string {`
`18`		`- return mustGetPool(poolPath).PoolGetToken1Path()`
	`18`	`+ return mustGetPool(poolPath).GetToken1Path()`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`func PoolGetFee(poolPath string) uint32 {`
`22`		`- return mustGetPool(poolPath).PoolGetFee()`
	`22`	`+ return mustGetPool(poolPath).GetFee()`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`func PoolGetBalanceToken0(poolPath string) string {`
`26`		`- return mustGetPool(poolPath).PoolGetBalanceToken0().ToString()`
	`26`	`+ return mustGetPool(poolPath).GetBalanceToken0().ToString()`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`func PoolGetBalanceToken1(poolPath string) string {`
`30`		`- return mustGetPool(poolPath).PoolGetBalanceToken1().ToString()`
	`30`	`+ return mustGetPool(poolPath).GetBalanceToken1().ToString()`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`func PoolGetTickSpacing(poolPath string) int32 {`
`34`		`- return mustGetPool(poolPath).PoolGetTickSpacing()`
	`34`	`+ return mustGetPool(poolPath).GetTickSpacing()`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`func PoolGetMaxLiquidityPerTick(poolPath string) string {`
`38`		`- return mustGetPool(poolPath).PoolGetMaxLiquidityPerTick().ToString()`
	`38`	`+ return mustGetPool(poolPath).GetMaxLiquidityPerTick().ToString()`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`func PoolGetSlot0SqrtPriceX96(poolPath string) string {`
`42`		`- return mustGetPool(poolPath).PoolGetSlot0SqrtPriceX96().ToString()`
	`42`	`+ return mustGetPool(poolPath).GetSlot0SqrtPriceX96().ToString()`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`func PoolGetSlot0Tick(poolPath string) int32 {`
`46`		`- return mustGetPool(poolPath).PoolGetSlot0Tick()`
	`46`	`+ return mustGetPool(poolPath).GetSlot0Tick()`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`func PoolGetSlot0FeeProtocol(poolPath string) uint8 {`
`50`		`- return mustGetPool(poolPath).PoolGetSlot0FeeProtocol()`
	`50`	`+ return mustGetPool(poolPath).GetSlot0FeeProtocol()`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`func PoolGetSlot0Unlocked(poolPath string) bool {`
`54`		`- return mustGetPool(poolPath).PoolGetSlot0Unlocked()`
	`54`	`+ return mustGetPool(poolPath).GetSlot0Unlocked()`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`func PoolGetFeeGrowthGlobal0X128(poolPath string) string {`
`58`		`- return mustGetPool(poolPath).PoolGetFeeGrowthGlobal0X128().ToString()`
	`58`	`+ return mustGetPool(poolPath).GetFeeGrowthGlobal0X128().ToString()`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`func PoolGetFeeGrowthGlobal1X128(poolPath string) string {`
`62`		`- return mustGetPool(poolPath).PoolGetFeeGrowthGlobal1X128().ToString()`
	`62`	`+ return mustGetPool(poolPath).GetFeeGrowthGlobal1X128().ToString()`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`func PoolGetProtocolFeesToken0(poolPath string) string {`
`66`		`- return mustGetPool(poolPath).PoolGetProtocolFeesToken0().ToString()`
	`66`	`+ return mustGetPool(poolPath).GetProtocolFeesToken0().ToString()`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`func PoolGetProtocolFeesToken1(poolPath string) string {`
`70`		`- return mustGetPool(poolPath).PoolGetProtocolFeesToken1().ToString()`
	`70`	`+ return mustGetPool(poolPath).GetProtocolFeesToken1().ToString()`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`func PoolGetLiquidity(poolPath string) string {`
`74`		`- return mustGetPool(poolPath).PoolGetLiquidity().ToString()`
	`74`	`+ return mustGetPool(poolPath).GetLiquidity().ToString()`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`// position`
`78`	`78`	`func PoolGetPositionLiquidity(poolPath, key string) string {`
`79`		`- return mustGetPool(poolPath).PoolGetPositionLiquidity(key).ToString()`
	`79`	`+ return mustGetPool(poolPath).GetPositionLiquidity(key).ToString()`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`func PoolGetPositionFeeGrowthInside0LastX128(poolPath, key string) string {`
`83`		`- return mustGetPool(poolPath).PoolGetPositionFeeGrowthInside0LastX128(key).ToString()`
	`83`	`+ return mustGetPool(poolPath).GetPositionFeeGrowthInside0LastX128(key).ToString()`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`func PoolGetPositionFeeGrowthInside1LastX128(poolPath, key string) string {`
`87`		`- return mustGetPool(poolPath).PoolGetPositionFeeGrowthInside1LastX128(key).ToString()`
	`87`	`+ return mustGetPool(poolPath).GetPositionFeeGrowthInside1LastX128(key).ToString()`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`func PoolGetPositionTokensOwed0(poolPath, key string) string {`
`91`		`- return mustGetPool(poolPath).PoolGetPositionTokensOwed0(key).ToString()`
	`91`	`+ return mustGetPool(poolPath).GetPositionTokensOwed0(key).ToString()`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`func PoolGetPositionTokensOwed1(poolPath, key string) string {`
`95`		`- return mustGetPool(poolPath).PoolGetPositionTokensOwed1(key).ToString()`
	`95`	`+ return mustGetPool(poolPath).GetPositionTokensOwed1(key).ToString()`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`// tick`
`99`	`99`	`func PoolGetTickLiquidityGross(poolPath string, tick int32) string {`
`100`		`- return mustGetPool(poolPath).PoolGetTickLiquidityGross(tick).ToString()`
	`100`	`+ return mustGetPool(poolPath).GetTickLiquidityGross(tick).ToString()`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`func PoolGetTickLiquidityNet(poolPath string, tick int32) string {`
`104`		`- return mustGetPool(poolPath).PoolGetTickLiquidityNet(tick).ToString()`
	`104`	`+ return mustGetPool(poolPath).GetTickLiquidityNet(tick).ToString()`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`func PoolGetTickFeeGrowthOutside0X128(poolPath string, tick int32) string {`
`108`		`- return mustGetPool(poolPath).PoolGetTickFeeGrowthOutside0X128(tick).ToString()`
	`108`	`+ return mustGetPool(poolPath).GetTickFeeGrowthOutside0X128(tick).ToString()`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`func PoolGetTickFeeGrowthOutside1X128(poolPath string, tick int32) string {`
`112`		`- return mustGetPool(poolPath).PoolGetTickFeeGrowthOutside1X128(tick).ToString()`
	`112`	`+ return mustGetPool(poolPath).GetTickFeeGrowthOutside1X128(tick).ToString()`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`func PoolGetTickCumulativeOutside(poolPath string, tick int32) int64 {`
`116`		`- return mustGetPool(poolPath).PoolGetTickCumulativeOutside(tick)`
	`116`	`+ return mustGetPool(poolPath).GetTickCumulativeOutside(tick)`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`func PoolGetTickSecondsPerLiquidityOutsideX128(poolPath string, tick int32) string {`
`120`		`- return mustGetPool(poolPath).PoolGetTickSecondsPerLiquidityOutsideX128(tick).ToString()`
	`120`	`+ return mustGetPool(poolPath).GetTickSecondsPerLiquidityOutsideX128(tick).ToString()`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`func PoolGetTickSecondsOutside(poolPath string, tick int32) uint32 {`
`124`		`- return mustGetPool(poolPath).PoolGetTickSecondsOutside(tick)`
	`124`	`+ return mustGetPool(poolPath).GetTickSecondsOutside(tick)`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`func PoolGetTickInitialized(poolPath string, tick int32) bool {`
`128`		`- return mustGetPool(poolPath).PoolGetTickInitialized(tick)`
	`128`	`+ return mustGetPool(poolPath).GetTickInitialized(tick)`
`129`	`129`	`}`
Original file line number	Diff line number	Diff line change
`@@ -985,71 +985,71 @@ func checkAmountRange(amount *u256.Uint) (uint64, error) {`
`985`	`985`	`}`
`986`	`986`
`987`	`987`	`// receiver getters`
`988`		`-func (p *Pool) PoolGetToken0Path() string {`
	`988`	`+func (p *Pool) GetToken0Path() string {`
`989`	`989`	`return p.token0Path`
`990`	`990`	`}`
`991`	`991`
`992`		`-func (p *Pool) PoolGetToken1Path() string {`
	`992`	`+func (p *Pool) GetToken1Path() string {`
`993`	`993`	`return p.token1Path`
`994`	`994`	`}`
`995`	`995`
`996`		`-func (p *Pool) PoolGetFee() uint32 {`
	`996`	`+func (p *Pool) GetFee() uint32 {`
`997`	`997`	`return p.fee`
`998`	`998`	`}`
`999`	`999`
`1000`		`-func (p Pool) PoolGetBalanceToken0() u256.Uint {`
	`1000`	`+func (p Pool) GetBalanceToken0() u256.Uint {`
`1001`	`1001`	`return p.balances.token0`
`1002`	`1002`	`}`
`1003`	`1003`
`1004`		`-func (p Pool) PoolGetBalanceToken1() u256.Uint {`
	`1004`	`+func (p Pool) GetBalanceToken1() u256.Uint {`
`1005`	`1005`	`return p.balances.token1`
`1006`	`1006`	`}`
`1007`	`1007`
`1008`		`-func (p *Pool) PoolGetTickSpacing() int32 {`
	`1008`	`+func (p *Pool) GetTickSpacing() int32 {`
`1009`	`1009`	`return p.tickSpacing`
`1010`	`1010`	`}`
`1011`	`1011`
`1012`		`-func (p Pool) PoolGetMaxLiquidityPerTick() u256.Uint {`
	`1012`	`+func (p Pool) GetMaxLiquidityPerTick() u256.Uint {`
`1013`	`1013`	`return p.maxLiquidityPerTick`
`1014`	`1014`	`}`
`1015`	`1015`
`1016`		`-func (p *Pool) PoolGetSlot0() Slot0 {`
	`1016`	`+func (p *Pool) GetSlot0() Slot0 {`
`1017`	`1017`	`return p.slot0`
`1018`	`1018`	`}`
`1019`	`1019`
`1020`		`-func (p Pool) PoolGetSlot0SqrtPriceX96() u256.Uint {`
	`1020`	`+func (p Pool) GetSlot0SqrtPriceX96() u256.Uint {`
`1021`	`1021`	`return p.slot0.sqrtPriceX96`
`1022`	`1022`	`}`
`1023`	`1023`
`1024`		`-func (p *Pool) PoolGetSlot0Tick() int32 {`
	`1024`	`+func (p *Pool) GetSlot0Tick() int32 {`
`1025`	`1025`	`return p.slot0.tick`
`1026`	`1026`	`}`
`1027`	`1027`
`1028`		`-func (p *Pool) PoolGetSlot0FeeProtocol() uint8 {`
	`1028`	`+func (p *Pool) GetSlot0FeeProtocol() uint8 {`
`1029`	`1029`	`return p.slot0.feeProtocol`
`1030`	`1030`	`}`
`1031`	`1031`
`1032`		`-func (p *Pool) PoolGetSlot0Unlocked() bool {`
	`1032`	`+func (p *Pool) GetSlot0Unlocked() bool {`
`1033`	`1033`	`return p.slot0.unlocked`
`1034`	`1034`	`}`
`1035`	`1035`
`1036`		`-func (p Pool) PoolGetFeeGrowthGlobal0X128() u256.Uint {`
	`1036`	`+func (p Pool) GetFeeGrowthGlobal0X128() u256.Uint {`
`1037`	`1037`	`return p.feeGrowthGlobal0X128`
`1038`	`1038`	`}`
`1039`	`1039`
`1040`		`-func (p Pool) PoolGetFeeGrowthGlobal1X128() u256.Uint {`
	`1040`	`+func (p Pool) GetFeeGrowthGlobal1X128() u256.Uint {`
`1041`	`1041`	`return p.feeGrowthGlobal1X128`
`1042`	`1042`	`}`
`1043`	`1043`
`1044`		`-func (p Pool) PoolGetProtocolFeesToken0() u256.Uint {`
	`1044`	`+func (p Pool) GetProtocolFeesToken0() u256.Uint {`
`1045`	`1045`	`return p.protocolFees.token0`
`1046`	`1046`	`}`
`1047`	`1047`
`1048`		`-func (p Pool) PoolGetProtocolFeesToken1() u256.Uint {`
	`1048`	`+func (p Pool) GetProtocolFeesToken1() u256.Uint {`
`1049`	`1049`	`return p.protocolFees.token1`
`1050`	`1050`	`}`
`1051`	`1051`
`1052`		`-func (p Pool) PoolGetLiquidity() u256.Uint {`
	`1052`	`+func (p Pool) GetLiquidity() u256.Uint {`
`1053`	`1053`	`return p.liquidity`
`1054`	`1054`	`}`
`1055`	`1055`
Original file line number	Diff line number	Diff line change
`@@ -107,23 +107,23 @@ func positionUpdate(`
`107`	`107`
`108`	`108`	`// receiver getters`
`109`	`109`
`110`		`-func (p Pool) PoolGetPositionLiquidity(key string) u256.Uint {`
	`110`	`+func (p Pool) GetPositionLiquidity(key string) u256.Uint {`
`111`	`111`	`return p.mustGetPosition(key).liquidity`
`112`	`112`	`}`
`113`	`113`
`114`		`-func (p Pool) PoolGetPositionFeeGrowthInside0LastX128(key string) u256.Uint {`
	`114`	`+func (p Pool) GetPositionFeeGrowthInside0LastX128(key string) u256.Uint {`
`115`	`115`	`return p.mustGetPosition(key).feeGrowthInside0LastX128`
`116`	`116`	`}`
`117`	`117`
`118`		`-func (p Pool) PoolGetPositionFeeGrowthInside1LastX128(key string) u256.Uint {`
	`118`	`+func (p Pool) GetPositionFeeGrowthInside1LastX128(key string) u256.Uint {`
`119`	`119`	`return p.mustGetPosition(key).feeGrowthInside1LastX128`
`120`	`120`	`}`
`121`	`121`
`122`		`-func (p Pool) PoolGetPositionTokensOwed0(key string) u256.Uint {`
	`122`	`+func (p Pool) GetPositionTokensOwed0(key string) u256.Uint {`
`123`	`123`	`return p.mustGetPosition(key).tokensOwed0`
`124`	`124`	`}`
`125`	`125`
`126`		`-func (p Pool) PoolGetPositionTokensOwed1(key string) u256.Uint {`
	`126`	`+func (p Pool) GetPositionTokensOwed1(key string) u256.Uint {`
`127`	`127`	`return p.mustGetPosition(key).tokensOwed1`
`128`	`128`	`}`
`129`	`129`
Original file line number	Diff line number	Diff line change
`@@ -144,35 +144,35 @@ func getFeeGrowthAboveX128(`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`// receiver getters`
`147`		`-func (p Pool) PoolGetTickLiquidityGross(tick int32) u256.Uint {`
	`147`	`+func (p Pool) GetTickLiquidityGross(tick int32) u256.Uint {`
`148`	`148`	`return p.mustGetTick(tick).liquidityGross`
`149`	`149`	`}`
`150`	`150`
`151`		`-func (p Pool) PoolGetTickLiquidityNet(tick int32) i256.Int {`
	`151`	`+func (p Pool) GetTickLiquidityNet(tick int32) i256.Int {`
`152`	`152`	`return p.mustGetTick(tick).liquidityNet`
`153`	`153`	`}`
`154`	`154`
`155`		`-func (p Pool) PoolGetTickFeeGrowthOutside0X128(tick int32) u256.Uint {`
	`155`	`+func (p Pool) GetTickFeeGrowthOutside0X128(tick int32) u256.Uint {`
`156`	`156`	`return p.mustGetTick(tick).feeGrowthOutside0X128`
`157`	`157`	`}`
`158`	`158`
`159`		`-func (p Pool) PoolGetTickFeeGrowthOutside1X128(tick int32) u256.Uint {`
	`159`	`+func (p Pool) GetTickFeeGrowthOutside1X128(tick int32) u256.Uint {`
`160`	`160`	`return p.mustGetTick(tick).feeGrowthOutside1X128`
`161`	`161`	`}`
`162`	`162`
`163`		`-func (p *Pool) PoolGetTickCumulativeOutside(tick int32) int64 {`
	`163`	`+func (p *Pool) GetTickCumulativeOutside(tick int32) int64 {`
`164`	`164`	`return p.mustGetTick(tick).tickCumulativeOutside`
`165`	`165`	`}`
`166`	`166`
`167`		`-func (p Pool) PoolGetTickSecondsPerLiquidityOutsideX128(tick int32) u256.Uint {`
	`167`	`+func (p Pool) GetTickSecondsPerLiquidityOutsideX128(tick int32) u256.Uint {`
`168`	`168`	`return p.mustGetTick(tick).secondsPerLiquidityOutsideX128`
`169`	`169`	`}`
`170`	`170`
`171`		`-func (p *Pool) PoolGetTickSecondsOutside(tick int32) uint32 {`
	`171`	`+func (p *Pool) GetTickSecondsOutside(tick int32) uint32 {`
`172`	`172`	`return p.mustGetTick(tick).secondsOutside`
`173`	`173`	`}`
`174`	`174`
`175`		`-func (p *Pool) PoolGetTickInitialized(tick int32) bool {`
	`175`	`+func (p *Pool) GetTickInitialized(tick int32) bool {`
`176`	`176`	`return p.mustGetTick(tick).initialized`
`177`	`177`	`}`
`178`	`178`