Repository: osmosis-labs/osmosis
Pull request #5295 (2023-05-25 00:11:12)

perf: remove repeated pool unmarshaling and uptime accum refetching overhead in swaps
<!-- < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < ☺
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: #XXX

## What is the purpose of the change

This is a second improvement identified in:
https://github.com/osmosis-labs/osmosis/pull/5287

It focuses around:
- removes repeated proto unmarshaling inside the loop as we cross ticks in `updateUptimeAccumulatorsToNow`
- repeated uptime accumulator fetching and unsmarsharling. Instead, we fetch them once at the top and operated on the accumulators passed into methods as a slice. In Go, slice elements are mutated as long as they are edited directly via slice instead of copied to a local variable.

## Testing and Verifying

- Covered by existing tests
- Added new tests where applicable

Added strict tests to ensure that the parameter `uptimeAccums` are mutated in:

- [x] `updateGivenPoolUptimeAccumulatorsToNow`
- [x] `claimAndResetFullRangeBalancerPool`
- [x] `prepareBalancerPoolAsFullRange`  

## Documentation and Release Note

  - [ ] Does this pull request introduce a new feature or user-facing behavior changes?
  - [ ] Changelog entry added to `Unreleased` section of `CHANGELOG.md`?

Where is the change documented? 
  - [ ] Specification (`x/{module}/README.md`)
  - [ ] Osmosis documentation site
  - [ ] Code comments?
  - [x] N/A


Patch:
diff --git a/.github/workflows/changelog-entry-reminder.yml b/.github/workflows/changelog-entry-reminder.yml
index cbbf0f5d1..1b4f11df4 100644
--- a/.github/workflows/changelog-entry-reminder.yml
+++ b/.github/workflows/changelog-entry-reminder.yml
@@ -4,6 +4,8 @@ on:
     types: [assigned, opened, synchronize, reopened, labeled, unlabeled]
     branches:
       - main
+    paths-ignore:
+      - '**/*.md'
 jobs:
   build:
     name: Check Actions
diff --git a/.github/workflows/required_labels.yml b/.github/workflows/required_labels.yml
index a5aacac0c..b0a14a342 100644
--- a/.github/workflows/required_labels.yml
+++ b/.github/workflows/required_labels.yml
@@ -5,6 +5,8 @@ on:
     types: [opened, labeled, unlabeled, synchronize]
     branches:
       - 'main'
+    paths-ignore:
+      - '**/*.md'
 jobs:
   state_compatability_labels:
     runs-on: ubuntu-latest
diff --git a/Makefile b/Makefile
index d03ac729d..2718226ee 100644
--- a/Makefile
+++ b/Makefile
@@ -5,7 +5,7 @@ COMMIT := $(shell git log -1 --format='%H')
 LEDGER_ENABLED ?= true
 SDK_PACK := $(shell go list -m github.com/cosmos/cosmos-sdk | sed  's/ /\@/g')
 GO_VERSION := $(shell cat go.mod | grep -E 'go [0-9].[0-9]+' | cut -d ' ' -f 2)
-GO_MODULE := $(shell cat go.mod | grep module | cut -d ' ' -f 2)
+GO_MODULE := $(shell cat go.mod | grep "module " | cut -d ' ' -f 2)
 BUILDDIR ?= $(CURDIR)/build
 DOCKER := $(shell which docker)
 E2E_UPGRADE_VERSION := "v16"
diff --git a/app/keepers/keepers.go b/app/keepers/keepers.go
index e584b4910..e2656ba7c 100644
--- a/app/keepers/keepers.go
+++ b/app/keepers/keepers.go
@@ -33,8 +33,8 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/upgrade"
 	upgradekeeper "github.com/cosmos/cosmos-sdk/x/upgrade/keeper"
 	upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
-	icq "github.com/strangelove-ventures/async-icq/v4"
-	icqtypes "github.com/strangelove-ventures/async-icq/v4/types"
+	icq "github.com/cosmos/ibc-apps/modules/async-icq/v4"
+	icqtypes "github.com/cosmos/ibc-apps/modules/async-icq/v4/types"
 
 	downtimedetector "github.com/osmosis-labs/osmosis/v15/x/downtime-detector"
 	downtimetypes "github.com/osmosis-labs/osmosis/v15/x/downtime-detector/types"
