chore: remove Pool prefix from pool's receiver getter

r3v4s · r3v4s · commit d1248acd3baa · 2024-12-09T14:36:16.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
@@ -759,71 +759,71 @@ func checkAmountRange(amount *i256.Int) uint64 {
 }
 
 // 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
`@@ -759,71 +759,71 @@ func checkAmountRange(amount *i256.Int) uint64 {`
`759`	`759`	`}`
`760`	`760`
`761`	`761`	`// receiver getters`
`762`		`-func (p *Pool) PoolGetToken0Path() string {`
	`762`	`+func (p *Pool) GetToken0Path() string {`
`763`	`763`	`return p.token0Path`
`764`	`764`	`}`
`765`	`765`
`766`		`-func (p *Pool) PoolGetToken1Path() string {`
	`766`	`+func (p *Pool) GetToken1Path() string {`
`767`	`767`	`return p.token1Path`
`768`	`768`	`}`
`769`	`769`
`770`		`-func (p *Pool) PoolGetFee() uint32 {`
	`770`	`+func (p *Pool) GetFee() uint32 {`
`771`	`771`	`return p.fee`
`772`	`772`	`}`
`773`	`773`
`774`		`-func (p Pool) PoolGetBalanceToken0() u256.Uint {`
	`774`	`+func (p Pool) GetBalanceToken0() u256.Uint {`
`775`	`775`	`return p.balances.token0`
`776`	`776`	`}`
`777`	`777`
`778`		`-func (p Pool) PoolGetBalanceToken1() u256.Uint {`
	`778`	`+func (p Pool) GetBalanceToken1() u256.Uint {`
`779`	`779`	`return p.balances.token1`
`780`	`780`	`}`
`781`	`781`
`782`		`-func (p *Pool) PoolGetTickSpacing() int32 {`
	`782`	`+func (p *Pool) GetTickSpacing() int32 {`
`783`	`783`	`return p.tickSpacing`
`784`	`784`	`}`
`785`	`785`
`786`		`-func (p Pool) PoolGetMaxLiquidityPerTick() u256.Uint {`
	`786`	`+func (p Pool) GetMaxLiquidityPerTick() u256.Uint {`
`787`	`787`	`return p.maxLiquidityPerTick`
`788`	`788`	`}`
`789`	`789`
`790`		`-func (p *Pool) PoolGetSlot0() Slot0 {`
	`790`	`+func (p *Pool) GetSlot0() Slot0 {`
`791`	`791`	`return p.slot0`
`792`	`792`	`}`
`793`	`793`
`794`		`-func (p Pool) PoolGetSlot0SqrtPriceX96() u256.Uint {`
	`794`	`+func (p Pool) GetSlot0SqrtPriceX96() u256.Uint {`
`795`	`795`	`return p.slot0.sqrtPriceX96`
`796`	`796`	`}`
`797`	`797`
`798`		`-func (p *Pool) PoolGetSlot0Tick() int32 {`
	`798`	`+func (p *Pool) GetSlot0Tick() int32 {`
`799`	`799`	`return p.slot0.tick`
`800`	`800`	`}`
`801`	`801`
`802`		`-func (p *Pool) PoolGetSlot0FeeProtocol() uint8 {`
	`802`	`+func (p *Pool) GetSlot0FeeProtocol() uint8 {`
`803`	`803`	`return p.slot0.feeProtocol`
`804`	`804`	`}`
`805`	`805`
`806`		`-func (p *Pool) PoolGetSlot0Unlocked() bool {`
	`806`	`+func (p *Pool) GetSlot0Unlocked() bool {`
`807`	`807`	`return p.slot0.unlocked`
`808`	`808`	`}`
`809`	`809`
`810`		`-func (p Pool) PoolGetFeeGrowthGlobal0X128() u256.Uint {`
	`810`	`+func (p Pool) GetFeeGrowthGlobal0X128() u256.Uint {`
`811`	`811`	`return p.feeGrowthGlobal0X128`
`812`	`812`	`}`
`813`	`813`
`814`		`-func (p Pool) PoolGetFeeGrowthGlobal1X128() u256.Uint {`
	`814`	`+func (p Pool) GetFeeGrowthGlobal1X128() u256.Uint {`
`815`	`815`	`return p.feeGrowthGlobal1X128`
`816`	`816`	`}`
`817`	`817`
`818`		`-func (p Pool) PoolGetProtocolFeesToken0() u256.Uint {`
	`818`	`+func (p Pool) GetProtocolFeesToken0() u256.Uint {`
`819`	`819`	`return p.protocolFees.token0`
`820`	`820`	`}`
`821`	`821`
`822`		`-func (p Pool) PoolGetProtocolFeesToken1() u256.Uint {`
	`822`	`+func (p Pool) GetProtocolFeesToken1() u256.Uint {`
`823`	`823`	`return p.protocolFees.token1`
`824`	`824`	`}`
`825`	`825`
`826`		`-func (p Pool) PoolGetLiquidity() u256.Uint {`
	`826`	`+func (p Pool) GetLiquidity() u256.Uint {`
`827`	`827`	`return p.liquidity`
`828`	`828`	`}`
`829`	`829`
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`