Repository: osmosis-labs/osmosis
Pull request #4602 (2023-03-13 18:38:24)

refactor(CL): position state - only store sdk.Dec instead of position's struct
<!-- < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < ☺
v                               ✰  Thanks for creating a PR! ✰    
v    Before smashing the submit button please review the checkboxes.
v    If a checkbox is n/a - please still include it but + a little note why
v    If your PR doesn't close an issue, that's OK!  Just remove the Closes: #XXX line!
☺ > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >  -->

Closes: #4593

## What is the purpose of the change

This change is needed to productive implement genesis for CL.

Since the only value for position state entry is liquidity, we can serialize `sdk.DecProto` into state as opposed to defining a separate struct. The bulk of the data can be stored in key.

Also, moving query logic into its own package to avoid import cycles.

## Brief Changelog

- change position state value to `sdk.DecProto` instead of `model.Position`
- `model.Position` is used only for queries
- queries in their own package `types/query` to prevent import cycle

## Testing and Verifying

This change is a trivial rework / code cleanup without any test coverage.

## Documentation and Release Note

  - Does this pull request introduce a new feature or user-facing behavior changes? no
  - Is a relevant changelog entry added to the `Unreleased` section in `CHANGELOG.md`? no
  - How is the feature or change documented? not applicable


Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1fe6ad487..4f29b283b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -40,6 +40,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Misc Improvements
+
+  * [#4582](https://github.com/osmosis-labs/osmosis/pull/4582) Consistently generate build tags metadata, to return a comma-separated list without stray quotes. This affects the output from `version` CLI subcommand and server info API calls.
+
 ## v15.0.0
 
 This release containts the following new modules:
diff --git a/Dockerfile b/Dockerfile
index e2de25d8c..eb0b2c575 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -46,7 +46,7 @@ RUN --mount=type=cache,target=/root/.cache/go-build \
             -X github.com/cosmos/cosmos-sdk/version.AppName="osmosisd" \
             -X github.com/cosmos/cosmos-sdk/version.Version=${GIT_VERSION} \
             -X github.com/cosmos/cosmos-sdk/version.Commit=${GIT_COMMIT} \
-            -X github.com/cosmos/cosmos-sdk/version.BuildTags='netgo,ledger,muslc' \
+            -X github.com/cosmos/cosmos-sdk/version.BuildTags=netgo,ledger,muslc \
             -w -s -linkmode=external -extldflags '-Wl,-z,muldefs -static'" \
         -trimpath \
         -o /osmosis/build/osmosisd \
diff --git a/Makefile b/Makefile
index 933e2b33c..d8d13d86b 100644
--- a/Makefile
+++ b/Makefile
@@ -50,7 +50,7 @@ build_tags += $(BUILD_TAGS)
 build_tags := $(strip $(build_tags))
 
 whitespace :=
-whitespace += $(whitespace)
+whitespace := $(whitespace) $(whitespace)
 comma := ,
 build_tags_comma_sep := $(subst $(whitespace),$(comma),$(build_tags))
 
diff --git a/go.mod b/go.mod
index 153dc1633..f659c5b28 100644
--- a/go.mod
+++ b/go.mod
@@ -10,7 +10,7 @@ require (
 	github.com/cosmos/ibc-go/v4 v4.3.0
 	github.com/gogo/protobuf v1.3.3
 	github.com/golang/mock v1.6.0
-	github.com/golang/protobuf v1.5.2
+	github.com/golang/protobuf v1.5.3
 	github.com/golangci/golangci-lint v1.51.2
 	github.com/gorilla/mux v1.8.0
 	github.com/grpc-ecosystem/grpc-gateway v1.16.0
@@ -34,7 +34,7 @@ require (
 	github.com/tendermint/tendermint v0.34.24
 	github.com/tendermint/tm-db v0.6.8-0.20220506192307-f628bb5dc95b
 	github.com/tidwall/btree v1.6.0
-	go.uber.org/multierr v1.9.0
+	go.uber.org/multierr v1.10.0
 	golang.org/x/exp v0.0.0-20221212164502-fae10dda9338
 	google.golang.org/genproto v0.0.0-20221227171554-f9683d7f8bef
 	google.golang.org/grpc v1.52.0
@@ -194,7 +194,7 @@ require (
 	github.com/jingyugao/rowserrcheck v1.1.1 // indirect
 	github.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af // indirect
 	github.com/jmhodges/levigo v1.0.0 // indirect
-	github.com/joho/godotenv v1.4.0
+	github.com/joho/godotenv v1.5.1
 	github.com/julz/importas v0.1.0 // indirect
 	github.com/kisielk/errcheck v1.6.3 // indirect
 	github.com/kisielk/gotool v1.0.0 // indirect
diff --git a/go.sum b/go.sum
index 4838824f1..fddf658da 100644
--- a/go.sum
+++ b/go.sum
@@ -481,8 +481,9 @@ github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QD
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
@@ -694,8 +695,8 @@ github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHW
 github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
 github.com/jmhodges/levigo v1.0.0 h1:q5EC36kV79HWeTBWsod3mG11EgStG3qArTKcvlksN1U=
 github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ=
-github.com/joho/godotenv v1.4.0 h1:3l4+N6zfMWnkbPEXKng2o2/MR5mSwTrBih4ZEkkz1lg=
-github.com/joho/godotenv v1.4.0/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
 github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
@@ -1282,8 +1283,8 @@ go.uber.org/goleak v1.1.12 h1:gZAh5/EyT/HQwlpkCy6wTpqfH9H8Lz8zbm3dZh+OyzA=
 go.uber.org/goleak v1.1.12/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
-go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI=
-go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ=
+go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ=
+go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
 go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
diff --git a/proto/osmosis/concentrated-liquidity/pool-model/query.proto b/proto/osmosis/concentrated-liquidity/pool-model/query.proto
index a53708c4c..4bb7394af 100644
--- a/proto/osmosis/concentrated-liquidity/pool-model/query.proto
+++ b/proto/osmosis/concentrated-liquidity/pool-model/query.proto
@@ -12,7 +12,9 @@ import "cosmos_proto/cosmos.proto";
 import "google/protobuf/timestamp.proto";
 import "google/protobuf/duration.proto";
 
-option go_package = "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types";
+import "osmosis/concentrated-liquidity/position.proto";
+
+option go_package = "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types/query";
 
 service Query {
   // Pools returns all concentrated liquidity pools
@@ -57,30 +59,7 @@ message QueryUserPositionsRequest {
 }
 
 message QueryUserPositionsResponse {
-  repeated FullPositionByOwnerResult positions = 1
-      [ (gogoproto.nullable) = false ];
-}
-
-message FullPositionByOwnerResult {
-  uint64 pool_id = 1 [ (gogoproto.moretags) = "yaml:\"pool_id\"" ];
-  int64 lower_tick = 2;
-  int64 upper_tick = 3;
-  google.protobuf.Timestamp join_time = 4 [
-    (gogoproto.nullable) = false,
-    (gogoproto.stdtime) = true,
-    (gogoproto.moretags) = "yaml:\"join_time\""
-  ];
-  google.protobuf.Duration freeze_duration = 5 [
-    (gogoproto.nullable) = false,
-    (gogoproto.stdduration) = true,
-    (gogoproto.jsontag) = "duration,omitempty",
-    (gogoproto.moretags) = "yaml:\"freeze_duration\""
-  ];
-  string liquidity = 6 [
-    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
-    (gogoproto.moretags) = "yaml:\"liquidity\"",
-    (gogoproto.nullable) = false
-  ];
+  repeated Position positions = 1 [ (gogoproto.nullable) = false ];
 }
 
 //=============================== Pool
diff --git a/proto/osmosis/concentrated-liquidity/position.proto b/proto/osmosis/concentrated-liquidity/position.proto
index ed4ff6ead..921caa80b 100644
--- a/proto/osmosis/concentrated-liquidity/position.proto
+++ b/proto/osmosis/concentrated-liquidity/position.proto
@@ -12,8 +12,25 @@ import "gogoproto/gogo.proto";
 
 option go_package = "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/model";
 
+// Position contains position's pool id, lower tick, upper tick
+// liquidity, join time and freeze duration.
 message Position {
-  string liquidity = 1 [
+  string address = 1 [ (gogoproto.moretags) = "yaml:\"address\"" ];
+  uint64 pool_id = 2 [ (gogoproto.moretags) = "yaml:\"pool_id\"" ];
+  int64 lower_tick = 3;
+  int64 upper_tick = 4;
+  google.protobuf.Timestamp join_time = 5 [
+    (gogoproto.nullable) = false,
+    (gogoproto.stdtime) = true,
+    (gogoproto.moretags) = "yaml:\"join_time\""
+  ];
+  google.protobuf.Duration freeze_duration = 6 [
+    (gogoproto.nullable) = false,
+    (gogoproto.stdduration) = true,
+    (gogoproto.jsontag) = "duration,omitempty",
+    (gogoproto.moretags) = "yaml:\"freeze_duration\""
+  ];
+  string liquidity = 7 [
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
     (gogoproto.moretags) = "yaml:\"liquidity\"",
     (gogoproto.nullable) = false
diff --git a/x/concentrated-liquidity/client/cli/query.go b/x/concentrated-liquidity/client/cli/query.go
index 9149e1aab..6b265e821 100644
--- a/x/concentrated-liquidity/client/cli/query.go
+++ b/x/concentrated-liquidity/client/cli/query.go
@@ -5,52 +5,53 @@ import (
 
 	"github.com/osmosis-labs/osmosis/osmoutils/osmocli"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
+	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types/query"
 )
 
 // GetQueryCmd returns the cli query commands for this module.
 func GetQueryCmd() *cobra.Command {
 	cmd := osmocli.QueryIndexCmd(types.ModuleName)
-	osmocli.AddQueryCmd(cmd, types.NewQueryClient, GetCmdPool)
-	osmocli.AddQueryCmd(cmd, types.NewQueryClient, GetCmdPools)
-	osmocli.AddQueryCmd(cmd, types.NewQueryClient, GetUserPositions)
-	osmocli.AddQueryCmd(cmd, types.NewQueryClient, GetClaimableFees)
+	osmocli.AddQueryCmd(cmd, query.NewQueryClient, GetCmdPool)
+	osmocli.AddQueryCmd(cmd, query.NewQueryClient, GetCmdPools)
+	osmocli.AddQueryCmd(cmd, query.NewQueryClient, GetUserPositions)
+	osmocli.AddQueryCmd(cmd, query.NewQueryClient, GetClaimableFees)
 	cmd.AddCommand(
-		osmocli.GetParams[*types.QueryParamsRequest](
-			types.ModuleName, types.NewQueryClient),
+		osmocli.GetParams[*query.QueryParamsRequest](
+			types.ModuleName, query.NewQueryClient),
 	)
 	return cmd
 }
 
-func GetUserPositions() (*osmocli.QueryDescriptor, *types.QueryUserPositionsRequest) {
+func GetUserPositions() (*osmocli.QueryDescriptor, *query.QueryUserPositionsRequest) {
 	return &osmocli.QueryDescriptor{
 			Use:   "user-positions [address]",
 			Short: "Query user's positions",
 			Long: `{{.Short}}{{.ExampleHeader}}
 {{.CommandPrefix}} user-positions osmo12smx2wdlyttvyzvzg54y2vnqwq2qjateuf7thj`,
 			CustomFlagOverrides: poolIdFlagOverride},
-		&types.QueryUserPositionsRequest{}
+		&query.QueryUserPositionsRequest{}
 }
 
-func GetCmdPool() (*osmocli.QueryDescriptor, *types.QueryPoolRequest) {
+func GetCmdPool() (*osmocli.QueryDescriptor, *query.QueryPoolRequest) {
 	return &osmocli.QueryDescriptor{
 		Use:   "pool [poolID]",
 		Short: "Query pool",
 		Long: `{{.Short}}{{.ExampleHeader}}
-{{.CommandPrefix}} pool 1`}, &types.QueryPoolRequest{}
+{{.CommandPrefix}} pool 1`}, &query.QueryPoolRequest{}
 }
 
-func GetCmdPools() (*osmocli.QueryDescriptor, *types.QueryPoolsRequest) {
+func GetCmdPools() (*osmocli.QueryDescriptor, *query.QueryPoolsRequest) {
 	return &osmocli.QueryDescriptor{
 		Use:   "pools",
 		Short: "Query pools",
 		Long: `{{.Short}}{{.ExampleHeader}}
-{{.CommandPrefix}} pools`}, &types.QueryPoolsRequest{}
+{{.CommandPrefix}} pools`}, &query.QueryPoolsRequest{}
 }
 
-func GetClaimableFees() (*osmocli.QueryDescriptor, *types.QueryClaimableFeesRequest) {
+func GetClaimableFees() (*osmocli.QueryDescriptor, *query.QueryClaimableFeesRequest) {
 	return &osmocli.QueryDescriptor{
 		Use:   "claimable-fees [poolID] [address] [lowerTick] [upperTick]",
 		Short: "Query claimable fees",
 		Long: `{{.Short}}{{.ExampleHeader}}
-{{.CommandPrefix}} claimable-fees 1 osmo12smx2wdlyttvyzvzg54y2vnqwq2qjateuf7thj [-100] 100`}, &types.QueryClaimableFeesRequest{}
+{{.CommandPrefix}} claimable-fees 1 osmo12smx2wdlyttvyzvzg54y2vnqwq2qjateuf7thj [-100] 100`}, &query.QueryClaimableFeesRequest{}
 }
diff --git a/x/concentrated-liquidity/clmodule/module.go b/x/concentrated-liquidity/clmodule/module.go
index 6a2595843..2e9f41413 100644
--- a/x/concentrated-liquidity/clmodule/module.go
+++ b/x/concentrated-liquidity/clmodule/module.go
@@ -20,6 +20,7 @@ import (
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/client/cli"
 	clmodel "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/model"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/simulation"
+	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types/query"
 
 	clkeeper "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
@@ -60,7 +61,7 @@ func (b AppModuleBasic) RegisterRESTRoutes(ctx client.Context, r *mux.Router) {
 }
 
 func (b AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux) {
-	types.RegisterQueryHandlerClient(context.Background(), mux, types.NewQueryClient(clientCtx)) //nolint:errcheck
+	query.RegisterQueryHandlerClient(context.Background(), mux, query.NewQueryClient(clientCtx)) //nolint:errcheck
 }
 
 func (b AppModuleBasic) GetTxCmd() *cobra.Command {
@@ -93,7 +94,7 @@ func NewAppModule(cdc codec.Codec, keeper clkeeper.Keeper) AppModule {
 func (am AppModule) RegisterServices(cfg module.Configurator) {
 	types.RegisterMsgServer(cfg.MsgServer(), clkeeper.NewMsgServerImpl(&am.keeper))
 	clmodel.RegisterMsgCreatorServer(cfg.MsgServer(), clkeeper.NewMsgCreatorServerImpl(&am.keeper))
-	types.RegisterQueryServer(cfg.QueryServer(), clkeeper.NewQuerier(am.keeper))
+	query.RegisterQueryServer(cfg.QueryServer(), clkeeper.NewQuerier(am.keeper))
 }
 
 func (am AppModule) RegisterInvariants(ir sdk.InvariantRegistry) {
diff --git a/x/concentrated-liquidity/grpc_query.go b/x/concentrated-liquidity/grpc_query.go
index c6e782248..692badb34 100644
--- a/x/concentrated-liquidity/grpc_query.go
+++ b/x/concentrated-liquidity/grpc_query.go
@@ -14,6 +14,7 @@ import (
 	"github.com/osmosis-labs/osmosis/osmoutils"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/model"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
+	clquery "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types/query"
 )
 
 const (
@@ -24,7 +25,7 @@ var (
 	liquidityDepthRangeQueryLimitInt = sdk.NewInt(liquidityDepthRangeQueryLimit)
 )
 
-var _ types.QueryServer = Querier{}
+var _ clquery.QueryServer = Querier{}
 
 // Querier defines a wrapper around the x/concentrated-liquidity keeper providing gRPC method
 // handlers.
@@ -39,8 +40,8 @@ func NewQuerier(k Keeper) Querier {
 // Pool checks if a pool exists and returns the desired pool.
 func (q Querier) Pool(
 	ctx context.Context,
-	req *types.QueryPoolRequest,
-) (*types.QueryPoolResponse, error) {
+	req *clquery.QueryPoolRequest,
+) (*clquery.QueryPoolResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
@@ -56,11 +57,11 @@ func (q Querier) Pool(
 		return nil, err
 	}
 
-	return &types.QueryPoolResponse{Pool: any}, nil
+	return &clquery.QueryPoolResponse{Pool: any}, nil
 }
 
 // UserPositions returns positions of a specified address
-func (q Querier) UserPositions(ctx context.Context, req *types.QueryUserPositionsRequest) (*types.QueryUserPositionsResponse, error) {
+func (q Querier) UserPositions(ctx context.Context, req *clquery.QueryUserPositionsRequest) (*clquery.QueryUserPositionsResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
@@ -76,7 +77,7 @@ func (q Querier) UserPositions(ctx context.Context, req *types.QueryUserPosition
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 
-	return &types.QueryUserPositionsResponse{
+	return &clquery.QueryUserPositionsResponse{
 		Positions: userPositions,
 	}, nil
 }
@@ -84,8 +85,8 @@ func (q Querier) UserPositions(ctx context.Context, req *types.QueryUserPosition
 // Pools returns all concentrated pools in existence.
 func (q Querier) Pools(
 	ctx context.Context,
-	req *types.QueryPoolsRequest,
-) (*types.QueryPoolsResponse, error) {
+	req *clquery.QueryPoolsRequest,
+) (*clquery.QueryPoolsResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
@@ -121,20 +122,20 @@ func (q Querier) Pools(
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 
-	return &types.QueryPoolsResponse{
+	return &clquery.QueryPoolsResponse{
 		Pools:      anys,
 		Pagination: pageRes,
 	}, nil
 }
 
 // Params returns module params
-func (q Querier) Params(goCtx context.Context, req *types.QueryParamsRequest) (*types.QueryParamsResponse, error) {
+func (q Querier) Params(goCtx context.Context, req *clquery.QueryParamsRequest) (*clquery.QueryParamsResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
-	return &types.QueryParamsResponse{Params: q.Keeper.GetParams(ctx)}, nil
+	return &clquery.QueryParamsResponse{Params: q.Keeper.GetParams(ctx)}, nil
 }
 
 // LiquidityDepthsForRange returns liquidity depths for the given range.
-func (q Querier) LiquidityDepthsForRange(goCtx context.Context, req *types.QueryLiquidityDepthsForRangeRequest) (*types.QueryLiquidityDepthsForRangeResponse, error) {
+func (q Querier) LiquidityDepthsForRange(goCtx context.Context, req *clquery.QueryLiquidityDepthsForRangeRequest) (*clquery.QueryLiquidityDepthsForRangeResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
 	if req == nil {
@@ -156,12 +157,12 @@ func (q Querier) LiquidityDepthsForRange(goCtx context.Context, req *types.Query
 		return nil, err
 	}
 
-	return &types.QueryLiquidityDepthsForRangeResponse{
+	return &clquery.QueryLiquidityDepthsForRangeResponse{
 		LiquidityDepths: liquidityDepths,
 	}, nil
 }
 
-func (q Querier) ClaimableFees(ctx context.Context, req *types.QueryClaimableFeesRequest) (*types.QueryClaimableFeesResponse, error) {
+func (q Querier) ClaimableFees(ctx context.Context, req *clquery.QueryClaimableFeesRequest) (*clquery.QueryClaimableFeesResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
@@ -177,7 +178,7 @@ func (q Querier) ClaimableFees(ctx context.Context, req *types.QueryClaimableFee
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 
-	return &types.QueryClaimableFeesResponse{
+	return &clquery.QueryClaimableFeesResponse{
 		ClaimableFees: claimableFees,
 	}, nil
 }
diff --git a/x/concentrated-liquidity/incentives.go b/x/concentrated-liquidity/incentives.go
index 16296aeab..a00c8bc39 100644
--- a/x/concentrated-liquidity/incentives.go
+++ b/x/concentrated-liquidity/incentives.go
@@ -344,7 +344,7 @@ func (k Keeper) GetUptimeGrowthOutsideRange(ctx sdk.Context, poolId uint64, lowe
 }
 
 // initOrUpdatePositionUptime either adds or updates records for all uptime accumulators `position` qualifies for
-func (k Keeper) initOrUpdatePositionUptime(ctx sdk.Context, poolId uint64, position *model.Position, owner sdk.AccAddress, lowerTick, upperTick int64, liquidityDelta sdk.Dec, joinTime time.Time, freezeDuration time.Duration) error {
+func (k Keeper) initOrUpdatePositionUptime(ctx sdk.Context, poolId uint64, liquidity sdk.Dec, owner sdk.AccAddress, lowerTick, upperTick int64, liquidityDelta sdk.Dec, joinTime time.Time, freezeDuration time.Duration) error {
 	// We update accumulators _prior_ to any position-related updates to ensure
 	// past rewards aren't distributed to new liquidity. We also update pool's
 	// LastLiquidityUpdate here.
@@ -392,7 +392,7 @@ func (k Keeper) initOrUpdatePositionUptime(ctx sdk.Context, poolId uint64, posit
 				// Since the position should only be entitled to uptime growth within its range, we checkpoint globalUptimeGrowthInsideRange as
 				// its accumulator's init value. During the claiming (or, equivalently, position updating) process, we ensure that incentives are
 				// not overpaid.
-				err = curUptimeAccum.NewPositionCustomAcc(positionName, position.Liquidity, globalUptimeGrowthInsideRange[uptimeIndex], emptyOptions)
+				err = curUptimeAccum.NewPositionCustomAcc(positionName, liquidity, globalUptimeGrowthInsideRange[uptimeIndex], emptyOptions)
 				if err != nil {
 					return err
 				}
diff --git a/x/concentrated-liquidity/lp.go b/x/concentrated-liquidity/lp.go
index e4fbc9eae..5e1609637 100644
--- a/x/concentrated-liquidity/lp.go
+++ b/x/concentrated-liquidity/lp.go
@@ -122,7 +122,7 @@ func (k Keeper) withdrawPosition(ctx sdk.Context, poolId uint64, owner sdk.AccAd
 	}
 
 	// Retrieve the position in the pool for the provided owner and tick range.
-	position, err := k.GetPosition(ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration)
+	availableLiquidity, err := k.GetPositionLiquidity(ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration)
 	if err != nil {
 		return sdk.Int{}, sdk.Int{}, err
 	}
@@ -137,7 +137,6 @@ func (k Keeper) withdrawPosition(ctx sdk.Context, poolId uint64, owner sdk.AccAd
 
 	// Check if the requested liquidity amount to withdraw is less than or equal to the available liquidity for the position.
 	// If it is greater than the available liquidity, return an error.
-	availableLiquidity := position.Liquidity
 	if requestedLiquidityAmountToWithdraw.GT(availableLiquidity) {
 		return sdk.Int{}, sdk.Int{}, types.InsufficientLiquidityError{Actual: requestedLiquidityAmountToWithdraw, Available: availableLiquidity}
 	}
diff --git a/x/concentrated-liquidity/model/position.pb.go b/x/concentrated-liquidity/model/position.pb.go
index 40480bec7..00d7dd8a3 100644
--- a/x/concentrated-liquidity/model/position.pb.go
+++ b/x/concentrated-liquidity/model/position.pb.go
@@ -15,15 +15,18 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	_ "github.com/gogo/protobuf/types"
+	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
 	io "io"
 	math "math"
 	math_bits "math/bits"
+	time "time"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
+var _ = time.Kitchen
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the proto package it is being compiled against.
@@ -31,8 +34,16 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
+// Position contains position's pool id, lower tick, upper tick
+// liquidity, join time and freeze duration.
 type Position struct {
-	Liquidity github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=liquidity,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidity" yaml:"liquidity"`
+	Address        string                                 `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty" yaml:"address"`
+	PoolId         uint64                                 `protobuf:"varint,2,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
+	LowerTick      int64                                  `protobuf:"varint,3,opt,name=lower_tick,json=lowerTick,proto3" json:"lower_tick,omitempty"`
+	UpperTick      int64                                  `protobuf:"varint,4,opt,name=upper_tick,json=upperTick,proto3" json:"upper_tick,omitempty"`
+	JoinTime       time.Time                              `protobuf:"bytes,5,opt,name=join_time,json=joinTime,proto3,stdtime" json:"join_time" yaml:"join_time"`
+	FreezeDuration time.Duration                          `protobuf:"bytes,6,opt,name=freeze_duration,json=freezeDuration,proto3,stdduration" json:"duration,omitempty" yaml:"freeze_duration"`
+	Liquidity      github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=liquidity,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidity" yaml:"liquidity"`
 }
 
 func (m *Position) Reset()         { *m = Position{} }
@@ -68,6 +79,48 @@ func (m *Position) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Position proto.InternalMessageInfo
 
+func (m *Position) GetAddress() string {
+	if m != nil {
+		return m.Address
+	}
+	return ""
+}
+
+func (m *Position) GetPoolId() uint64 {
+	if m != nil {
+		return m.PoolId
+	}
+	return 0
+}
+
+func (m *Position) GetLowerTick() int64 {
+	if m != nil {
+		return m.LowerTick
+	}
+	return 0
+}
+
+func (m *Position) GetUpperTick() int64 {
+	if m != nil {
+		return m.UpperTick
+	}
+	return 0
+}
+
+func (m *Position) GetJoinTime() time.Time {
+	if m != nil {
+		return m.JoinTime
+	}
+	return time.Time{}
+}
+
+func (m *Position) GetFreezeDuration() time.Duration {
+	if m != nil {
+		return m.FreezeDuration
+	}
+	return 0
+}
+
 func init() {
 	proto.RegisterType((*Position)(nil), "osmosis.concentratedliquidity.v1beta1.Position")
 }
@@ -77,25 +130,37 @@ func init() {
 }
 
 var fileDescriptor_ffdfd7b30d37d326 = []byte{
-	// 281 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x90, 0xb1, 0x4a, 0xf5, 0x30,
-	0x18, 0x86, 0xdb, 0xe5, 0xe7, 0x3f, 0x9d, 0xe4, 0xe0, 0xa0, 0x1d, 0x52, 0x29, 0x28, 0x2e, 0x6d,
-	0x28, 0xe2, 0xe2, 0x58, 0xbc, 0x00, 0x71, 0x14, 0x41, 0xd3, 0x36, 0xc6, 0x60, 0xd2, 0xaf, 0x36,
-	0x5f, 0x0f, 0xf6, 0x2e, 0xbc, 0xac, 0x33, 0x9e, 0x51, 0x1c, 0x8a, 0xb4, 0x77, 0xe0, 0x15, 0x88,
-	0x6d, 0xec, 0x39, 0x08, 0x4e, 0xc9, 0x1b, 0x9e, 0xbc, 0x79, 0xf2, 0x79, 0x11, 0x18, 0x0d, 0x46,
-	0x1a, 0x9a, 0x43, 0x99, 0xf3, 0x12, 0x6b, 0x86, 0xbc, 0x88, 0x94, 0x7c, 0x6e, 0x64, 0x21, 0xb1,
-	0xa5, 0x15, 0x18, 0x89, 0x12, 0xca, 0xb8, 0xaa, 0x01, 0x61, 0x79, 0x6c, 0xf1, 0x78, 0x17, 0x9f,
-	0xe9, 0x78, 0x95, 0x64, 0x1c, 0x59, 0xe2, 0x1f, 0xe6, 0x23, 0x77, 0x37, 0x5e, 0xa2, 0x53, 0x98,
-	0x1a, 0xfc, 0x40, 0x00, 0x08, 0xc5, 0xe9, 0x98, 0xb2, 0xe6, 0x81, 0xa2, 0xd4, 0xdc, 0x20, 0xd3,
-	0x95, 0x05, 0xc8, 0x6f, 0xa0, 0x68, 0x6a, 0xb6, 0x55, 0xf0, 0xf7, 0x05, 0x08, 0x98, 0x8a, 0xbf,
-	0x77, 0xd3, 0x69, 0xa8, 0xbc, 0xff, 0x57, 0x56, 0x75, 0x79, 0xef, 0x2d, 0x66, 0xa5, 0x03, 0xf7,
-	0xc8, 0x3d, 0x5d, 0xa4, 0xe9, 0xba, 0x0b, 0x9c, 0xf7, 0x2e, 0x38, 0x11, 0x12, 0x1f, 0x9b, 0x2c,
-	0xce, 0x41, 0x5b, 0x2d, 0xbb, 0x44, 0xa6, 0x78, 0xa2, 0xd8, 0x56, 0xdc, 0xc4, 0x97, 0x3c, 0xff,
-	0xec, 0x82, 0xbd, 0x96, 0x69, 0x75, 0x11, 0xce, 0x45, 0xe1, 0xf5, 0xb6, 0x34, 0xbd, 0x5d, 0xf7,
-	0xc4, 0xdd, 0xf4, 0xc4, 0xfd, 0xe8, 0x89, 0xfb, 0x3a, 0x10, 0x67, 0x33, 0x10, 0xe7, 0x6d, 0x20,
-	0xce, 0x4d, 0xba, 0xf3, 0x80, 0x9d, 0x55, 0xa4, 0x58, 0x66, 0x7e, 0x02, 0x5d, 0x25, 0xe7, 0xf4,
-	0xe5, 0xaf, 0x69, 0x6b, 0x28, 0xb8, 0xca, 0xfe, 0x8d, 0x5f, 0x3a, 0xfb, 0x0a, 0x00, 0x00, 0xff,
-	0xff, 0xe1, 0x99, 0xf8, 0x00, 0x9c, 0x01, 0x00, 0x00,
+	// 471 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xcf, 0x8b, 0xd3, 0x40,
+	0x14, 0xc7, 0x1b, 0xbb, 0xb6, 0xdb, 0x11, 0x56, 0x09, 0x22, 0xd9, 0xa2, 0x49, 0x09, 0x28, 0x05,
+	0xb7, 0x09, 0x55, 0x04, 0xf1, 0x18, 0xf6, 0xe2, 0x4d, 0xc2, 0x7a, 0x11, 0x21, 0x26, 0x99, 0xd9,
+	0x38, 0x36, 0xe9, 0x8b, 0x99, 0xc9, 0x6a, 0xc5, 0x3f, 0x62, 0x8f, 0xfe, 0x49, 0x7b, 0xdc, 0xa3,
+	0xec, 0x21, 0x4a, 0x7b, 0xf3, 0xd8, 0xbf, 0x40, 0xe6, 0x47, 0xda, 0x52, 0xf1, 0x94, 0xbc, 0xf7,
+	0xfd, 0xce, 0xe7, 0xfd, 0xe0, 0xa1, 0x09, 0xb0, 0x02, 0x18, 0x65, 0x7e, 0x0a, 0xf3, 0x94, 0xcc,
+	0x79, 0x15, 0x73, 0x82, 0x27, 0x39, 0xfd, 0x5c, 0x53, 0x4c, 0xf9, 0xc2, 0x2f, 0x81, 0x51, 0x4e,
+	0x61, 0xee, 0x95, 0x15, 0x70, 0x30, 0x1f, 0x6b, 0xbb, 0xb7, 0x6b, 0xdf, 0xb8, 0xbd, 0x8b, 0x69,
+	0x42, 0x78, 0x3c, 0x1d, 0x1e, 0xa7, 0xd2, 0x17, 0xc9, 0x47, 0xbe, 0x0a, 0x14, 0x61, 0xe8, 0x64,
+	0x00, 0x59, 0x4e, 0x7c, 0x19, 0x25, 0xf5, 0xb9, 0xcf, 0x69, 0x41, 0x18, 0x8f, 0x8b, 0x52, 0x1b,
+	0xec, 0x7d, 0x03, 0xae, 0xab, 0x78, 0xdb, 0xc2, 0xf0, 0x7e, 0x06, 0x19, 0x28, 0xb0, 0xf8, 0x53,
+	0x59, 0xf7, 0xa6, 0x8b, 0x0e, 0xdf, 0xe8, 0x5e, 0xcd, 0x13, 0xd4, 0x8f, 0x31, 0xae, 0x08, 0x63,
+	0x96, 0x31, 0x32, 0xc6, 0x83, 0xc0, 0x5c, 0x37, 0xce, 0xd1, 0x22, 0x2e, 0xf2, 0x57, 0xae, 0x16,
+	0xdc, 0xb0, 0xb5, 0x98, 0x4f, 0x51, 0xbf, 0x04, 0xc8, 0x23, 0x8a, 0xad, 0x5b, 0x23, 0x63, 0x7c,
+	0xb0, 0xeb, 0xd6, 0x82, 0x1b, 0xf6, 0xc4, 0xdf, 0x6b, 0x6c, 0x3e, 0x42, 0x28, 0x87, 0x2f, 0xa4,
+	0x8a, 0x38, 0x4d, 0x67, 0x56, 0x77, 0x64, 0x8c, 0xbb, 0xe1, 0x40, 0x66, 0xce, 0x68, 0x3a, 0x13,
+	0x72, 0x5d, 0x96, 0xad, 0x7c, 0xa0, 0x64, 0x99, 0x91, 0xf2, 0x5b, 0x34, 0xf8, 0x04, 0x74, 0x1e,
+	0x89, 0x99, 0xad, 0xdb, 0x23, 0x63, 0x7c, 0xe7, 0xd9, 0xd0, 0x53, 0xf3, 0x7a, 0xed, 0xbc, 0xde,
+	0x59, 0xbb, 0x90, 0xe0, 0xe1, 0x55, 0xe3, 0x74, 0xd6, 0x8d, 0x73, 0x4f, 0x35, 0xb3, 0x79, 0xea,
+	0x5e, 0xfe, 0x72, 0x8c, 0xf0, 0x50, 0xc4, 0xc2, 0x6c, 0x7e, 0x47, 0x77, 0xcf, 0x2b, 0x42, 0xbe,
+	0x91, 0xa8, 0xdd, 0x95, 0xd5, 0x93, 0xf0, 0xe3, 0x7f, 0xe0, 0xa7, 0xda, 0x10, 0xbc, 0x14, 0xec,
+	0x3f, 0x8d, 0x63, 0xb6, 0x4f, 0x4e, 0xa0, 0xa0, 0x9c, 0x14, 0x25, 0x5f, 0xac, 0x1b, 0xe7, 0x81,
+	0xaa, 0xb8, 0x47, 0x75, 0x7f, 0x88, 0xba, 0x47, 0x2a, 0xdb, 0x92, 0xcc, 0x0f, 0x68, 0xb0, 0xb9,
+	0x00, 0xab, 0x2f, 0xf7, 0x1d, 0x08, 0xf8, 0x4d, 0xe3, 0x3c, 0xc9, 0x28, 0xff, 0x58, 0x27, 0x5e,
+	0x0a, 0x85, 0xbe, 0x02, 0xfd, 0x99, 0x30, 0x3c, 0xf3, 0xf9, 0xa2, 0x24, 0xcc, 0x3b, 0x25, 0xe9,
+	0x76, 0xc4, 0x0d, 0xc8, 0x0d, 0xb7, 0xd0, 0xe0, 0xfd, 0xd5, 0xd2, 0x36, 0xae, 0x97, 0xb6, 0xf1,
+	0x7b, 0x69, 0x1b, 0x97, 0x2b, 0xbb, 0x73, 0xbd, 0xb2, 0x3b, 0x3f, 0x57, 0x76, 0xe7, 0x5d, 0xb0,
+	0x53, 0x40, 0x9f, 0xe6, 0x24, 0x8f, 0x13, 0xd6, 0x06, 0xfe, 0xc5, 0xf4, 0x85, 0xff, 0xf5, 0x7f,
+	0xc7, 0x5d, 0x00, 0x26, 0x79, 0xd2, 0x93, 0xcb, 0x79, 0xfe, 0x37, 0x00, 0x00, 0xff, 0xff, 0xd3,
+	0x13, 0x7a, 0xe7, 0x0b, 0x03, 0x00, 0x00,
 }
 
 func (m *Position) Marshal() (dAtA []byte, err error) {
@@ -127,7 +192,45 @@ func (m *Position) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i = encodeVarintPosition(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0xa
+	dAtA[i] = 0x3a
+	n1, err1 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.FreezeDuration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.FreezeDuration):])
+	if err1 != nil {
+		return 0, err1
+	}
+	i -= n1
+	i = encodeVarintPosition(dAtA, i, uint64(n1))
+	i--
+	dAtA[i] = 0x32
+	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.JoinTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.JoinTime):])
+	if err2 != nil {
+		return 0, err2
+	}
+	i -= n2
+	i = encodeVarintPosition(dAtA, i, uint64(n2))
+	i--
+	dAtA[i] = 0x2a
+	if m.UpperTick != 0 {
+		i = encodeVarintPosition(dAtA, i, uint64(m.UpperTick))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.LowerTick != 0 {
+		i = encodeVarintPosition(dAtA, i, uint64(m.LowerTick))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.PoolId != 0 {
+		i = encodeVarintPosition(dAtA, i, uint64(m.PoolId))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Address) > 0 {
+		i -= len(m.Address)
+		copy(dAtA[i:], m.Address)
+		i = encodeVarintPosition(dAtA, i, uint64(len(m.Address)))
+		i--
+		dAtA[i] = 0xa
+	}
 	return len(dAtA) - i, nil
 }
 
@@ -148,6 +251,23 @@ func (m *Position) Size() (n int) {
 	}
 	var l int
 	_ = l
+	l = len(m.Address)
+	if l > 0 {
+		n += 1 + l + sovPosition(uint64(l))
+	}
+	if m.PoolId != 0 {
+		n += 1 + sovPosition(uint64(m.PoolId))
+	}
+	if m.LowerTick != 0 {
+		n += 1 + sovPosition(uint64(m.LowerTick))
+	}
+	if m.UpperTick != 0 {
+		n += 1 + sovPosition(uint64(m.UpperTick))
+	}
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.JoinTime)
+	n += 1 + l + sovPosition(uint64(l))
+	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.FreezeDuration)
+	n += 1 + l + sovPosition(uint64(l))
 	l = m.Liquidity.Size()
 	n += 1 + l + sovPosition(uint64(l))
 	return n
@@ -189,6 +309,161 @@ func (m *Position) Unmarshal(dAtA []byte) error {
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPosition
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthPosition
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPosition
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Address = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
+			}
+			m.PoolId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPosition
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.PoolId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LowerTick", wireType)
+			}
+			m.LowerTick = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPosition
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.LowerTick |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UpperTick", wireType)
+			}
+			m.UpperTick = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPosition
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.UpperTick |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field JoinTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPosition
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPosition
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPosition
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.JoinTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FreezeDuration", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPosition
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPosition
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPosition
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.FreezeDuration, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 7:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Liquidity", wireType)
 			}
diff --git a/x/concentrated-liquidity/position.go b/x/concentrated-liquidity/position.go
index f6ed1f2d5..10ac8a120 100644
--- a/x/concentrated-liquidity/position.go
+++ b/x/concentrated-liquidity/position.go
@@ -13,7 +13,8 @@ import (
 
 var emptyOptions = &accum.Options{}
 
-// getOrInitPosition retrieves the position for the given tick range. If it doesn't exist, it returns an initialized position with zero liquidity.
+// getOrInitPosition retrieves the position's liquidity for the given tick range.
+// If it doesn't exist, it returns zero.
 func (k Keeper) getOrInitPosition(
 	ctx sdk.Context,
 	poolId uint64,
@@ -21,18 +22,18 @@ func (k Keeper) getOrInitPosition(
 	lowerTick, upperTick int64,
 	joinTime time.Time,
 	freezeDuration time.Duration,
-) (*model.Position, error) {
+) (sdk.Dec, error) {
 	if !k.poolExists(ctx, poolId) {
-		return nil, types.PoolNotFoundError{PoolId: poolId}
+		return sdk.Dec{}, types.PoolNotFoundError{PoolId: poolId}
 	}
 	if k.hasFullPosition(ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration) {
-		position, err := k.GetPosition(ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration)
+		positionLiquidity, err := k.GetPositionLiquidity(ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration)
 		if err != nil {
-			return nil, err
+			return sdk.Dec{}, err
 		}
-		return position, nil
+		return positionLiquidity, nil
 	}
-	return &model.Position{Liquidity: sdk.ZeroDec()}, nil
+	return sdk.ZeroDec(), nil
 }
 
 // initOrUpdatePosition checks to see if the specified owner has an existing position at the given tick range.
@@ -48,30 +49,24 @@ func (k Keeper) initOrUpdatePosition(
 	joinTime time.Time,
 	freezeDuration time.Duration,
 ) (err error) {
-	position, err := k.getOrInitPosition(ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration)
+	liquidity, err := k.getOrInitPosition(ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration)
 	if err != nil {
 		return err
 	}
 
-	liquidityBefore := position.Liquidity
-
 	// note that liquidityIn can be either positive or negative.
 	// If negative, this would work as a subtraction from liquidityBefore
-	liquidityAfter := liquidityBefore.Add(liquidityDelta)
-	if liquidityAfter.IsNegative() {
-		return types.NegativeLiquidityError{Liquidity: liquidityAfter}
+	liquidity = liquidity.Add(liquidityDelta)
+	if liquidity.IsNegative() {
+		return types.NegativeLiquidityError{Liquidity: liquidity}
 	}
 
-	position.Liquidity = liquidityAfter
-
-	// TODO: consider deleting position if liquidity becomes zero
-
-	err = k.initOrUpdatePositionUptime(ctx, poolId, position, owner, lowerTick, upperTick, liquidityDelta, joinTime, freezeDuration)
+	err = k.initOrUpdatePositionUptime(ctx, poolId, liquidity, owner, lowerTick, upperTick, liquidityDelta, joinTime, freezeDuration)
 	if err != nil {
 		return err
 	}
 
-	k.setPosition(ctx, poolId, owner, lowerTick, upperTick, position, joinTime, freezeDuration)
+	k.setPosition(ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration, liquidity)
 	return nil
 }
 
@@ -81,26 +76,26 @@ func (k Keeper) hasFullPosition(ctx sdk.Context, poolId uint64, owner sdk.AccAdd
 	return store.Has(key)
 }
 
-// GetPosition checks if a position exists at the provided upper and lower ticks and freezeDuration time for the given owner. Returns position if found.
-func (k Keeper) GetPosition(ctx sdk.Context, poolId uint64, owner sdk.AccAddress, lowerTick, upperTick int64, joinTime time.Time, freezeDuration time.Duration) (*model.Position, error) {
+// GetPositionLiquidity checks if a position exists at the provided upper and lower ticks and freezeDuration time for the given owner. Returns position if found.
+func (k Keeper) GetPositionLiquidity(ctx sdk.Context, poolId uint64, owner sdk.AccAddress, lowerTick, upperTick int64, joinTime time.Time, freezeDuration time.Duration) (sdk.Dec, error) {
 	store := ctx.KVStore(k.storeKey)
-	positionStruct := &model.Position{}
 	key := types.KeyFullPosition(poolId, owner, lowerTick, upperTick, joinTime, freezeDuration)
 
-	found, err := osmoutils.Get(store, key, positionStruct)
+	liquidityStruct := &sdk.DecProto{}
+	found, err := osmoutils.Get(store, key, liquidityStruct)
 	if err != nil {
-		return nil, err
+		return sdk.Dec{}, err
 	}
 
 	if !found {
-		return nil, types.PositionNotFoundError{PoolId: poolId, LowerTick: lowerTick, UpperTick: upperTick, JoinTime: joinTime, FreezeDuration: freezeDuration}
+		return sdk.Dec{}, types.PositionNotFoundError{PoolId: poolId, LowerTick: lowerTick, UpperTick: upperTick, JoinTime: joinTime, FreezeDuration: freezeDuration}
 	}
 
-	return positionStruct, nil
+	return liquidityStruct.Dec, nil
 }
 
 // GetUserPositions gets all the existing user positions, with the option to filter by a specific pool.
-func (k Keeper) GetUserPositions(ctx sdk.Context, addr sdk.AccAddress, poolId uint64) ([]types.FullPositionByOwnerResult, error) {
+func (k Keeper) GetUserPositions(ctx sdk.Context, addr sdk.AccAddress, poolId uint64) ([]model.Position, error) {
 	if poolId == 0 {
 		return osmoutils.GatherValuesFromStorePrefixWithKeyParser(ctx.KVStore(k.storeKey), types.KeyUserPositions(addr), ParseFullPositionFromBytes)
 	} else {
@@ -114,13 +109,13 @@ func (k Keeper) setPosition(ctx sdk.Context,
 	poolId uint64,
 	owner sdk.AccAddress,
 	lowerTick, upperTick int64,
-	position *model.Position,
 	joinTime time.Time,
 	freezeDuration time.Duration,
+	liquidity sdk.Dec,
 ) {
 	store := ctx.KVStore(k.storeKey)
 	key := types.KeyFullPosition(poolId, owner, lowerTick, upperTick, joinTime, freezeDuration)
-	osmoutils.MustSet(store, key, position)
+	osmoutils.MustSetDec(store, key, liquidity)
 }
 
 func (k Keeper) deletePosition(ctx sdk.Context,
diff --git a/x/concentrated-liquidity/store.go b/x/concentrated-liquidity/store.go
index 9950fa93d..d1a2581b6 100644
--- a/x/concentrated-liquidity/store.go
+++ b/x/concentrated-liquidity/store.go
@@ -16,20 +16,26 @@ import (
 )
 
 // getAllPositionsWithVaryingFreezeTimes returns multiple positions indexed by poolId, addr, lowerTick, upperTick with varying freeze times.
-func (k Keeper) getAllPositionsWithVaryingFreezeTimes(ctx sdk.Context, poolId uint64, addr sdk.AccAddress, lowerTick, upperTick int64) ([]model.Position, error) {
-	return osmoutils.GatherValuesFromStorePrefix(ctx.KVStore(k.storeKey), types.KeyPosition(poolId, addr, lowerTick, upperTick), ParsePositionFromBz)
+func (k Keeper) getAllPositionsWithVaryingFreezeTimes(ctx sdk.Context, poolId uint64, addr sdk.AccAddress, lowerTick, upperTick int64) ([]sdk.Dec, error) {
+	return osmoutils.GatherValuesFromStorePrefix(ctx.KVStore(k.storeKey), types.KeyPosition(poolId, addr, lowerTick, upperTick), ParseLiquidityFromBz)
 }
 
-// ParsePositionFromBz parses a position from a byte array.
-// Returns a struct containing the liquidity associated with the position.
+// getAllPositions gets all CL positions for export genesis.
+// nolint: unused
+func (k Keeper) getAllPositions(ctx sdk.Context) ([]model.Position, error) {
+	return osmoutils.GatherValuesFromStorePrefixWithKeyParser(ctx.KVStore(k.storeKey), types.PositionPrefix, ParseFullPositionFromBytes)
+}
+
+// ParseLiquidityFromBz parses and returns a position's liquidity from a byte array.
 // Returns an error if the byte array is empty.
 // Returns an error if fails to parse.
-func ParsePositionFromBz(bz []byte) (position model.Position, err error) {
+func ParseLiquidityFromBz(bz []byte) (sdk.Dec, error) {
 	if len(bz) == 0 {
-		return model.Position{}, errors.New("position not found")
+		return sdk.Dec{}, errors.New("position not found")
 	}
-	err = proto.Unmarshal(bz, &position)
-	return position, err
+	liquidityStruct := &sdk.DecProto{}
+	err := proto.Unmarshal(bz, liquidityStruct)
+	return liquidityStruct.Dec, err
 }
 
 // ParseFullPositionFromBytes parses a full position from key and value bytes.
@@ -37,12 +43,12 @@ func ParsePositionFromBz(bz []byte) (position model.Position, err error) {
 // associated with the position.
 // Returns an error if the key or value is not found.
 // Returns an error if fails to parse either.
-func ParseFullPositionFromBytes(key, value []byte) (types.FullPositionByOwnerResult, error) {
+func ParseFullPositionFromBytes(key, value []byte) (model.Position, error) {
 	if len(key) == 0 {
-		return types.FullPositionByOwnerResult{}, errors.New("key not found")
+		return model.Position{}, errors.New("key not found")
 	}
 	if len(value) == 0 {
-		return types.FullPositionByOwnerResult{}, fmt.Errorf("value not found for key (%s)", value)
+		return model.Position{}, fmt.Errorf("value not found for key (%s)", value)
 	}
 
 	keyStr := string(key)
@@ -52,61 +58,68 @@ func ParseFullPositionFromBytes(key, value []byte) (types.FullPositionByOwnerRes
 	fullPositionKeyComponents := strings.Split(keyStr, types.KeySeparator)
 
 	if len(fullPositionKeyComponents) < 6 {
-		return types.FullPositionByOwnerResult{}, fmt.Errorf(`invalid position key (%s), must have at least 6 components:
+		return model.Position{}, fmt.Errorf(`invalid position key (%s), must have at least 6 components:
 	(position prefix, owner address, pool id, lower tick, upper tick, join time, freeze duration),
 	all separated by (%s)`, keyStr, types.KeySeparator)
 	}
 
-	// We only care about the last 5 components, which are:
+	// We only care about the last 6 components, which are:
+	// - owner address
 	// - pool id
 	// - lower tick
 	// - upper tick
 	// - join time
 	// - freeze duration
-	relevantPositionKeyComponents := fullPositionKeyComponents[len(fullPositionKeyComponents)-5:]
+	relevantPositionKeyComponents := fullPositionKeyComponents[len(fullPositionKeyComponents)-6:]
 
 	positionPrefix := fullPositionKeyComponents[0]
 	if positionPrefix != string(types.PositionPrefix) {
-		return types.FullPositionByOwnerResult{}, fmt.Errorf("Wrong position prefix, got: %v, required %v", []byte(positionPrefix), types.PositionPrefix)
+		return model.Position{}, fmt.Errorf("Wrong position prefix, got: %v, required %v", []byte(positionPrefix), types.PositionPrefix)
+	}
+
+	if err := sdk.VerifyAddressFormat([]byte(relevantPositionKeyComponents[0])); err != nil {
+		return model.Position{}, err
 	}
+	address := sdk.AccAddress(relevantPositionKeyComponents[0])
 
-	poolId, err := strconv.ParseUint(relevantPositionKeyComponents[0], 10, 64)
+	poolId, err := strconv.ParseUint(relevantPositionKeyComponents[1], 10, 64)
 	if err != nil {
-		return types.FullPositionByOwnerResult{}, err
+		return model.Position{}, err
 	}
 
-	lowerTick, err := strconv.ParseInt(relevantPositionKeyComponents[1], 10, 64)
+	lowerTick, err := strconv.ParseInt(relevantPositionKeyComponents[2], 10, 64)
 	if err != nil {
-		return types.FullPositionByOwnerResult{}, err
+		return model.Position{}, err
 	}
 
-	upperTick, err := strconv.ParseInt(relevantPositionKeyComponents[2], 10, 64)
+	upperTick, err := strconv.ParseInt(relevantPositionKeyComponents[3], 10, 64)
 	if err != nil {
-		return types.FullPositionByOwnerResult{}, err
+		return model.Position{}, err
 	}
 
-	joinTime, err := osmoutils.ParseTimeString(relevantPositionKeyComponents[3])
+	joinTime, err := osmoutils.ParseTimeString(relevantPositionKeyComponents[4])
 	if err != nil {
-		return types.FullPositionByOwnerResult{}, err
+		return model.Position{}, err
 	}
 
-	freezeDuration, err := strconv.ParseUint(relevantPositionKeyComponents[4], 10, 64)
+	freezeDuration, err := strconv.ParseUint(relevantPositionKeyComponents[5], 10, 64)
 	if err != nil {
-		return types.FullPositionByOwnerResult{}, err
+		return model.Position{}, err
 	}
 
-	positionValue, err := ParsePositionFromBz(value)
+	liquidity, err := ParseLiquidityFromBz(value)
 	if err != nil {
-		return types.FullPositionByOwnerResult{}, err
+		return model.Position{}, err
 	}
 
-	return types.FullPositionByOwnerResult{
+	return model.Position{
+		Address:        address.String(),
 		PoolId:         poolId,
 		LowerTick:      lowerTick,
 		UpperTick:      upperTick,
+		Liquidity:      liquidity,
 		JoinTime:       joinTime,
 		FreezeDuration: time.Duration(freezeDuration),
-		Liquidity:      positionValue.Liquidity,
 	}, nil
 }
 
diff --git a/x/concentrated-liquidity/tick.go b/x/concentrated-liquidity/tick.go
index bdc09b9e4..ababa0220 100644
--- a/x/concentrated-liquidity/tick.go
+++ b/x/concentrated-liquidity/tick.go
@@ -8,7 +8,8 @@ import (
 	"github.com/osmosis-labs/osmosis/osmoutils"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/internal/math"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/model"
-	types "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
+	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
+	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types/query"
 )
 
 // initOrUpdateTick retrieves the tickInfo from the specified tickIndex and updates both the liquidityNet and LiquidityGross.
@@ -179,9 +180,9 @@ func GetMinAndMaxTicksFromExponentAtPriceOne(exponentAtPriceOne sdk.Int) (minTic
 
 // GetPerTickLiquidityDepthFromRange uses the given lower tick and upper tick, iterates over ticks, creates and returns LiquidityDepth array.
 // LiquidityNet from the tick is used to indicate liquidity depths.
-func (k Keeper) GetPerTickLiquidityDepthFromRange(ctx sdk.Context, poolId uint64, lowerTick, upperTick int64) ([]types.LiquidityDepth, error) {
+func (k Keeper) GetPerTickLiquidityDepthFromRange(ctx sdk.Context, poolId uint64, lowerTick, upperTick int64) ([]query.LiquidityDepth, error) {
 	if !k.poolExists(ctx, poolId) {
-		return []types.LiquidityDepth{}, types.PoolNotFoundError{PoolId: poolId}
+		return []query.LiquidityDepth{}, types.PoolNotFoundError{PoolId: poolId}
 	}
 	store := ctx.KVStore(k.storeKey)
 	prefixBz := types.KeyTickPrefix(poolId)
@@ -191,27 +192,27 @@ func (k Keeper) GetPerTickLiquidityDepthFromRange(ctx sdk.Context, poolId uint64
 	upperKey := types.TickIndexToBytes(upperTick)
 	iterator := prefixStore.Iterator(lowerKey, storetypes.InclusiveEndBytes(upperKey))
 
-	liquidityDepths := []types.LiquidityDepth{}
+	liquidityDepths := []query.LiquidityDepth{}
 
 	defer iterator.Close()
 	for ; iterator.Valid(); iterator.Next() {
 		tickIndex, err := types.TickIndexFromBytes(iterator.Key())
 		if err != nil {
-			return []types.LiquidityDepth{}, err
+			return []query.LiquidityDepth{}, err
 		}
 
 		keyTick := types.KeyTick(poolId, tickIndex)
 		tickStruct := model.TickInfo{}
 		found, err := osmoutils.Get(store, keyTick, &tickStruct)
 		if err != nil {
-			return []types.LiquidityDepth{}, err
+			return []query.LiquidityDepth{}, err
 		}
 
 		if !found {
 			continue
 		}
 
-		liquidityDepth := types.LiquidityDepth{
+		liquidityDepth := query.LiquidityDepth{
 			TickIndex:    sdk.NewInt(tickIndex),
 			LiquidityNet: tickStruct.LiquidityNet,
 		}
diff --git a/x/concentrated-liquidity/types/keys.go b/x/concentrated-liquidity/types/keys.go
index 3226f51a6..b10cee2d9 100644
--- a/x/concentrated-liquidity/types/keys.go
+++ b/x/concentrated-liquidity/types/keys.go
@@ -5,7 +5,6 @@ import (
 	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/types/address"
 
 	"github.com/osmosis-labs/osmosis/osmoutils"
 )
@@ -70,24 +69,20 @@ func KeyTickPrefix(poolId uint64) []byte {
 // KeyFullPosition uses pool Id, owner, lower tick, upper tick, joinTime and freezeDuration for keys
 func KeyFullPosition(poolId uint64, addr sdk.AccAddress, lowerTick, upperTick int64, joinTime time.Time, freezeDuration time.Duration) []byte {
 	joinTimeKey := osmoutils.FormatTimeString(joinTime)
-	addrKey := address.MustLengthPrefix(addr.Bytes())
-	return []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%d%s%s%s%d", PositionPrefix, KeySeparator, addrKey, KeySeparator, poolId, KeySeparator, lowerTick, KeySeparator, upperTick, KeySeparator, joinTimeKey, KeySeparator, uint64(freezeDuration)))
+	return []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%d%s%s%s%d", PositionPrefix, KeySeparator, addr.Bytes(), KeySeparator, poolId, KeySeparator, lowerTick, KeySeparator, upperTick, KeySeparator, joinTimeKey, KeySeparator, uint64(freezeDuration)))
 }
 
 // KeyPosition uses pool Id, owner, lower tick and upper tick for keys
 func KeyPosition(poolId uint64, addr sdk.AccAddress, lowerTick, upperTick int64) []byte {
-	addrKey := address.MustLengthPrefix(addr.Bytes())
-	return []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%d", PositionPrefix, KeySeparator, addrKey, KeySeparator, poolId, KeySeparator, lowerTick, KeySeparator, upperTick))
+	return []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%d", PositionPrefix, KeySeparator, addr.Bytes(), KeySeparator, poolId, KeySeparator, lowerTick, KeySeparator, upperTick))
 }
 
 func KeyAddressAndPoolId(addr sdk.AccAddress, poolId uint64) []byte {
-	addrKey := address.MustLengthPrefix(addr.Bytes())
-	return []byte(fmt.Sprintf("%s%s%s%s%d", PositionPrefix, KeySeparator, addrKey, KeySeparator, poolId))
+	return []byte(fmt.Sprintf("%s%s%s%s%d", PositionPrefix, KeySeparator, addr.Bytes(), KeySeparator, poolId))
 }
 
 func KeyUserPositions(addr sdk.AccAddress) []byte {
-	addrKey := address.MustLengthPrefix(addr.Bytes())
-	return []byte(fmt.Sprintf("%s%s%s", PositionPrefix, KeySeparator, addrKey))
+	return []byte(fmt.Sprintf("%s%s%s", PositionPrefix, KeySeparator, addr.Bytes()))
 }
 
 func KeyPool(poolId uint64) []byte {
diff --git a/x/concentrated-liquidity/types/query.pb.go b/x/concentrated-liquidity/types/query/query.pb.go
similarity index 80%
rename from x/concentrated-liquidity/types/query.pb.go
rename to x/concentrated-liquidity/types/query/query.pb.go
index c9fff7431..208e7c107 100644
--- a/x/concentrated-liquidity/types/query.pb.go
+++ b/x/concentrated-liquidity/types/query/query.pb.go
@@ -1,13 +1,13 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: osmosis/concentrated-liquidity/pool-model/query.proto
 
-package types
+package query
 
 import (
 	context "context"
 	fmt "fmt"
 	_ "github.com/cosmos/cosmos-proto"
-	types1 "github.com/cosmos/cosmos-sdk/codec/types"
+	types "github.com/cosmos/cosmos-sdk/codec/types"
 	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
 	types2 "github.com/cosmos/cosmos-sdk/types"
 	query "github.com/cosmos/cosmos-sdk/types/query"
@@ -15,7 +15,8 @@ import (
 	grpc1 "github.com/gogo/protobuf/grpc"
 	proto "github.com/gogo/protobuf/proto"
 	_ "github.com/gogo/protobuf/types"
-	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
+	model "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/model"
+	types1 "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
 	_ "google.golang.org/genproto/googleapis/api/annotations"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
@@ -23,14 +24,12 @@ import (
 	io "io"
 	math "math"
 	math_bits "math/bits"
-	time "time"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
-var _ = time.Kitchen
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the proto package it is being compiled against.
@@ -92,7 +91,7 @@ func (m *QueryUserPositionsRequest) GetPoolId() uint64 {
 }
 
 type QueryUserPositionsResponse struct {
-	Positions []FullPositionByOwnerResult `protobuf:"bytes,1,rep,name=positions,proto3" json:"positions"`
+	Positions []model.Position `protobuf:"bytes,1,rep,name=positions,proto3" json:"positions"`
 }
 
 func (m *QueryUserPositionsResponse) Reset()         { *m = QueryUserPositionsResponse{} }
@@ -128,90 +127,13 @@ func (m *QueryUserPositionsResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryUserPositionsResponse proto.InternalMessageInfo
 
-func (m *QueryUserPositionsResponse) GetPositions() []FullPositionByOwnerResult {
+func (m *QueryUserPositionsResponse) GetPositions() []model.Position {
 	if m != nil {
 		return m.Positions
 	}
 	return nil
 }
 
-type FullPositionByOwnerResult struct {
-	PoolId         uint64                                 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
-	LowerTick      int64                                  `protobuf:"varint,2,opt,name=lower_tick,json=lowerTick,proto3" json:"lower_tick,omitempty"`
-	UpperTick      int64                                  `protobuf:"varint,3,opt,name=upper_tick,json=upperTick,proto3" json:"upper_tick,omitempty"`
-	JoinTime       time.Time                              `protobuf:"bytes,4,opt,name=join_time,json=joinTime,proto3,stdtime" json:"join_time" yaml:"join_time"`
-	FreezeDuration time.Duration                          `protobuf:"bytes,5,opt,name=freeze_duration,json=freezeDuration,proto3,stdduration" json:"duration,omitempty" yaml:"freeze_duration"`
-	Liquidity      github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=liquidity,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidity" yaml:"liquidity"`
-}
-
-func (m *FullPositionByOwnerResult) Reset()         { *m = FullPositionByOwnerResult{} }
-func (m *FullPositionByOwnerResult) String() string { return proto.CompactTextString(m) }
-func (*FullPositionByOwnerResult) ProtoMessage()    {}
-func (*FullPositionByOwnerResult) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ce34c1e206115391, []int{2}
-}
-func (m *FullPositionByOwnerResult) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *FullPositionByOwnerResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_FullPositionByOwnerResult.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *FullPositionByOwnerResult) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FullPositionByOwnerResult.Merge(m, src)
-}
-func (m *FullPositionByOwnerResult) XXX_Size() int {
-	return m.Size()
-}
-func (m *FullPositionByOwnerResult) XXX_DiscardUnknown() {
-	xxx_messageInfo_FullPositionByOwnerResult.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FullPositionByOwnerResult proto.InternalMessageInfo
-
-func (m *FullPositionByOwnerResult) GetPoolId() uint64 {
-	if m != nil {
-		return m.PoolId
-	}
-	return 0
-}
-
-func (m *FullPositionByOwnerResult) GetLowerTick() int64 {
-	if m != nil {
-		return m.LowerTick
-	}
-	return 0
-}
-
-func (m *FullPositionByOwnerResult) GetUpperTick() int64 {
-	if m != nil {
-		return m.UpperTick
-	}
-	return 0
-}
-
-func (m *FullPositionByOwnerResult) GetJoinTime() time.Time {
-	if m != nil {
-		return m.JoinTime
-	}
-	return time.Time{}
-}
-
-func (m *FullPositionByOwnerResult) GetFreezeDuration() time.Duration {
-	if m != nil {
-		return m.FreezeDuration
-	}
-	return 0
-}
-
 // =============================== Pool
 type QueryPoolRequest struct {
 	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
@@ -221,7 +143,7 @@ func (m *QueryPoolRequest) Reset()         { *m = QueryPoolRequest{} }
 func (m *QueryPoolRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPoolRequest) ProtoMessage()    {}
 func (*QueryPoolRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ce34c1e206115391, []int{3}
+	return fileDescriptor_ce34c1e206115391, []int{2}
 }
 func (m *QueryPoolRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -258,14 +180,14 @@ func (m *QueryPoolRequest) GetPoolId() uint64 {
 }
 
 type QueryPoolResponse struct {
-	Pool *types1.Any `protobuf:"bytes,1,opt,name=pool,proto3" json:"pool,omitempty"`
+	Pool *types.Any `protobuf:"bytes,1,opt,name=pool,proto3" json:"pool,omitempty"`
 }
 
 func (m *QueryPoolResponse) Reset()         { *m = QueryPoolResponse{} }
 func (m *QueryPoolResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPoolResponse) ProtoMessage()    {}
 func (*QueryPoolResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ce34c1e206115391, []int{4}
+	return fileDescriptor_ce34c1e206115391, []int{3}
 }
 func (m *QueryPoolResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -294,7 +216,7 @@ func (m *QueryPoolResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryPoolResponse proto.InternalMessageInfo
 
-func (m *QueryPoolResponse) GetPool() *types1.Any {
+func (m *QueryPoolResponse) GetPool() *types.Any {
 	if m != nil {
 		return m.Pool
 	}
@@ -311,7 +233,7 @@ func (m *QueryPoolsRequest) Reset()         { *m = QueryPoolsRequest{} }
 func (m *QueryPoolsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPoolsRequest) ProtoMessage()    {}
 func (*QueryPoolsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ce34c1e206115391, []int{5}
+	return fileDescriptor_ce34c1e206115391, []int{4}
 }
 func (m *QueryPoolsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -348,7 +270,7 @@ func (m *QueryPoolsRequest) GetPagination() *query.PageRequest {
 }
 
 type QueryPoolsResponse struct {
-	Pools []*types1.Any `protobuf:"bytes,1,rep,name=pools,proto3" json:"pools,omitempty"`
+	Pools []*types.Any `protobuf:"bytes,1,rep,name=pools,proto3" json:"pools,omitempty"`
 	// pagination defines the pagination in the response.
 	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
@@ -357,7 +279,7 @@ func (m *QueryPoolsResponse) Reset()         { *m = QueryPoolsResponse{} }
 func (m *QueryPoolsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPoolsResponse) ProtoMessage()    {}
 func (*QueryPoolsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ce34c1e206115391, []int{6}
+	return fileDescriptor_ce34c1e206115391, []int{5}
 }
 func (m *QueryPoolsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -386,7 +308,7 @@ func (m *QueryPoolsResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryPoolsResponse proto.InternalMessageInfo
 
-func (m *QueryPoolsResponse) GetPools() []*types1.Any {
+func (m *QueryPoolsResponse) GetPools() []*types.Any {
 	if m != nil {
 		return m.Pools
 	}
@@ -408,7 +330,7 @@ func (m *QueryParamsRequest) Reset()         { *m = QueryParamsRequest{} }
 func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryParamsRequest) ProtoMessage()    {}
 func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ce34c1e206115391, []int{7}
+	return fileDescriptor_ce34c1e206115391, []int{6}
 }
 func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -438,14 +360,14 @@ func (m *QueryParamsRequest) XXX_DiscardUnknown() {
 var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo
 
 type QueryParamsResponse struct {
-	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
+	Params types1.Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
 }
 
 func (m *QueryParamsResponse) Reset()         { *m = QueryParamsResponse{} }
 func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryParamsResponse) ProtoMessage()    {}
 func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ce34c1e206115391, []int{8}
+	return fileDescriptor_ce34c1e206115391, []int{7}
 }
 func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -474,11 +396,11 @@ func (m *QueryParamsResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo
 
-func (m *QueryParamsResponse) GetParams() Params {
+func (m *QueryParamsResponse) GetParams() types1.Params {
 	if m != nil {
 		return m.Params
 	}
-	return Params{}
+	return types1.Params{}
 }
 
 // =============================== LiquidityDepthsForRange
@@ -492,7 +414,7 @@ func (m *QueryLiquidityDepthsForRangeRequest) Reset()         { *m = QueryLiquid
 func (m *QueryLiquidityDepthsForRangeRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryLiquidityDepthsForRangeRequest) ProtoMessage()    {}
 func (*QueryLiquidityDepthsForRangeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ce34c1e206115391, []int{9}
+	return fileDescriptor_ce34c1e206115391, []int{8}
 }
 func (m *QueryLiquidityDepthsForRangeRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -536,7 +458,7 @@ func (m *QueryLiquidityDepthsForRangeResponse) Reset()         { *m = QueryLiqui
 func (m *QueryLiquidityDepthsForRangeResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryLiquidityDepthsForRangeResponse) ProtoMessage()    {}
 func (*QueryLiquidityDepthsForRangeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ce34c1e206115391, []int{10}
+	return fileDescriptor_ce34c1e206115391, []int{9}
 }
 func (m *QueryLiquidityDepthsForRangeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -581,7 +503,7 @@ func (m *LiquidityDepth) Reset()         { *m = LiquidityDepth{} }
 func (m *LiquidityDepth) String() string { return proto.CompactTextString(m) }
 func (*LiquidityDepth) ProtoMessage()    {}
 func (*LiquidityDepth) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ce34c1e206115391, []int{11}
+	return fileDescriptor_ce34c1e206115391, []int{10}
 }
 func (m *LiquidityDepth) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -622,7 +544,7 @@ func (m *QueryClaimableFeesRequest) Reset()         { *m = QueryClaimableFeesReq
 func (m *QueryClaimableFeesRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryClaimableFeesRequest) ProtoMessage()    {}
 func (*QueryClaimableFeesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ce34c1e206115391, []int{12}
+	return fileDescriptor_ce34c1e206115391, []int{11}
 }
 func (m *QueryClaimableFeesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -687,7 +609,7 @@ func (m *QueryClaimableFeesResponse) Reset()         { *m = QueryClaimableFeesRe
 func (m *QueryClaimableFeesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryClaimableFeesResponse) ProtoMessage()    {}
 func (*QueryClaimableFeesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ce34c1e206115391, []int{13}
+	return fileDescriptor_ce34c1e206115391, []int{12}
 }
 func (m *QueryClaimableFeesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -726,7 +648,6 @@ func (m *QueryClaimableFeesResponse) GetClaimableFees() []types2.Coin {
 func init() {
 	proto.RegisterType((*QueryUserPositionsRequest)(nil), "osmosis.concentratedliquidity.v1beta1.QueryUserPositionsRequest")
 	proto.RegisterType((*QueryUserPositionsResponse)(nil), "osmosis.concentratedliquidity.v1beta1.QueryUserPositionsResponse")
-	proto.RegisterType((*FullPositionByOwnerResult)(nil), "osmosis.concentratedliquidity.v1beta1.FullPositionByOwnerResult")
 	proto.RegisterType((*QueryPoolRequest)(nil), "osmosis.concentratedliquidity.v1beta1.QueryPoolRequest")
 	proto.RegisterType((*QueryPoolResponse)(nil), "osmosis.concentratedliquidity.v1beta1.QueryPoolResponse")
 	proto.RegisterType((*QueryPoolsRequest)(nil), "osmosis.concentratedliquidity.v1beta1.QueryPoolsRequest")
@@ -745,84 +666,74 @@ func init() {
 }
 
 var fileDescriptor_ce34c1e206115391 = []byte{
-	// 1225 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdf, 0x6f, 0xdb, 0x54,
-	0x14, 0xae, 0xdb, 0x34, 0x23, 0xb7, 0xb4, 0x6b, 0x2f, 0x1d, 0xa4, 0xd1, 0x96, 0x54, 0x17, 0x36,
-	0x0a, 0x6b, 0x6c, 0xb5, 0x6b, 0xa1, 0x54, 0xfc, 0x58, 0xdd, 0xaa, 0x50, 0x40, 0x50, 0xac, 0xed,
-	0x65, 0x4c, 0x32, 0x4e, 0x7c, 0x9b, 0x99, 0x3a, 0xbe, 0xae, 0xed, 0x74, 0x0b, 0xa3, 0x2f, 0xfb,
-	0x03, 0xd0, 0x24, 0xf6, 0x80, 0x78, 0xe5, 0x3f, 0x40, 0x08, 0x89, 0x07, 0xde, 0x27, 0x9e, 0x26,
-	0xf1, 0x32, 0x81, 0x94, 0xa1, 0x96, 0x27, 0x1e, 0xfb, 0x8e, 0x84, 0x7c, 0x7f, 0x38, 0x76, 0x92,
-	0x2e, 0x71, 0xc7, 0x53, 0xe2, 0x7b, 0xce, 0xf9, 0xce, 0x77, 0xee, 0xf9, 0xee, 0xb9, 0x36, 0x58,
-	0x26, 0x7e, 0x9d, 0xf8, 0x96, 0xaf, 0x54, 0x89, 0x53, 0xc5, 0x4e, 0xe0, 0x19, 0x01, 0x36, 0xcb,
-	0xb6, 0xb5, 0xd7, 0xb0, 0x4c, 0x2b, 0x68, 0x2a, 0x2e, 0x21, 0x76, 0xb9, 0x4e, 0x4c, 0x6c, 0x2b,
-	0x7b, 0x0d, 0xec, 0x35, 0x65, 0xd7, 0x23, 0x01, 0x81, 0x17, 0x79, 0x98, 0x1c, 0x0f, 0x8b, 0xa2,
-	0xe4, 0xfd, 0x85, 0x0a, 0x0e, 0x8c, 0x85, 0xc2, 0x74, 0x8d, 0xd4, 0x08, 0x8d, 0x50, 0xc2, 0x7f,
-	0x2c, 0xb8, 0x70, 0xb9, 0x5f, 0x4e, 0xc3, 0x33, 0xea, 0x3e, 0x77, 0x2e, 0x56, 0xa9, 0xb7, 0x52,
-	0x31, 0x7c, 0xac, 0x70, 0x5c, 0xa5, 0x4a, 0x2c, 0x87, 0xdb, 0x5f, 0x8f, 0xdb, 0x29, 0xc5, 0xc8,
-	0xcb, 0x35, 0x6a, 0x96, 0x63, 0x04, 0x16, 0x11, 0xbe, 0xe7, 0x6b, 0x84, 0xd4, 0x6c, 0xac, 0x18,
-	0xae, 0xa5, 0x18, 0x8e, 0x43, 0x02, 0x6a, 0x14, 0x99, 0x66, 0xb8, 0x95, 0x3e, 0x55, 0x1a, 0x3b,
-	0x8a, 0xe1, 0x34, 0x85, 0x89, 0x25, 0xd1, 0x59, 0x29, 0xec, 0x81, 0x9b, 0x4a, 0x9d, 0x51, 0x81,
-	0x55, 0xc7, 0x7e, 0x60, 0xd4, 0x5d, 0x51, 0x40, 0xa7, 0x83, 0xd9, 0xf0, 0x62, 0xa4, 0xd0, 0x3e,
-	0x98, 0xf9, 0x2c, 0xa4, 0x7d, 0xdd, 0xc7, 0xde, 0x36, 0xf1, 0x2d, 0x4a, 0x49, 0xc3, 0x7b, 0x0d,
-	0xec, 0x07, 0x70, 0x1e, 0x9c, 0x31, 0x4c, 0xd3, 0xc3, 0xbe, 0x9f, 0x97, 0x66, 0xa5, 0xb9, 0x9c,
-	0x0a, 0x8f, 0x5b, 0xa5, 0x89, 0xa6, 0x51, 0xb7, 0x57, 0x11, 0x37, 0x20, 0x4d, 0xb8, 0xc0, 0xcb,
-	0xe0, 0x4c, 0xd8, 0x2f, 0xdd, 0x32, 0xf3, 0xc3, 0xb3, 0xd2, 0x5c, 0x26, 0xee, 0xcd, 0x0d, 0x48,
-	0xcb, 0x86, 0xff, 0xb6, 0x4c, 0x74, 0x4f, 0x02, 0x85, 0x5e, 0x89, 0x7d, 0x97, 0x38, 0x3e, 0x86,
-	0x26, 0xc8, 0xb9, 0x62, 0x31, 0x2f, 0xcd, 0x8e, 0xcc, 0x8d, 0x2d, 0x5e, 0x95, 0x07, 0xea, 0xba,
-	0xbc, 0xd9, 0xb0, 0x6d, 0x01, 0xa8, 0x36, 0x3f, 0xbd, 0xed, 0x60, 0x4f, 0xc3, 0x7e, 0xc3, 0x0e,
-	0xd4, 0xcc, 0xc3, 0x56, 0x69, 0x48, 0x6b, 0x03, 0xa3, 0x5f, 0x47, 0xc0, 0xcc, 0x89, 0xee, 0xf1,
-	0x7a, 0xa4, 0x7e, 0xf5, 0xc0, 0x0b, 0x00, 0xd8, 0xe4, 0x36, 0xf6, 0xf4, 0xc0, 0xaa, 0xee, 0xd2,
-	0xfa, 0x47, 0xb4, 0x1c, 0x5d, 0xb9, 0x66, 0x55, 0x77, 0x43, 0x73, 0xc3, 0x75, 0x85, 0x79, 0x84,
-	0x99, 0xe9, 0x0a, 0x35, 0x5f, 0x07, 0xb9, 0x2f, 0x89, 0xe5, 0xe8, 0x61, 0xf7, 0xf2, 0x99, 0x59,
-	0x69, 0x6e, 0x6c, 0xb1, 0x20, 0xb3, 0xce, 0xc9, 0xa2, 0x73, 0xf2, 0x35, 0xd1, 0x5a, 0xf5, 0x7c,
-	0x58, 0xc8, 0x71, 0xab, 0x34, 0xc9, 0xc8, 0x44, 0xa1, 0xe8, 0xfe, 0x93, 0x92, 0xa4, 0x3d, 0x17,
-	0x3e, 0x87, 0xce, 0xf0, 0x6b, 0x70, 0x76, 0xc7, 0xc3, 0xf8, 0x2b, 0xac, 0x8b, 0xae, 0xe7, 0x47,
-	0x29, 0xf8, 0x4c, 0x17, 0xf8, 0x06, 0x77, 0x50, 0x57, 0x42, 0xec, 0x7f, 0x5a, 0x25, 0x28, 0x42,
-	0xe6, 0x49, 0xdd, 0x0a, 0x70, 0xdd, 0x0d, 0x9a, 0xc7, 0xad, 0xd2, 0x8b, 0x2c, 0x63, 0x07, 0x2a,
-	0xfa, 0x2e, 0xcc, 0x3b, 0xc1, 0x56, 0x05, 0x12, 0xfc, 0x02, 0xe4, 0xa2, 0xee, 0xe4, 0xb3, 0x54,
-	0x3f, 0x6a, 0x08, 0xfe, 0x47, 0xab, 0x74, 0xa9, 0x66, 0x05, 0xb7, 0x1a, 0x15, 0xb9, 0x4a, 0xea,
-	0x5c, 0xcf, 0xfc, 0xa7, 0xec, 0x9b, 0xbb, 0x4a, 0xd0, 0x74, 0xb1, 0x2f, 0x6f, 0xe0, 0x6a, 0xbb,
-	0xc4, 0x08, 0x08, 0x69, 0x6d, 0x50, 0xf4, 0x1e, 0x98, 0xa4, 0x1a, 0xda, 0x26, 0xc4, 0x16, 0x9a,
-	0x4d, 0xd3, 0x35, 0xf4, 0x01, 0x98, 0x8a, 0x01, 0x70, 0xed, 0x5d, 0x01, 0x99, 0xd0, 0x4c, 0xc3,
-	0xc7, 0x16, 0xa7, 0xbb, 0xb6, 0x6a, 0xcd, 0x69, 0xaa, 0xb9, 0xdf, 0x7e, 0x2a, 0x8f, 0x86, 0x51,
-	0x5b, 0x1a, 0x75, 0x46, 0x9f, 0xc7, 0x90, 0xa2, 0xf3, 0xb3, 0x09, 0x40, 0x7b, 0x0a, 0x50, 0x51,
-	0x8c, 0x2d, 0x5e, 0x92, 0xf9, 0x01, 0x0e, 0x47, 0x86, 0xcc, 0xa6, 0x9a, 0x90, 0xee, 0xb6, 0x51,
-	0xc3, 0x3c, 0x56, 0x8b, 0x45, 0xa2, 0x07, 0x12, 0x80, 0x71, 0x74, 0x4e, 0x74, 0x19, 0x8c, 0x86,
-	0xb9, 0xc5, 0x01, 0xe9, 0xcb, 0x94, 0x79, 0xc3, 0xf7, 0x7b, 0xb0, 0x7a, 0xb5, 0x2f, 0x2b, 0x96,
-	0x33, 0x41, 0x6b, 0x5a, 0xb0, 0xa2, 0x13, 0x93, 0x13, 0x47, 0x37, 0xc0, 0x0b, 0x89, 0x55, 0x4e,
-	0x76, 0x1d, 0x64, 0xd9, 0x64, 0xe5, 0xfb, 0x7a, 0xb1, 0xcf, 0x71, 0x66, 0xe1, 0xfc, 0xcc, 0xf2,
-	0x50, 0xf4, 0xfd, 0x30, 0x78, 0x99, 0x82, 0x7f, 0x2c, 0xfc, 0x36, 0xb0, 0x1b, 0xdc, 0xf2, 0x37,
-	0x89, 0xa7, 0x19, 0x4e, 0xb4, 0x79, 0xe9, 0x8e, 0x6e, 0xa5, 0xeb, 0xe8, 0xe6, 0xd4, 0xf5, 0x14,
-	0x42, 0xdd, 0x72, 0x82, 0xe3, 0x56, 0x69, 0x8a, 0x0b, 0x35, 0x42, 0x42, 0xf1, 0xf3, 0x5f, 0xe9,
-	0x3a, 0xff, 0xcf, 0x90, 0xa3, 0x8d, 0x84, 0x62, 0x43, 0x04, 0x7d, 0x23, 0x81, 0x57, 0x9e, 0xbe,
-	0x39, 0xbc, 0x15, 0x3b, 0x60, 0x32, 0xda, 0x67, 0xdd, 0xa4, 0x3e, 0x5c, 0x42, 0xcb, 0x03, 0xce,
-	0xd8, 0x64, 0x06, 0xde, 0xa4, 0xb3, 0x76, 0x32, 0x2f, 0xfa, 0x53, 0x02, 0x13, 0x49, 0x4f, 0xb8,
-	0x0b, 0xc6, 0xdb, 0xa9, 0x1d, 0x1c, 0xf0, 0x7b, 0x65, 0x33, 0xf5, 0x5c, 0x98, 0xee, 0x98, 0x0b,
-	0x21, 0x18, 0xd2, 0x9e, 0x8f, 0x9e, 0x3f, 0xc1, 0x01, 0xbc, 0x09, 0x40, 0xb8, 0x49, 0xba, 0xe5,
-	0x98, 0xf8, 0x0e, 0x6f, 0xec, 0x3b, 0xa9, 0x37, 0x7d, 0x8c, 0x65, 0xe2, 0xdb, 0x1d, 0xfe, 0x6c,
-	0x85, 0x78, 0xe8, 0x89, 0xc4, 0xaf, 0xce, 0x75, 0xdb, 0xb0, 0xea, 0x46, 0xc5, 0xc6, 0x9b, 0x18,
-	0xfb, 0xa7, 0x52, 0xe0, 0x6b, 0x20, 0xeb, 0x63, 0xc7, 0xc4, 0x1e, 0x27, 0x39, 0x75, 0xdc, 0x2a,
-	0x8d, 0x33, 0x5f, 0xb6, 0x8e, 0x34, 0xee, 0x00, 0x97, 0x12, 0x62, 0xa5, 0x17, 0x89, 0x7a, 0xae,
-	0xaf, 0xfc, 0x96, 0x12, 0xf2, 0xcb, 0x74, 0x46, 0x9d, 0x20, 0xa8, 0x03, 0x7e, 0x45, 0x77, 0x14,
-	0xc8, 0x55, 0xa4, 0x83, 0x89, 0xaa, 0x30, 0xe8, 0x3b, 0x18, 0x0b, 0x0d, 0xcd, 0x24, 0x46, 0x89,
-	0x50, 0xcc, 0x3a, 0xb1, 0x1c, 0xf5, 0x02, 0xbf, 0xb7, 0xce, 0xb1, 0xb4, 0xc9, 0x70, 0xa4, 0x8d,
-	0x57, 0xe3, 0x89, 0x16, 0x7f, 0xc8, 0x81, 0x51, 0x9a, 0x1f, 0xfe, 0x28, 0x01, 0x3a, 0xc2, 0x7c,
-	0xb8, 0x32, 0xa0, 0x40, 0xbb, 0x66, 0x71, 0xe1, 0xad, 0x53, 0x44, 0xb2, 0x4a, 0xd1, 0xd2, 0xbd,
-	0xdf, 0xff, 0xfe, 0x76, 0x58, 0x86, 0xf3, 0x4a, 0xaf, 0x57, 0xc7, 0xf6, 0x9b, 0x63, 0xf4, 0xe6,
-	0x47, 0xa9, 0xfe, 0x22, 0x81, 0x4c, 0x88, 0x03, 0xdf, 0x4c, 0x9b, 0x59, 0x50, 0x5e, 0x49, 0x1f,
-	0xc8, 0x19, 0xbf, 0x4b, 0x19, 0xaf, 0xc0, 0x37, 0xd2, 0x30, 0x56, 0xee, 0x72, 0x61, 0x1e, 0xc0,
-	0x9f, 0x25, 0x90, 0x65, 0x03, 0x18, 0xa6, 0xdb, 0xb7, 0xf8, 0x4d, 0x50, 0x58, 0x3d, 0x4d, 0x28,
-	0xaf, 0x60, 0x99, 0x56, 0xa0, 0xc0, 0xf2, 0xa0, 0x15, 0x30, 0xb6, 0xff, 0x4a, 0xe0, 0xa5, 0x13,
-	0xc6, 0x1f, 0xfc, 0x30, 0x0d, 0x9d, 0xa7, 0x5f, 0x30, 0x85, 0x8f, 0xfe, 0x17, 0x2c, 0x5e, 0xeb,
-	0x16, 0xad, 0x75, 0x1d, 0xae, 0x0d, 0x58, 0x6b, 0xe7, 0xf0, 0xd6, 0x77, 0x88, 0xa7, 0x7b, 0xb4,
-	0xc6, 0xc7, 0x12, 0x18, 0x4f, 0xbc, 0x51, 0xc3, 0xab, 0x69, 0x98, 0xf6, 0xfa, 0x0a, 0x28, 0xac,
-	0x3d, 0x03, 0x02, 0xaf, 0x50, 0xa5, 0x15, 0xbe, 0x0d, 0x57, 0x07, 0xd6, 0x23, 0x47, 0x50, 0xee,
-	0xf2, 0xaf, 0x8b, 0x03, 0xf8, 0x40, 0x02, 0xe3, 0x89, 0x49, 0x94, 0xae, 0xb4, 0x5e, 0x53, 0x3a,
-	0x5d, 0x69, 0x3d, 0xc7, 0xa0, 0x7a, 0xf3, 0xe1, 0x61, 0x51, 0x7a, 0x74, 0x58, 0x94, 0xfe, 0x3a,
-	0x2c, 0x4a, 0xf7, 0x8f, 0x8a, 0x43, 0x8f, 0x8e, 0x8a, 0x43, 0x8f, 0x8f, 0x8a, 0x43, 0x37, 0xd4,
-	0xd8, 0x15, 0xc3, 0xd3, 0x94, 0x6d, 0xa3, 0xe2, 0x47, 0x7b, 0xb0, 0xbf, 0xb0, 0xac, 0xdc, 0x39,
-	0xe9, 0x33, 0x94, 0x5e, 0x41, 0x95, 0x2c, 0x7d, 0x97, 0xbb, 0xf2, 0x5f, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0xff, 0xfd, 0xe2, 0x01, 0x29, 0x0f, 0x00, 0x00,
+	// 1071 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdd, 0x6e, 0x1b, 0x45,
+	0x14, 0xce, 0x36, 0x8e, 0x2b, 0x4f, 0x70, 0x68, 0x86, 0x54, 0x34, 0x16, 0xd8, 0xd5, 0x40, 0x4b,
+	0xa0, 0xf5, 0xae, 0x92, 0xc6, 0x10, 0x22, 0xfe, 0x62, 0x57, 0xa1, 0x06, 0x84, 0xca, 0x02, 0x37,
+	0x05, 0xc9, 0x5a, 0xef, 0x4e, 0xdc, 0x55, 0xd6, 0x3b, 0x9b, 0x9d, 0x75, 0xa8, 0x55, 0xe5, 0x86,
+	0x07, 0x40, 0x48, 0xf4, 0x8a, 0x5b, 0xde, 0x00, 0x21, 0x24, 0xde, 0xa0, 0xe2, 0xaa, 0x12, 0x37,
+	0x15, 0x48, 0x06, 0x25, 0x3c, 0x81, 0xef, 0x91, 0xd0, 0xce, 0x9c, 0x5d, 0xef, 0x1a, 0xa7, 0xf6,
+	0xa6, 0x5c, 0xd9, 0xe3, 0xf3, 0xf3, 0x7d, 0xe7, 0xcc, 0x37, 0x67, 0xc6, 0xa8, 0xc6, 0x78, 0x97,
+	0x71, 0x9b, 0x6b, 0x26, 0x73, 0x4d, 0xea, 0x06, 0xbe, 0x11, 0x50, 0xab, 0xea, 0xd8, 0x07, 0x3d,
+	0xdb, 0xb2, 0x83, 0xbe, 0xe6, 0x31, 0xe6, 0x54, 0xbb, 0xcc, 0xa2, 0x8e, 0x76, 0xd0, 0xa3, 0x7e,
+	0x5f, 0xf5, 0x7c, 0x16, 0x30, 0x7c, 0x05, 0xc2, 0xd4, 0x64, 0x58, 0x1c, 0xa5, 0x1e, 0xae, 0xb7,
+	0x69, 0x60, 0xac, 0x97, 0x56, 0x3a, 0xac, 0xc3, 0x44, 0x84, 0x16, 0x7e, 0x93, 0xc1, 0xa5, 0x6b,
+	0xd3, 0x30, 0x0d, 0xdf, 0xe8, 0x72, 0x70, 0x2e, 0x9b, 0xc2, 0x5b, 0x6b, 0x1b, 0x9c, 0x6a, 0x90,
+	0x57, 0x33, 0x99, 0xed, 0x82, 0xfd, 0xb5, 0xa4, 0x5d, 0x50, 0x8c, 0xbd, 0x3c, 0xa3, 0x63, 0xbb,
+	0x46, 0x60, 0xb3, 0xc8, 0xf7, 0x85, 0x0e, 0x63, 0x1d, 0x87, 0x6a, 0x86, 0x67, 0x6b, 0x86, 0xeb,
+	0xb2, 0x40, 0x18, 0x23, 0xa4, 0x55, 0xb0, 0x8a, 0x55, 0xbb, 0xb7, 0xa7, 0x19, 0x6e, 0x3f, 0x32,
+	0x49, 0x90, 0x96, 0x2c, 0x45, 0x2e, 0xc0, 0x54, 0x19, 0x8f, 0x0a, 0xec, 0x2e, 0xe5, 0x81, 0xd1,
+	0xf5, 0xa2, 0x02, 0xc6, 0x1d, 0xac, 0x9e, 0x9f, 0x24, 0x55, 0x9d, 0xba, 0x03, 0xdc, 0x1e, 0xb9,
+	0x93, 0x43, 0xb4, 0xfa, 0x49, 0x58, 0xe5, 0xe7, 0x9c, 0xfa, 0xb7, 0xc1, 0xc4, 0x75, 0x7a, 0xd0,
+	0xa3, 0x3c, 0xc0, 0xd7, 0xd1, 0x79, 0xc3, 0xb2, 0x7c, 0xca, 0xf9, 0x25, 0xe5, 0xb2, 0xb2, 0x56,
+	0xa8, 0xe3, 0xe1, 0xa0, 0xb2, 0xd4, 0x37, 0xba, 0xce, 0x36, 0x01, 0x03, 0xd1, 0x23, 0x17, 0x7c,
+	0x0d, 0x9d, 0x0f, 0xb7, 0xb7, 0x65, 0x5b, 0x97, 0xce, 0x5d, 0x56, 0xd6, 0x72, 0x49, 0x6f, 0x30,
+	0x10, 0x3d, 0x1f, 0x7e, 0x6b, 0x5a, 0xe4, 0x00, 0x95, 0x26, 0xe1, 0x72, 0x8f, 0xb9, 0x9c, 0xe2,
+	0x4f, 0x51, 0x21, 0xe2, 0x19, 0x42, 0xcf, 0xaf, 0x2d, 0x6e, 0x68, 0xea, 0x4c, 0x1a, 0x51, 0xa3,
+	0x64, 0xf5, 0xdc, 0xc3, 0x41, 0x65, 0x4e, 0x1f, 0xe5, 0x21, 0xef, 0xa2, 0x0b, 0x02, 0xf2, 0x36,
+	0x63, 0x4e, 0x54, 0x61, 0x82, 0xb3, 0x32, 0x95, 0xf3, 0x2d, 0xb4, 0x9c, 0x48, 0x00, 0x54, 0x6f,
+	0xa0, 0x5c, 0x68, 0x16, 0xe1, 0x8b, 0x1b, 0x2b, 0xaa, 0xdc, 0x1e, 0x35, 0xda, 0x1e, 0x75, 0xc7,
+	0xed, 0xd7, 0x0b, 0xbf, 0xfe, 0x54, 0x5d, 0x08, 0xa3, 0x9a, 0xba, 0x70, 0x26, 0x5f, 0x24, 0x32,
+	0xc5, 0xdd, 0xde, 0x45, 0x68, 0x24, 0x31, 0xd1, 0xc2, 0xc5, 0x8d, 0xab, 0x2a, 0xa8, 0x23, 0xd4,
+	0xa3, 0x2a, 0x8f, 0x4c, 0x5c, 0xa9, 0xd1, 0xa1, 0x10, 0xab, 0x27, 0x22, 0xc9, 0x03, 0x05, 0xe1,
+	0x64, 0x76, 0x20, 0x5a, 0x43, 0x0b, 0x21, 0x76, 0xd4, 0xcf, 0xa9, 0x4c, 0xa5, 0x37, 0x7e, 0x7f,
+	0x02, 0xab, 0x57, 0xa6, 0xb2, 0x92, 0x98, 0x29, 0x5a, 0x2b, 0x11, 0x2b, 0x71, 0x1c, 0x81, 0x38,
+	0xb9, 0x83, 0x9e, 0x4b, 0xfd, 0x0a, 0x64, 0x1b, 0x28, 0x2f, 0x8f, 0x2d, 0xf4, 0xf5, 0xca, 0x94,
+	0xdd, 0x97, 0xe1, 0xb0, 0xe7, 0x10, 0x4a, 0xbe, 0x3f, 0x87, 0x5e, 0x12, 0xc9, 0x3f, 0x8a, 0xfc,
+	0x6e, 0x52, 0x2f, 0xb8, 0xcb, 0x77, 0x99, 0xaf, 0x1b, 0x6e, 0xdc, 0xbc, 0x4c, 0x22, 0xc0, 0x6d,
+	0x84, 0x1c, 0xf6, 0x15, 0xf5, 0x5b, 0x81, 0x6d, 0xee, 0x8b, 0x7e, 0x14, 0xea, 0x8d, 0x10, 0xf6,
+	0xf7, 0x41, 0xe5, 0x6a, 0xc7, 0x0e, 0xee, 0xf6, 0xda, 0xaa, 0xc9, 0xba, 0x70, 0xaa, 0xe1, 0xa3,
+	0xca, 0xad, 0x7d, 0x2d, 0xe8, 0x7b, 0x94, 0xab, 0x4d, 0x37, 0x18, 0x0e, 0x2a, 0xcb, 0x32, 0xfb,
+	0x28, 0x13, 0xd1, 0x0b, 0x62, 0xf1, 0x99, 0x6d, 0xee, 0x87, 0x18, 0x3d, 0xcf, 0x8b, 0x30, 0xe6,
+	0x9f, 0x0e, 0x63, 0x94, 0x89, 0xe8, 0x05, 0xb1, 0x08, 0x31, 0xc8, 0x37, 0x0a, 0x7a, 0xf9, 0xc9,
+	0xcd, 0x81, 0xad, 0xd8, 0x43, 0x17, 0xe2, 0x3e, 0xb7, 0x2c, 0xe1, 0x03, 0x12, 0xaa, 0xcd, 0x78,
+	0x24, 0xd3, 0x08, 0xb0, 0x49, 0xcf, 0x3a, 0x69, 0x5c, 0xf2, 0x87, 0x82, 0x96, 0xd2, 0x9e, 0x78,
+	0x1f, 0x15, 0x47, 0xd0, 0x2e, 0x0d, 0x60, 0x0a, 0xed, 0x66, 0x68, 0xc5, 0x4d, 0x6a, 0x0e, 0x07,
+	0x95, 0x15, 0x68, 0x77, 0x32, 0x19, 0xd1, 0x9f, 0x89, 0xd7, 0x1f, 0xd3, 0x00, 0x7f, 0x89, 0x50,
+	0xd8, 0xa4, 0x96, 0xed, 0x5a, 0xf4, 0x1e, 0x6c, 0xec, 0xdb, 0x99, 0x9b, 0xbe, 0x28, 0x91, 0xa0,
+	0xdd, 0xe1, 0x47, 0x33, 0xcc, 0x47, 0xfe, 0x54, 0x60, 0xd0, 0x36, 0x1c, 0xc3, 0xee, 0x1a, 0x6d,
+	0x87, 0xee, 0x52, 0xca, 0xcf, 0xa4, 0xc0, 0x57, 0x51, 0x9e, 0x53, 0xd7, 0xa2, 0x3e, 0x90, 0x5c,
+	0x1e, 0x0e, 0x2a, 0x45, 0xe9, 0x2b, 0x7f, 0x27, 0x3a, 0x38, 0xe0, 0xcd, 0x94, 0x58, 0x43, 0x21,
+	0xcd, 0xd7, 0x2f, 0x4e, 0x95, 0xdf, 0x66, 0x4a, 0x7e, 0xb9, 0xf1, 0xa8, 0x53, 0x04, 0x75, 0x04,
+	0x13, 0x7d, 0xac, 0x40, 0x50, 0x51, 0x0b, 0x2d, 0x99, 0x91, 0xa1, 0xb5, 0x47, 0x69, 0xa4, 0xa1,
+	0xd5, 0xd4, 0x28, 0x89, 0x14, 0xd3, 0x60, 0xb6, 0x5b, 0x7f, 0x31, 0x6c, 0xfe, 0x70, 0x50, 0xb9,
+	0x28, 0x61, 0xd3, 0xe1, 0x44, 0x2f, 0x9a, 0x49, 0xa0, 0x8d, 0x1f, 0x0a, 0x68, 0x41, 0xe0, 0xe3,
+	0x1f, 0x15, 0x24, 0x46, 0x18, 0xc7, 0x5b, 0x33, 0x0a, 0xf4, 0x3f, 0xb3, 0xb8, 0xf4, 0xe6, 0x19,
+	0x22, 0x65, 0xa5, 0x64, 0xf3, 0xeb, 0xdf, 0xfe, 0xfe, 0xee, 0x9c, 0x8a, 0xaf, 0x6b, 0x93, 0x6e,
+	0xe2, 0xd1, 0x45, 0x1c, 0x3f, 0x2b, 0x04, 0xd5, 0x5f, 0x14, 0x94, 0x0b, 0xf3, 0xe0, 0x37, 0xb2,
+	0x22, 0x47, 0x94, 0xb7, 0xb2, 0x07, 0x02, 0xe3, 0x77, 0x04, 0xe3, 0x2d, 0xfc, 0x7a, 0x16, 0xc6,
+	0xda, 0x7d, 0x10, 0xe6, 0x11, 0xfe, 0x59, 0x41, 0x79, 0x39, 0x80, 0x71, 0xb6, 0xbe, 0x25, 0x6f,
+	0x82, 0xd2, 0xf6, 0x59, 0x42, 0xa1, 0x82, 0x9a, 0xa8, 0x40, 0xc3, 0xd5, 0x59, 0x2b, 0x90, 0x6c,
+	0xff, 0x51, 0xd0, 0xf3, 0xa7, 0x8c, 0x3f, 0xfc, 0x41, 0x16, 0x3a, 0x4f, 0xbe, 0x60, 0x4a, 0x1f,
+	0xfe, 0x2f, 0xb9, 0xa0, 0xd6, 0xa6, 0xa8, 0xb5, 0x81, 0x77, 0x66, 0xac, 0x75, 0x7c, 0x78, 0xb7,
+	0xf6, 0x98, 0xdf, 0xf2, 0x45, 0x8d, 0x8f, 0x15, 0x54, 0x4c, 0x3d, 0xc0, 0xf0, 0x7b, 0x59, 0x98,
+	0x4e, 0x7a, 0x33, 0x96, 0x76, 0x9e, 0x22, 0x03, 0x54, 0x58, 0x17, 0x15, 0xbe, 0x85, 0xb7, 0x67,
+	0xd6, 0x23, 0x64, 0xd0, 0xee, 0xc3, 0x5b, 0xf4, 0x08, 0x3f, 0x50, 0x50, 0x31, 0x35, 0x89, 0xb2,
+	0x95, 0x36, 0x69, 0x4a, 0x67, 0x2b, 0x6d, 0xe2, 0x18, 0xac, 0xb7, 0x1f, 0x1e, 0x97, 0x95, 0x47,
+	0xc7, 0x65, 0xe5, 0xaf, 0xe3, 0xb2, 0xf2, 0xed, 0x49, 0x79, 0xee, 0xd1, 0x49, 0x79, 0xee, 0xf1,
+	0x49, 0x79, 0xee, 0xce, 0xad, 0xc4, 0x15, 0x03, 0x30, 0x55, 0xc7, 0x68, 0xf3, 0xb8, 0x07, 0x87,
+	0xeb, 0x35, 0xed, 0xde, 0x69, 0xaf, 0x7a, 0x71, 0x05, 0xc9, 0xff, 0x2b, 0xed, 0xbc, 0x78, 0xd1,
+	0xdd, 0xf8, 0x37, 0x00, 0x00, 0xff, 0xff, 0xf6, 0xc7, 0x07, 0x64, 0x8c, 0x0d, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1167,70 +1078,6 @@ func (m *QueryUserPositionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, err
 	return len(dAtA) - i, nil
 }
 
-func (m *FullPositionByOwnerResult) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *FullPositionByOwnerResult) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *FullPositionByOwnerResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size := m.Liquidity.Size()
-		i -= size
-		if _, err := m.Liquidity.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintQuery(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x32
-	n1, err1 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.FreezeDuration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.FreezeDuration):])
-	if err1 != nil {
-		return 0, err1
-	}
-	i -= n1
-	i = encodeVarintQuery(dAtA, i, uint64(n1))
-	i--
-	dAtA[i] = 0x2a
-	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.JoinTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.JoinTime):])
-	if err2 != nil {
-		return 0, err2
-	}
-	i -= n2
-	i = encodeVarintQuery(dAtA, i, uint64(n2))
-	i--
-	dAtA[i] = 0x22
-	if m.UpperTick != 0 {
-		i = encodeVarintQuery(dAtA, i, uint64(m.UpperTick))
-		i--
-		dAtA[i] = 0x18
-	}
-	if m.LowerTick != 0 {
-		i = encodeVarintQuery(dAtA, i, uint64(m.LowerTick))
-		i--
-		dAtA[i] = 0x10
-	}
-	if m.PoolId != 0 {
-		i = encodeVarintQuery(dAtA, i, uint64(m.PoolId))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
 func (m *QueryPoolRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -1686,30 +1533,6 @@ func (m *QueryUserPositionsResponse) Size() (n int) {
 	return n
 }
 
-func (m *FullPositionByOwnerResult) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.PoolId != 0 {
-		n += 1 + sovQuery(uint64(m.PoolId))
-	}
-	if m.LowerTick != 0 {
-		n += 1 + sovQuery(uint64(m.LowerTick))
-	}
-	if m.UpperTick != 0 {
-		n += 1 + sovQuery(uint64(m.UpperTick))
-	}
-	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.JoinTime)
-	n += 1 + l + sovQuery(uint64(l))
-	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.FreezeDuration)
-	n += 1 + l + sovQuery(uint64(l))
-	l = m.Liquidity.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
 func (m *QueryPoolRequest) Size() (n int) {
 	if m == nil {
 		return 0
@@ -2033,7 +1856,7 @@ func (m *QueryUserPositionsResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Positions = append(m.Positions, FullPositionByOwnerResult{})
+			m.Positions = append(m.Positions, model.Position{})
 			if err := m.Positions[len(m.Positions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -2059,213 +1882,6 @@ func (m *QueryUserPositionsResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *FullPositionByOwnerResult) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowQuery
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: FullPositionByOwnerResult: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: FullPositionByOwnerResult: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType)
-			}
-			m.PoolId = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.PoolId |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LowerTick", wireType)
-			}
-			m.LowerTick = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.LowerTick |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UpperTick", wireType)
-			}
-			m.UpperTick = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.UpperTick |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field JoinTime", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.JoinTime, dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field FreezeDuration", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.FreezeDuration, dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Liquidity", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Liquidity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipQuery(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func (m *QueryPoolRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -2394,7 +2010,7 @@ func (m *QueryPoolResponse) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Pool == nil {
-				m.Pool = &types1.Any{}
+				m.Pool = &types.Any{}
 			}
 			if err := m.Pool.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -2565,7 +2181,7 @@ func (m *QueryPoolsResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Pools = append(m.Pools, &types1.Any{})
+			m.Pools = append(m.Pools, &types.Any{})
 			if err := m.Pools[len(m.Pools)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/x/concentrated-liquidity/types/query.pb.gw.go b/x/concentrated-liquidity/types/query/query.pb.gw.go
similarity index 99%
rename from x/concentrated-liquidity/types/query.pb.gw.go
rename to x/concentrated-liquidity/types/query/query.pb.gw.go
index 695f1bac3..184587ff0 100644
--- a/x/concentrated-liquidity/types/query.pb.gw.go
+++ b/x/concentrated-liquidity/types/query/query.pb.gw.go
@@ -2,11 +2,11 @@
 // source: osmosis/concentrated-liquidity/pool-model/query.proto
 
 /*
-Package types is a reverse proxy.
+Package query is a reverse proxy.
 
 It translates gRPC into RESTful JSON APIs.
 */
-package types
+package query
 
 import (
 	"context"


Test patch:
diff --git a/tests/cl-go-client/main.go b/tests/cl-go-client/main.go
index bfdfb2724..339350c3e 100644
--- a/tests/cl-go-client/main.go
+++ b/tests/cl-go-client/main.go
@@ -15,7 +15,8 @@ import (
 
 	cl "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/model"
-	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
+	cltypes "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
+	clquery "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types/query"
 )
 
 const (
@@ -62,12 +63,12 @@ func main() {
 	log.Println("connected to: ", "chain-id", statusResp.NodeInfo.Network, "height", statusResp.SyncInfo.LatestBlockHeight)
 
 	// Instantiate a query client for your `blog` blockchain
-	clQueryClient := types.NewQueryClient(igniteClient.Context())
+	clQueryClient := clquery.NewQueryClient(igniteClient.Context())
 
 	// Query pool with id 1 and create new if does not exist.
-	_, err = clQueryClient.Pool(ctx, &types.QueryPoolRequest{PoolId: expectedPoolId})
+	_, err = clQueryClient.Pool(ctx, &clquery.QueryPoolRequest{PoolId: expectedPoolId})
 	if err != nil {
-		if !strings.Contains(err.Error(), types.PoolNotFoundError{PoolId: expectedPoolId}.Error()) {
+		if !strings.Contains(err.Error(), cltypes.PoolNotFoundError{PoolId: expectedPoolId}.Error()) {
 			log.Fatal(err)
 		}
 		createdPoolId := createPool(igniteClient, defaultAccountName)
@@ -125,7 +126,7 @@ func createPool(igniteClient cosmosclient.Client, accountName string) uint64 {
 }
 
 func createPosition(client cosmosclient.Client, poolId uint64, senderKeyringAccountName string, lowerTick int64, upperTick int64, tokenDesired0, tokenDesired1 sdk.Coin, tokenMinAmount0, tokenMinAmount1 sdk.Int) (amountCreated0, amountCreated1 sdk.Int, liquidityCreated sdk.Dec) {
-	msg := &types.MsgCreatePosition{
+	msg := &cltypes.MsgCreatePosition{
 		PoolId:          poolId,
 		Sender:          getAccountAddressFromKeyring(client, senderKeyringAccountName),
 		LowerTick:       lowerTick,
@@ -139,7 +140,7 @@ func createPosition(client cosmosclient.Client, poolId uint64, senderKeyringAcco
 	if err != nil {
 		log.Fatal(err)
 	}
-	resp := types.MsgCreatePositionResponse{}
+	resp := cltypes.MsgCreatePositionResponse{}
 	if err := txResp.Decode(&resp); err != nil {
 		log.Fatal(err)
 	}
diff --git a/tests/e2e/configurer/chain/commands.go b/tests/e2e/configurer/chain/commands.go
index b579232fc..5339e0ca8 100644
--- a/tests/e2e/configurer/chain/commands.go
+++ b/tests/e2e/configurer/chain/commands.go
@@ -47,6 +47,17 @@ func (n *NodeConfig) CreateBalancerPool(poolFile, from string) uint64 {
 	return poolID
 }
 
+func (n *NodeConfig) CreateStableswapPool(poolFile, from string) uint64 {
+	n.LogActionF("creating stableswap pool from file %s", poolFile)
+	cmd := []string{"osmosisd", "tx", "gamm", "create-pool", fmt.Sprintf("--pool-file=/osmosis/%s", poolFile), "--pool-type=stableswap", fmt.Sprintf("--from=%s", from)}
+	_, _, err := n.containerManager.ExecTxCmd(n.t, n.chainId, n.Name, cmd)
+	require.NoError(n.t, err)
+
+	poolID := n.QueryNumPools()
+	n.LogActionF("successfully created stableswap pool with ID %d", poolID)
+	return poolID
+}
+
 func (n *NodeConfig) CreateConcentratedPool(from, denom1, denom2 string, tickSpacing uint64, exponentAtPriceOne int64, swapFee string) uint64 {
 	n.LogActionF("creating concentrated pool")
 
diff --git a/tests/e2e/configurer/chain/queries.go b/tests/e2e/configurer/chain/queries.go
index 791cb2dc5..1d7daed42 100644
--- a/tests/e2e/configurer/chain/queries.go
+++ b/tests/e2e/configurer/chain/queries.go
@@ -20,7 +20,9 @@ import (
 	tmabcitypes "github.com/tendermint/tendermint/abci/types"
 
 	"github.com/osmosis-labs/osmosis/v15/tests/e2e/util"
+	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/model"
 	cltypes "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
+	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types/query"
 	epochstypes "github.com/osmosis-labs/osmosis/v15/x/epochs/types"
 	gammtypes "github.com/osmosis-labs/osmosis/v15/x/gamm/types"
 	poolmanagertypes "github.com/osmosis-labs/osmosis/v15/x/poolmanager/types"
@@ -267,13 +269,13 @@ func (n *NodeConfig) QueryPoolType(poolId string) string {
 	return poolTypeResponse.PoolType
 }
 
-func (n *NodeConfig) QueryConcentratedPositions(address string) []cltypes.FullPositionByOwnerResult {
+func (n *NodeConfig) QueryConcentratedPositions(address string) []model.Position {
 	path := fmt.Sprintf("/osmosis/concentratedliquidity/v1beta1/positions/%s", address)
 
 	bz, err := n.QueryGRPCGateway(path)
 	require.NoError(n.t, err)
 
-	var positionsResponse cltypes.QueryUserPositionsResponse
+	var positionsResponse query.QueryUserPositionsResponse
 	err = util.Cdc.UnmarshalJSON(bz, &positionsResponse)
 	require.NoError(n.t, err)
 	return positionsResponse.Positions
@@ -283,7 +285,7 @@ func (n *NodeConfig) QueryConcentratedPool(poolId uint64) (cltypes.ConcentratedP
 	bz, err := n.QueryGRPCGateway(path)
 	require.NoError(n.t, err)
 
-	var poolResponse cltypes.QueryPoolResponse
+	var poolResponse query.QueryPoolResponse
 	err = util.Cdc.UnmarshalJSON(bz, &poolResponse)
 	require.NoError(n.t, err)
 
diff --git a/tests/e2e/configurer/config/constants.go b/tests/e2e/configurer/config/constants.go
index b37e1c2be..a0d458534 100644
--- a/tests/e2e/configurer/config/constants.go
+++ b/tests/e2e/configurer/config/constants.go
@@ -28,13 +28,15 @@ var (
 	InitialMinExpeditedDeposit = MinExpeditedDepositValue / 4
 	// The first id of a pool create via CLI before starting an
 	// upgrade.
-	// Note: that we create a pool with id 1 via genesis
-	// in the initialization package. As a result, the first
-	// pre-upgrade should have id 2.
-	// This value gets mutated during the pre-upgrade pool
-	// creation in case more pools are added to genesis
-	// in the future
-	PreUpgradePoolId uint64 = 2
+	PreUpgradePoolId uint64
+
+	PreUpgradeStableSwapPoolId uint64
 
 	StrideMigrateWallet = "stride-migration"
+
+	LockupWallet = "lockup-wallet"
+
+	LockupWalletSuperfluid = "lockup-wallet-superfluid"
+
+	StableswapWallet = "stableswap-wallet"
 )
diff --git a/tests/e2e/configurer/upgrade.go b/tests/e2e/configurer/upgrade.go
index 58026906b..3cad88144 100644
--- a/tests/e2e/configurer/upgrade.go
+++ b/tests/e2e/configurer/upgrade.go
@@ -106,9 +106,6 @@ func (uc *UpgradeConfigurer) ConfigureChain(chainConfig *chain.Config) error {
 }
 
 func (uc *UpgradeConfigurer) CreatePreUpgradeState() error {
-	const lockupWallet = "lockup-wallet"
-	const lockupWalletSuperfluid = "lockup-wallet-superfluid"
-
 	chainA := uc.chainConfigs[0]
 	chainANode, err := chainA.GetDefaultNode()
 	if err != nil {
@@ -128,14 +125,25 @@ func (uc *UpgradeConfigurer) CreatePreUpgradeState() error {
 	config.PreUpgradePoolId = chainANode.CreateBalancerPool("pool1A.json", initialization.ValidatorWalletName)
 	poolShareDenom := fmt.Sprintf("gamm/pool/%d", config.PreUpgradePoolId)
 	chainBNode.CreateBalancerPool("pool1B.json", initialization.ValidatorWalletName)
+	config.PreUpgradeStableSwapPoolId = chainANode.CreateStableswapPool("stablePool.json", initialization.ValidatorWalletName)
+	chainBNode.CreateStableswapPool("stablePool.json", initialization.ValidatorWalletName)
 
 	// enable superfluid assets on chainA
 	chainA.EnableSuperfluidAsset(poolShareDenom)
 
-	// setup wallets and send gamm tokens to these wallets (only chainA)
-	lockupWalletAddrA, lockupWalletSuperfluidAddrA := chainANode.CreateWallet(lockupWallet), chainANode.CreateWallet(lockupWalletSuperfluid)
-	chainANode.BankSend("10000000000000000000"+poolShareDenom, chainA.NodeConfigs[0].PublicAddress, lockupWalletAddrA)
-	chainANode.BankSend("10000000000000000000"+poolShareDenom, chainA.NodeConfigs[0].PublicAddress, lockupWalletSuperfluidAddrA)
+	// Setup wallets and send tokens to wallets (only chainA)
+	config.LockupWallet = chainANode.CreateWalletAndFund(config.LockupWallet, []string{
+		"10000000000000000000" + poolShareDenom,
+	})
+	config.LockupWalletSuperfluid = chainANode.CreateWalletAndFund(config.LockupWalletSuperfluid, []string{
+		"10000000000000000000" + poolShareDenom,
+	})
+	config.StableswapWallet = chainANode.CreateWalletAndFund(config.LockupWalletSuperfluid, []string{
+		"100000stake",
+	})
+
+	// test swap exact amount in for stable swap pool (only chainA)A
+	chainANode.SwapExactAmountIn("2000stake", "1", fmt.Sprintf("%d", config.PreUpgradeStableSwapPoolId), "uosmo", config.StableswapWallet)
 
 	// Upload the rate limiting contract to both chains (as they both will be updated)
 	uc.t.Logf("Uploading rate limiting contract to both chains")
@@ -149,7 +157,7 @@ func (uc *UpgradeConfigurer) CreatePreUpgradeState() error {
 	}
 
 	// test lock and add to existing lock for both regular and superfluid lockups (only chainA)
-	chainA.LockAndAddToExistingLock(sdk.NewInt(1000000000000000000), poolShareDenom, lockupWalletAddrA, lockupWalletSuperfluidAddrA)
+	chainA.LockAndAddToExistingLock(sdk.NewInt(1000000000000000000), poolShareDenom, config.LockupWallet, config.LockupWalletSuperfluid)
 
 	// LP to pools 833, 817, 810
 	// initialize lp wallets
diff --git a/tests/e2e/e2e_test.go b/tests/e2e/e2e_test.go
index e2cec58ec..26967f394 100644
--- a/tests/e2e/e2e_test.go
+++ b/tests/e2e/e2e_test.go
@@ -21,6 +21,7 @@ import (
 
 	ibchookskeeper "github.com/osmosis-labs/osmosis/x/ibc-hooks/keeper"
 
+	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/model"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
 	ibcratelimittypes "github.com/osmosis-labs/osmosis/v15/x/ibc-rate-limit/types"
 
@@ -250,7 +251,7 @@ func (s *IntegrationTestSuite) TestConcentratedLiquidity() {
 	s.Require().Equal(len(positionsAddress3), 2)
 
 	// Assert returned positions:
-	validateCLPosition := func(position types.FullPositionByOwnerResult, poolId uint64, lowerTick, upperTick int64) {
+	validateCLPosition := func(position model.Position, poolId uint64, lowerTick, upperTick int64) {
 		s.Require().Equal(position.PoolId, poolId)
 		s.Require().Equal(position.LowerTick, int64(lowerTick))
 		s.Require().Equal(position.UpperTick, int64(upperTick))
@@ -321,6 +322,33 @@ func (s *IntegrationTestSuite) TestConcentratedLiquidity() {
 
 }
 
+func (s *IntegrationTestSuite) TestStableSwapPostUpgrade() {
+	if s.skipUpgrade {
+		s.T().Skip("Skipping StableSwapPostUpgrade test")
+	}
+
+	chainA := s.configurer.GetChainConfig(0)
+	chainANode, err := chainA.GetDefaultNode()
+	s.Require().NoError(err)
+
+	const (
+		denomA = "stake"
+		denomB = "uosmo"
+
+		minAmountOut = "1"
+	)
+
+	coinAIn, coinBIn := fmt.Sprintf("20000%s", denomA), fmt.Sprintf("1%s", denomB)
+
+	chainANode.BankSend(initialization.WalletFeeTokens.String(), chainA.NodeConfigs[0].PublicAddress, config.StableswapWallet)
+	chainANode.BankSend(coinAIn, chainA.NodeConfigs[0].PublicAddress, config.StableswapWallet)
+	chainANode.BankSend(coinBIn, chainA.NodeConfigs[0].PublicAddress, config.StableswapWallet)
+
+	s.T().Log("performing swaps")
+	chainANode.SwapExactAmountIn(coinAIn, minAmountOut, fmt.Sprintf("%d", config.PreUpgradeStableSwapPoolId), denomB, config.StableswapWallet)
+	chainANode.SwapExactAmountIn(coinBIn, minAmountOut, fmt.Sprintf("%d", config.PreUpgradeStableSwapPoolId), denomA, config.StableswapWallet)
+}
+
 // TestGeometricTwapMigration tests that the geometric twap record
 // migration runs succesfully. It does so by attempting to execute
 // the swap on the pool created pre-upgrade. When a pool is created
diff --git a/tests/e2e/scripts/stablePool.json b/tests/e2e/scripts/stablePool.json
new file mode 100644
index 000000000..0f6d3be97
--- /dev/null
+++ b/tests/e2e/scripts/stablePool.json
@@ -0,0 +1,7 @@
+{
+	"initial-deposit": "1000000stake,1000uosmo",
+	"swap-fee": "0.005",
+	"exit-fee": "0",
+	"future-governor": "",
+        "scaling-factors": "1000,1"
+}
\ No newline at end of file
diff --git a/x/concentrated-liquidity/export_test.go b/x/concentrated-liquidity/export_test.go
index 9dccff6b6..4c69ff8cd 100644
--- a/x/concentrated-liquidity/export_test.go
+++ b/x/concentrated-liquidity/export_test.go
@@ -105,12 +105,12 @@ func ConvertPoolInterfaceToConcentrated(poolI poolmanagertypes.PoolI) (types.Con
 	return convertPoolInterfaceToConcentrated(poolI)
 }
 
-func (k Keeper) GetAllPositionsWithVaryingFreezeTimes(ctx sdk.Context, poolId uint64, addr sdk.AccAddress, lowerTick, upperTick int64) ([]model.Position, error) {
+func (k Keeper) GetAllPositionsWithVaryingFreezeTimes(ctx sdk.Context, poolId uint64, addr sdk.AccAddress, lowerTick, upperTick int64) ([]sdk.Dec, error) {
 	return k.getAllPositionsWithVaryingFreezeTimes(ctx, poolId, addr, lowerTick, upperTick)
 }
 
-func (k Keeper) SetPosition(ctx sdk.Context, poolId uint64, owner sdk.AccAddress, lowerTick, upperTick int64, position *model.Position, joinTime time.Time, freezeDuration time.Duration) {
-	k.setPosition(ctx, poolId, owner, lowerTick, upperTick, position, joinTime, freezeDuration)
+func (k Keeper) SetPosition(ctx sdk.Context, poolId uint64, owner sdk.AccAddress, lowerTick, upperTick int64, joinTime time.Time, freezeDuration time.Duration, liquidity sdk.Dec) {
+	k.setPosition(ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration, liquidity)
 }
 
 func (k Keeper) ValidateSwapFee(ctx sdk.Context, params types.Params, swapFee sdk.Dec) bool {
@@ -228,6 +228,6 @@ func (k Keeper) GetInitialUptimeGrowthOutsidesForTick(ctx sdk.Context, poolId ui
 	return k.getInitialUptimeGrowthOutsidesForTick(ctx, poolId, tick)
 }
 
-func (k Keeper) InitOrUpdatePositionUptime(ctx sdk.Context, poolId uint64, position *model.Position, owner sdk.AccAddress, lowerTick, upperTick int64, liquidityDelta sdk.Dec, joinTime time.Time, freezeDuration time.Duration) error {
+func (k Keeper) InitOrUpdatePositionUptime(ctx sdk.Context, poolId uint64, position sdk.Dec, owner sdk.AccAddress, lowerTick, upperTick int64, liquidityDelta sdk.Dec, joinTime time.Time, freezeDuration time.Duration) error {
 	return k.initOrUpdatePositionUptime(ctx, poolId, position, owner, lowerTick, upperTick, liquidityDelta, joinTime, freezeDuration)
 }
diff --git a/x/concentrated-liquidity/incentives_test.go b/x/concentrated-liquidity/incentives_test.go
index 552915b8b..48f7e89d9 100644
--- a/x/concentrated-liquidity/incentives_test.go
+++ b/x/concentrated-liquidity/incentives_test.go
@@ -1540,8 +1540,8 @@ func (s *KeeperTestSuite) TestInitOrUpdatePositionUptime() {
 	}
 
 	tests := []struct {
-		name     string
-		position *model.Position
+		name              string
+		positionLiquidity sdk.Dec
 
 		lowerTick               tick
 		upperTick               tick
@@ -1561,10 +1561,8 @@ func (s *KeeperTestSuite) TestInitOrUpdatePositionUptime() {
 		// New position tests
 
 		{
-			name: "(lower < curr < upper) default freeze time with nonzero uptime trackers",
-			position: &model.Position{
-				Liquidity: DefaultLiquidityAmt,
-			},
+			name:              "(lower < curr < upper) default freeze time with nonzero uptime trackers",
+			positionLiquidity: DefaultLiquidityAmt,
 			lowerTick: tick{
 				tickIndex:      -50,
 				uptimeTrackers: wrapUptimeTrackers(uptimeHelper.hundredTokensMultiDenom),
@@ -1579,10 +1577,8 @@ func (s *KeeperTestSuite) TestInitOrUpdatePositionUptime() {
 			expectedUnclaimedRewards: uptimeHelper.emptyExpectedAccumValues,
 		},
 		{
-			name: "(lower < upper < curr) default freeze time with nonzero uptime trackers",
-			position: &model.Position{
-				Liquidity: DefaultLiquidityAmt,
-			},
+			name:              "(lower < upper < curr) default freeze time with nonzero uptime trackers",
+			positionLiquidity: DefaultLiquidityAmt,
 			lowerTick: tick{
 				tickIndex:      -50,
 				uptimeTrackers: wrapUptimeTrackers(uptimeHelper.hundredTokensMultiDenom),
@@ -1597,10 +1593,8 @@ func (s *KeeperTestSuite) TestInitOrUpdatePositionUptime() {
 			expectedUnclaimedRewards: uptimeHelper.emptyExpectedAccumValues,
 		},
 		{
-			name: "(curr < lower < upper) default freeze time with nonzero uptime trackers",
-			position: &model.Position{
-				Liquidity: DefaultLiquidityAmt,
-			},
+			name:              "(curr < lower < upper) default freeze time with nonzero uptime trackers",
+			positionLiquidity: DefaultLiquidityAmt,
 			lowerTick: tick{
 				tickIndex:      -50,
 				uptimeTrackers: wrapUptimeTrackers(uptimeHelper.threeHundredTokensMultiDenom),
@@ -1615,10 +1609,8 @@ func (s *KeeperTestSuite) TestInitOrUpdatePositionUptime() {
 			expectedUnclaimedRewards: uptimeHelper.emptyExpectedAccumValues,
 		},
 		{
-			name: "(lower < curr < upper) default freeze time with nonzero and variable uptime trackers",
-			position: &model.Position{
-				Liquidity: DefaultLiquidityAmt,
-			},
+			name:              "(lower < curr < upper) default freeze time with nonzero and variable uptime trackers",
+			positionLiquidity: DefaultLiquidityAmt,
 			lowerTick: tick{
 				tickIndex:      -50,
 				uptimeTrackers: wrapUptimeTrackers(uptimeHelper.varyingTokensMultiDenom),
@@ -1665,10 +1657,8 @@ func (s *KeeperTestSuite) TestInitOrUpdatePositionUptime() {
 		// Existing position tests
 
 		{
-			name: "(lower < curr < upper) add to frozen position with no new uptime growth",
-			position: &model.Position{
-				Liquidity: DefaultLiquidityAmt,
-			},
+			name:              "(lower < curr < upper) add to frozen position with no new uptime growth",
+			positionLiquidity: DefaultLiquidityAmt,
 			lowerTick: tick{
 				tickIndex:      -50,
 				uptimeTrackers: wrapUptimeTrackers(uptimeHelper.hundredTokensMultiDenom),
@@ -1697,10 +1687,8 @@ func (s *KeeperTestSuite) TestInitOrUpdatePositionUptime() {
 			expectedUnclaimedRewards: uptimeHelper.emptyExpectedAccumValues,
 		},
 		{
-			name: "(lower < curr < upper) add to frozen position with new growth",
-			position: &model.Position{
-				Liquidity: DefaultLiquidityAmt,
-			},
+			name:              "(lower < curr < upper) add to frozen position with new growth",
+			positionLiquidity: DefaultLiquidityAmt,
 			lowerTick: tick{
 				tickIndex:      -50,
 				uptimeTrackers: wrapUptimeTrackers(uptimeHelper.hundredTokensMultiDenom),
@@ -1754,9 +1742,9 @@ func (s *KeeperTestSuite) TestInitOrUpdatePositionUptime() {
 
 			// If applicable, set up existing position and update ticks & global accums
 			if test.existingPosition {
-				err := s.App.ConcentratedLiquidityKeeper.InitOrUpdatePositionUptime(s.Ctx, clPool.GetId(), test.position, s.TestAccs[0], test.lowerTick.tickIndex, test.upperTick.tickIndex, test.position.Liquidity, DefaultJoinTime, DefaultFreezeDuration)
+				err := s.App.ConcentratedLiquidityKeeper.InitOrUpdatePositionUptime(s.Ctx, clPool.GetId(), test.positionLiquidity, s.TestAccs[0], test.lowerTick.tickIndex, test.upperTick.tickIndex, test.positionLiquidity, DefaultJoinTime, DefaultFreezeDuration)
 				s.Require().NoError(err)
-				s.App.ConcentratedLiquidityKeeper.SetPosition(s.Ctx, clPool.GetId(), s.TestAccs[0], test.lowerTick.tickIndex, test.upperTick.tickIndex, test.position, DefaultJoinTime, DefaultFreezeDuration)
+				s.App.ConcentratedLiquidityKeeper.SetPosition(s.Ctx, clPool.GetId(), s.TestAccs[0], test.lowerTick.tickIndex, test.upperTick.tickIndex, DefaultJoinTime, DefaultFreezeDuration, test.positionLiquidity)
 
 				s.initializeTick(s.Ctx, test.currentTickIndex.Int64(), test.newLowerTick.tickIndex, sdk.ZeroDec(), cl.EmptyCoins, test.newLowerTick.uptimeTrackers, true)
 				s.initializeTick(s.Ctx, test.currentTickIndex.Int64(), test.newUpperTick.tickIndex, sdk.ZeroDec(), cl.EmptyCoins, test.newUpperTick.uptimeTrackers, false)
@@ -1771,7 +1759,7 @@ func (s *KeeperTestSuite) TestInitOrUpdatePositionUptime() {
 
 			// --- System under test ---
 
-			err := s.App.ConcentratedLiquidityKeeper.InitOrUpdatePositionUptime(s.Ctx, clPool.GetId(), test.position, s.TestAccs[0], test.lowerTick.tickIndex, test.upperTick.tickIndex, test.position.Liquidity, DefaultJoinTime, DefaultFreezeDuration)
+			err := s.App.ConcentratedLiquidityKeeper.InitOrUpdatePositionUptime(s.Ctx, clPool.GetId(), test.positionLiquidity, s.TestAccs[0], test.lowerTick.tickIndex, test.upperTick.tickIndex, test.positionLiquidity, DefaultJoinTime, DefaultFreezeDuration)
 
 			// --- Error catching ---
 
@@ -1807,13 +1795,13 @@ func (s *KeeperTestSuite) TestInitOrUpdatePositionUptime() {
 					s.Require().Equal(test.expectedInitAccumValue[uptimeIndex], positionRecord.InitAccumValue)
 
 					if test.existingPosition {
-						s.Require().Equal(sdk.NewDec(2).Mul(test.position.Liquidity), positionRecord.NumShares)
+						s.Require().Equal(sdk.NewDec(2).Mul(test.positionLiquidity), positionRecord.NumShares)
 					} else {
-						s.Require().Equal(test.position.Liquidity, positionRecord.NumShares)
+						s.Require().Equal(test.positionLiquidity, positionRecord.NumShares)
 					}
 
 					// Note that the rewards only apply to the initial shares, not the new ones
-					s.Require().Equal(test.expectedUnclaimedRewards[uptimeIndex].MulDec(test.position.Liquidity), positionRecord.UnclaimedRewards)
+					s.Require().Equal(test.expectedUnclaimedRewards[uptimeIndex].MulDec(test.positionLiquidity), positionRecord.UnclaimedRewards)
 				} else {
 					s.Require().False(recordExists)
 				}
diff --git a/x/concentrated-liquidity/keeper_test.go b/x/concentrated-liquidity/keeper_test.go
index 46d2cc7bc..44f96c5a3 100644
--- a/x/concentrated-liquidity/keeper_test.go
+++ b/x/concentrated-liquidity/keeper_test.go
@@ -62,13 +62,13 @@ func (s *KeeperTestSuite) SetupDefaultPosition(poolId uint64) {
 	s.SetupPosition(poolId, s.TestAccs[0], DefaultCoin0, DefaultCoin1, DefaultLowerTick, DefaultUpperTick, s.Ctx.BlockTime(), DefaultFreezeDuration)
 }
 
-func (s *KeeperTestSuite) SetupPosition(poolId uint64, owner sdk.AccAddress, coin0, coin1 sdk.Coin, lowerTick, upperTick int64, joinTime time.Time, freezeDuration time.Duration) model.Position {
+func (s *KeeperTestSuite) SetupPosition(poolId uint64, owner sdk.AccAddress, coin0, coin1 sdk.Coin, lowerTick, upperTick int64, joinTime time.Time, freezeDuration time.Duration) sdk.Dec {
 	s.FundAcc(owner, sdk.NewCoins(coin0, coin1))
 	_, _, _, err := s.App.ConcentratedLiquidityKeeper.CreatePosition(s.Ctx, poolId, owner, coin0.Amount, coin1.Amount, sdk.ZeroInt(), sdk.ZeroInt(), lowerTick, upperTick, freezeDuration)
 	s.Require().NoError(err)
-	position, err := s.App.ConcentratedLiquidityKeeper.GetPosition(s.Ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration)
+	liquidity, err := s.App.ConcentratedLiquidityKeeper.GetPositionLiquidity(s.Ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration)
 	s.Require().NoError(err)
-	return *position
+	return liquidity
 }
 
 // SetupDefaultPositions sets up four different positions to the given pool with different accounts for each position./
@@ -110,9 +110,8 @@ func (s *KeeperTestSuite) SetupOverlappingRangePositionAcc(poolId uint64, owner
 
 // validatePositionUpdate validates that position with given parameters has expectedRemainingLiquidity left.
 func (s *KeeperTestSuite) validatePositionUpdate(ctx sdk.Context, poolId uint64, owner sdk.AccAddress, lowerTick int64, upperTick int64, joinTime time.Time, freezeDuration time.Duration, expectedRemainingLiquidity sdk.Dec) {
-	position, err := s.App.ConcentratedLiquidityKeeper.GetPosition(ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration)
+	newPositionLiquidity, err := s.App.ConcentratedLiquidityKeeper.GetPositionLiquidity(ctx, poolId, owner, lowerTick, upperTick, joinTime, freezeDuration)
 	s.Require().NoError(err)
-	newPositionLiquidity := position.Liquidity
 	s.Require().Equal(expectedRemainingLiquidity.String(), newPositionLiquidity.String())
 	s.Require().True(newPositionLiquidity.GTE(sdk.ZeroDec()))
 }
diff --git a/x/concentrated-liquidity/lp_test.go b/x/concentrated-liquidity/lp_test.go
index 9b60b6ce1..476e58e85 100644
--- a/x/concentrated-liquidity/lp_test.go
+++ b/x/concentrated-liquidity/lp_test.go
@@ -257,11 +257,11 @@ func (s *KeeperTestSuite) TestCreatePosition() {
 				s.Require().Equal(userBalancePrePositionCreation.String(), userBalancePostPositionCreation.String())
 				s.Require().Equal(poolBalancePrePositionCreation.String(), poolBalancePostPositionCreation.String())
 
-				// Redundantly ensure that position was not created
-				position, err := clKeeper.GetPosition(s.Ctx, tc.poolId, s.TestAccs[0], tc.lowerTick, tc.upperTick, defaultJoinTime, tc.freezeDuration)
+				// Redundantly ensure that liquidity was not created
+				liquidity, err := clKeeper.GetPositionLiquidity(s.Ctx, tc.poolId, s.TestAccs[0], tc.lowerTick, tc.upperTick, defaultJoinTime, tc.freezeDuration)
 				s.Require().Error(err)
 				s.Require().ErrorAs(err, &types.PositionNotFoundError{PoolId: tc.poolId, LowerTick: tc.lowerTick, UpperTick: tc.upperTick})
-				s.Require().Nil(position)
+				s.Require().Equal(sdk.Dec{}, liquidity)
 				return
 			}
 
@@ -511,11 +511,11 @@ func (s *KeeperTestSuite) TestWithdrawPosition() {
 			s.Require().Equal(expectedBalanceDelta.String(), ownerBalancerAfterCollect.Sub(ownerBalancerBeforeCollect).String())
 
 			if expectedRemainingLiquidity.IsZero() {
-				// Check that the position was deleted.
-				position, err := concentratedLiquidityKeeper.GetPosition(ctx, config.poolId, owner, config.lowerTick, config.upperTick, defaultJoinTime, config.freezeDuration)
+				// Check that the positionLiquidity was deleted.
+				positionLiquidity, err := concentratedLiquidityKeeper.GetPositionLiquidity(ctx, config.poolId, owner, config.lowerTick, config.upperTick, defaultJoinTime, config.freezeDuration)
 				s.Require().Error(err)
 				s.Require().ErrorAs(err, &types.PositionNotFoundError{PoolId: config.poolId, LowerTick: config.lowerTick, JoinTime: defaultJoinTime, UpperTick: config.upperTick})
-				s.Require().Nil(position)
+				s.Require().Equal(sdk.Dec{}, positionLiquidity)
 			} else {
 				// Check that the position was updated.
 				s.validatePositionUpdate(ctx, config.poolId, owner, config.lowerTick, config.upperTick, defaultJoinTime, config.freezeDuration, expectedRemainingLiquidity)
@@ -1031,11 +1031,11 @@ func (s *KeeperTestSuite) TestInverseRelation_CreatePosition_WithdrawPosition()
 			s.Require().Equal(userBalancePrePositionCreation, userBalancePostPositionCreation)
 			s.Require().Equal(poolBalancePrePositionCreation, poolBalancePostPositionCreation)
 
-			// 3. Check that position was deleted
-			position, err := clKeeper.GetPosition(s.Ctx, tc.poolId, s.TestAccs[0], tc.lowerTick, tc.upperTick, defaultJoinTime, tc.freezeDuration)
+			// 3. Check that position's liquidity was deleted
+			positionLiquidity, err := clKeeper.GetPositionLiquidity(s.Ctx, tc.poolId, s.TestAccs[0], tc.lowerTick, tc.upperTick, defaultJoinTime, tc.freezeDuration)
 			s.Require().Error(err)
 			s.Require().ErrorAs(err, &types.PositionNotFoundError{PoolId: tc.poolId, LowerTick: tc.lowerTick, UpperTick: tc.upperTick})
-			s.Require().Nil(position)
+			s.Require().Equal(sdk.Dec{}, positionLiquidity)
 
 			// 4. Check that pool has come back to original state
 			poolAfter, err := clKeeper.GetPool(s.Ctx, poolID)
diff --git a/x/concentrated-liquidity/position_test.go b/x/concentrated-liquidity/position_test.go
index 901f42ad3..64049d7b9 100644
--- a/x/concentrated-liquidity/position_test.go
+++ b/x/concentrated-liquidity/position_test.go
@@ -1,7 +1,6 @@
 package concentrated_liquidity_test
 
 import (
-	"fmt"
 	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -160,12 +159,12 @@ func (s *KeeperTestSuite) TestInitOrUpdatePosition() {
 			// We keep track of init blocktime to test error cases
 			s.Ctx = s.Ctx.WithBlockTime(s.Ctx.BlockTime().Add(test.timeElapsedSinceInit))
 
-			// Get the position info for poolId 1
-			positionInfo, err := s.App.ConcentratedLiquidityKeeper.GetPosition(s.Ctx, validPoolId, s.TestAccs[0], test.param.lowerTick, test.param.upperTick, test.param.joinTime, test.param.freezeDuration)
+			// Get the position liquidity for poolId 1
+			liquidity, err := s.App.ConcentratedLiquidityKeeper.GetPositionLiquidity(s.Ctx, validPoolId, s.TestAccs[0], test.param.lowerTick, test.param.upperTick, test.param.joinTime, test.param.freezeDuration)
 			if test.positionExists {
 				// If we had a position before, ensure the position info displays proper liquidity
 				s.Require().NoError(err)
-				s.Require().Equal(preexistingLiquidity, positionInfo.Liquidity)
+				s.Require().Equal(preexistingLiquidity, liquidity)
 			} else {
 				// If we did not have a position before, ensure getting the non-existent position returns an error
 				s.Require().Error(err)
@@ -196,12 +195,12 @@ func (s *KeeperTestSuite) TestInitOrUpdatePosition() {
 			}
 			s.Require().NoError(err)
 
-			// Get the tick info for poolId 1
-			positionInfo, err = s.App.ConcentratedLiquidityKeeper.GetPosition(s.Ctx, validPoolId, s.TestAccs[0], test.param.lowerTick, test.param.upperTick, test.param.joinTime, test.param.freezeDuration)
+			// Get the position liquidity for poolId 1
+			liquidity, err = s.App.ConcentratedLiquidityKeeper.GetPositionLiquidity(s.Ctx, validPoolId, s.TestAccs[0], test.param.lowerTick, test.param.upperTick, test.param.joinTime, test.param.freezeDuration)
 			s.Require().NoError(err)
-			fmt.Println(positionInfo)
+
 			// Check that the initialized or updated position matches our expectation
-			s.Require().Equal(test.expectedLiquidity, positionInfo.Liquidity)
+			s.Require().Equal(test.expectedLiquidity, liquidity)
 
 			// ---Tests for ensuring uptime accumulators behaved as expected---
 
@@ -282,7 +281,7 @@ func (s *KeeperTestSuite) TestGetPosition() {
 		upperTick        int64
 		joinTime         time.Time
 		freezeDuration   time.Duration
-		expectedPosition *model.Position
+		expectedPosition sdk.Dec
 		expectedErr      error
 	}{
 		{
@@ -292,7 +291,7 @@ func (s *KeeperTestSuite) TestGetPosition() {
 			upperTick:        DefaultUpperTick,
 			joinTime:         DefaultJoinTime,
 			freezeDuration:   DefaultFreezeDuration,
-			expectedPosition: &model.Position{Liquidity: DefaultLiquidityAmt},
+			expectedPosition: DefaultLiquidityAmt,
 		},
 		{
 			name:           "Get position info on existing pool and existing position but wrong owner",
@@ -346,20 +345,21 @@ func (s *KeeperTestSuite) TestGetPosition() {
 			err := s.App.ConcentratedLiquidityKeeper.InitOrUpdatePosition(s.Ctx, validPoolId, s.TestAccs[0], DefaultLowerTick, DefaultUpperTick, DefaultLiquidityAmt, DefaultJoinTime, DefaultFreezeDuration)
 
 			// System under test
-			position, err := s.App.ConcentratedLiquidityKeeper.GetPosition(s.Ctx, test.poolToGet, s.TestAccs[test.ownerIndex], test.lowerTick, test.upperTick, test.joinTime, test.freezeDuration)
+			positionLiquidity, err := s.App.ConcentratedLiquidityKeeper.GetPositionLiquidity(s.Ctx, test.poolToGet, s.TestAccs[test.ownerIndex], test.lowerTick, test.upperTick, test.joinTime, test.freezeDuration)
 			if test.expectedErr != nil {
 				s.Require().Error(err)
 				s.Require().ErrorIs(err, test.expectedErr)
-				s.Require().Nil(position)
+				s.Require().Equal(sdk.Dec{}, positionLiquidity)
 			} else {
 				s.Require().NoError(err)
-				s.Require().Equal(test.expectedPosition, position)
+				s.Require().Equal(test.expectedPosition, positionLiquidity)
 			}
 		})
 	}
 }
 
 func (s *KeeperTestSuite) TestGetAllUserPositions() {
+	s.Setup()
 	defaultAddress := s.TestAccs[0]
 	secondAddress := s.TestAccs[1]
 	defaultJoinTime := s.Ctx.BlockTime()
@@ -427,19 +427,20 @@ func (s *KeeperTestSuite) TestGetAllUserPositions() {
 			// Create a default CL pools
 			s.PrepareMultipleConcentratedPools(3)
 
-			expectedUserPositions := []types.FullPositionByOwnerResult{}
+			expectedUserPositions := []model.Position{}
 			for _, pos := range test.setupPositions {
 				// if position does not exist this errors
-				position := s.SetupPosition(pos.poolId, pos.acc, pos.coin0, pos.coin1, pos.lowerTick, pos.upperTick, pos.joinTime, pos.freezeDuration)
+				liquidity := s.SetupPosition(pos.poolId, pos.acc, pos.coin0, pos.coin1, pos.lowerTick, pos.upperTick, pos.joinTime, pos.freezeDuration)
 				if pos.acc.Equals(pos.acc) {
 					if test.poolId == 0 || test.poolId == pos.poolId {
-						expectedUserPositions = append(expectedUserPositions, types.FullPositionByOwnerResult{
+						expectedUserPositions = append(expectedUserPositions, model.Position{
 							PoolId:         pos.poolId,
+							Address:        pos.acc.String(),
 							LowerTick:      pos.lowerTick,
 							UpperTick:      pos.upperTick,
 							JoinTime:       pos.joinTime,
 							FreezeDuration: pos.freezeDuration,
-							Liquidity:      position.Liquidity,
+							Liquidity:      liquidity,
 						})
 					}
 				}
@@ -537,11 +538,11 @@ func (s *KeeperTestSuite) TestDeletePosition() {
 			} else {
 				s.Require().NoError(err)
 
-				// Since the position is deleted, retrieving it should return an error.
-				position, err := s.App.ConcentratedLiquidityKeeper.GetPosition(s.Ctx, test.poolToGet, s.TestAccs[test.ownerIndex], test.lowerTick, test.upperTick, test.joinTime, test.freezeDuration)
+				// Since the positionLiquidity is deleted, retrieving it should return an error.
+				positionLiquidity, err := s.App.ConcentratedLiquidityKeeper.GetPositionLiquidity(s.Ctx, test.poolToGet, s.TestAccs[test.ownerIndex], test.lowerTick, test.upperTick, test.joinTime, test.freezeDuration)
 				s.Require().Error(err)
 				s.Require().ErrorIs(err, types.PositionNotFoundError{PoolId: test.poolToGet, LowerTick: test.lowerTick, UpperTick: test.upperTick, JoinTime: test.joinTime, FreezeDuration: test.freezeDuration})
-				s.Require().Nil(position)
+				s.Require().Equal(sdk.Dec{}, positionLiquidity)
 			}
 		})
 	}
diff --git a/x/concentrated-liquidity/store_test.go b/x/concentrated-liquidity/store_test.go
index b92fd3746..767080236 100644
--- a/x/concentrated-liquidity/store_test.go
+++ b/x/concentrated-liquidity/store_test.go
@@ -14,6 +14,7 @@ import (
 )
 
 func (s *KeeperTestSuite) TestGetAllPositionsWithVaryingFreezeTimes() {
+	s.Setup()
 	defaultAddress := s.TestAccs[0]
 	secondAddress := s.TestAccs[1]
 	defaultJoinTime := s.Ctx.BlockTime()
@@ -63,18 +64,17 @@ func (s *KeeperTestSuite) TestGetAllPositionsWithVaryingFreezeTimes() {
 			// Setup.
 			s.SetupTest()
 			s.Ctx = s.Ctx.WithBlockTime(defaultJoinTime)
-			ctx := s.Ctx
 			s.PrepareConcentratedPool()
-			expectedPositions := []model.Position{}
+			expectedPositions := []sdk.Dec{}
 			for _, pos := range tc.setupPositions {
-				position := s.SetupPosition(pos.poolId, pos.acc, pos.coin0, pos.coin1, pos.lowerTick, pos.upperTick, pos.joinTime, pos.freezeDuration)
+				positionLiquidity := s.SetupPosition(pos.poolId, pos.acc, pos.coin0, pos.coin1, pos.lowerTick, pos.upperTick, pos.joinTime, pos.freezeDuration)
 				if pos.acc.Equals(defaultAddress) {
-					expectedPositions = append(expectedPositions, position)
+					expectedPositions = append(expectedPositions, positionLiquidity)
 				}
 			}
 
 			// System under test.
-			actualPositions, err := s.App.ConcentratedLiquidityKeeper.GetAllPositionsWithVaryingFreezeTimes(ctx, 1, defaultAddress, DefaultLowerTick, DefaultUpperTick)
+			actualPositions, err := s.App.ConcentratedLiquidityKeeper.GetAllPositionsWithVaryingFreezeTimes(s.Ctx, 1, defaultAddress, DefaultLowerTick, DefaultUpperTick)
 			s.NoError(err)
 
 			// Assertions.
@@ -88,7 +88,7 @@ func (s *KeeperTestSuite) TestParseFullPositionFromBytes() {
 	cdc := s.App.AppCodec()
 	joinTimeFormat := osmoutils.FormatTimeString
 	addrFormat := address.MustLengthPrefix
-	DefaultJoinTime := s.Ctx.BlockTime()
+	defaultJoinTime := time.Unix(0, 0).UTC()
 
 	tests := map[string]struct {
 		key          []byte
@@ -96,78 +96,80 @@ func (s *KeeperTestSuite) TestParseFullPositionFromBytes() {
 		expectingErr bool
 	}{
 		"Empty val": {
-			key:          types.KeyFullPosition(defaultPoolId, defaultAddress, DefaultLowerTick, DefaultUpperTick, DefaultJoinTime, DefaultFreezeDuration),
+			key:          types.KeyFullPosition(defaultPoolId, defaultAddress, DefaultLowerTick, DefaultUpperTick, defaultJoinTime, DefaultFreezeDuration),
 			val:          []byte{},
 			expectingErr: true,
 		},
 		"Empty key": {
 			key:          []byte{},
-			val:          cdc.MustMarshal(&model.Position{Liquidity: DefaultLiquidityAmt}),
+			val:          cdc.MustMarshal(&sdk.DecProto{Dec: DefaultLiquidityAmt}),
 			expectingErr: true,
 		},
 		"Random key": {
 			key:          []byte{112, 12, 14, 4, 5},
-			val:          cdc.MustMarshal(&model.Position{Liquidity: DefaultLiquidityAmt}),
+			val:          cdc.MustMarshal(&sdk.DecProto{Dec: DefaultLiquidityAmt}),
 			expectingErr: true,
 		},
 		"Using not full key (wrong key)": {
 			key:          types.KeyPosition(defaultPoolId, defaultAddress, DefaultLowerTick, DefaultUpperTick),
-			val:          cdc.MustMarshal(&model.Position{Liquidity: DefaultLiquidityAmt}),
+			val:          cdc.MustMarshal(&sdk.DecProto{Dec: DefaultLiquidityAmt}),
 			expectingErr: true,
 		},
 		"One key separator missing in key": {
-			key:          []byte(fmt.Sprintf("%s%s%s%d%s%d%s%d%s%s%s%s", types.PositionPrefix, addrFormat(defaultAddress.Bytes()), "|", defaultPoolId, "|", DefaultLowerTick, "|", DefaultUpperTick, "|", joinTimeFormat(DefaultJoinTime), "|", DefaultFreezeDuration.String())),
-			val:          cdc.MustMarshal(&model.Position{Liquidity: DefaultLiquidityAmt}),
+			key:          []byte(fmt.Sprintf("%s%s%s%d%s%d%s%d%s%s%s%s", types.PositionPrefix, addrFormat(defaultAddress.Bytes()), "|", defaultPoolId, "|", DefaultLowerTick, "|", DefaultUpperTick, "|", joinTimeFormat(defaultJoinTime), "|", DefaultFreezeDuration.String())),
+			val:          cdc.MustMarshal(&sdk.DecProto{Dec: DefaultLiquidityAmt}),
 			expectingErr: true,
 		},
 		"Wrong position prefix": {
-			key:          []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%d%s%s%s%s", []byte{0x01}, "|", addrFormat(defaultAddress), "|", defaultPoolId, "|", DefaultLowerTick, "|", DefaultUpperTick, "|", joinTimeFormat(DefaultJoinTime), "|", DefaultFreezeDuration.String())),
-			val:          cdc.MustMarshal(&model.Position{Liquidity: DefaultLiquidityAmt}),
+			key:          []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%d%s%s%s%s", []byte{0x01}, "|", addrFormat(defaultAddress), "|", defaultPoolId, "|", DefaultLowerTick, "|", DefaultUpperTick, "|", joinTimeFormat(defaultJoinTime), "|", DefaultFreezeDuration.String())),
+			val:          cdc.MustMarshal(&sdk.DecProto{Dec: DefaultLiquidityAmt}),
 			expectingErr: true,
 		},
 		"Wrong poolid": {
-			key:          []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%d%s%s%s%s", types.PositionPrefix, "|", addrFormat(defaultAddress), "|", -1, "|", DefaultLowerTick, "|", DefaultUpperTick, "|", joinTimeFormat(DefaultJoinTime), "|", DefaultFreezeDuration.String())),
-			val:          cdc.MustMarshal(&model.Position{Liquidity: DefaultLiquidityAmt}),
+			key:          []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%d%s%s%s%s", types.PositionPrefix, "|", addrFormat(defaultAddress), "|", -1, "|", DefaultLowerTick, "|", DefaultUpperTick, "|", joinTimeFormat(defaultJoinTime), "|", DefaultFreezeDuration.String())),
+			val:          cdc.MustMarshal(&sdk.DecProto{Dec: DefaultLiquidityAmt}),
 			expectingErr: true,
 		},
 		"Wrong lower tick": {
-			key:          []byte(fmt.Sprintf("%s%s%s%s%d%s%s%s%d%s%s%s%s", types.PositionPrefix, "|", addrFormat(defaultAddress), "|", defaultPoolId, "|", "WrongLowerTick", "|", DefaultUpperTick, "|", joinTimeFormat(DefaultJoinTime), "|", DefaultFreezeDuration.String())),
-			val:          cdc.MustMarshal(&model.Position{Liquidity: DefaultLiquidityAmt}),
+			key:          []byte(fmt.Sprintf("%s%s%s%s%d%s%s%s%d%s%s%s%s", types.PositionPrefix, "|", addrFormat(defaultAddress), "|", defaultPoolId, "|", "WrongLowerTick", "|", DefaultUpperTick, "|", joinTimeFormat(defaultJoinTime), "|", DefaultFreezeDuration.String())),
+			val:          cdc.MustMarshal(&sdk.DecProto{Dec: DefaultLiquidityAmt}),
 			expectingErr: true,
 		},
 		"Wrong upper tick": {
-			key:          []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%s%s%s%s%s", types.PositionPrefix, "|", addrFormat(defaultAddress), "|", defaultPoolId, "|", DefaultLowerTick, "|", "WrongUpperTick", "|", joinTimeFormat(DefaultJoinTime), "|", DefaultFreezeDuration.String())),
-			val:          cdc.MustMarshal(&model.Position{Liquidity: DefaultLiquidityAmt}),
+			key:          []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%s%s%s%s%s", types.PositionPrefix, "|", addrFormat(defaultAddress), "|", defaultPoolId, "|", DefaultLowerTick, "|", "WrongUpperTick", "|", joinTimeFormat(defaultJoinTime), "|", DefaultFreezeDuration.String())),
+			val:          cdc.MustMarshal(&sdk.DecProto{Dec: DefaultLiquidityAmt}),
 			expectingErr: true,
 		},
 		"Wrong join time": {
-			key:          []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%d%s%s%s%s", types.PositionPrefix, "|", addrFormat(defaultAddress), "|", defaultPoolId, "|", DefaultLowerTick, "|", DefaultUpperTick, "|", DefaultJoinTime, "|", DefaultFreezeDuration.String())),
-			val:          cdc.MustMarshal(&model.Position{Liquidity: DefaultLiquidityAmt}),
+			key:          []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%d%s%s%s%s", types.PositionPrefix, "|", addrFormat(defaultAddress), "|", defaultPoolId, "|", DefaultLowerTick, "|", DefaultUpperTick, "|", defaultJoinTime, "|", DefaultFreezeDuration.String())),
+			val:          cdc.MustMarshal(&sdk.DecProto{Dec: DefaultLiquidityAmt}),
 			expectingErr: true,
 		},
 		"Wrong freeze duration": {
-			key:          []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%d%s%s%s%s", types.PositionPrefix, "|", addrFormat(defaultAddress), "|", defaultPoolId, "|", DefaultLowerTick, "|", DefaultUpperTick, "|", DefaultJoinTime, "|", DefaultFreezeDuration)),
-			val:          cdc.MustMarshal(&model.Position{Liquidity: DefaultLiquidityAmt}),
+			key:          []byte(fmt.Sprintf("%s%s%s%s%d%s%d%s%d%s%s%s%s", types.PositionPrefix, "|", addrFormat(defaultAddress), "|", defaultPoolId, "|", DefaultLowerTick, "|", DefaultUpperTick, "|", defaultJoinTime, "|", DefaultFreezeDuration)),
+			val:          cdc.MustMarshal(&sdk.DecProto{Dec: DefaultLiquidityAmt}),
 			expectingErr: true,
 		},
 		"Invalid val bytes": {
-			key:          types.KeyFullPosition(defaultPoolId, defaultAddress, DefaultLowerTick, DefaultUpperTick, DefaultJoinTime, DefaultFreezeDuration),
+			key:          types.KeyFullPosition(defaultPoolId, defaultAddress, DefaultLowerTick, DefaultUpperTick, defaultJoinTime, DefaultFreezeDuration),
 			val:          []byte{1, 2, 3, 4, 5, 6, 7},
 			expectingErr: true,
 		},
 		"Sufficient test case": {
-			key:          types.KeyFullPosition(defaultPoolId, defaultAddress, DefaultLowerTick, DefaultUpperTick, DefaultJoinTime, DefaultFreezeDuration),
-			val:          cdc.MustMarshal(&model.Position{Liquidity: DefaultLiquidityAmt}),
+			key:          types.KeyFullPosition(defaultPoolId, defaultAddress, DefaultLowerTick, DefaultUpperTick, defaultJoinTime, DefaultFreezeDuration),
+			val:          cdc.MustMarshal(&sdk.DecProto{Dec: DefaultLiquidityAmt}),
 			expectingErr: false,
 		},
 	}
 
 	for name, tc := range tests {
+		tc := tc
 		s.Run(name, func() {
+
 			fullPosition, err := cl.ParseFullPositionFromBytes(tc.key, tc.val)
 			if tc.expectingErr {
 				s.Require().Error(err)
-				s.Require().Equal(fullPosition, types.FullPositionByOwnerResult{})
+				s.Require().Equal(fullPosition, model.Position{})
 			} else {
 				s.Require().NoError(err)
 
@@ -175,10 +177,9 @@ func (s *KeeperTestSuite) TestParseFullPositionFromBytes() {
 				s.Require().Equal(defaultPoolId, fullPosition.PoolId)
 				s.Require().Equal(DefaultLowerTick, fullPosition.LowerTick)
 				s.Require().Equal(DefaultUpperTick, fullPosition.UpperTick)
-				s.Require().Equal(DefaultJoinTime, fullPosition.JoinTime)
+				s.Require().Equal(defaultJoinTime, fullPosition.JoinTime)
 				s.Require().Equal(DefaultFreezeDuration, fullPosition.FreezeDuration)
 				s.Require().Equal(DefaultLiquidityAmt, fullPosition.Liquidity)
-
 			}
 		})
 	}
diff --git a/x/concentrated-liquidity/tick_test.go b/x/concentrated-liquidity/tick_test.go
index 701471df3..bd9e9aa23 100644
--- a/x/concentrated-liquidity/tick_test.go
+++ b/x/concentrated-liquidity/tick_test.go
@@ -9,7 +9,8 @@ import (
 
 	cl "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/model"
-	types "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
+	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
+	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types/query"
 )
 
 const validPoolId = 1
@@ -590,19 +591,19 @@ func (s *KeeperTestSuite) TestCrossTick() {
 }
 
 func (s *KeeperTestSuite) TestGetLiquidityDepthFromIterator() {
-	firstTickLiquidityDepth := types.LiquidityDepth{
+	firstTickLiquidityDepth := query.LiquidityDepth{
 		TickIndex:    sdk.NewInt(-3),
 		LiquidityNet: sdk.NewDec(-30),
 	}
-	secondTickLiquidityDepth := types.LiquidityDepth{
+	secondTickLiquidityDepth := query.LiquidityDepth{
 		TickIndex:    sdk.NewInt(1),
 		LiquidityNet: sdk.NewDec(10),
 	}
-	thirdTickLiquidityDepth := types.LiquidityDepth{
+	thirdTickLiquidityDepth := query.LiquidityDepth{
 		TickIndex:    sdk.NewInt(2),
 		LiquidityNet: sdk.NewDec(20),
 	}
-	fourthTickLiquidityDepth := types.LiquidityDepth{
+	fourthTickLiquidityDepth := query.LiquidityDepth{
 		TickIndex:    sdk.NewInt(4),
 		LiquidityNet: sdk.NewDec(40),
 	}
@@ -612,13 +613,13 @@ func (s *KeeperTestSuite) TestGetLiquidityDepthFromIterator() {
 		expectedErr             bool
 		lowerTick               int64
 		upperTick               int64
-		expectedLiquidityDepths []types.LiquidityDepth
+		expectedLiquidityDepths []query.LiquidityDepth
 	}{
 		{
 			name:      "Entire range of user position",
 			lowerTick: firstTickLiquidityDepth.TickIndex.Int64(),
 			upperTick: fourthTickLiquidityDepth.TickIndex.Int64(),
-			expectedLiquidityDepths: []types.LiquidityDepth{
+			expectedLiquidityDepths: []query.LiquidityDepth{
 				firstTickLiquidityDepth,
 				secondTickLiquidityDepth,
 				thirdTickLiquidityDepth,
@@ -629,7 +630,7 @@ func (s *KeeperTestSuite) TestGetLiquidityDepthFromIterator() {
 			name:      "Half range of user position",
 			lowerTick: thirdTickLiquidityDepth.TickIndex.Int64(),
 			upperTick: fourthTickLiquidityDepth.TickIndex.Int64(),
-			expectedLiquidityDepths: []types.LiquidityDepth{
+			expectedLiquidityDepths: []query.LiquidityDepth{
 				thirdTickLiquidityDepth,
 				fourthTickLiquidityDepth,
 			},
@@ -638,7 +639,7 @@ func (s *KeeperTestSuite) TestGetLiquidityDepthFromIterator() {
 			name:      "single range",
 			lowerTick: thirdTickLiquidityDepth.TickIndex.Int64(),
 			upperTick: thirdTickLiquidityDepth.TickIndex.Int64(),
-			expectedLiquidityDepths: []types.LiquidityDepth{
+			expectedLiquidityDepths: []query.LiquidityDepth{
 				thirdTickLiquidityDepth,
 			},
 		},
@@ -646,7 +647,7 @@ func (s *KeeperTestSuite) TestGetLiquidityDepthFromIterator() {
 			name:                    "tick that does not exist",
 			lowerTick:               10,
 			upperTick:               10,
-			expectedLiquidityDepths: []types.LiquidityDepth{},
+			expectedLiquidityDepths: []query.LiquidityDepth{},
 		},
 		{
 			name:        "invalid pool id",
diff --git a/x/gamm/keeper/migrate_test.go b/x/gamm/keeper/migrate_test.go
index 3bf200669..7e0793716 100644
--- a/x/gamm/keeper/migrate_test.go
+++ b/x/gamm/keeper/migrate_test.go
@@ -8,7 +8,6 @@ import (
 
 	"github.com/osmosis-labs/osmosis/osmomath"
 	cl "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity"
-	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/model"
 	"github.com/osmosis-labs/osmosis/v15/x/gamm/types"
 )
 
@@ -34,7 +33,7 @@ func (suite *KeeperTestSuite) TestMigrate() {
 		param                  param
 		expectedErr            error
 		sharesToCreate         sdk.Int
-		expectedPosition       *model.Position
+		expectedLiquidity      sdk.Dec
 		setupPoolMigrationLink bool
 		errTolerance           osmomath.ErrTolerance
 	}{
@@ -46,7 +45,7 @@ func (suite *KeeperTestSuite) TestMigrate() {
 				sharesToMigrateAmount: defaultGammShares.Amount,
 			},
 			sharesToCreate:         defaultGammShares.Amount,
-			expectedPosition:       &model.Position{Liquidity: sdk.MustNewDecFromStr("100000000000.000000010000000000")},
+			expectedLiquidity:      sdk.MustNewDecFromStr("100000000000.000000010000000000"),
 			setupPoolMigrationLink: true,
 			errTolerance:           defaultErrorTolerance,
 		},
@@ -58,7 +57,7 @@ func (suite *KeeperTestSuite) TestMigrate() {
 				sharesToMigrateAmount: defaultGammShares.Amount,
 			},
 			sharesToCreate:         defaultGammShares.Amount,
-			expectedPosition:       &model.Position{Liquidity: sdk.MustNewDecFromStr("100000000000.000000010000000000")},
+			expectedLiquidity:      sdk.MustNewDecFromStr("100000000000.000000010000000000"),
 			setupPoolMigrationLink: false,
 			expectedErr:            types.PoolMigrationLinkNotFoundError{PoolIdLeaving: 1},
 			errTolerance:           defaultErrorTolerance,
@@ -71,7 +70,7 @@ func (suite *KeeperTestSuite) TestMigrate() {
 				sharesToMigrateAmount: defaultGammShares.Amount.Quo(sdk.NewInt(2)),
 			},
 			sharesToCreate:         defaultGammShares.Amount,
-			expectedPosition:       &model.Position{Liquidity: sdk.MustNewDecFromStr("50000000000.000000005000000000")},
+			expectedLiquidity:      sdk.MustNewDecFromStr("50000000000.000000005000000000"),
 			setupPoolMigrationLink: true,
 			errTolerance:           defaultErrorTolerance,
 		},
@@ -83,7 +82,7 @@ func (suite *KeeperTestSuite) TestMigrate() {
 				sharesToMigrateAmount: defaultGammShares.Amount.Quo(sdk.NewInt(2)),
 			},
 			sharesToCreate:         defaultGammShares.Amount.Mul(sdk.NewInt(2)),
-			expectedPosition:       &model.Position{Liquidity: sdk.MustNewDecFromStr("49999999999.000000004999999999")},
+			expectedLiquidity:      sdk.MustNewDecFromStr("49999999999.000000004999999999"),
 			setupPoolMigrationLink: true,
 			errTolerance:           defaultErrorTolerance,
 		},
@@ -95,7 +94,7 @@ func (suite *KeeperTestSuite) TestMigrate() {
 				sharesToMigrateAmount: invalidGammShares.Amount,
 			},
 			sharesToCreate:         defaultGammShares.Amount,
-			expectedPosition:       &model.Position{Liquidity: sdk.MustNewDecFromStr("100000000000.000000010000000000")},
+			expectedLiquidity:      sdk.MustNewDecFromStr("100000000000.000000010000000000"),
 			setupPoolMigrationLink: true,
 			expectedErr:            sdkerrors.Wrap(sdkerrors.ErrInsufficientFunds, fmt.Sprintf("%s is smaller than %s", defaultGammShares, invalidGammShares)),
 		},
@@ -167,7 +166,7 @@ func (suite *KeeperTestSuite) TestMigrate() {
 
 			// Assure the position was not created.
 			// TODO: When we implement lock breaking, we need to change time.Time{} to the lock's end time.
-			_, err := suite.App.ConcentratedLiquidityKeeper.GetPosition(suite.Ctx, clPool.GetId(), test.param.sender, minTick, maxTick, defaultJoinTime, 0)
+			_, err := suite.App.ConcentratedLiquidityKeeper.GetPositionLiquidity(suite.Ctx, clPool.GetId(), test.param.sender, minTick, maxTick, defaultJoinTime, 0)
 			suite.Require().Error(err)
 			continue
 		}
@@ -187,9 +186,9 @@ func (suite *KeeperTestSuite) TestMigrate() {
 
 		// Assure the expected position was created.
 		// TODO: When we implement lock breaking, we need to change time.Time{} to the lock's end time.
-		position, err := suite.App.ConcentratedLiquidityKeeper.GetPosition(suite.Ctx, clPool.GetId(), test.param.sender, minTick, maxTick, defaultJoinTime, 0)
+		position, err := suite.App.ConcentratedLiquidityKeeper.GetPositionLiquidity(suite.Ctx, clPool.GetId(), test.param.sender, minTick, maxTick, defaultJoinTime, 0)
 		suite.Require().NoError(err)
-		suite.Require().Equal(test.expectedPosition, position)
+		suite.Require().Equal(test.expectedLiquidity, position)
 
 		// Note gamm pool balance after migration
 		gammPoolEthBalancePostMigrate := suite.App.BankKeeper.GetBalance(suite.Ctx, balancerPoolAddress, ETH)
diff --git a/x/superfluid/keeper/migrate_test.go b/x/superfluid/keeper/migrate_test.go
index aec29e25d..8abcbbf92 100644
--- a/x/superfluid/keeper/migrate_test.go
+++ b/x/superfluid/keeper/migrate_test.go
@@ -197,7 +197,7 @@ func (suite *KeeperTestSuite) TestUnlockAndMigrate() {
 
 			// Check that concentrated liquidity position now exists
 			minTick, maxTick := cl.GetMinAndMaxTicksFromExponentAtPriceOne(clPool.GetPrecisionFactorAtPriceOne())
-			position, err := suite.App.ConcentratedLiquidityKeeper.GetPosition(ctx, poolIdEntering, poolJoinAcc, minTick, maxTick, defaultJoinTime, freezeDuration)
+			position, err := suite.App.ConcentratedLiquidityKeeper.GetPositionLiquidity(ctx, poolIdEntering, poolJoinAcc, minTick, maxTick, defaultJoinTime, freezeDuration)
 			suite.Require().NoError(err)
 			suite.Require().NotNil(position)