@@ -48,6 +48,7 @@ import (
 	ibchookskeeper "github.com/osmosis-labs/osmosis/x/ibc-hooks/keeper"
 	ibchookstypes "github.com/osmosis-labs/osmosis/x/ibc-hooks/types"
 
+	icqkeeper "github.com/cosmos/ibc-apps/modules/async-icq/v4/keeper"
 	icahost "github.com/cosmos/ibc-go/v4/modules/apps/27-interchain-accounts/host"
 	icahostkeeper "github.com/cosmos/ibc-go/v4/modules/apps/27-interchain-accounts/host/keeper"
 	icahosttypes "github.com/cosmos/ibc-go/v4/modules/apps/27-interchain-accounts/host/types"
@@ -58,7 +59,6 @@ import (
 	porttypes "github.com/cosmos/ibc-go/v4/modules/core/05-port/types"
 	ibchost "github.com/cosmos/ibc-go/v4/modules/core/24-host"
 	ibckeeper "github.com/cosmos/ibc-go/v4/modules/core/keeper"
-	icqkeeper "github.com/strangelove-ventures/async-icq/v4/keeper"
 
 	packetforward "github.com/strangelove-ventures/packet-forward-middleware/v4/router"
 	packetforwardkeeper "github.com/strangelove-ventures/packet-forward-middleware/v4/router/keeper"
@@ -276,7 +276,7 @@ func (appKeepers *AppKeepers) InitNormalKeepers(
 		appKeepers.IBCKeeper.ChannelKeeper,
 		&appKeepers.IBCKeeper.PortKeeper,
 		appKeepers.ScopedICQKeeper,
-		NewQuerierWrapper(bApp),
+		bApp.GRPCQueryRouter(),
 	)
 	appKeepers.ICQKeeper = &icqKeeper
 
diff --git a/app/keepers/modules.go b/app/keepers/modules.go
index c87775784..c89e91564 100644
--- a/app/keepers/modules.go
+++ b/app/keepers/modules.go
@@ -26,8 +26,8 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/staking"
 	"github.com/cosmos/cosmos-sdk/x/upgrade"
 	upgradeclient "github.com/cosmos/cosmos-sdk/x/upgrade/client"
+	icq "github.com/cosmos/ibc-apps/modules/async-icq/v4"
 	ica "github.com/cosmos/ibc-go/v4/modules/apps/27-interchain-accounts"
-	icq "github.com/strangelove-ventures/async-icq/v4"
 
 	_ "github.com/osmosis-labs/osmosis/v15/client/docs/statik"
 	clclient "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/client"
diff --git a/app/modules.go b/app/modules.go
index 4cdcca6b1..d4088f142 100644
--- a/app/modules.go
+++ b/app/modules.go
@@ -5,7 +5,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/client"
 	capabilitykeeper "github.com/cosmos/cosmos-sdk/x/capability/keeper"
 	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
-	icq "github.com/strangelove-ventures/async-icq/v4"
+	icq "github.com/cosmos/ibc-apps/modules/async-icq/v4"
 
 	ibctransfertypes "github.com/cosmos/ibc-go/v4/modules/apps/transfer/types"
 	ibc "github.com/cosmos/ibc-go/v4/modules/core"
@@ -20,7 +20,7 @@ import (
 	ica "github.com/cosmos/ibc-go/v4/modules/apps/27-interchain-accounts"
 	icatypes "github.com/cosmos/ibc-go/v4/modules/apps/27-interchain-accounts/types"
 
-	icqtypes "github.com/strangelove-ventures/async-icq/v4/types"
+	icqtypes "github.com/cosmos/ibc-apps/modules/async-icq/v4/types"
 
 	downtimemodule "github.com/osmosis-labs/osmosis/v15/x/downtime-detector/module"
 	downtimetypes "github.com/osmosis-labs/osmosis/v15/x/downtime-detector/types"
diff --git a/app/upgrades/v15/constants.go b/app/upgrades/v15/constants.go
index 351396832..a59f959fe 100644
--- a/app/upgrades/v15/constants.go
+++ b/app/upgrades/v15/constants.go
@@ -2,7 +2,7 @@ package v15
 
 import (
 	store "github.com/cosmos/cosmos-sdk/store/types"
-	icqtypes "github.com/strangelove-ventures/async-icq/v4/types"
+	icqtypes "github.com/cosmos/ibc-apps/modules/async-icq/v4/types"
 	packetforwardtypes "github.com/strangelove-ventures/packet-forward-middleware/v4/router/types"
 
 	"github.com/osmosis-labs/osmosis/v15/app/upgrades"
diff --git a/app/upgrades/v15/upgrades.go b/app/upgrades/v15/upgrades.go
index 3c4e59443..fb62156e2 100644
--- a/app/upgrades/v15/upgrades.go
+++ b/app/upgrades/v15/upgrades.go
@@ -12,8 +12,8 @@ import (
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 	upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
-	icqkeeper "github.com/strangelove-ventures/async-icq/v4/keeper"
-	icqtypes "github.com/strangelove-ventures/async-icq/v4/types"
+	icqkeeper "github.com/cosmos/ibc-apps/modules/async-icq/v4/keeper"
+	icqtypes "github.com/cosmos/ibc-apps/modules/async-icq/v4/types"
 
 	"github.com/osmosis-labs/osmosis/v15/wasmbinding"
 	ibcratelimit "github.com/osmosis-labs/osmosis/v15/x/ibc-rate-limit"
diff --git a/go.mod b/go.mod
index 39bc772c6..3a3b9522f 100644
--- a/go.mod
+++ b/go.mod
@@ -8,6 +8,7 @@ require (
 	github.com/cosmos/cosmos-proto v1.0.0-beta.2
 	github.com/cosmos/cosmos-sdk v0.47.2
 	github.com/cosmos/go-bip39 v1.0.0
+	github.com/cosmos/ibc-apps/modules/async-icq/v4 v4.0.0-20230524151648-c02fa46c2860
 	github.com/cosmos/ibc-go/v4 v4.3.0
 	github.com/gogo/protobuf v1.3.3
 	github.com/golang/mock v1.6.0
@@ -29,7 +30,6 @@ require (
 	github.com/spf13/cobra v1.7.0
 	github.com/spf13/pflag v1.0.5
 	github.com/spf13/viper v1.15.0
-	github.com/strangelove-ventures/async-icq/v4 v4.0.0-rc0
 	github.com/strangelove-ventures/packet-forward-middleware/v4 v4.0.5
 	github.com/stretchr/testify v1.8.3
 	github.com/tendermint/tendermint v0.34.26
@@ -106,7 +106,7 @@ require (
 	github.com/bombsimon/wsl/v3 v3.4.0 // indirect
 	github.com/breml/bidichk v0.2.4 // indirect
 	github.com/breml/errchkjson v0.3.1 // indirect
-	github.com/btcsuite/btcd v0.22.2 // indirect
+	github.com/btcsuite/btcd v0.22.3 // indirect
 	github.com/butuzov/ireturn v0.1.1 // indirect
 	github.com/cenkalti/backoff/v4 v4.1.3 // indirect
 	github.com/cespare/xxhash v1.1.0 // indirect
@@ -329,5 +329,4 @@ replace (
 	github.com/tendermint/tendermint => github.com/informalsystems/tendermint v0.34.24
 	// use grpc compatible with cosmos protobufs
 	google.golang.org/grpc => google.golang.org/grpc v1.33.2
-
 )
diff --git a/go.sum b/go.sum
index 20a2215dc..df7c571ee 100644
--- a/go.sum
+++ b/go.sum
@@ -166,8 +166,8 @@ github.com/btcsuite/btcd v0.0.0-20190315201642-aa6e0f35703c/go.mod h1:DrZx5ec/dm
 github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
 github.com/btcsuite/btcd v0.21.0-beta.0.20201114000516-e9c7a5ac6401/go.mod h1:Sv4JPQ3/M+teHz9Bo5jBpkNcP0x6r7rdihlNL/7tTAs=
 github.com/btcsuite/btcd v0.22.1/go.mod h1:wqgTSL29+50LRkmOVknEdmt8ZojIzhuWvgu/iptuN7Y=
-github.com/btcsuite/btcd v0.22.2 h1:vBZ+lGGd1XubpOWO67ITJpAEsICWhA0YzqkcpkgNBfo=
-github.com/btcsuite/btcd v0.22.2/go.mod h1:wqgTSL29+50LRkmOVknEdmt8ZojIzhuWvgu/iptuN7Y=
+github.com/btcsuite/btcd v0.22.3 h1:kYNaWFvOw6xvqP0vR20RP1Zq1DVMBxEO8QN5d1/EfNg=
+github.com/btcsuite/btcd v0.22.3/go.mod h1:wqgTSL29+50LRkmOVknEdmt8ZojIzhuWvgu/iptuN7Y=
 github.com/btcsuite/btcd/btcec/v2 v2.1.2/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE=
 github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
@@ -252,6 +252,8 @@ github.com/cosmos/gorocksdb v1.2.0 h1:d0l3jJG8M4hBouIZq0mDUHZ+zjOx044J3nGRskwTb4
 github.com/cosmos/gorocksdb v1.2.0/go.mod h1:aaKvKItm514hKfNJpUJXnnOWeBnk2GL4+Qw9NHizILw=
 github.com/cosmos/iavl v0.19.4 h1:t82sN+Y0WeqxDLJRSpNd8YFX5URIrT+p8n6oJbJ2Dok=
 github.com/cosmos/iavl v0.19.4/go.mod h1:X9PKD3J0iFxdmgNLa7b2LYWdsGd90ToV5cAONApkEPw=
+github.com/cosmos/ibc-apps/modules/async-icq/v4 v4.0.0-20230524151648-c02fa46c2860 h1:25/KpA4WJqdFjKFsa3VEL0ctWRovkEsqIn2phCAi9v0=
+github.com/cosmos/ibc-apps/modules/async-icq/v4 v4.0.0-20230524151648-c02fa46c2860/go.mod h1:X/dLZ6QxTImzno7qvD6huLhh6ZZBcRt2URn4YCLcXFY=
 github.com/cosmos/ibc-go/v4 v4.3.0 h1:yOzVsyZzsv4XPBux8gq+D0LhZn45yGWKjvT+6Vyo5no=
 github.com/cosmos/ibc-go/v4 v4.3.0/go.mod h1:CcLvIoi9NNtIbNsxs4KjBGjYhlwqtsmXy1AKARKiMzQ=
 github.com/cosmos/interchain-accounts v0.2.6 h1:TV2M2g1/Rb9MCNw1YePdBKE0rcEczNj1RGHT+2iRYas=
@@ -1135,8 +1137,6 @@ github.com/ssgreg/nlreturn/v2 v2.2.1/go.mod h1:E/iiPB78hV7Szg2YfRgyIrk1AD6JVMTRk
 github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q=
 github.com/stbenjam/no-sprintf-host-port v0.1.1 h1:tYugd/yrm1O0dV+ThCbaKZh195Dfm07ysF0U6JQXczc=
 github.com/stbenjam/no-sprintf-host-port v0.1.1/go.mod h1:TLhvtIvONRzdmkFiio4O8LHsN9N74I+PhRquPsxpL0I=
-github.com/strangelove-ventures/async-icq/v4 v4.0.0-rc0 h1:foE/5O2/XiqGsdTKx3R0BTfKgW9KnUYyQLZt0WFSesE=
-github.com/strangelove-ventures/async-icq/v4 v4.0.0-rc0/go.mod h1:thzXHoaK1MgPDCjN7Rp9A/VcHA4cmjQpKCtVNt2O2xk=
 github.com/strangelove-ventures/packet-forward-middleware/v4 v4.0.5 h1:KKUqeGhVBK38+1LwThC8IeIcsJZ6COX5kvhiJroFqCM=
 github.com/strangelove-ventures/packet-forward-middleware/v4 v4.0.5/go.mod h1:4zAtg449/JISRmf+sbmqolqSLP+QJBh+EtWkWtt/AKE=
 github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
diff --git a/proto/osmosis/concentrated-liquidity/query.proto b/proto/osmosis/concentrated-liquidity/query.proto
index e3d0c779c..b35123cfc 100644
--- a/proto/osmosis/concentrated-liquidity/query.proto
+++ b/proto/osmosis/concentrated-liquidity/query.proto
@@ -118,11 +118,7 @@ message TickLiquidityNet {
     (gogoproto.moretags) = "yaml:\"liquidity_net\"",
     (gogoproto.nullable) = false
   ];
-  string tick_index = 2 [
-    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
-    (gogoproto.moretags) = "yaml:\"tick\"",
-    (gogoproto.nullable) = false
-  ];
+  int64 tick_index = 2 [ (gogoproto.moretags) = "yaml:\"tick_index\"" ];
 }
 
 message LiquidityDepthWithRange {
@@ -131,16 +127,8 @@ message LiquidityDepthWithRange {
     (gogoproto.moretags) = "yaml:\"liquidity_net\"",
     (gogoproto.nullable) = false
   ];
-  string lower_tick = 2 [
-    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
-    (gogoproto.moretags) = "yaml:\"tick\"",
-    (gogoproto.nullable) = false
-  ];
-  string upper_tick = 3 [
-    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int",
-    (gogoproto.moretags) = "yaml:\"tick\"",
-    (gogoproto.nullable) = false
-  ];
+  int64 lower_tick = 2 [ (gogoproto.moretags) = "yaml:\"lower_tick\"" ];
+  int64 upper_tick = 3 [ (gogoproto.moretags) = "yaml:\"upper_tick\"" ];
 }
 
 //=============================== LiquidityNetInDirection
diff --git a/x/concentrated-liquidity/client/queryproto/query.pb.go b/x/concentrated-liquidity/client/queryproto/query.pb.go
index b70b96ecb..611c51e3d 100644
--- a/x/concentrated-liquidity/client/queryproto/query.pb.go
+++ b/x/concentrated-liquidity/client/queryproto/query.pb.go
@@ -405,7 +405,7 @@ func (m *ParamsResponse) GetParams() types1.Params {
 
 type TickLiquidityNet struct {
 	LiquidityNet github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=liquidity_net,json=liquidityNet,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidity_net" yaml:"liquidity_net"`
-	TickIndex    github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=tick_index,json=tickIndex,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"tick_index" yaml:"tick"`
+	TickIndex    int64                                  `protobuf:"varint,2,opt,name=tick_index,json=tickIndex,proto3" json:"tick_index,omitempty" yaml:"tick_index"`
 }
 
 func (m *TickLiquidityNet) Reset()         { *m = TickLiquidityNet{} }
@@ -441,10 +441,17 @@ func (m *TickLiquidityNet) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_TickLiquidityNet proto.InternalMessageInfo
 
+func (m *TickLiquidityNet) GetTickIndex() int64 {
+	if m != nil {
+		return m.TickIndex
+	}
+	return 0
+}
+
 type LiquidityDepthWithRange struct {
 	LiquidityAmount github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=liquidity_amount,json=liquidityAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidity_amount" yaml:"liquidity_net"`
-	LowerTick       github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=lower_tick,json=lowerTick,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"lower_tick" yaml:"tick"`
-	UpperTick       github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=upper_tick,json=upperTick,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"upper_tick" yaml:"tick"`
+	LowerTick       int64                                  `protobuf:"varint,2,opt,name=lower_tick,json=lowerTick,proto3" json:"lower_tick,omitempty" yaml:"lower_tick"`
+	UpperTick       int64                                  `protobuf:"varint,3,opt,name=upper_tick,json=upperTick,proto3" json:"upper_tick,omitempty" yaml:"upper_tick"`
 }
 
 func (m *LiquidityDepthWithRange) Reset()         { *m = LiquidityDepthWithRange{} }
@@ -480,6 +487,20 @@ func (m *LiquidityDepthWithRange) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_LiquidityDepthWithRange proto.InternalMessageInfo
 
+func (m *LiquidityDepthWithRange) GetLowerTick() int64 {
+	if m != nil {
+		return m.LowerTick
+	}
+	return 0
+}
+
+func (m *LiquidityDepthWithRange) GetUpperTick() int64 {
+	if m != nil {
+		return m.UpperTick
+	}
+	return 0
+}
+
 // =============================== LiquidityNetInDirection
 type LiquidityNetInDirectionRequest struct {
 	PoolId     uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"`
@@ -919,97 +940,96 @@ func init() {
 }
 
 var fileDescriptor_5c83e18b11fd607d = []byte{
-	// 1434 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0x4f, 0x6f, 0x1b, 0x45,
-	0x14, 0xcf, 0x3a, 0x4d, 0x5a, 0x4f, 0xe2, 0xfe, 0x99, 0x38, 0x34, 0x75, 0x5b, 0xbb, 0x0c, 0x6a,
-	0x89, 0xda, 0x66, 0x57, 0x6d, 0x13, 0x55, 0xf4, 0x0f, 0x28, 0x76, 0x48, 0x65, 0x8a, 0x42, 0x58,
-	0x11, 0x90, 0x10, 0xd2, 0x6a, 0xbd, 0x3b, 0x71, 0x46, 0xb1, 0x67, 0x9c, 0xdd, 0xd9, 0xb6, 0x16,
-	0xe2, 0x42, 0x85, 0xc4, 0xad, 0x48, 0x7c, 0x08, 0x38, 0x70, 0xe4, 0x33, 0xa0, 0xc2, 0x01, 0x55,
-	0xe2, 0x82, 0x90, 0x30, 0xd0, 0x72, 0xe3, 0x66, 0xbe, 0x00, 0xda, 0xd9, 0x99, 0xdd, 0xb5, 0xeb,
-	0x28, 0x76, 0x12, 0x4e, 0xde, 0xd9, 0xf7, 0xde, 0xef, 0xf7, 0x7e, 0x6f, 0xdf, 0xfc, 0x33, 0xb8,
-	0xcc, 0xfc, 0x26, 0xf3, 0x89, 0x6f, 0x38, 0x8c, 0x3a, 0x98, 0x72, 0xcf, 0xe6, 0xd8, 0x5d, 0x68,
-	0x90, 0x9d, 0x80, 0xb8, 0x84, 0xb7, 0x8d, 0x9d, 0x00, 0x7b, 0x6d, 0xbd, 0xe5, 0x31, 0xce, 0xe0,
-	0x45, 0xe9, 0xab, 0xa7, 0x7d, 0x63, 0x57, 0xfd, 0xc1, 0xb5, 0x1a, 0xe6, 0xf6, 0xb5, 0x42, 0xbe,
-	0xce, 0xea, 0x4c, 0x44, 0x18, 0xe1, 0x53, 0x14, 0x5c, 0xb8, 0xb2, 0x07, 0x51, 0xcb, 0xf6, 0xec,
-	0xa6, 0x2f, 0x9d, 0x8b, 0x8e, 0xf0, 0x36, 0x6a, 0xb6, 0x8f, 0x0d, 0x89, 0x6b, 0x38, 0x8c, 0x50,
-	0x69, 0xbf, 0x9c, 0xb6, 0x8b, 0x14, 0x63, 0xaf, 0x96, 0x5d, 0x27, 0xd4, 0xe6, 0x84, 0x29, 0xdf,
-	0x73, 0x75, 0xc6, 0xea, 0x0d, 0x6c, 0xd8, 0x2d, 0x62, 0xd8, 0x94, 0x32, 0x2e, 0x8c, 0x8a, 0xe9,
-	0x8c, 0xb4, 0x8a, 0x51, 0x2d, 0xd8, 0x34, 0x6c, 0xda, 0x56, 0xa6, 0x88, 0xc4, 0x8a, 0xa4, 0x44,
-	0x03, 0x69, 0x2a, 0xf5, 0x47, 0x71, 0xd2, 0xc4, 0x3e, 0xb7, 0x9b, 0x2d, 0x25, 0xa0, 0xdf, 0xc1,
-	0x0d, 0xbc, 0x74, 0x52, 0x0b, 0x7b, 0x55, 0x83, 0xf9, 0x24, 0x71, 0x47, 0x3b, 0x20, 0xbf, 0xe1,
-	0x63, 0x6f, 0x5d, 0xbe, 0xf5, 0x4d, 0xbc, 0x13, 0x60, 0x9f, 0xc3, 0xab, 0xe0, 0xa8, 0xed, 0xba,
-	0x1e, 0xf6, 0xfd, 0x39, 0xed, 0x82, 0x36, 0x9f, 0x2d, 0xc3, 0x6e, 0xa7, 0x74, 0xbc, 0x6d, 0x37,
-	0x1b, 0xb7, 0x90, 0x34, 0x20, 0x53, 0xb9, 0xc0, 0x2b, 0xe0, 0x68, 0x8b, 0xb1, 0x86, 0x45, 0xdc,
-	0xb9, 0xcc, 0x05, 0x6d, 0xfe, 0x48, 0xda, 0x5b, 0x1a, 0x90, 0x39, 0x19, 0x3e, 0x55, 0x5d, 0xf4,
-	0xa5, 0x06, 0x66, 0xfb, 0x38, 0xfd, 0x16, 0xa3, 0x3e, 0x86, 0x0c, 0x64, 0x55, 0x7a, 0x21, 0xed,
-	0xf8, 0xfc, 0xd4, 0xf5, 0xfb, 0xfa, 0x50, 0xad, 0xa1, 0x2b, 0xb0, 0x8f, 0x08, 0xdf, 0xda, 0xa0,
-	0x2e, 0xf6, 0x1a, 0x6d, 0x42, 0xeb, 0xcb, 0xbe, 0x8f, 0x79, 0xd9, 0xc3, 0xf6, 0xb6, 0xcb, 0x1e,
-	0xd2, 0xf2, 0x91, 0xa7, 0x9d, 0xd2, 0x98, 0x99, 0x70, 0xa0, 0x35, 0x30, 0xa3, 0x02, 0xcb, 0xed,
-	0xaa, 0xab, 0xc4, 0xdf, 0x04, 0x53, 0xca, 0x27, 0x94, 0xa4, 0x09, 0x49, 0xaf, 0x74, 0x3b, 0x25,
-	0xa8, 0x24, 0xc5, 0x46, 0x64, 0x02, 0x35, 0xaa, 0xba, 0xe8, 0x0b, 0x0d, 0xe4, 0x7b, 0x01, 0xa5,
-	0xb2, 0x26, 0x38, 0xa6, 0xdc, 0x04, 0xdc, 0xff, 0x22, 0x2c, 0xa6, 0x40, 0x1f, 0x82, 0xe9, 0x75,
-	0xc6, 0x1a, 0xf1, 0xd7, 0x5c, 0x05, 0x20, 0xe9, 0x5e, 0xf1, 0x89, 0xa6, 0xae, 0x5f, 0xd2, 0x65,
-	0xe3, 0x85, 0xad, 0xae, 0x47, 0xb3, 0x31, 0x26, 0xb5, 0xeb, 0x58, 0xc6, 0x9a, 0xa9, 0x48, 0xf4,
-	0x44, 0x03, 0x39, 0x09, 0x2c, 0x85, 0x2d, 0x81, 0x89, 0xf0, 0xb3, 0xaa, 0xcf, 0x95, 0xd7, 0xa3,
-	0xf6, 0xd4, 0x55, 0x7b, 0xea, 0xcb, 0xb4, 0x5d, 0xce, 0xfe, 0xf4, 0xfd, 0xc2, 0x44, 0x18, 0x57,
-	0x35, 0x23, 0x6f, 0x78, 0x6f, 0x40, 0x42, 0xaf, 0xef, 0x99, 0x50, 0xc4, 0xd9, 0x93, 0xd1, 0x09,
-	0x90, 0x5b, 0x17, 0xf3, 0x5b, 0xa6, 0x8b, 0x36, 0xc0, 0x71, 0xf5, 0x42, 0xa6, 0x58, 0x01, 0x93,
-	0xd1, 0x12, 0x20, 0x2b, 0x7f, 0x71, 0x8f, 0xca, 0x47, 0xe1, 0xb2, 0xa6, 0x32, 0x14, 0xfd, 0xae,
-	0x81, 0x93, 0x1f, 0x10, 0x67, 0xfb, 0x5d, 0xe5, 0xb6, 0x86, 0x39, 0xdc, 0x06, 0xb9, 0x38, 0xcc,
-	0xa2, 0x98, 0xcb, 0xa9, 0xb2, 0x1a, 0x46, 0xfe, 0xd6, 0x29, 0x5d, 0xaa, 0x13, 0xbe, 0x15, 0xd4,
-	0x74, 0x87, 0x35, 0xe5, 0x24, 0x97, 0x3f, 0x0b, 0xbe, 0xbb, 0x6d, 0xf0, 0x76, 0x0b, 0xfb, 0xfa,
-	0x0a, 0x76, 0xba, 0x9d, 0x52, 0x3e, 0xea, 0xab, 0x1e, 0x30, 0x64, 0x4e, 0x37, 0xd2, 0x64, 0x9f,
-	0x00, 0xc0, 0x89, 0xb3, 0x6d, 0x11, 0xea, 0xe2, 0x47, 0xa2, 0x64, 0xd9, 0xf2, 0xdd, 0x11, 0x98,
-	0xaa, 0x94, 0x77, 0x3b, 0xa5, 0xa9, 0x88, 0x29, 0x44, 0x42, 0x66, 0x36, 0xfc, 0xa9, 0x86, 0x78,
-	0xe8, 0x69, 0x06, 0x9c, 0x8e, 0xb5, 0xad, 0xe0, 0x16, 0xdf, 0x0a, 0x1b, 0xce, 0xb4, 0x69, 0x1d,
-	0xc3, 0x1d, 0x70, 0x32, 0xc9, 0xcc, 0x6e, 0xb2, 0x80, 0x1e, 0xb6, 0xd2, 0x13, 0xf1, 0x78, 0x59,
-	0xc0, 0x87, 0x62, 0x1b, 0xec, 0x21, 0xf6, 0xac, 0x30, 0xc3, 0x43, 0x12, 0x2b, 0x00, 0xc3, 0x6f,
-	0x18, 0xa2, 0x07, 0xad, 0x96, 0x42, 0x1f, 0x3f, 0x14, 0x74, 0x01, 0x18, 0xa2, 0xa3, 0x3f, 0x32,
-	0xa0, 0x98, 0x6e, 0x93, 0x2a, 0x5d, 0x21, 0x1e, 0x76, 0xc2, 0x76, 0x55, 0xf3, 0x31, 0xb5, 0x5e,
-	0x6a, 0x7b, 0xad, 0x97, 0x50, 0x07, 0xc7, 0x38, 0xdb, 0xc6, 0xd4, 0x22, 0x54, 0x56, 0x62, 0xa6,
-	0xdb, 0x29, 0x9d, 0x90, 0xec, 0xd2, 0x82, 0xcc, 0xa3, 0xe2, 0xb1, 0x4a, 0xe1, 0x22, 0x00, 0x3e,
-	0xb7, 0x3d, 0x9e, 0xa8, 0x1b, 0x2f, 0xcf, 0x76, 0x3b, 0xa5, 0x53, 0x51, 0x44, 0x62, 0x43, 0x66,
-	0x56, 0x0c, 0x44, 0x4d, 0xde, 0x00, 0xd3, 0x81, 0x8f, 0x2d, 0x27, 0x90, 0x55, 0x39, 0x72, 0x41,
-	0x9b, 0x3f, 0x56, 0x3e, 0xdd, 0xed, 0x94, 0x66, 0xa2, 0xb8, 0xb4, 0x15, 0x99, 0x20, 0xf0, 0x71,
-	0x25, 0x88, 0xca, 0xb9, 0x08, 0x40, 0x8d, 0x05, 0xd4, 0x8d, 0x02, 0x27, 0xfa, 0x09, 0x13, 0x1b,
-	0x32, 0xb3, 0x62, 0x90, 0x26, 0xa4, 0xcc, 0x12, 0xef, 0xe6, 0x26, 0x07, 0x11, 0x2a, 0x6b, 0x44,
-	0xb8, 0xc6, 0xca, 0x62, 0xf0, 0x4d, 0x06, 0x94, 0x76, 0xad, 0xb0, 0x9c, 0xf5, 0x5b, 0xe9, 0xa6,
-	0x75, 0xc3, 0x86, 0x56, 0x6b, 0xd4, 0xcd, 0x21, 0x57, 0xde, 0xfe, 0xe9, 0x2e, 0x57, 0x84, 0xa4,
-	0x57, 0xc5, 0x34, 0xf1, 0xe1, 0xab, 0x60, 0xda, 0x09, 0x3c, 0x0f, 0x53, 0x9e, 0x74, 0xeb, 0xb8,
-	0x39, 0x25, 0xdf, 0x09, 0xad, 0x0f, 0xc1, 0x29, 0xe5, 0x12, 0x47, 0xcb, 0xbe, 0x7b, 0x67, 0xe4,
-	0x29, 0x34, 0x17, 0x95, 0xe7, 0x25, 0x40, 0x64, 0x9e, 0x94, 0xef, 0xe2, 0xac, 0xd1, 0x7d, 0x70,
-	0x2e, 0x1e, 0xac, 0x47, 0xfd, 0x29, 0xe6, 0xf4, 0x7e, 0x1a, 0x11, 0x3d, 0xd6, 0xc0, 0xf9, 0x5d,
-	0xd0, 0x64, 0xd1, 0x6b, 0x20, 0x9b, 0xe8, 0x8b, 0xaa, 0xfd, 0xe6, 0x90, 0xd5, 0xde, 0x65, 0xf1,
-	0x51, 0x7b, 0x76, 0xa2, 0xf2, 0x3d, 0x90, 0xaf, 0x34, 0x6c, 0xd2, 0xb4, 0x6b, 0x0d, 0xbc, 0x8a,
-	0xb1, 0x7f, 0xe0, 0x4d, 0xfb, 0x11, 0x98, 0xed, 0x03, 0x94, 0x6a, 0x2c, 0x70, 0xdc, 0x51, 0x06,
-	0x6b, 0x13, 0x63, 0xd5, 0x40, 0x67, 0x7a, 0x36, 0x2a, 0x25, 0xa0, 0xc2, 0x08, 0x2d, 0x9f, 0x0f,
-	0xb3, 0xed, 0x76, 0x4a, 0xb3, 0xf2, 0x1b, 0xf5, 0x84, 0x23, 0x33, 0xe7, 0xa4, 0x89, 0xd0, 0x06,
-	0x28, 0xc4, 0xcc, 0x55, 0x51, 0x1c, 0xf2, 0xe0, 0x10, 0x04, 0x3d, 0xce, 0x80, 0xb3, 0x03, 0x71,
-	0xa5, 0xae, 0x1d, 0x90, 0x4f, 0x12, 0x23, 0xb1, 0x7d, 0x6f, 0x75, 0xaf, 0x49, 0x75, 0x67, 0xfb,
-	0xd5, 0x25, 0x20, 0xc8, 0x9c, 0x71, 0x5e, 0xa6, 0x0e, 0x29, 0x37, 0x99, 0xb7, 0x89, 0x09, 0xc7,
-	0x6e, 0x9a, 0x32, 0x33, 0x22, 0xe5, 0x20, 0x10, 0x64, 0xce, 0xc4, 0xaf, 0x13, 0xca, 0xeb, 0x4f,
-	0x72, 0x60, 0xe2, 0xfd, 0xf0, 0x10, 0x01, 0xbf, 0xd5, 0x80, 0x38, 0x7d, 0xf8, 0xf0, 0xc6, 0xd0,
-	0x87, 0xae, 0xe4, 0xf0, 0x54, 0x58, 0x1c, 0x2d, 0x28, 0x2a, 0x32, 0x5a, 0xfc, 0xfc, 0x97, 0xbf,
-	0xbf, 0xce, 0xe8, 0xf0, 0xaa, 0x31, 0xe8, 0x40, 0x9e, 0x9c, 0xc7, 0xe3, 0xdb, 0x85, 0x48, 0xf0,
-	0x3b, 0x0d, 0x4c, 0x46, 0xe7, 0x0f, 0x38, 0x34, 0x6d, 0xfa, 0xf8, 0x53, 0x58, 0x1a, 0x31, 0x4a,
-	0x66, 0xbb, 0x24, 0xb2, 0x35, 0xe0, 0xc2, 0xb0, 0xd9, 0x46, 0x39, 0xfe, 0xac, 0x81, 0x5c, 0xcf,
-	0x51, 0x1e, 0xde, 0x1e, 0x92, 0x7f, 0xd0, 0xa5, 0xa3, 0x70, 0x67, 0x7f, 0xc1, 0x52, 0x43, 0x59,
-	0x68, 0xb8, 0x03, 0x6f, 0x0d, 0x5d, 0x71, 0x89, 0x60, 0x7c, 0x2a, 0xef, 0x31, 0x9f, 0xc1, 0x7f,
-	0x34, 0x30, 0x3b, 0x70, 0x89, 0x83, 0x95, 0x51, 0xd7, 0xb1, 0x01, 0xcb, 0x6d, 0x61, 0xe5, 0x60,
-	0x20, 0x52, 0xe8, 0x3d, 0x21, 0x74, 0x19, 0xbe, 0x35, 0xa4, 0xd0, 0x64, 0x1f, 0x54, 0x67, 0x1e,
-	0xcb, 0x13, 0x9a, 0xfe, 0xd5, 0x52, 0x87, 0xbe, 0xde, 0x7d, 0x14, 0xbe, 0x3d, 0x6a, 0xaa, 0x03,
-	0x4f, 0x3a, 0x85, 0xd5, 0x83, 0xc2, 0x48, 0xcd, 0x55, 0xa1, 0xb9, 0x02, 0x97, 0x47, 0xd6, 0x4c,
-	0x31, 0xb7, 0x08, 0xb5, 0xdc, 0x58, 0xd9, 0x8f, 0x1a, 0xc8, 0xf5, 0x2c, 0xf8, 0x43, 0x37, 0xed,
-	0xa0, 0x7d, 0x67, 0xe8, 0xa6, 0x1d, 0xb8, 0xc7, 0xa0, 0xbb, 0x42, 0xd7, 0x4d, 0xb8, 0x34, 0xa4,
-	0xae, 0xde, 0x1d, 0x05, 0xfe, 0xa5, 0x81, 0x99, 0x01, 0x4b, 0x3d, 0x5c, 0x1e, 0x35, 0xa9, 0x97,
-	0xb6, 0x9f, 0x42, 0xf9, 0x20, 0x10, 0x52, 0x5d, 0x45, 0xa8, 0xbb, 0x0b, 0x6f, 0x8f, 0xac, 0x2e,
-	0x59, 0xde, 0xe1, 0x0f, 0x5a, 0x78, 0x9b, 0x4d, 0x2e, 0xd5, 0xf0, 0xd6, 0x88, 0x57, 0xe7, 0xd4,
-	0xd5, 0xbe, 0x70, 0x7b, 0x5f, 0xb1, 0xfb, 0xfc, 0x58, 0xf1, 0x0e, 0x5d, 0x6b, 0x5b, 0xc4, 0x2d,
-	0x6f, 0x3d, 0x7d, 0x5e, 0xd4, 0x9e, 0x3d, 0x2f, 0x6a, 0x7f, 0x3e, 0x2f, 0x6a, 0x5f, 0xbd, 0x28,
-	0x8e, 0x3d, 0x7b, 0x51, 0x1c, 0xfb, 0xf5, 0x45, 0x71, 0xec, 0xe3, 0xb5, 0xd4, 0xe1, 0x4f, 0x42,
-	0x2f, 0x34, 0xec, 0x9a, 0x1f, 0xf3, 0x3c, 0xb8, 0xb6, 0x64, 0x3c, 0xda, 0xed, 0x2f, 0x1d, 0xa7,
-	0x41, 0x30, 0xe5, 0xd1, 0xbf, 0x55, 0xd1, 0xbd, 0x7b, 0x52, 0xfc, 0xdc, 0xf8, 0x2f, 0x00, 0x00,
-	0xff, 0xff, 0xad, 0x5e, 0x43, 0x48, 0x84, 0x13, 0x00, 0x00,
+	// 1424 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcd, 0x6f, 0x1b, 0x45,
+	0x14, 0xcf, 0xa6, 0x4d, 0x5a, 0x4f, 0xe2, 0x7e, 0x4c, 0x1c, 0x9a, 0xba, 0xad, 0x5d, 0x06, 0xb5,
+	0x44, 0x6d, 0xb3, 0xab, 0x7e, 0x44, 0x15, 0xfd, 0x00, 0x65, 0x1d, 0x52, 0x99, 0xa2, 0x10, 0x56,
+	0x04, 0x24, 0x2e, 0xab, 0xf5, 0xee, 0xc4, 0x19, 0xc5, 0x9e, 0x71, 0x76, 0x67, 0xdb, 0x5a, 0x88,
+	0x0b, 0x15, 0x12, 0xb7, 0x22, 0xf1, 0x47, 0xc0, 0x81, 0x23, 0xfc, 0x0b, 0xa8, 0x70, 0x40, 0x95,
+	0xb8, 0x20, 0x0e, 0x06, 0x5a, 0x6e, 0xdc, 0xcc, 0x85, 0x23, 0xda, 0xd9, 0x99, 0xdd, 0xb5, 0xe3,
+	0x28, 0x76, 0x52, 0x4e, 0xde, 0xd9, 0xf7, 0xf1, 0x7b, 0xbf, 0x37, 0x6f, 0xde, 0xbc, 0x35, 0xb8,
+	0xc4, 0x82, 0x26, 0x0b, 0x48, 0x60, 0xb8, 0x8c, 0xba, 0x98, 0x72, 0xdf, 0xe1, 0xd8, 0x5b, 0x68,
+	0x90, 0xed, 0x90, 0x78, 0x84, 0xb7, 0x8d, 0xed, 0x10, 0xfb, 0x6d, 0xbd, 0xe5, 0x33, 0xce, 0xe0,
+	0x05, 0xa9, 0xab, 0x67, 0x75, 0x13, 0x55, 0xfd, 0xc1, 0xd5, 0x1a, 0xe6, 0xce, 0xd5, 0x62, 0xa1,
+	0xce, 0xea, 0x4c, 0x58, 0x18, 0xd1, 0x53, 0x6c, 0x5c, 0xbc, 0xbc, 0x07, 0x50, 0xcb, 0xf1, 0x9d,
+	0x66, 0x20, 0x95, 0x4b, 0xae, 0xd0, 0x36, 0x6a, 0x4e, 0x80, 0x0d, 0xe9, 0xd7, 0x70, 0x19, 0xa1,
+	0x52, 0x7e, 0x29, 0x2b, 0x17, 0x21, 0x26, 0x5a, 0x2d, 0xa7, 0x4e, 0xa8, 0xc3, 0x09, 0x53, 0xba,
+	0x67, 0xeb, 0x8c, 0xd5, 0x1b, 0xd8, 0x70, 0x5a, 0xc4, 0x70, 0x28, 0x65, 0x5c, 0x08, 0x15, 0xd2,
+	0x69, 0x29, 0x15, 0xab, 0x5a, 0xb8, 0x61, 0x38, 0xb4, 0xad, 0x44, 0x31, 0x88, 0x1d, 0x53, 0x89,
+	0x17, 0x52, 0x54, 0xee, 0xb7, 0xe2, 0xa4, 0x89, 0x03, 0xee, 0x34, 0x5b, 0x8a, 0x40, 0xbf, 0x82,
+	0x17, 0xfa, 0xd9, 0xa0, 0x16, 0xf6, 0xca, 0x06, 0x0b, 0x48, 0xaa, 0x8e, 0xb6, 0x41, 0x61, 0x3d,
+	0xc0, 0xfe, 0x9a, 0x7c, 0x1b, 0x58, 0x78, 0x3b, 0xc4, 0x01, 0x87, 0x57, 0xc0, 0x11, 0xc7, 0xf3,
+	0x7c, 0x1c, 0x04, 0x73, 0xda, 0x79, 0x6d, 0x3e, 0x67, 0xc2, 0x6e, 0xa7, 0x7c, 0xac, 0xed, 0x34,
+	0x1b, 0xb7, 0x90, 0x14, 0x20, 0x4b, 0xa9, 0xc0, 0xcb, 0xe0, 0x48, 0x8b, 0xb1, 0x86, 0x4d, 0xbc,
+	0xb9, 0xf1, 0xf3, 0xda, 0xfc, 0xe1, 0xac, 0xb6, 0x14, 0x20, 0x6b, 0x32, 0x7a, 0xaa, 0x7a, 0xe8,
+	0x0b, 0x0d, 0xcc, 0xf6, 0x61, 0x06, 0x2d, 0x46, 0x03, 0x0c, 0x19, 0xc8, 0xa9, 0xf0, 0x22, 0xd8,
+	0x43, 0xf3, 0x53, 0xd7, 0xee, 0xeb, 0x43, 0x95, 0x86, 0xae, 0x9c, 0x7d, 0x44, 0xf8, 0xe6, 0x3a,
+	0xf5, 0xb0, 0xdf, 0x68, 0x13, 0x5a, 0x5f, 0x0a, 0x02, 0xcc, 0x4d, 0x1f, 0x3b, 0x5b, 0x1e, 0x7b,
+	0x48, 0xcd, 0xc3, 0x4f, 0x3b, 0xe5, 0x31, 0x2b, 0xc5, 0x40, 0xab, 0x60, 0x46, 0x19, 0x9a, 0xed,
+	0xaa, 0xa7, 0xc8, 0xdf, 0x04, 0x53, 0x4a, 0x27, 0xa2, 0xa4, 0x09, 0x4a, 0xaf, 0x74, 0x3b, 0x65,
+	0xa8, 0x28, 0x25, 0x42, 0x64, 0x01, 0xb5, 0xaa, 0x7a, 0xe8, 0x73, 0x0d, 0x14, 0x7a, 0x1d, 0x4a,
+	0x66, 0x4d, 0x70, 0x54, 0xa9, 0x09, 0x77, 0xff, 0x0b, 0xb1, 0x04, 0x02, 0x7d, 0x08, 0xa6, 0xd7,
+	0x18, 0x6b, 0x24, 0xbb, 0xb9, 0x02, 0x40, 0x5a, 0xbd, 0x62, 0x8b, 0xa6, 0xae, 0x5d, 0xd4, 0x65,
+	0xe1, 0x45, 0xa5, 0xae, 0xc7, 0xa7, 0x31, 0x01, 0x75, 0xea, 0x58, 0xda, 0x5a, 0x19, 0x4b, 0xf4,
+	0x44, 0x03, 0x79, 0xe9, 0x58, 0x12, 0x5b, 0x04, 0x13, 0xd1, 0xb6, 0xaa, 0xed, 0x2a, 0xe8, 0x71,
+	0x79, 0xea, 0xaa, 0x3c, 0xf5, 0x25, 0xda, 0x36, 0x73, 0x3f, 0x7d, 0xb7, 0x30, 0x11, 0xd9, 0x55,
+	0xad, 0x58, 0x1b, 0xde, 0x1b, 0x10, 0xd0, 0xeb, 0x7b, 0x06, 0x14, 0x63, 0xf6, 0x44, 0x74, 0x1c,
+	0xe4, 0xd7, 0xc4, 0xf9, 0x96, 0xe1, 0xa2, 0x75, 0x70, 0x4c, 0xbd, 0x90, 0x21, 0x56, 0xc0, 0x64,
+	0xdc, 0x02, 0x64, 0xe6, 0x2f, 0xec, 0x91, 0xf9, 0xd8, 0x5c, 0xe6, 0x54, 0x9a, 0xa2, 0xef, 0x35,
+	0x70, 0xe2, 0x03, 0xe2, 0x6e, 0xbd, 0xab, 0xd4, 0x56, 0x31, 0x87, 0x5b, 0x20, 0x9f, 0x98, 0xd9,
+	0x14, 0x73, 0x79, 0x54, 0x56, 0x22, 0xcb, 0xdf, 0x3a, 0xe5, 0x8b, 0x75, 0xc2, 0x37, 0xc3, 0x9a,
+	0xee, 0xb2, 0xa6, 0x3c, 0xe4, 0xf2, 0x67, 0x21, 0xf0, 0xb6, 0x0c, 0xde, 0x6e, 0xe1, 0x40, 0x5f,
+	0xc6, 0x6e, 0xb7, 0x53, 0x2e, 0xc4, 0x75, 0xd5, 0xe3, 0x0c, 0x59, 0xd3, 0x8d, 0x2c, 0xd8, 0x0d,
+	0x00, 0x38, 0x71, 0xb7, 0x6c, 0x42, 0x3d, 0xfc, 0x48, 0xa4, 0xec, 0x90, 0x39, 0xdb, 0xed, 0x94,
+	0x4f, 0xc6, 0xb6, 0xa9, 0x0c, 0x59, 0xb9, 0x68, 0x51, 0x15, 0xcf, 0xff, 0x6a, 0xe0, 0x54, 0x12,
+	0xf3, 0x32, 0x6e, 0xf1, 0xcd, 0xa8, 0x90, 0x2c, 0x87, 0xd6, 0x31, 0xdc, 0x06, 0x27, 0x52, 0x44,
+	0xa7, 0xc9, 0x42, 0xfa, 0xb2, 0x19, 0x1c, 0x4f, 0xd6, 0x4b, 0xc2, 0x7d, 0x44, 0xa2, 0xc1, 0x1e,
+	0x62, 0xdf, 0x8e, 0x22, 0xdc, 0x49, 0x22, 0x95, 0x21, 0x2b, 0x27, 0x16, 0x51, 0xce, 0x23, 0xab,
+	0xb0, 0xd5, 0x52, 0x56, 0x87, 0xfa, 0xad, 0x52, 0x19, 0xb2, 0x72, 0x62, 0x11, 0x59, 0xa1, 0xdf,
+	0xc7, 0x41, 0x29, 0xbb, 0x5d, 0x55, 0xba, 0x4c, 0x7c, 0xec, 0x46, 0x65, 0xa3, 0xce, 0x45, 0xa6,
+	0x6f, 0x69, 0x7b, 0xf5, 0x2d, 0xa8, 0x83, 0xa3, 0x9c, 0x6d, 0x61, 0x6a, 0x93, 0xb8, 0x62, 0x73,
+	0xe6, 0x4c, 0xb7, 0x53, 0x3e, 0x2e, 0xd3, 0x2f, 0x25, 0xc8, 0x3a, 0x22, 0x1e, 0xab, 0x34, 0x8a,
+	0x3a, 0xe0, 0x8e, 0xcf, 0x77, 0x89, 0x3a, 0x95, 0x21, 0x2b, 0x27, 0x16, 0x82, 0xeb, 0x1b, 0x60,
+	0x3a, 0x0c, 0xb0, 0xed, 0x86, 0x92, 0xed, 0xe1, 0xf3, 0xda, 0xfc, 0x51, 0xf3, 0x54, 0xb7, 0x53,
+	0x9e, 0x91, 0x6c, 0x33, 0x52, 0x64, 0x81, 0x30, 0xc0, 0x95, 0x30, 0x49, 0x53, 0x8d, 0x85, 0xd4,
+	0x8b, 0x0d, 0x27, 0xfa, 0x01, 0x53, 0x19, 0xb2, 0x72, 0x62, 0x91, 0x05, 0xa4, 0xcc, 0x16, 0xef,
+	0xe6, 0x26, 0x07, 0x01, 0x2a, 0x69, 0x0c, 0xb8, 0xca, 0x4c, 0xb1, 0xf8, 0x7a, 0x1c, 0x94, 0x77,
+	0xcd, 0xb0, 0x3c, 0x7d, 0x9b, 0xd9, 0x22, 0xf3, 0xa2, 0x02, 0x54, 0xbd, 0xe2, 0xe6, 0x90, 0x1d,
+	0xb0, 0xff, 0xd8, 0xc9, 0x93, 0x99, 0xd6, 0x96, 0x28, 0xeb, 0x00, 0xbe, 0x0a, 0xa6, 0xdd, 0xd0,
+	0xf7, 0x31, 0xe5, 0x99, 0xea, 0xb2, 0xa6, 0xe4, 0x3b, 0xc1, 0xf5, 0x21, 0x38, 0xa9, 0x54, 0x12,
+	0x6b, 0xb1, 0x33, 0x39, 0xf3, 0x9d, 0x91, 0x4b, 0x7e, 0x2e, 0x4e, 0xcf, 0x0e, 0x87, 0xc8, 0x3a,
+	0x21, 0xdf, 0x25, 0x51, 0xa3, 0xfb, 0xe0, 0x6c, 0xb2, 0x58, 0x8b, 0xeb, 0x53, 0x9c, 0xc1, 0xfd,
+	0x14, 0x22, 0x7a, 0xac, 0x81, 0x73, 0xbb, 0x78, 0x93, 0x49, 0xaf, 0x81, 0x5c, 0xca, 0x2f, 0xce,
+	0xf6, 0x9b, 0x43, 0x66, 0x7b, 0x97, 0x66, 0xa1, 0xee, 0xce, 0x94, 0xe5, 0x7b, 0xa0, 0x50, 0x69,
+	0x38, 0xa4, 0xe9, 0xd4, 0x1a, 0x78, 0x05, 0xe3, 0xe0, 0xc0, 0x97, 0xe7, 0x23, 0x30, 0xdb, 0xe7,
+	0x50, 0xb2, 0xb1, 0xc1, 0x31, 0x57, 0x09, 0xec, 0x0d, 0x8c, 0x55, 0x01, 0x9d, 0xee, 0xb9, 0x30,
+	0x14, 0x81, 0x0a, 0x23, 0xd4, 0x3c, 0x17, 0x45, 0xdb, 0xed, 0x94, 0x67, 0xe5, 0x1e, 0xf5, 0x98,
+	0x23, 0x2b, 0xef, 0x66, 0x81, 0xd0, 0x3a, 0x28, 0x26, 0xc8, 0x55, 0x91, 0x1c, 0xf2, 0xe0, 0x25,
+	0x10, 0x7a, 0x3c, 0x0e, 0xce, 0x0c, 0xf4, 0x2b, 0x79, 0x6d, 0x83, 0x42, 0x1a, 0x18, 0x49, 0xe4,
+	0x7b, 0xb3, 0x7b, 0x4d, 0xb2, 0x3b, 0xd3, 0xcf, 0x2e, 0x75, 0x82, 0xac, 0x19, 0x77, 0x27, 0x74,
+	0x04, 0xb9, 0xc1, 0xfc, 0x0d, 0x4c, 0x38, 0xf6, 0xb2, 0x90, 0xe3, 0x23, 0x42, 0x0e, 0x72, 0x82,
+	0xac, 0x99, 0xe4, 0x75, 0x0a, 0x79, 0xed, 0x49, 0x1e, 0x4c, 0xbc, 0x1f, 0x5d, 0xe6, 0xf0, 0x1b,
+	0x0d, 0x88, 0x29, 0x20, 0x80, 0xd7, 0x87, 0x1e, 0x7e, 0xd2, 0x21, 0xa6, 0x78, 0x63, 0x34, 0xa3,
+	0x38, 0xc9, 0xe8, 0xc6, 0x67, 0xbf, 0xfc, 0xf5, 0xd5, 0xb8, 0x0e, 0xaf, 0x18, 0x83, 0x06, 0xe3,
+	0x74, 0x2e, 0x4e, 0xa6, 0x7c, 0x11, 0xe0, 0xb7, 0x1a, 0x98, 0x8c, 0xe7, 0x00, 0x38, 0x34, 0x6c,
+	0x76, 0x0c, 0x29, 0x2e, 0x8e, 0x68, 0x25, 0xa3, 0x5d, 0x14, 0xd1, 0x1a, 0x70, 0x61, 0xd8, 0x68,
+	0xe3, 0x18, 0x7f, 0xd6, 0x40, 0xbe, 0x67, 0xa4, 0x86, 0xb7, 0x87, 0xc4, 0x1f, 0x34, 0xfc, 0x17,
+	0xef, 0xec, 0xcf, 0x58, 0x72, 0x30, 0x05, 0x87, 0x3b, 0xf0, 0xd6, 0xd0, 0x19, 0x97, 0x1e, 0x8c,
+	0x4f, 0xe4, 0xf7, 0xc4, 0xa7, 0xf0, 0x6f, 0x0d, 0xcc, 0x0e, 0x6c, 0x71, 0xb0, 0x32, 0x6a, 0x1f,
+	0x1b, 0xd0, 0x6e, 0x8b, 0xcb, 0x07, 0x73, 0x22, 0x89, 0xde, 0x13, 0x44, 0x97, 0xe0, 0x5b, 0x43,
+	0x12, 0x4d, 0xef, 0x41, 0x35, 0xaf, 0xd8, 0xbe, 0xe0, 0xf4, 0x4f, 0x76, 0x48, 0xeb, 0xbd, 0x47,
+	0xe1, 0xdb, 0xa3, 0x86, 0x3a, 0x70, 0xd2, 0x29, 0xae, 0x1c, 0xd4, 0x8d, 0xe4, 0x5c, 0x15, 0x9c,
+	0x2b, 0x70, 0x69, 0x64, 0xce, 0x14, 0x73, 0x9b, 0x50, 0xdb, 0x4b, 0x98, 0xfd, 0xa8, 0x81, 0x7c,
+	0x4f, 0xc3, 0x1f, 0xba, 0x68, 0x07, 0xdd, 0x3b, 0x43, 0x17, 0xed, 0xc0, 0x3b, 0x06, 0xdd, 0x15,
+	0xbc, 0x6e, 0xc2, 0xc5, 0x21, 0x79, 0xf5, 0xde, 0x28, 0xf0, 0x4f, 0x0d, 0xcc, 0x0c, 0x68, 0xf5,
+	0x70, 0x69, 0xd4, 0xa0, 0x76, 0x5c, 0x3f, 0x45, 0xf3, 0x20, 0x2e, 0x24, 0xbb, 0x8a, 0x60, 0x77,
+	0x17, 0xde, 0x1e, 0x99, 0x5d, 0xda, 0xde, 0xe1, 0x0f, 0x5a, 0xf4, 0x55, 0x99, 0x7e, 0xdc, 0xc2,
+	0x5b, 0x23, 0x7e, 0xc2, 0x66, 0x3e, 0xb1, 0x8b, 0xb7, 0xf7, 0x65, 0xbb, 0xcf, 0xcd, 0x4a, 0x6e,
+	0xe8, 0x5a, 0xdb, 0x26, 0x9e, 0xb9, 0xf9, 0xf4, 0x79, 0x49, 0x7b, 0xf6, 0xbc, 0xa4, 0xfd, 0xf1,
+	0xbc, 0xa4, 0x7d, 0xf9, 0xa2, 0x34, 0xf6, 0xec, 0x45, 0x69, 0xec, 0xd7, 0x17, 0xa5, 0xb1, 0x8f,
+	0x57, 0x33, 0xc3, 0x9f, 0x74, 0xbd, 0xd0, 0x70, 0x6a, 0x41, 0x82, 0xf3, 0xe0, 0xea, 0xa2, 0xf1,
+	0x68, 0xb7, 0xbf, 0x56, 0xdc, 0x06, 0xc1, 0x94, 0xc7, 0xff, 0x1a, 0xc5, 0xdf, 0xbf, 0x93, 0xe2,
+	0xe7, 0xfa, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x6c, 0x0f, 0x0b, 0xff, 0x0c, 0x13, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1663,16 +1683,11 @@ func (m *TickLiquidityNet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	{
-		size := m.TickIndex.Size()
-		i -= size
-		if _, err := m.TickIndex.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintQuery(dAtA, i, uint64(size))
+	if m.TickIndex != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.TickIndex))
+		i--
+		dAtA[i] = 0x10
 	}
-	i--
-	dAtA[i] = 0x12
 	{
 		size := m.LiquidityNet.Size()
 		i -= size
@@ -1706,26 +1721,16 @@ func (m *LiquidityDepthWithRange) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	_ = i
 	var l int
 	_ = l
-	{
-		size := m.UpperTick.Size()
-		i -= size
-		if _, err := m.UpperTick.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintQuery(dAtA, i, uint64(size))
+	if m.UpperTick != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.UpperTick))
+		i--
+		dAtA[i] = 0x18
 	}
-	i--
-	dAtA[i] = 0x1a
-	{
-		size := m.LowerTick.Size()
-		i -= size
-		if _, err := m.LowerTick.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintQuery(dAtA, i, uint64(size))
+	if m.LowerTick != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.LowerTick))
+		i--
+		dAtA[i] = 0x10
 	}
-	i--
-	dAtA[i] = 0x12
 	{
 		size := m.LiquidityAmount.Size()
 		i -= size
@@ -2190,8 +2195,9 @@ func (m *TickLiquidityNet) Size() (n int) {
 	_ = l
 	l = m.LiquidityNet.Size()
 	n += 1 + l + sovQuery(uint64(l))
-	l = m.TickIndex.Size()
-	n += 1 + l + sovQuery(uint64(l))
+	if m.TickIndex != 0 {
+		n += 1 + sovQuery(uint64(m.TickIndex))
+	}
 	return n
 }
 
@@ -2203,10 +2209,12 @@ func (m *LiquidityDepthWithRange) Size() (n int) {
 	_ = l
 	l = m.LiquidityAmount.Size()
 	n += 1 + l + sovQuery(uint64(l))
-	l = m.LowerTick.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	l = m.UpperTick.Size()
-	n += 1 + l + sovQuery(uint64(l))
+	if m.LowerTick != 0 {
+		n += 1 + sovQuery(uint64(m.LowerTick))
+	}
+	if m.UpperTick != 0 {
+		n += 1 + sovQuery(uint64(m.UpperTick))
+	}
 	return n
 }
 
@@ -3091,10 +3099,10 @@ func (m *TickLiquidityNet) Unmarshal(dAtA []byte) error {
 			}
 			iNdEx = postIndex
 		case 2:
-			if wireType != 2 {
+			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field TickIndex", wireType)
 			}
-			var stringLen uint64
+			m.TickIndex = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -3104,26 +3112,11 @@ func (m *TickLiquidityNet) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.TickIndex |= int64(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.TickIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -3209,10 +3202,10 @@ func (m *LiquidityDepthWithRange) Unmarshal(dAtA []byte) error {
 			}
 			iNdEx = postIndex
 		case 2:
-			if wireType != 2 {
+			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field LowerTick", wireType)
 			}
-			var stringLen uint64
+			m.LowerTick = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -3222,31 +3215,16 @@ func (m *LiquidityDepthWithRange) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.LowerTick |= int64(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.LowerTick.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		case 3:
-			if wireType != 2 {
+			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field UpperTick", wireType)
 			}
-			var stringLen uint64
+			m.UpperTick = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -3256,26 +3234,11 @@ func (m *LiquidityDepthWithRange) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.UpperTick |= int64(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.UpperTick.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
diff --git a/x/concentrated-liquidity/fees.go b/x/concentrated-liquidity/fees.go
index 21dc21fcb..c49bc44b8 100644
--- a/x/concentrated-liquidity/fees.go
+++ b/x/concentrated-liquidity/fees.go
@@ -32,20 +32,6 @@ func (k Keeper) GetFeeAccumulator(ctx sdk.Context, poolId uint64) (accum.Accumul
 	return acc, nil
 }
 
-// chargeFee charges the given fee on the pool with the given id by updating
-// the internal per-pool accumulator that tracks fee growth per one unit of
-// liquidity. Returns error if fails to get accumulator.
-func (k Keeper) chargeFee(ctx sdk.Context, poolId uint64, feeUpdate sdk.DecCoin) error {
-	feeAccumulator, err := k.GetFeeAccumulator(ctx, poolId)
-	if err != nil {
-		return err
-	}
-
-	feeAccumulator.AddToAccumulator(sdk.NewDecCoins(feeUpdate))
-
-	return nil
-}
-
 // initOrUpdatePositionFeeAccumulator mutates the fee accumulator position by either creating or updating it
 // for the given pool id in the range specified by the given lower and upper ticks, position id and liquidityDelta.
 // If liquidityDelta is positive, it adds liquidity. If liquidityDelta is negative, it removes liquidity.
diff --git a/x/concentrated-liquidity/incentives.go b/x/concentrated-liquidity/incentives.go
index 15a5111f4..7c037ada3 100644
--- a/x/concentrated-liquidity/incentives.go
+++ b/x/concentrated-liquidity/incentives.go
@@ -107,6 +107,7 @@ func (k Keeper) getInitialUptimeGrowthOppositeDirectionOfLastTraversalForTick(ct
 // if it exists, adds the number of full range shares it qualifies for to the CL pool uptime accumulators.
 // This is functionally equivalent to treating the Balancer pool shares as a single full range position on the CL pool,
 // but just for the purposes of incentives. The Balancer pool liquidity is not actually traded against in CL pool swaps.
+// The given uptime accumulators are mutated to reflect the added full range shares.
 //
 // If no canonical Balancer pool exists, this function is a no-op.
 //
@@ -114,7 +115,10 @@ func (k Keeper) getInitialUptimeGrowthOppositeDirectionOfLastTraversalForTick(ct
 // Returns error if a canonical pool ID exists but there is an issue when retrieving the pool assets for this pool.
 //
 // CONTRACT: canonical Balancer pool has the same denoms as the CL pool and is an even-weighted 2-asset pool.
-func (k Keeper) prepareBalancerPoolAsFullRange(ctx sdk.Context, clPoolId uint64) (uint64, sdk.Dec, error) {
+// CONTRACT: the caller validates that the pool with the given id exists.
+// CONTRACT: caller is responsible for the uptimeAccums to be up-to-date.
+// CONTRACT: uptimeAccums are associated with the given pool id.
+func (k Keeper) prepareBalancerPoolAsFullRange(ctx sdk.Context, clPoolId uint64, uptimeAccums []accum.AccumulatorObject) (uint64, sdk.Dec, error) {
 	// Get CL pool from ID
 	clPool, err := k.getPoolById(ctx, clPoolId)
 	if err != nil {
@@ -204,17 +208,12 @@ func (k Keeper) prepareBalancerPoolAsFullRange(ctx sdk.Context, clPoolId uint64)
 
 	// Create a temporary position record on all uptime accumulators with this amount. We expect this to be cleared later
 	// with `claimAndResetFullRangeBalancerPool`
-	uptimeAccums, err := k.GetUptimeAccumulators(ctx, clPoolId)
-	if err != nil {
-		return 0, sdk.ZeroDec(), err
-	}
-
 	// Add full range equivalent shares to each uptime accumulator.
 	// Note that we expect spot price divergence between the CL and balancer pools to be handled by `GetLiquidityFromAmounts`
 	// returning a lower bound on qualifying liquidity.
-	for uptimeIndex, uptimeAccum := range uptimeAccums {
+	for uptimeIndex := range uptimeAccums {
 		balancerPositionName := string(types.KeyBalancerFullRange(clPoolId, canonicalBalancerPoolId, uint64(uptimeIndex)))
-		err := uptimeAccum.NewPosition(balancerPositionName, qualifyingFullRangeShares, nil)
+		err := uptimeAccums[uptimeIndex].NewPosition(balancerPositionName, qualifyingFullRangeShares, nil)
 		if err != nil {
 			return 0, sdk.ZeroDec(), err
 		}
@@ -226,11 +225,14 @@ func (k Keeper) prepareBalancerPoolAsFullRange(ctx sdk.Context, clPoolId uint64)
 // claimAndResetFullRangeBalancerPool claims rewards for the "full range" shares corresponding to the given Balancer pool, and
 // then deletes the record from the uptime accumulators. It adds the claimed rewards to the gauge corresponding to the longest duration
 // lock on the Balancer pool. Importantly, this is a dynamic check such that if a longer duration lock is added in the future, it will
-// begin using that lock.
+// begin using that lock. The given uptime accumulators are mutated to reflect the claimed rewards.
 //
 // Returns the number of coins that were claimed and distrbuted.
 // Returns error if either reward claiming, record deletion or adding to the gauge fails.
-func (k Keeper) claimAndResetFullRangeBalancerPool(ctx sdk.Context, clPoolId uint64, balPoolId uint64) (sdk.Coins, error) {
+// CONTRACT: the caller validates that the pool with the given id exists.
+// CONTRACT: caller is responsible for the uptimeAccums to be up-to-date.
+// CONTRACT: uptimeAccums are associated with the given pool id.
+func (k Keeper) claimAndResetFullRangeBalancerPool(ctx sdk.Context, clPoolId uint64, balPoolId uint64, uptimeAccums []accum.AccumulatorObject) (sdk.Coins, error) {
 	// Get CL pool from ID. This also serves as an early pool existence check.
 	clPool, err := k.getPoolById(ctx, clPoolId)
 	if err != nil {
@@ -249,24 +251,16 @@ func (k Keeper) claimAndResetFullRangeBalancerPool(ctx sdk.Context, clPoolId uin
 		return sdk.Coins{}, err
 	}
 
-	// Get all uptime accumulators for CL pool
-	// Create a temporary position record on all uptime accumulators with this amount. We expect this to be cleared later
-	// with `claimAndResetFullRangeBalancerPool`
-	uptimeAccums, err := k.GetUptimeAccumulators(ctx, clPoolId)
-	if err != nil {
-		return sdk.Coins{}, err
-	}
-
 	// Claim rewards on each uptime accumulator. Delete each record after claiming.
 	totalRewards := sdk.NewCoins()
-	for uptimeIndex, uptimeAccum := range uptimeAccums {
+	for uptimeIndex := range uptimeAccums {
 		// Generate key for the record on the the current uptime accumulator
 		balancerPositionName := string(types.KeyBalancerFullRange(clPoolId, balPoolId, uint64(uptimeIndex)))
 
 		// Ensure that the given balancer pool has a record on the given uptime accumulator.
 		// We expect this to have been set in a prior call to `prepareBalancerAsFullRange`, which
 		// should precede all calls of `claimAndResetFullRangeBalancerPool`
-		recordExists, err := uptimeAccum.HasPosition(balancerPositionName)
+		recordExists, err := uptimeAccums[uptimeIndex].HasPosition(balancerPositionName)
 		if err != nil {
 			return sdk.Coins{}, err
 		}
@@ -276,25 +270,25 @@ func (k Keeper) claimAndResetFullRangeBalancerPool(ctx sdk.Context, clPoolId uin
 
 		// Remove shares from record so it gets cleared when rewards are claimed.
 		// Note that we expect these shares to be correctly updated in a prior call to `prepareBalancerAsFullRange`.
-		numShares, err := uptimeAccum.GetPositionSize(balancerPositionName)
+		numShares, err := uptimeAccums[uptimeIndex].GetPositionSize(balancerPositionName)
 		if err != nil {
 			return sdk.Coins{}, err
 		}
 
-		err = uptimeAccum.RemoveFromPosition(balancerPositionName, numShares)
+		err = uptimeAccums[uptimeIndex].RemoveFromPosition(balancerPositionName, numShares)
 		if err != nil {
 			return sdk.Coins{}, err
 		}
 
 		// Claim rewards and log the amount claimed to be added to the relevant gauge later
-		claimedRewards, _, err := uptimeAccum.ClaimRewards(balancerPositionName)
+		claimedRewards, _, err := uptimeAccums[uptimeIndex].ClaimRewards(balancerPositionName)
 		if err != nil {
 			return sdk.Coins{}, err
 		}
 		totalRewards = totalRewards.Add(claimedRewards...)
 
 		// Ensure record was deleted
-		recordExists, err = uptimeAccum.HasPosition(balancerPositionName)
+		recordExists, err = uptimeAccums[uptimeIndex].HasPosition(balancerPositionName)
 		if err != nil {
 			return sdk.Coins{}, err
 		}
@@ -316,17 +310,55 @@ func (k Keeper) claimAndResetFullRangeBalancerPool(ctx sdk.Context, clPoolId uin
 	return totalRewards, nil
 }
 
-// updatePoolUptimeAccumulatorsToNow syncs all uptime accumulators to be up to date for the given pool.
+// updatePoolUptimeAccumulatorsToNow syncs all uptime accumulators that are refetched from state for the given
+// poold id to be up to date for the given pool. Updates the pool last liquidity update time with
+// the current block time and writes the updated pool to state.
 // Specifically, it gets the time elapsed since the last update and divides it
 // by the qualifying liquidity for each uptime. It then adds this value to the
 // respective accumulator and updates relevant time trackers accordingly.
 // WARNING: this method may mutate the pool, make sure to refetch the pool after calling this method.
+// Note: the following are the differences of this function from updateGivenPoolUptimeAccumulatorsToNow:
+// * this function fetches the uptime accumulators from state.
+// * this function fetches a pool from state by id.
+// updateGivenPoolUptimeAccumulatorsToNow is used in swaps for performance reasons to minimize state reads.
+// updatePoolUptimeAccumulatorsToNow is used in all other cases.
 func (k Keeper) updatePoolUptimeAccumulatorsToNow(ctx sdk.Context, poolId uint64) error {
 	pool, err := k.getPoolById(ctx, poolId)
 	if err != nil {
 		return err
 	}
 
+	uptimeAccums, err := k.GetUptimeAccumulators(ctx, poolId)
+	if err != nil {
+		return err
+	}
+
+	if err := k.updateGivenPoolUptimeAccumulatorsToNow(ctx, pool, uptimeAccums); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// updateGivenPoolUptimeAccumulatorsToNow syncs all given uptime accumulators for a given pool id
+// Updates the pool last liquidity update time with the current block time and writes the updated pool to state.
+// If last liquidity update happened in the current block, this function is a no-op.
+// Specifically, it gets the time elapsed since the last update and divides it
+// by the qualifying liquidity for each uptime. It then adds this value to the
+// respective accumulator and updates relevant time trackers accordingly.
+// CONTRACT: the caller validates that the pool with the given id exists.
+// CONTRACT: given uptimeAccums are associated with the given pool id.
+// CONTRACT: caller is responsible for the uptimeAccums to be up-to-date.
+// WARNING: this method may mutate the pool, make sure to refetch the pool after calling this method.
+// Note: the following are the differences of this function from updatePoolUptimeAccumulatorsToNow:
+// * this function does not refetch the uptime accumulators from state.
+// * this function operates on the given pool directly, instead of fetching it from state.
+// This is to avoid unnecessary state reads during swaps for performance reasons.
+func (k Keeper) updateGivenPoolUptimeAccumulatorsToNow(ctx sdk.Context, pool types.ConcentratedPoolExtension, uptimeAccums []accum.AccumulatorObject) error {
+	if pool == nil {
+		return types.ErrPoolNil
+	}
+
 	// Since our base unit of time is nanoseconds, we divide with truncation by 10^9 (10e8) to get
 	// time elapsed in seconds
 	timeElapsedNanoSec := sdk.NewDec(int64(ctx.BlockTime().Sub(pool.GetLastLiquidityUpdate())))
@@ -341,10 +373,12 @@ func (k Keeper) updatePoolUptimeAccumulatorsToNow(ctx sdk.Context, poolId uint64
 		return types.TimeElapsedNotPositiveError{TimeElapsed: timeElapsedSec}
 	}
 
+	poolId := pool.GetId()
+
 	// Set up canonical balancer pool as a full range position for the purposes of incentives.
 	// Note that this function fails quietly if no canonical balancer pool exists and only errors
 	// if it does exist and there is a lower level inconsistency.
-	balancerPoolId, _, err := k.prepareBalancerPoolAsFullRange(ctx, poolId)
+	balancerPoolId, _, err := k.prepareBalancerPoolAsFullRange(ctx, poolId, uptimeAccums)
 	if err != nil {
 		return err
 	}
@@ -355,17 +389,12 @@ func (k Keeper) updatePoolUptimeAccumulatorsToNow(ctx sdk.Context, poolId uint64
 		return err
 	}
 
-	uptimeAccums, err := k.GetUptimeAccumulators(ctx, poolId)
-	if err != nil {
-		return err
-	}
-
-	for uptimeIndex, uptimeAccum := range uptimeAccums {
+	for uptimeIndex := range uptimeAccums {
 		// Get relevant uptime-level values
 		curUptimeDuration := types.SupportedUptimes[uptimeIndex]
 
 		// Qualifying liquidity is the amount of liquidity that satisfies uptime requirements
-		qualifyingLiquidity, err := uptimeAccum.GetTotalShares()
+		qualifyingLiquidity, err := uptimeAccums[uptimeIndex].GetTotalShares()
 		if err != nil {
 			return err
 		}
@@ -381,7 +410,7 @@ func (k Keeper) updatePoolUptimeAccumulatorsToNow(ctx sdk.Context, poolId uint64
 		}
 
 		// Emit incentives to current uptime accumulator
-		uptimeAccum.AddToAccumulator(incentivesToAddToCurAccum)
+		uptimeAccums[uptimeIndex].AddToAccumulator(incentivesToAddToCurAccum)
 
 		// Update pool records (stored in state after loop)
 		poolIncentiveRecords = updatedPoolRecords
@@ -405,7 +434,7 @@ func (k Keeper) updatePoolUptimeAccumulatorsToNow(ctx sdk.Context, poolId uint64
 	// require a lot of capital to be tied up in a two week bond, which is a viable tradeoff given the relative
 	// simplicity of this approach.
 	if balancerPoolId != 0 {
-		_, err := k.claimAndResetFullRangeBalancerPool(ctx, poolId, balancerPoolId)
+		_, err := k.claimAndResetFullRangeBalancerPool(ctx, poolId, balancerPoolId, uptimeAccums)
 		if err != nil {
 			return err
 		}
diff --git a/x/concentrated-liquidity/swaps.go b/x/concentrated-liquidity/swaps.go
index ff55c17ce..189b583d8 100644
--- a/x/concentrated-liquidity/swaps.go
+++ b/x/concentrated-liquidity/swaps.go
@@ -318,6 +318,16 @@ func (k Keeper) computeOutAmtGivenIn(
 		return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, types.DenomDuplicatedError{TokenInDenom: tokenInMin.Denom, TokenOutDenom: tokenOutDenom}
 	}
 
+	uptimeAccums, err := k.GetUptimeAccumulators(ctx, poolId)
+	if err != nil {
+		return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, err
+	}
+
+	feeAccumulator, err := k.GetFeeAccumulator(ctx, poolId)
+	if err != nil {
+		return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, err
+	}
+
 	// initialize swap state with the following parameters:
 	// as we iterate through the following for loop, this swap state will get updated after each required iteration
 	swapState := SwapState{
@@ -404,8 +414,12 @@ func (k Keeper) computeOutAmtGivenIn(
 				return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, err
 			}
 
+			if err := k.updateGivenPoolUptimeAccumulatorsToNow(ctx, p, uptimeAccums); err != nil {
+				return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, err
+			}
+
 			// Retrieve the liquidity held in the next closest initialized tick
-			liquidityNet, err := k.crossTick(ctx, poolId, nextTick, &nextTickInfo, sdk.NewDecCoinFromDec(tokenInMin.Denom, swapState.feeGrowthGlobal))
+			liquidityNet, err := k.crossTick(ctx, poolId, nextTick, &nextTickInfo, sdk.NewDecCoinFromDec(tokenInMin.Denom, swapState.feeGrowthGlobal), feeAccumulator.GetValue(), uptimeAccums)
 			if err != nil {
 				return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, err
 			}
@@ -431,9 +445,8 @@ func (k Keeper) computeOutAmtGivenIn(
 		}
 	}
 
-	if err := k.chargeFee(ctx, poolId, sdk.NewDecCoinFromDec(tokenInMin.Denom, swapState.feeGrowthGlobal)); err != nil {
-		return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, err
-	}
+	// Add fee growth per share to the pool-global fee accumulator.
+	feeAccumulator.AddToAccumulator(sdk.NewDecCoins(sdk.NewDecCoinFromDec(tokenInMin.Denom, swapState.feeGrowthGlobal)))
 
 	// Coin amounts require int values
 	// Round amountIn up to avoid under charging
@@ -537,6 +550,16 @@ func (k Keeper) computeInAmtGivenOut(
 	nextTickIter := swapStrategy.InitializeNextTickIterator(ctx, poolId, swapState.tick)
 	defer nextTickIter.Close()
 
+	uptimeAccums, err := k.GetUptimeAccumulators(ctx, poolId)
+	if err != nil {
+		return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, err
+	}
+
+	feeAccumulator, err := k.GetFeeAccumulator(ctx, poolId)
+	if err != nil {
+		return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, err
+	}
+
 	// TODO: This should be GT 0 but some instances have very small remainder
 	// need to look into fixing this
 	for swapState.amountSpecifiedRemaining.GT(smallestDec) && !swapState.sqrtPrice.Equal(sqrtPriceLimit) {
@@ -598,8 +621,12 @@ func (k Keeper) computeInAmtGivenOut(
 				return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, err
 			}
 
+			if err := k.updateGivenPoolUptimeAccumulatorsToNow(ctx, p, uptimeAccums); err != nil {
+				return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, err
+			}
+
 			// retrieve the liquidity held in the next closest initialized tick
-			liquidityNet, err := k.crossTick(ctx, poolId, nextTick, &nextTickInfo, sdk.NewDecCoinFromDec(desiredTokenOut.Denom, swapState.feeGrowthGlobal))
+			liquidityNet, err := k.crossTick(ctx, poolId, nextTick, &nextTickInfo, sdk.NewDecCoinFromDec(desiredTokenOut.Denom, swapState.feeGrowthGlobal), feeAccumulator.GetValue(), uptimeAccums)
 			if err != nil {
 				return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, err
 			}
@@ -624,9 +651,8 @@ func (k Keeper) computeInAmtGivenOut(
 		}
 	}
 
-	if err := k.chargeFee(ctx, poolId, sdk.NewDecCoinFromDec(tokenInDenom, swapState.feeGrowthGlobal)); err != nil {
-		return sdk.Coin{}, sdk.Coin{}, 0, sdk.Dec{}, sdk.Dec{}, sdk.Dec{}, err
-	}
+	// Add fee growth per share to the pool-global fee accumulator.
+	feeAccumulator.AddToAccumulator(sdk.NewDecCoins(sdk.NewDecCoinFromDec(tokenInDenom, swapState.feeGrowthGlobal)))
 
 	// coin amounts require int values
 	// Round amount in up to avoid under charging the user.
diff --git a/x/concentrated-liquidity/tick.go b/x/concentrated-liquidity/tick.go
index 19c35bcef..773fa7ad3 100644
--- a/x/concentrated-liquidity/tick.go
+++ b/x/concentrated-liquidity/tick.go
@@ -6,10 +6,10 @@ import (
 	"github.com/cosmos/cosmos-sdk/store/prefix"
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/gogo/protobuf/proto"
 	db "github.com/tendermint/tm-db"
 
 	"github.com/osmosis-labs/osmosis/osmoutils"
+	"github.com/osmosis-labs/osmosis/osmoutils/accum"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/client/queryproto"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/math"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/model"
@@ -74,34 +74,22 @@ func (k Keeper) initOrUpdateTick(ctx sdk.Context, poolId uint64, currentTick int
 // It updates the given tick's uptime and fee accumulators and writes it back to state.
 // Prior to updating the tick info and writing it to state, it updates the pool uptime accumulators until the current block time.
 // WARNING: this method may mutate the pool, make sure to refetch the pool after calling this method.
-func (k Keeper) crossTick(ctx sdk.Context, poolId uint64, tickIndex int64, tickInfo *model.TickInfo, swapStateFeeGrowth sdk.DecCoin) (liquidityDelta sdk.Dec, err error) {
+// CONTRACT: the caller validates that the pool with the given id exists.
+// CONTRACT: caller is responsible for the uptimeAccums to be up-to-date.
+// CONTRACT: uptimeAccums are associated with the given pool id.
+func (k Keeper) crossTick(ctx sdk.Context, poolId uint64, tickIndex int64, tickInfo *model.TickInfo, swapStateFeeGrowth sdk.DecCoin, feeAccumValue sdk.DecCoins, uptimeAccums []accum.AccumulatorObject) (liquidityDelta sdk.Dec, err error) {
 	if tickInfo == nil {
 		return sdk.Dec{}, types.ErrNextTickInfoNil
 	}
 
-	feeAccum, err := k.GetFeeAccumulator(ctx, poolId)
-	if err != nil {
-		return sdk.Dec{}, err
-	}
-
 	// subtract tick's fee growth opposite direction of last traversal from current fee growth global, including the fee growth of the current swap.
-	tickInfo.FeeGrowthOppositeDirectionOfLastTraversal = feeAccum.GetValue().Add(swapStateFeeGrowth).Sub(tickInfo.FeeGrowthOppositeDirectionOfLastTraversal)
-
-	// Update global accums to now before uptime outside changes
-	if err := k.updatePoolUptimeAccumulatorsToNow(ctx, poolId); err != nil {
-		return sdk.Dec{}, err
-	}
-
-	uptimeAccums, err := k.GetUptimeAccumulators(ctx, poolId)
-	if err != nil {
-		return sdk.Dec{}, err
-	}
+	tickInfo.FeeGrowthOppositeDirectionOfLastTraversal = feeAccumValue.Add(swapStateFeeGrowth).Sub(tickInfo.FeeGrowthOppositeDirectionOfLastTraversal)
 
 	// For each supported uptime, subtract tick's uptime growth outside from the respective uptime accumulator
 	// This is functionally equivalent to "flipping" the trackers once the tick is crossed
 	updatedUptimeTrackers := tickInfo.UptimeTrackers
-	for uptimeId, uptimeAccum := range uptimeAccums {
-		updatedUptimeTrackers[uptimeId].UptimeGrowthOutside = uptimeAccum.GetValue().Sub(updatedUptimeTrackers[uptimeId].UptimeGrowthOutside)
+	for uptimeId := range uptimeAccums {
+		updatedUptimeTrackers[uptimeId].UptimeGrowthOutside = uptimeAccums[uptimeId].GetValue().Sub(updatedUptimeTrackers[uptimeId].UptimeGrowthOutside)
 	}
 
 	k.SetTickInfo(ctx, poolId, tickIndex, tickInfo)
@@ -268,15 +256,14 @@ func (k Keeper) GetTickLiquidityForFullRange(ctx sdk.Context, poolId uint64) ([]
 			return []queryproto.LiquidityDepthWithRange{}, err
 		}
 
-		tickStruct := model.TickInfo{}
-		err = proto.Unmarshal(nextTickIter.Value(), &tickStruct)
+		tickStruct, err := ParseTickFromBz(nextTickIter.Value())
 		if err != nil {
 			return []queryproto.LiquidityDepthWithRange{}, err
 		}
 
 		liquidityDepthForRange := queryproto.LiquidityDepthWithRange{
-			LowerTick:       sdk.NewInt(previousTickIndex),
-			UpperTick:       sdk.NewInt(tickIndex),
+			LowerTick:       previousTickIndex,
+			UpperTick:       tickIndex,
 			LiquidityAmount: totalLiquidityWithinRange,
 		}
 		liquidityDepthsForRange = append(liquidityDepthsForRange, liquidityDepthForRange)
@@ -414,15 +401,14 @@ func (k Keeper) GetTickLiquidityNetInDirection(ctx sdk.Context, poolId uint64, t
 			return []queryproto.TickLiquidityNet{}, err
 		}
 
-		tickStruct := model.TickInfo{}
-		err = proto.Unmarshal(iterator.Value(), &tickStruct)
+		tickStruct, err := ParseTickFromBz(iterator.Value())
 		if err != nil {
 			return []queryproto.TickLiquidityNet{}, err
 		}
 
 		liquidityDepth := queryproto.TickLiquidityNet{
 			LiquidityNet: tickStruct.LiquidityNet,
-			TickIndex:    sdk.NewInt(tickIndex),
+			TickIndex:    tickIndex,
 		}
 		liquidityDepths = append(liquidityDepths, liquidityDepth)
 	}
diff --git a/x/concentrated-liquidity/types/errors.go b/x/concentrated-liquidity/types/errors.go
index 44f21991e..be7504759 100644
--- a/x/concentrated-liquidity/types/errors.go
+++ b/x/concentrated-liquidity/types/errors.go
@@ -16,6 +16,7 @@ var (
 	ErrPermissionlessPoolCreationDisabled = errors.New("permissionless pool creation is disabled for the concentrated liquidity module")
 	ErrZeroLiquidity                      = errors.New("liquidity cannot be 0")
 	ErrNextTickInfoNil                    = errors.New("next tick info cannot be nil")
+	ErrPoolNil                            = errors.New("pool cannot be nil")
 )
 
 // x/concentrated-liquidity module sentinel errors.


Test patch:
diff --git a/app/upgrades/v15/export_test.go b/app/upgrades/v15/export_test.go
index 2b5d2f4f7..1d145c42c 100644
--- a/app/upgrades/v15/export_test.go
+++ b/app/upgrades/v15/export_test.go
@@ -4,7 +4,7 @@ import (
 	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
-	icqkeeper "github.com/strangelove-ventures/async-icq/v4/keeper"
+	icqkeeper "github.com/cosmos/ibc-apps/modules/async-icq/v4/keeper"
 
 	ibcratelimit "github.com/osmosis-labs/osmosis/v15/x/ibc-rate-limit"
 
diff --git a/tests/cl-genesis-positions/go.mod b/tests/cl-genesis-positions/go.mod
index 69ed58afe..3a3336554 100644
--- a/tests/cl-genesis-positions/go.mod
+++ b/tests/cl-genesis-positions/go.mod
@@ -118,7 +118,6 @@ require (
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/spf13/viper v1.15.0 // indirect
-	github.com/strangelove-ventures/async-icq/v4 v4.0.0-rc0 // indirect
 	github.com/strangelove-ventures/packet-forward-middleware/v4 v4.0.5 // indirect
 	github.com/stretchr/testify v1.8.3 // indirect
 	github.com/subosito/gotenv v1.4.2 // indirect
diff --git a/x/concentrated-liquidity/bench_test.go b/x/concentrated-liquidity/bench_test.go
index a8e75c48e..d3ad5134e 100644
--- a/x/concentrated-liquidity/bench_test.go
+++ b/x/concentrated-liquidity/bench_test.go
@@ -15,6 +15,8 @@ import (
 	clmath "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/math"
 	clmodel "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/model"
 	"github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types"
+	"github.com/osmosis-labs/osmosis/v15/x/gamm/pool-models/balancer"
+	gammtypes "github.com/osmosis-labs/osmosis/v15/x/gamm/types"
 )
 
 type BenchTestSuite struct {
@@ -56,6 +58,15 @@ func runBenchmark(b *testing.B, testFunc func(b *testing.B, s *BenchTestSuite, p
 		numberOfPositionsInt = sdk.NewInt(numberOfPositions)
 		maxAmountOfEachToken = sdk.NewInt(maxAmountDeposited).Mul(numberOfPositionsInt)
 		seed                 = int64(1)
+		defaultDenom0Asset   = balancer.PoolAsset{
+			Weight: sdk.NewInt(100),
+			Token:  sdk.NewCoin(denom0, sdk.NewInt(1000000000)),
+		}
+		defaultDenom1Asset = balancer.PoolAsset{
+			Weight: sdk.NewInt(100),
+			Token:  sdk.NewCoin(denom1, sdk.NewInt(1000000000)),
+		}
+		defaultPoolAssets = []balancer.PoolAsset{defaultDenom0Asset, defaultDenom1Asset}
 	)
 
 	rand.Seed(seed)
@@ -74,22 +85,38 @@ func runBenchmark(b *testing.B, testFunc func(b *testing.B, s *BenchTestSuite, p
 			))
 		}
 
-		// Create a pool
-		poolId, err := s.App.PoolManagerKeeper.CreatePool(s.Ctx, clmodel.NewMsgCreateConcentratedPool(
+		// Create a balancer pool
+		gammPoolId, err := s.App.PoolManagerKeeper.CreatePool(s.Ctx, balancer.NewMsgCreateBalancerPool(s.TestAccs[0], balancer.PoolParams{
+			SwapFee: sdk.MustNewDecFromStr("0.001"),
+			ExitFee: sdk.ZeroDec(),
+		}, defaultPoolAssets, ""))
+		noError(b, err)
+
+		// Create a cl pool.
+		clPoolId, err := s.App.PoolManagerKeeper.CreatePool(s.Ctx, clmodel.NewMsgCreateConcentratedPool(
 			s.TestAccs[0], denom0, denom1, tickSpacing, sdk.MustNewDecFromStr("0.001"),
 		))
 		noError(b, err)
 
 		clKeeper := s.App.ConcentratedLiquidityKeeper
+		gammKeeper := s.App.GAMMKeeper
+
+		// Create a link between the balancer and cl pool.
+		record := gammtypes.BalancerToConcentratedPoolLink{BalancerPoolId: gammPoolId, ClPoolId: clPoolId}
+		err = gammKeeper.ReplaceMigrationRecords(s.Ctx, []gammtypes.BalancerToConcentratedPoolLink{record})
+		s.Require().NoError(err)
+
+		_, err = gammKeeper.GetLinkedConcentratedPoolID(s.Ctx, gammPoolId)
+		s.Require().NoError(err)
 
 		// Create first position to set a price of 1 and tick of zero.
 		tokenDesired0 := sdk.NewCoin(denom0, sdk.NewInt(100))
 		tokenDesired1 := sdk.NewCoin(denom1, sdk.NewInt(100))
 		tokensDesired := sdk.NewCoins(tokenDesired0, tokenDesired1)
-		_, _, _, _, _, _, _, err = clKeeper.CreatePosition(s.Ctx, poolId, s.TestAccs[0], tokensDesired, sdk.ZeroInt(), sdk.ZeroInt(), types.MinTick, types.MaxTick)
+		_, _, _, _, _, _, _, err = clKeeper.CreatePosition(s.Ctx, clPoolId, s.TestAccs[0], tokensDesired, sdk.ZeroInt(), sdk.ZeroInt(), types.MinTick, types.MaxTick)
 		noError(b, err)
 
-		pool, err := clKeeper.GetPoolById(s.Ctx, poolId)
+		pool, err := clKeeper.GetPoolById(s.Ctx, clPoolId)
 		noError(b, err)
 
 		// Zero by default, can configure by setting a specific position.
@@ -136,7 +163,7 @@ func runBenchmark(b *testing.B, testFunc func(b *testing.B, s *BenchTestSuite, p
 				tokenDesired1 := sdk.NewCoin(denom1, sdk.NewInt(rand.Int63n(maxAmountDeposited)))
 
 				accountIndex := rand.Intn(len(s.TestAccs))
-				s.createPosition(accountIndex, poolId, tokenDesired0, tokenDesired1, lowerTick, upperTick)
+				s.createPosition(accountIndex, clPoolId, tokenDesired0, tokenDesired1, lowerTick, upperTick)
 			}
 		}
 
@@ -152,7 +179,7 @@ func runBenchmark(b *testing.B, testFunc func(b *testing.B, s *BenchTestSuite, p
 				accountIndex := rand.Intn(len(s.TestAccs))
 				account := s.TestAccs[accountIndex]
 				simapp.FundAccount(s.App.BankKeeper, s.Ctx, account, tokensDesired)
-				s.createPosition(accountIndex, poolId, tokenDesired0, tokenDesired1, lowerTick, upperTick)
+				s.createPosition(accountIndex, clPoolId, tokenDesired0, tokenDesired1, lowerTick, upperTick)
 			}
 		}
 
@@ -170,7 +197,7 @@ func runBenchmark(b *testing.B, testFunc func(b *testing.B, s *BenchTestSuite, p
 					accountIndex := rand.Intn(len(s.TestAccs))
 					account := s.TestAccs[accountIndex]
 					simapp.FundAccount(s.App.BankKeeper, s.Ctx, account, tokensDesired)
-					s.createPosition(accountIndex, poolId, tokenDesired0, tokenDesired1, lowerTick, upperTick)
+					s.createPosition(accountIndex, clPoolId, tokenDesired0, tokenDesired1, lowerTick, upperTick)
 				}
 			}
 
@@ -186,7 +213,7 @@ func runBenchmark(b *testing.B, testFunc func(b *testing.B, s *BenchTestSuite, p
 				accountIndex := rand.Intn(len(s.TestAccs))
 				account := s.TestAccs[accountIndex]
 				simapp.FundAccount(s.App.BankKeeper, s.Ctx, account, tokensDesired)
-				s.createPosition(accountIndex, poolId, tokenDesired0, tokenDesired1, lowerTick, upperTick)
+				s.createPosition(accountIndex, clPoolId, tokenDesired0, tokenDesired1, lowerTick, upperTick)
 			}
 		}
 
diff --git a/x/concentrated-liquidity/export_test.go b/x/concentrated-liquidity/export_test.go
index f42366849..beb8d421a 100644
--- a/x/concentrated-liquidity/export_test.go
+++ b/x/concentrated-liquidity/export_test.go
@@ -43,8 +43,8 @@ func (k Keeper) GetPoolById(ctx sdk.Context, poolId uint64) (types.ConcentratedP
 	return k.getPoolById(ctx, poolId)
 }
 
-func (k Keeper) CrossTick(ctx sdk.Context, poolId uint64, tickIndex int64, nextTickInfo *model.TickInfo, swapStateFeeGrowth sdk.DecCoin) (liquidityDelta sdk.Dec, err error) {
-	return k.crossTick(ctx, poolId, tickIndex, nextTickInfo, swapStateFeeGrowth)
+func (k Keeper) CrossTick(ctx sdk.Context, poolId uint64, tickIndex int64, nextTickInfo *model.TickInfo, swapStateFeeGrowth sdk.DecCoin, feeAccumValue sdk.DecCoins, uptimeAccums []accum.AccumulatorObject) (liquidityDelta sdk.Dec, err error) {
+	return k.crossTick(ctx, poolId, tickIndex, nextTickInfo, swapStateFeeGrowth, feeAccumValue, uptimeAccums)
 }
 
 func (k Keeper) SendCoinsBetweenPoolAndUser(ctx sdk.Context, denom0, denom1 string, amount0, amount1 sdk.Int, sender, receiver sdk.AccAddress) error {
@@ -194,10 +194,6 @@ func (k Keeper) GetInitialFeeGrowthOppositeDirectionOfLastTraversalForTick(ctx s
 	return k.getInitialFeeGrowthOppositeDirectionOfLastTraversalForTick(ctx, poolId, tick)
 }
 
-func (k Keeper) ChargeFee(ctx sdk.Context, poolId uint64, feeUpdate sdk.DecCoin) error {
-	return k.chargeFee(ctx, poolId, feeUpdate)
-}
-
 func ValidateTickRangeIsValid(tickSpacing uint64, lowerTick int64, upperTick int64) error {
 	return validateTickRangeIsValid(tickSpacing, lowerTick, upperTick)
 }
@@ -252,6 +248,10 @@ func (k Keeper) UpdateUptimeAccumulatorsToNow(ctx sdk.Context, poolId uint64) er
 	return k.updatePoolUptimeAccumulatorsToNow(ctx, poolId)
 }
 
+func (k Keeper) UpdateGivenPoolUptimeAccumulatorsToNow(ctx sdk.Context, pool types.ConcentratedPoolExtension, uptimeAccums []accum.AccumulatorObject) error {
+	return k.updateGivenPoolUptimeAccumulatorsToNow(ctx, pool, uptimeAccums)
+}
+
 func (k Keeper) SetIncentiveRecord(ctx sdk.Context, incentiveRecord types.IncentiveRecord) error {
 	return k.setIncentiveRecord(ctx, incentiveRecord)
 }
@@ -300,12 +300,12 @@ func (k Keeper) UpdatePoolForSwap(ctx sdk.Context, pool types.ConcentratedPoolEx
 	return k.updatePoolForSwap(ctx, pool, sender, tokenIn, tokenOut, newCurrentTick, newLiquidity, newSqrtPrice, totalFees)
 }
 
-func (k Keeper) PrepareBalancerPoolAsFullRange(ctx sdk.Context, clPoolId uint64) (uint64, sdk.Dec, error) {
-	return k.prepareBalancerPoolAsFullRange(ctx, clPoolId)
+func (k Keeper) PrepareBalancerPoolAsFullRange(ctx sdk.Context, clPoolId uint64, uptimeAccums []accum.AccumulatorObject) (uint64, sdk.Dec, error) {
+	return k.prepareBalancerPoolAsFullRange(ctx, clPoolId, uptimeAccums)
 }
 
-func (k Keeper) ClaimAndResetFullRangeBalancerPool(ctx sdk.Context, clPoolId uint64, balPoolId uint64) (sdk.Coins, error) {
-	return k.claimAndResetFullRangeBalancerPool(ctx, clPoolId, balPoolId)
+func (k Keeper) ClaimAndResetFullRangeBalancerPool(ctx sdk.Context, clPoolId uint64, balPoolId uint64, uptimeAccums []accum.AccumulatorObject) (sdk.Coins, error) {
+	return k.claimAndResetFullRangeBalancerPool(ctx, clPoolId, balPoolId, uptimeAccums)
 }
 
 func (k Keeper) UninitializePool(ctx sdk.Context, poolId uint64) error {
diff --git a/x/concentrated-liquidity/fees_test.go b/x/concentrated-liquidity/fees_test.go
index a66300467..df00e9665 100644
--- a/x/concentrated-liquidity/fees_test.go
+++ b/x/concentrated-liquidity/fees_test.go
@@ -409,8 +409,7 @@ func (s *KeeperTestSuite) TestGetFeeGrowthOutside() {
 				pool.SetCurrentTick(tc.currentTick)
 				err := s.App.ConcentratedLiquidityKeeper.SetPool(s.Ctx, pool)
 				s.Require().NoError(err)
-				err = s.App.ConcentratedLiquidityKeeper.ChargeFee(s.Ctx, validPoolId, tc.globalFeeGrowth)
-				s.Require().NoError(err)
+				s.AddToFeeAccumulator(validPoolId, tc.globalFeeGrowth)
 			}
 
 			// system under test
@@ -571,8 +570,7 @@ func (s *KeeperTestSuite) TestGetInitialFeeGrowthOppositeDirectionOfLastTraversa
 				s.Require().NoError(err)
 				s.SetupDefaultPosition(validPoolId)
 
-				err = clKeeper.ChargeFee(ctx, validPoolId, tc.initialGlobalFeeGrowth)
-				s.Require().NoError(err)
+				s.AddToFeeAccumulator(validPoolId, tc.initialGlobalFeeGrowth)
 			}
 
 			// System under test.
@@ -589,77 +587,6 @@ func (s *KeeperTestSuite) TestGetInitialFeeGrowthOppositeDirectionOfLastTraversa
 	}
 }
 
-func (s *KeeperTestSuite) TestChargeFee() {
-	// setup once at the beginning.
-	s.SetupTest()
-
-	ctx := s.Ctx
-	clKeeper := s.App.ConcentratedLiquidityKeeper
-
-	// create fee accumulators with ids 1 and 2 but not 3.
-	err := clKeeper.CreateFeeAccumulator(ctx, 1)
-	s.Require().NoError(err)
-	err = clKeeper.CreateFeeAccumulator(ctx, 2)
-	s.Require().NoError(err)
-
-	tests := []struct {
-		name      string
-		poolId    uint64
-		feeUpdate sdk.DecCoin
-
-		expectedGlobalGrowth sdk.DecCoins
-		expectError          error
-	}{
-		{
-			name:      "pool id 1 - one eth",
-			poolId:    1,
-			feeUpdate: oneEth,
-
-			expectedGlobalGrowth: sdk.NewDecCoins(oneEth),
-		},
-		{
-			name:      "pool id 1 - 2 usdc",
-			poolId:    1,
-			feeUpdate: sdk.NewDecCoin(USDC, sdk.NewInt(2)),
-
-			expectedGlobalGrowth: sdk.NewDecCoins(oneEth).Add(sdk.NewDecCoin(USDC, sdk.NewInt(2))),
-		},
-		{
-			name:      "pool id 2 - 1 usdc",
-			poolId:    2,
-			feeUpdate: oneEth,
-
-			expectedGlobalGrowth: sdk.NewDecCoins(oneEth),
-		},
-		{
-			name:      "accumulator does not exist",
-			poolId:    3,
-			feeUpdate: oneEth,
-
-			expectError: accum.AccumDoesNotExistError{AccumName: types.KeyFeePoolAccumulator(3)},
-		},
-	}
-
-	for _, tc := range tests {
-		tc := tc
-		s.Run(tc.name, func() {
-			// System under test.
-			err := clKeeper.ChargeFee(ctx, tc.poolId, tc.feeUpdate)
-
-			if tc.expectError != nil {
-				s.Require().Error(err)
-				s.Require().ErrorIs(err, tc.expectError)
-				return
-			}
-			s.Require().NoError(err)
-
-			feeAcumulator, err := clKeeper.GetFeeAccumulator(ctx, tc.poolId)
-			s.Require().NoError(err)
-			s.Require().Equal(tc.expectedGlobalGrowth, feeAcumulator.GetValue())
-		})
-	}
-}
-
 func (s *KeeperTestSuite) TestQueryAndCollectFees() {
 	ownerWithValidPosition := s.TestAccs[0]
 	emptyUptimeTrackers := wrapUptimeTrackers(getExpectedUptimes().emptyExpectedAccumValues)
@@ -921,8 +848,7 @@ func (s *KeeperTestSuite) TestQueryAndCollectFees() {
 			err = clKeeper.SetPool(ctx, validPool)
 			s.Require().NoError(err)
 
-			err = clKeeper.ChargeFee(ctx, validPoolId, tc.globalFeeGrowth[0])
-			s.Require().NoError(err)
+			s.AddToFeeAccumulator(validPoolId, tc.globalFeeGrowth[0])
 
 			poolFeeBalanceBeforeCollect := s.App.BankKeeper.GetBalance(ctx, validPool.GetFeesAddress(), ETH)
 			ownerBalancerBeforeCollect := s.App.BankKeeper.GetBalance(ctx, tc.owner, ETH)
@@ -1206,8 +1132,7 @@ func (s *KeeperTestSuite) TestPrepareClaimableFees() {
 
 			_ = clKeeper.SetPool(ctx, validPool)
 
-			err = clKeeper.ChargeFee(ctx, validPoolId, tc.globalFeeGrowth[0])
-			s.Require().NoError(err)
+			s.AddToFeeAccumulator(validPoolId, tc.globalFeeGrowth[0])
 
 			positionKey := types.KeyFeePositionAccumulator(DefaultPositionId)
 
diff --git a/x/concentrated-liquidity/incentives_test.go b/x/concentrated-liquidity/incentives_test.go
index 0cbbb8cfd..71887cdf2 100644
--- a/x/concentrated-liquidity/incentives_test.go
+++ b/x/concentrated-liquidity/incentives_test.go
@@ -1,6 +1,7 @@
 package concentrated_liquidity_test
 
 import (
+	"errors"
 	"fmt"
 	"time"
 
@@ -740,6 +741,89 @@ func (s *KeeperTestSuite) TestUpdateUptimeAccumulatorsToNow() {
 		expectedIncentiveRecords []types.IncentiveRecord
 		expectedError            error
 	}
+
+	validateResult := func(ctx sdk.Context, err error, tc updateAccumToNow, balancerPoolId, poolId uint64, initUptimeAccumValues []sdk.DecCoins, qualifyingBalancerLiquidity sdk.Dec, qualifyingLiquidity sdk.Dec) []sdk.DecCoins {
+		clKeeper := s.App.ConcentratedLiquidityKeeper
+
+		if tc.expectedError != nil {
+			s.Require().Error(err)
+			s.Require().ErrorContains(err, tc.expectedError.Error())
+
+			// Ensure accumulators remain unchanged
+			newUptimeAccumValues, err := clKeeper.GetUptimeAccumulatorValues(ctx, poolId)
+			s.Require().NoError(err)
+			s.Require().Equal(initUptimeAccumValues, newUptimeAccumValues)
+
+			// Ensure incentive records remain unchanged
+			updatedIncentiveRecords, err := clKeeper.GetAllIncentiveRecordsForPool(ctx, poolId)
+			s.Require().NoError(err)
+			s.Require().Equal(tc.poolIncentiveRecords, updatedIncentiveRecords)
+
+			return nil
+		}
+
+		s.Require().NoError(err)
+
+		// Get updated pool for testing purposes
+		clPool, err := clKeeper.GetPoolById(ctx, tc.poolId)
+		s.Require().NoError(err)
+
+		// Calculate expected uptime deltas using qualifying liquidity deltas.
+		// Recall that uptime accumulators track emitted incentives / qualifying liquidity.
+		expectedUptimeDeltas := []sdk.DecCoins{}
+		for _, curSupportedUptime := range types.SupportedUptimes {
+			// Calculate expected incentives for the current uptime by emitting incentives from
+			// all incentive records to their respective uptime accumulators in the pool.
+			// TODO: find a cleaner way to calculate this that does not involve iterating over all incentive records for each uptime accum.
+			curUptimeAccruedIncentives := cl.EmptyCoins
+			for _, poolRecord := range tc.poolIncentiveRecords {
+				if poolRecord.MinUptime == curSupportedUptime {
+					// We set the expected accrued incentives based on the total time that has elapsed since position creation
+					curUptimeAccruedIncentives = curUptimeAccruedIncentives.Add(sdk.NewDecCoins(expectedIncentivesFromRate(poolRecord.IncentiveDenom, poolRecord.IncentiveRecordBody.EmissionRate, defaultTestUptime+tc.timeElapsed, qualifyingLiquidity))...)
+				}
+			}
+			expectedUptimeDeltas = append(expectedUptimeDeltas, curUptimeAccruedIncentives)
+		}
+
+		// Get new uptime accum values for comparison
+		newUptimeAccumValues, err := clKeeper.GetUptimeAccumulatorValues(ctx, tc.poolId)
+		s.Require().NoError(err)
+
+		// Ensure that each accumulator value changes by the correct amount
+		totalUptimeDeltas := sdk.NewDecCoins()
+		for uptimeIndex := range newUptimeAccumValues {
+			uptimeDelta := newUptimeAccumValues[uptimeIndex].Sub(initUptimeAccumValues[uptimeIndex])
+			s.Require().Equal(expectedUptimeDeltas[uptimeIndex], uptimeDelta)
+
+			totalUptimeDeltas = totalUptimeDeltas.Add(uptimeDelta...)
+		}
+
+		// Ensure that LastLiquidityUpdate field is updated for pool
+		s.Require().Equal(ctx.BlockTime(), clPool.GetLastLiquidityUpdate())
+
+		// Ensure that pool's IncentiveRecords are updated to reflect emitted incentives
+		updatedIncentiveRecords, err := clKeeper.GetAllIncentiveRecordsForPool(ctx, tc.poolId)
+		s.Require().NoError(err)
+		s.Require().Equal(tc.expectedIncentiveRecords, updatedIncentiveRecords)
+
+		// If applicable, get gauge for canonical balancer pool and ensure it increased by the appropriate amount.
+		if tc.canonicalBalancerPoolAssets != nil {
+			gaugeId, err := s.App.PoolIncentivesKeeper.GetPoolGaugeId(ctx, balancerPoolId, longestLockableDuration)
+			s.Require().NoError(err)
+
+			gauge, err := s.App.IncentivesKeeper.GetGaugeByID(ctx, gaugeId)
+			s.Require().NoError(err)
+
+			// Since balancer shares are added prior to actual emissions to the pool, they are already factored into the
+			// accumulator values ("totalUptimeDeltas"). We leverage this to find the expected amount of incentives emitted
+			// to the gauge.
+			expectedGaugeShares := sdk.NewCoins(sdk.NormalizeCoins(totalUptimeDeltas.MulDec(qualifyingBalancerLiquidity))...)
+			s.Require().Equal(expectedGaugeShares, gauge.Coins)
+		}
+
+		return expectedUptimeDeltas
+	}
+
 	tests := map[string]updateAccumToNow{
 		"one incentive record": {
 			poolId:               defaultPoolId,
@@ -969,83 +1053,38 @@ func (s *KeeperTestSuite) TestUpdateUptimeAccumulatorsToNow() {
 			// Let `timeElapsed` time pass to test incentive distribution
 			s.Ctx = s.Ctx.WithBlockTime(s.Ctx.BlockTime().Add(tc.timeElapsed))
 
-			// System under test
-			err = clKeeper.UpdateUptimeAccumulatorsToNow(s.Ctx, tc.poolId)
-
-			if tc.expectedError != nil {
-				s.Require().Error(err)
-				s.Require().ErrorContains(err, tc.expectedError.Error())
+			// System under test 1
+			// Use cache context to avoud persisting updates for the next function
+			// that relies on the same test cases and setup.
+			cacheCtx, _ := s.Ctx.CacheContext()
+			err = clKeeper.UpdateUptimeAccumulatorsToNow(cacheCtx, tc.poolId)
 
-				// Ensure accumulators remain unchanged
-				newUptimeAccumValues, err := clKeeper.GetUptimeAccumulatorValues(s.Ctx, clPool.GetId())
-				s.Require().NoError(err)
-				s.Require().Equal(initUptimeAccumValues, newUptimeAccumValues)
+			validateResult(cacheCtx, err, tc, balancerPoolId, clPool.GetId(), initUptimeAccumValues, qualifyingBalancerLiquidity, qualifyingLiquidity)
 
-				// Ensure incentive records remain unchanged
-				updatedIncentiveRecords, err := clKeeper.GetAllIncentiveRecordsForPool(s.Ctx, clPool.GetId())
-				s.Require().NoError(err)
-				s.Require().Equal(tc.poolIncentiveRecords, updatedIncentiveRecords)
+			// Now test a similar method with different parameters
 
+			// Skip this test case as UpdatePoolGivenUptimeAccumulatorsToNow relies
+			// on this check to be done by the caller.
+			if errors.Is(tc.expectedError, types.PoolNotFoundError{PoolId: invalidPoolId}) {
 				return
 			}
 
+			uptimeAccs, err := clKeeper.GetUptimeAccumulators(s.Ctx, tc.poolId)
 			s.Require().NoError(err)
 
-			// Get updated pool for testing purposes
-			clPool, err = clKeeper.GetPoolById(s.Ctx, tc.poolId)
-			s.Require().NoError(err)
-
-			// Calculate expected uptime deltas using qualifying liquidity deltas.
-			// Recall that uptime accumulators track emitted incentives / qualifying liquidity.
-			expectedUptimeDeltas := []sdk.DecCoins{}
-			for _, curSupportedUptime := range types.SupportedUptimes {
-				// Calculate expected incentives for the current uptime by emitting incentives from
-				// all incentive records to their respective uptime accumulators in the pool.
-				// TODO: find a cleaner way to calculate this that does not involve iterating over all incentive records for each uptime accum.
-				curUptimeAccruedIncentives := cl.EmptyCoins
-				for _, poolRecord := range tc.poolIncentiveRecords {
-					if poolRecord.MinUptime == curSupportedUptime {
-						// We set the expected accrued incentives based on the total time that has elapsed since position creation
-						curUptimeAccruedIncentives = curUptimeAccruedIncentives.Add(sdk.NewDecCoins(expectedIncentivesFromRate(poolRecord.IncentiveDenom, poolRecord.IncentiveRecordBody.EmissionRate, defaultTestUptime+tc.timeElapsed, qualifyingLiquidity))...)
-					}
-				}
-				expectedUptimeDeltas = append(expectedUptimeDeltas, curUptimeAccruedIncentives)
-			}
-
-			// Get new uptime accum values for comparison
-			newUptimeAccumValues, err := clKeeper.GetUptimeAccumulatorValues(s.Ctx, tc.poolId)
-			s.Require().NoError(err)
+			// System under test 2
+			err = clKeeper.UpdateGivenPoolUptimeAccumulatorsToNow(s.Ctx, clPool, uptimeAccs)
 
-			// Ensure that each accumulator value changes by the correct amount
-			totalUptimeDeltas := sdk.NewDecCoins()
-			for uptimeIndex := range newUptimeAccumValues {
-				uptimeDelta := newUptimeAccumValues[uptimeIndex].Sub(initUptimeAccumValues[uptimeIndex])
-				s.Require().Equal(expectedUptimeDeltas[uptimeIndex], uptimeDelta)
+			expectedUptimeDeltas := validateResult(s.Ctx, err, tc, balancerPoolId, clPool.GetId(), initUptimeAccumValues, qualifyingBalancerLiquidity, qualifyingLiquidity)
 
-				totalUptimeDeltas = totalUptimeDeltas.Add(uptimeDelta...)
+			if tc.expectedError != nil {
+				return
 			}
 
-			// Ensure that LastLiquidityUpdate field is updated for pool
-			s.Require().Equal(s.Ctx.BlockTime(), clPool.GetLastLiquidityUpdate())
-
-			// Ensure that pool's IncentiveRecords are updated to reflect emitted incentives
-			updatedIncentiveRecords, err := clKeeper.GetAllIncentiveRecordsForPool(s.Ctx, tc.poolId)
-			s.Require().NoError(err)
-			s.Require().Equal(tc.expectedIncentiveRecords, updatedIncentiveRecords)
-
-			// If applicable, get gauge for canonical balancer pool and ensure it increased by the appropriate amount.
-			if tc.canonicalBalancerPoolAssets != nil {
-				gaugeId, err := s.App.PoolIncentivesKeeper.GetPoolGaugeId(s.Ctx, balancerPoolId, longestLockableDuration)
-				s.Require().NoError(err)
-
-				gauge, err := s.App.IncentivesKeeper.GetGaugeByID(s.Ctx, gaugeId)
-				s.Require().NoError(err)
-
-				// Since balancer shares are added prior to actual emissions to the pool, they are already factored into the
-				// accumulator values ("totalUptimeDeltas"). We leverage this to find the expected amount of incentives emitted
-				// to the gauge.
-				expectedGaugeShares := sdk.NewCoins(sdk.NormalizeCoins(totalUptimeDeltas.MulDec(qualifyingBalancerLiquidity))...)
-				s.Require().Equal(expectedGaugeShares, gauge.Coins)
+			// Ensure that each uptime accumulater value that was passed in as an argument changes by the correct amount.
+			for uptimeIndex := range uptimeAccs {
+				expectedValue := initUptimeAccumValues[uptimeIndex].Add(expectedUptimeDeltas[uptimeIndex]...)
+				s.Require().Equal(expectedValue, uptimeAccs[uptimeIndex].GetValue())
 			}
 		})
 	}
@@ -3327,7 +3366,11 @@ func (s *KeeperTestSuite) TestPrepareBalancerPoolAsFullRange() {
 
 			// --- System under test ---
 
-			retrievedBalancerPoolId, addedLiquidity, err := s.App.ConcentratedLiquidityKeeper.PrepareBalancerPoolAsFullRange(s.Ctx, concentratedPoolId)
+			// Get uptime accums for the cl pool.
+			uptimeAccums, err := s.App.ConcentratedLiquidityKeeper.GetUptimeAccumulators(s.Ctx, clPool.GetId())
+			s.Require().NoError(err)
+
+			retrievedBalancerPoolId, addedLiquidity, err := s.App.ConcentratedLiquidityKeeper.PrepareBalancerPoolAsFullRange(s.Ctx, concentratedPoolId, uptimeAccums)
 
 			// --- Assertions ---
 
@@ -3348,16 +3391,21 @@ func (s *KeeperTestSuite) TestPrepareBalancerPoolAsFullRange() {
 			updatedClPool, err = s.App.ConcentratedLiquidityKeeper.GetPoolById(s.Ctx, clPool.GetId())
 			s.Require().NoError(err)
 
-			clPoolUptimeAccumulators, err := s.App.ConcentratedLiquidityKeeper.GetUptimeAccumulators(s.Ctx, clPool.GetId())
+			clPoolUptimeAccumulatorsFromState, err := s.App.ConcentratedLiquidityKeeper.GetUptimeAccumulators(s.Ctx, clPool.GetId())
 			s.Require().NoError(err)
 
-			s.Require().True(len(clPoolUptimeAccumulators) > 0)
-			for _, uptimeAccum := range clPoolUptimeAccumulators {
+			s.Require().True(len(clPoolUptimeAccumulatorsFromState) > 0)
+			expectedShares := qualifyingShares.Add(initialLiquidity)
+			for uptimeIdx, uptimeAccum := range clPoolUptimeAccumulatorsFromState {
 				currAccumShares, err := uptimeAccum.GetTotalShares()
 				s.Require().NoError(err)
 
 				// Ensure each accum has the correct number of final shares
-				s.Require().Equal(qualifyingShares.Add(initialLiquidity), currAccumShares)
+				s.Require().Equal(expectedShares, currAccumShares)
+
+				// Also validate uptime accumulators passed in as parameter.
+				currAccumShares, err = uptimeAccums[uptimeIdx].GetTotalShares()
+				s.Require().Equal(expectedShares, currAccumShares)
 			}
 
 			// Ensure added liquidity is equal to the amount accum shares changed by
@@ -3525,7 +3573,11 @@ func (s *KeeperTestSuite) TestClaimAndResetFullRangeBalancerPool() {
 			// Add balancer shares to CL accumulatores
 			addedLiquidity := sdk.ZeroDec()
 			if !tc.balSharesNotAddedToAccums {
-				addedBalPool, qualifiedShares, err := s.App.ConcentratedLiquidityKeeper.PrepareBalancerPoolAsFullRange(s.Ctx, clPool.GetId())
+				// Get uptime accums for the cl pool.
+				uptimeAccums, err := s.App.ConcentratedLiquidityKeeper.GetUptimeAccumulators(s.Ctx, clPool.GetId())
+				s.Require().NoError(err)
+
+				addedBalPool, qualifiedShares, err := s.App.ConcentratedLiquidityKeeper.PrepareBalancerPoolAsFullRange(s.Ctx, clPool.GetId(), uptimeAccums)
 				addedLiquidity = addedLiquidity.Add(qualifiedShares)
 
 				// If a valid link exists, ensure no error and sanity check the output pool ID
@@ -3549,7 +3601,11 @@ func (s *KeeperTestSuite) TestClaimAndResetFullRangeBalancerPool() {
 
 			// --- System under test ---
 
-			amountClaimed, err := s.App.ConcentratedLiquidityKeeper.ClaimAndResetFullRangeBalancerPool(s.Ctx, clPoolId, balancerPoolId)
+			// Get uptime accums for the cl pool.
+			uptimeAccums, err := s.App.ConcentratedLiquidityKeeper.GetUptimeAccumulators(s.Ctx, clPool.GetId())
+			s.Require().NoError(err)
+
+			amountClaimed, err := s.App.ConcentratedLiquidityKeeper.ClaimAndResetFullRangeBalancerPool(s.Ctx, clPoolId, balancerPoolId, uptimeAccums)
 
 			// --- Assertions ---
 
@@ -3558,11 +3614,11 @@ func (s *KeeperTestSuite) TestClaimAndResetFullRangeBalancerPool() {
 				s.Require().ErrorContains(err, tc.expectedError.Error())
 				s.Require().Equal(sdk.Coins{}, amountClaimed)
 
-				clPoolUptimeAccumulators, err := s.App.ConcentratedLiquidityKeeper.GetUptimeAccumulators(s.Ctx, clPool.GetId())
+				clPoolUptimeAccumulatorsFromState, err := s.App.ConcentratedLiquidityKeeper.GetUptimeAccumulators(s.Ctx, clPool.GetId())
 				s.Require().NoError(err)
 
-				s.Require().True(len(clPoolUptimeAccumulators) > 0)
-				for _, uptimeAccum := range clPoolUptimeAccumulators {
+				s.Require().True(len(clPoolUptimeAccumulatorsFromState) > 0)
+				for uptimeIdx, uptimeAccum := range clPoolUptimeAccumulatorsFromState {
 					currAccumShares, err := uptimeAccum.GetTotalShares()
 					s.Require().NoError(err)
 
@@ -3575,8 +3631,14 @@ func (s *KeeperTestSuite) TestClaimAndResetFullRangeBalancerPool() {
 						addedLiquidity = sdk.ZeroDec()
 					}
 
+					expectedLiquidity := initialLiquidity.Add(addedLiquidity)
+
 					// Ensure accum shares remain unchanged after error
-					s.Require().Equal(initialLiquidity.Add(addedLiquidity), currAccumShares)
+					s.Require().Equal(expectedLiquidity, currAccumShares)
+
+					// Also validate uptime accumulators passed in as parameter.
+					currAccumShares, err = uptimeAccums[uptimeIdx].GetTotalShares()
+					s.Require().Equal(expectedLiquidity, currAccumShares)
 				}
 
 				// If gauge exists, ensure it remains empty after error
diff --git a/x/concentrated-liquidity/keeper_test.go b/x/concentrated-liquidity/keeper_test.go
index 0cfc335ac..761ecbfcd 100644
--- a/x/concentrated-liquidity/keeper_test.go
+++ b/x/concentrated-liquidity/keeper_test.go
@@ -324,11 +324,25 @@ func (s *KeeperTestSuite) crossTickAndChargeFee(poolId uint64, tickIndexToCross
 	nextTickInfo, err := s.App.ConcentratedLiquidityKeeper.GetTickInfo(s.Ctx, poolId, tickIndexToCross)
 	s.Require().NoError(err)
 
+	uptimeAccums, err := s.App.ConcentratedLiquidityKeeper.GetUptimeAccumulators(s.Ctx, poolId)
+	s.Require().NoError(err)
+
+	feeAccum, err := s.App.ConcentratedLiquidityKeeper.GetFeeAccumulator(s.Ctx, poolId)
+	s.Require().NoError(err)
+
 	// Cross the tick to update it.
-	_, err = s.App.ConcentratedLiquidityKeeper.CrossTick(s.Ctx, poolId, tickIndexToCross, &nextTickInfo, DefaultFeeAccumCoins[0])
+	_, err = s.App.ConcentratedLiquidityKeeper.CrossTick(s.Ctx, poolId, tickIndexToCross, &nextTickInfo, DefaultFeeAccumCoins[0], feeAccum.GetValue(), uptimeAccums)
 	s.Require().NoError(err)
-	err = s.App.ConcentratedLiquidityKeeper.ChargeFee(s.Ctx, poolId, DefaultFeeAccumCoins[0])
+	s.AddToFeeAccumulator(poolId, DefaultFeeAccumCoins[0])
+}
+
+// AddToFeeAccumulator adds the given fee to pool by updating
+// the internal per-pool accumulator that tracks fee growth per one unit of
+// liquidity.
+func (s *KeeperTestSuite) AddToFeeAccumulator(poolId uint64, feeUpdate sdk.DecCoin) {
+	feeAccumulator, err := s.App.ConcentratedLiquidityKeeper.GetFeeAccumulator(s.Ctx, poolId)
 	s.Require().NoError(err)
+	feeAccumulator.AddToAccumulator(sdk.NewDecCoins(feeUpdate))
 }
 
 func (s *KeeperTestSuite) validatePositionFeeGrowth(poolId uint64, positionId uint64, expectedUnclaimedRewards sdk.DecCoins) {
diff --git a/x/concentrated-liquidity/lp_test.go b/x/concentrated-liquidity/lp_test.go
index 0143a1891..ac94725c7 100644
--- a/x/concentrated-liquidity/lp_test.go
+++ b/x/concentrated-liquidity/lp_test.go
@@ -284,8 +284,7 @@ func (s *KeeperTestSuite) TestCreatePosition() {
 
 			// Pre-set fee growth accumulator
 			if !tc.preSetChargeFee.IsZero() {
-				err = clKeeper.ChargeFee(s.Ctx, 1, tc.preSetChargeFee)
-				s.Require().NoError(err)
+				s.AddToFeeAccumulator(poolID, tc.preSetChargeFee)
 			}
 
 			expectedNumCreatePositionEvents := 1
@@ -565,8 +564,7 @@ func (s *KeeperTestSuite) TestWithdrawPosition() {
 
 			// Set global fee growth to 1 ETH and charge the fee to the pool.
 			globalFeeGrowth := sdk.NewDecCoin(ETH, sdk.NewInt(1))
-			err = concentratedLiquidityKeeper.ChargeFee(s.Ctx, pool.GetId(), globalFeeGrowth)
-			s.Require().NoError(err)
+			s.AddToFeeAccumulator(pool.GetId(), globalFeeGrowth)
 
 			// Add global uptime growth
 			err = addToUptimeAccums(s.Ctx, pool.GetId(), concentratedLiquidityKeeper, defaultUptimeGrowth)
@@ -1653,8 +1651,7 @@ func (s *KeeperTestSuite) TestInverseRelation_CreatePosition_WithdrawPosition()
 
 			// Pre-set fee growth accumulator
 			if !tc.preSetChargeFee.IsZero() {
-				err = clKeeper.ChargeFee(s.Ctx, 1, tc.preSetChargeFee)
-				s.Require().NoError(err)
+				s.AddToFeeAccumulator(1, tc.preSetChargeFee)
 			}
 
 			// If we want to test a non-first position, we create a first position with a separate account
diff --git a/x/concentrated-liquidity/tick_test.go b/x/concentrated-liquidity/tick_test.go
index d16374f05..b354db272 100644
--- a/x/concentrated-liquidity/tick_test.go
+++ b/x/concentrated-liquidity/tick_test.go
@@ -428,8 +428,7 @@ func (s *KeeperTestSuite) TestGetTickInfo() {
 			if test.poolToGet == validPoolId {
 				s.SetupDefaultPosition(test.poolToGet)
 			}
-			err = clKeeper.ChargeFee(s.Ctx, validPoolId, oneEth)
-			s.Require().NoError(err)
+			s.AddToFeeAccumulator(validPoolId, oneEth)
 
 			// System under test
 			tickInfo, err := clKeeper.GetTickInfo(s.Ctx, test.poolToGet, test.tickToGet)
@@ -553,14 +552,6 @@ func (s *KeeperTestSuite) TestCrossTick() {
 			expectedLiquidityDelta:  DefaultLiquidityAmt.Neg(),
 			expectedTickFeeGrowthOppositeDirectionOfLastTraversal: DefaultFeeAccumCoins.Add(defaultAdditiveFee.Add(defaultAdditiveFee)),
 		},
-		{
-			name:                    "error: Try invalid tick",
-			poolToGet:               2,
-			preInitializedTickIndex: preInitializedTickIndex,
-			tickToGet:               preInitializedTickIndex,
-			additiveFee:             defaultAdditiveFee,
-			expectedErr:             accum.AccumDoesNotExistError{},
-		},
 		{
 			name:                    "error: Nil tick",
 			poolToGet:               validPoolId,
@@ -589,17 +580,16 @@ func (s *KeeperTestSuite) TestCrossTick() {
 			// Charge fee to make sure that the global fee accumulator is always updated.
 			// This is to test that the per-tick fee growth accumulator gets initialized.
 			defaultAccumCoins := sdk.NewDecCoin("foo", sdk.NewInt(50))
-			err := s.App.ConcentratedLiquidityKeeper.ChargeFee(s.Ctx, validPoolId, defaultAccumCoins)
-			s.Require().NoError(err)
+			s.AddToFeeAccumulator(validPoolId, defaultAccumCoins)
 
 			// Initialize global uptime accums
 			if test.initGlobalUptimeAccumValues != nil {
-				err = addToUptimeAccums(s.Ctx, clPool.GetId(), s.App.ConcentratedLiquidityKeeper, test.initGlobalUptimeAccumValues)
+				err := addToUptimeAccums(s.Ctx, clPool.GetId(), s.App.ConcentratedLiquidityKeeper, test.initGlobalUptimeAccumValues)
 				s.Require().NoError(err)
 			}
 
 			// Set up an initialized tick
-			err = s.App.ConcentratedLiquidityKeeper.InitOrUpdateTick(s.Ctx, validPoolId, DefaultCurrTick, test.preInitializedTickIndex, DefaultLiquidityAmt, true)
+			err := s.App.ConcentratedLiquidityKeeper.InitOrUpdateTick(s.Ctx, validPoolId, DefaultCurrTick, test.preInitializedTickIndex, DefaultLiquidityAmt, true)
 			s.Require().NoError(err)
 
 			// Update global uptime accums for edge case testing
@@ -610,8 +600,7 @@ func (s *KeeperTestSuite) TestCrossTick() {
 
 			// update the fee accumulator so that we have accum value > tick fee growth value
 			// now we have 100 foo coins inside the pool accumulator
-			err = s.App.ConcentratedLiquidityKeeper.ChargeFee(s.Ctx, validPoolId, defaultAccumCoins)
-			s.Require().NoError(err)
+			s.AddToFeeAccumulator(validPoolId, defaultAccumCoins)
 
 			var nextTickInfo *model.TickInfo
 
@@ -629,8 +618,18 @@ func (s *KeeperTestSuite) TestCrossTick() {
 				nextTickInfo = &model.TickInfo{}
 			}
 
+			var uptimeAccums []accum.AccumulatorObject
+			var feeAccum accum.AccumulatorObject
+			if test.poolToGet == validPoolId {
+				uptimeAccums, err = s.App.ConcentratedLiquidityKeeper.GetUptimeAccumulators(s.Ctx, test.poolToGet)
+				s.Require().NoError(err)
+
+				feeAccum, err = s.App.ConcentratedLiquidityKeeper.GetFeeAccumulator(s.Ctx, test.poolToGet)
+				s.Require().NoError(err)
+			}
+
 			// System under test
-			liquidityDelta, err := s.App.ConcentratedLiquidityKeeper.CrossTick(s.Ctx, test.poolToGet, test.tickToGet, nextTickInfo, test.additiveFee)
+			liquidityDelta, err := s.App.ConcentratedLiquidityKeeper.CrossTick(s.Ctx, test.poolToGet, test.tickToGet, nextTickInfo, test.additiveFee, feeAccum.GetValue(), uptimeAccums)
 			if test.expectedErr != nil {
 				s.Require().Error(err)
 				s.Require().ErrorAs(err, &test.expectedErr)
@@ -675,8 +674,8 @@ func (s *KeeperTestSuite) TestGetTickLiquidityForFullRange() {
 			expectedLiquidityDepthForRange: []queryproto.LiquidityDepthWithRange{
 				{
 					LiquidityAmount: sdk.NewDec(10),
-					LowerTick:       sdk.NewInt(DefaultMinTick),
-					UpperTick:       sdk.NewInt(DefaultMaxTick),
+					LowerTick:       DefaultMinTick,
+					UpperTick:       DefaultMaxTick,
 				},
 			},
 		},
@@ -689,8 +688,8 @@ func (s *KeeperTestSuite) TestGetTickLiquidityForFullRange() {
 			expectedLiquidityDepthForRange: []queryproto.LiquidityDepthWithRange{
 				{
 					LiquidityAmount: sdk.NewDec(10),
-					LowerTick:       sdk.NewInt(DefaultMinTick),
-					UpperTick:       sdk.NewInt(5),
+					LowerTick:       DefaultMinTick,
+					UpperTick:       5,
 				},
 			},
 		},
@@ -707,18 +706,18 @@ func (s *KeeperTestSuite) TestGetTickLiquidityForFullRange() {
 			expectedLiquidityDepthForRange: []queryproto.LiquidityDepthWithRange{
 				{
 					LiquidityAmount: sdk.NewDec(10),
-					LowerTick:       sdk.NewInt(-20),
-					UpperTick:       sdk.NewInt(10),
+					LowerTick:       -20,
+					UpperTick:       10,
 				},
 				{
 					LiquidityAmount: sdk.NewDec(60),
-					LowerTick:       sdk.NewInt(10),
-					UpperTick:       sdk.NewInt(20),
+					LowerTick:       10,
+					UpperTick:       20,
 				},
 				{
 					LiquidityAmount: sdk.NewDec(50),
-					LowerTick:       sdk.NewInt(20),
-					UpperTick:       sdk.NewInt(30),
+					LowerTick:       20,
+					UpperTick:       30,
 				},
 			},
 		},
@@ -735,18 +734,18 @@ func (s *KeeperTestSuite) TestGetTickLiquidityForFullRange() {
 			expectedLiquidityDepthForRange: []queryproto.LiquidityDepthWithRange{
 				{
 					LiquidityAmount: sdk.NewDec(10),
-					LowerTick:       sdk.NewInt(DefaultMinTick),
-					UpperTick:       sdk.NewInt(10),
+					LowerTick:       DefaultMinTick,
+					UpperTick:       10,
 				},
 				{
 					LiquidityAmount: sdk.NewDec(60),
-					LowerTick:       sdk.NewInt(10),
-					UpperTick:       sdk.NewInt(30),
+					LowerTick:       10,
+					UpperTick:       30,
 				},
 				{
 					LiquidityAmount: sdk.NewDec(10),
-					LowerTick:       sdk.NewInt(30),
-					UpperTick:       sdk.NewInt(DefaultMaxTick),
+					LowerTick:       30,
+					UpperTick:       DefaultMaxTick,
 				},
 			},
 		},
@@ -766,28 +765,28 @@ func (s *KeeperTestSuite) TestGetTickLiquidityForFullRange() {
 			expectedLiquidityDepthForRange: []queryproto.LiquidityDepthWithRange{
 				{
 					LiquidityAmount: sdk.NewDec(10),
-					LowerTick:       sdk.NewInt(-20),
-					UpperTick:       sdk.NewInt(10),
+					LowerTick:       -20,
+					UpperTick:       10,
 				},
 				{
 					LiquidityAmount: sdk.NewDec(60),
-					LowerTick:       sdk.NewInt(10),
-					UpperTick:       sdk.NewInt(11),
+					LowerTick:       10,
+					UpperTick:       11,
 				},
 				{
 					LiquidityAmount: sdk.NewDec(160),
-					LowerTick:       sdk.NewInt(11),
-					UpperTick:       sdk.NewInt(13),
+					LowerTick:       11,
+					UpperTick:       13,
 				},
 				{
 					LiquidityAmount: sdk.NewDec(60),
-					LowerTick:       sdk.NewInt(13),
-					UpperTick:       sdk.NewInt(20),
+					LowerTick:       13,
+					UpperTick:       20,
 				},
 				{
 					LiquidityAmount: sdk.NewDec(50),
-					LowerTick:       sdk.NewInt(20),
-					UpperTick:       sdk.NewInt(30),
+					LowerTick:       20,
+					UpperTick:       30,
 				},
 			},
 		},
@@ -842,7 +841,7 @@ func (s *KeeperTestSuite) TestGetTickLiquidityNetInDirection() {
 			expectedLiquidityDepths: []queryproto.TickLiquidityNet{
 				{
 					LiquidityNet: sdk.NewDec(10),
-					TickIndex:    sdk.NewInt(DefaultMinTick),
+					TickIndex:    DefaultMinTick,
 				},
 			},
 		},
@@ -859,7 +858,7 @@ func (s *KeeperTestSuite) TestGetTickLiquidityNetInDirection() {
 			expectedLiquidityDepths: []queryproto.TickLiquidityNet{
 				{
 					LiquidityNet: sdk.NewDec(-10),
-					TickIndex:    sdk.NewInt(DefaultMaxTick),
+					TickIndex:    DefaultMaxTick,
 				},
 			},
 		},
@@ -878,7 +877,7 @@ func (s *KeeperTestSuite) TestGetTickLiquidityNetInDirection() {
 			expectedLiquidityDepths: []queryproto.TickLiquidityNet{
 				{
 					LiquidityNet: sdk.NewDec(10),
-					TickIndex:    sdk.NewInt(DefaultMinTick),
+					TickIndex:    DefaultMinTick,
 				},
 			},
 		},
@@ -897,15 +896,15 @@ func (s *KeeperTestSuite) TestGetTickLiquidityNetInDirection() {
 			expectedLiquidityDepths: []queryproto.TickLiquidityNet{
 				{
 					LiquidityNet: sdk.NewDec(20),
-					TickIndex:    sdk.NewInt(5),
+					TickIndex:    5,
 				},
 				{
 					LiquidityNet: sdk.NewDec(-20),
-					TickIndex:    sdk.NewInt(10),
+					TickIndex:    10,
 				},
 				{
 					LiquidityNet: sdk.NewDec(-10),
-					TickIndex:    sdk.NewInt(DefaultMaxTick),
+					TickIndex:    DefaultMaxTick,
 				},
 			},
 		},
@@ -924,7 +923,7 @@ func (s *KeeperTestSuite) TestGetTickLiquidityNetInDirection() {
 			expectedLiquidityDepths: []queryproto.TickLiquidityNet{
 				{
 					LiquidityNet: sdk.NewDec(20),
-					TickIndex:    sdk.NewInt(-10),
+					TickIndex:    -10,
 				},
 			},
 		},
@@ -955,7 +954,7 @@ func (s *KeeperTestSuite) TestGetTickLiquidityNetInDirection() {
 			expectedLiquidityDepths: []queryproto.TickLiquidityNet{
 				{
 					LiquidityNet: sdk.NewDec(-20),
-					TickIndex:    sdk.NewInt(10),
+					TickIndex:    10,
 				},
 			},
 		},
@@ -976,11 +975,11 @@ func (s *KeeperTestSuite) TestGetTickLiquidityNetInDirection() {
 			expectedLiquidityDepths: []queryproto.TickLiquidityNet{
 				{
 					LiquidityNet: sdk.NewDec(20),
-					TickIndex:    sdk.NewInt(-5),
+					TickIndex:    -5,
 				},
 				{
 					LiquidityNet: sdk.NewDec(10),
-					TickIndex:    sdk.NewInt(DefaultMinTick),
+					TickIndex:    DefaultMinTick,
 				},
 			},
 		},
@@ -1001,19 +1000,19 @@ func (s *KeeperTestSuite) TestGetTickLiquidityNetInDirection() {
 			expectedLiquidityDepths: []queryproto.TickLiquidityNet{
 				{
 					LiquidityNet: sdk.NewDec(40),
-					TickIndex:    sdk.NewInt(2),
+					TickIndex:    2,
 				},
 				{
 					LiquidityNet: sdk.NewDec(-20),
-					TickIndex:    sdk.NewInt(5),
+					TickIndex:    5,
 				},
 				{
 					LiquidityNet: sdk.NewDec(-40),
-					TickIndex:    sdk.NewInt(10),
+					TickIndex:    10,
 				},
 				{
 					LiquidityNet: sdk.NewDec(-10),
-					TickIndex:    sdk.NewInt(DefaultMaxTick),
+					TickIndex:    DefaultMaxTick,
 				},
 			},
 		},
@@ -1032,7 +1031,7 @@ func (s *KeeperTestSuite) TestGetTickLiquidityNetInDirection() {
 			expectedLiquidityDepths: []queryproto.TickLiquidityNet{
 				{
 					LiquidityNet: sdk.NewDec(20),
-					TickIndex:    sdk.NewInt(-10),
+					TickIndex:    -10,
 				},
 			},
 		},
@@ -1051,7 +1050,7 @@ func (s *KeeperTestSuite) TestGetTickLiquidityNetInDirection() {
 			expectedLiquidityDepths: []queryproto.TickLiquidityNet{
 				{
 					LiquidityNet: sdk.NewDec(20),
-					TickIndex:    sdk.NewInt(-10),
+					TickIndex:    -10,
 				},
 			},
 		},
@@ -1070,7 +1069,7 @@ func (s *KeeperTestSuite) TestGetTickLiquidityNetInDirection() {
 			expectedLiquidityDepths: []queryproto.TickLiquidityNet{
 				{
 					LiquidityNet: sdk.NewDec(-20),
-					TickIndex:    sdk.NewInt(10),
+					TickIndex:    10,
 				},
 			},
 		},
@@ -1089,7 +1088,7 @@ func (s *KeeperTestSuite) TestGetTickLiquidityNetInDirection() {
 			expectedLiquidityDepths: []queryproto.TickLiquidityNet{
 				{
 					LiquidityNet: sdk.NewDec(-20),
-					TickIndex:    sdk.NewInt(10),
+					TickIndex:    10,
 				},
 			},
 		},