From e3ac929b13bb08fab85bfa30a448d677e331a659 Mon Sep 17 00:00:00 2001
From: Julian Compagni Portis <jcompagni@gmail.com>
Date: Wed, 29 May 2024 03:36:50 -0400
Subject: [PATCH 01/10] don't check bank balance for estimateXX queries

also general cleanup for estimateXX
---
 proto/neutron/dex/query.proto                 |  28 +-
 wasmbinding/queries.go                        |   2 -
 .../grpc_query_estimate_multi_hop_swap.go     |  17 +-
 ...grpc_query_estimate_multi_hop_swap_test.go |  27 +-
 .../grpc_query_estimate_place_limit_order.go  |  28 +-
 x/dex/keeper/msg_server_test.go               |   8 +-
 x/dex/keeper/simulation_bank_keeper.go        |  41 ++
 x/dex/types/query.pb.go                       | 608 ++++++------------
 8 files changed, 288 insertions(+), 471 deletions(-)
 create mode 100644 x/dex/keeper/simulation_bank_keeper.go

diff --git a/proto/neutron/dex/query.proto b/proto/neutron/dex/query.proto
index ef524da0c..f72e99c59 100644
--- a/proto/neutron/dex/query.proto
+++ b/proto/neutron/dex/query.proto
@@ -260,25 +260,22 @@ message QueryGetPoolReservesResponse {
 }
 
 message QueryEstimateMultiHopSwapRequest {
-  string creator = 1;
-  string receiver = 2;
-  repeated MultiHopRoute routes = 3;
-  string amount_in = 4 [
+  repeated MultiHopRoute routes = 1;
+  string amount_in = 2 [
     (gogoproto.moretags) = "yaml:\"amount_in\"",
     (gogoproto.customtype) = "cosmossdk.io/math.Int",
     (gogoproto.nullable) = false,
     (gogoproto.jsontag) = "amount_in"
   ];
-  string exit_limit_price = 5 [
+  string exit_limit_price = 3 [
     (gogoproto.moretags) = "yaml:\"exit_limit_price\"",
     (gogoproto.customtype) = "github.com/neutron-org/neutron/v4/utils/math.PrecDec",
     (gogoproto.nullable) = false,
     (gogoproto.jsontag) = "exit_limit_price"
   ];
-
   // If pickBestRoute == true then all routes are run and the route with the
   // best price is chosen otherwise, the first succesful route is used.
-  bool pick_best_route = 6;
+  bool pick_best_route = 4;
 }
 
 message QueryEstimateMultiHopSwapResponse {
@@ -290,25 +287,22 @@ message QueryEstimateMultiHopSwapResponse {
 }
 
 message QueryEstimatePlaceLimitOrderRequest {
-  string creator = 1;
-  string receiver = 2;
-  string token_in = 3;
-  string token_out = 4;
-  int64 tick_index_in_to_out = 5;
-  string amount_in = 6 [
+  string token_in = 1;
+  string token_out = 2;
+  int64 tick_index_in_to_out = 3;
+  string amount_in = 4 [
     (gogoproto.moretags) = "yaml:\"amount_in\"",
     (gogoproto.customtype) = "cosmossdk.io/math.Int",
     (gogoproto.nullable) = false,
     (gogoproto.jsontag) = "amount_in"
   ];
-  LimitOrderType order_type = 7;
-
+  LimitOrderType order_type = 5;
   // expirationTime is only valid iff orderType == GOOD_TIL_TIME.
-  google.protobuf.Timestamp expiration_time = 8 [
+  google.protobuf.Timestamp expiration_time = 9 [
     (gogoproto.stdtime) = true,
     (gogoproto.nullable) = true
   ];
-  string maxAmount_out = 9 [
+  string max_amount_out = 6 [
     (gogoproto.moretags) = "yaml:\"max_amount_out\"",
     (gogoproto.customtype) = "cosmossdk.io/math.Int",
     (gogoproto.nullable) = true,
diff --git a/wasmbinding/queries.go b/wasmbinding/queries.go
index 39b602658..371a97229 100644
--- a/wasmbinding/queries.go
+++ b/wasmbinding/queries.go
@@ -146,8 +146,6 @@ func (qp *QueryPlugin) DexQuery(ctx sdk.Context, query bindings.DexQuery) (data
 		data, err = dexQuery(ctx, query.EstimateMultiHopSwap, qp.dexKeeper.EstimateMultiHopSwap)
 	case query.EstimatePlaceLimitOrder != nil:
 		q := dextypes.QueryEstimatePlaceLimitOrderRequest{
-			Creator:          query.EstimatePlaceLimitOrder.Creator,
-			Receiver:         query.EstimatePlaceLimitOrder.Receiver,
 			TokenIn:          query.EstimatePlaceLimitOrder.TokenIn,
 			TokenOut:         query.EstimatePlaceLimitOrder.TokenOut,
 			TickIndexInToOut: query.EstimatePlaceLimitOrder.TickIndexInToOut,
diff --git a/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go b/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go
index eb133dce9..6eb3e9fee 100644
--- a/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go
+++ b/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go
@@ -8,14 +8,13 @@ import (
 	"github.com/neutron-org/neutron/v4/x/dex/types"
 )
 
-// TODO: This doesn't run ValidateBasic() checks.
 func (k Keeper) EstimateMultiHopSwap(
 	goCtx context.Context,
 	req *types.QueryEstimateMultiHopSwapRequest,
 ) (*types.QueryEstimateMultiHopSwapResponse, error) {
 	msg := types.MsgMultiHopSwap{
-		Creator:        req.Creator,
-		Receiver:       req.Receiver,
+		Creator:        "neutron1dft8nwxzr0u27wvr2cknpermjkreqvp9fdy0uz",
+		Receiver:       "neutron1dft8nwxzr0u27wvr2cknpermjkreqvp9fdy0uz",
 		Routes:         req.Routes,
 		AmountIn:       req.AmountIn,
 		ExitLimitPrice: req.ExitLimitPrice,
@@ -28,23 +27,23 @@ func (k Keeper) EstimateMultiHopSwap(
 	ctx := sdk.UnwrapSDKContext(goCtx)
 	cacheCtx, _ := ctx.CacheContext()
 
-	callerAddr := sdk.MustAccAddressFromBech32(req.Creator)
-	receiverAddr := sdk.MustAccAddressFromBech32(req.Receiver)
-
+	oldBK := k.bankKeeper
+	k.bankKeeper = NewSimulationBankKeeper(k.bankKeeper)
 	coinOut, err := k.MultiHopSwapCore(
 		cacheCtx,
 		req.AmountIn,
 		req.Routes,
 		req.ExitLimitPrice,
 		req.PickBestRoute,
-		callerAddr,
-		receiverAddr,
+		[]byte("caller"),
+		[]byte("receiver"),
 	)
 	if err != nil {
 		return nil, err
 	}
 
-	// NB: Critically, we do not write the best route's buffered state context since this is only an estimate.
+	//nolint:staticcheck // Should be unnecessary but out of an abundance of caution we restore the old bankkeeper
+	k.bankKeeper = oldBK
 
 	return &types.QueryEstimateMultiHopSwapResponse{CoinOut: coinOut}, nil
 }
diff --git a/x/dex/keeper/grpc_query_estimate_multi_hop_swap_test.go b/x/dex/keeper/grpc_query_estimate_multi_hop_swap_test.go
index a7acde67b..0df412dfd 100644
--- a/x/dex/keeper/grpc_query_estimate_multi_hop_swap_test.go
+++ b/x/dex/keeper/grpc_query_estimate_multi_hop_swap_test.go
@@ -3,14 +3,13 @@ package keeper_test
 import (
 	"cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
 	math_utils "github.com/neutron-org/neutron/v4/utils/math"
 	"github.com/neutron-org/neutron/v4/x/dex/types"
 )
 
 func (s *DexTestSuite) TestEstimateMultiHopSwapSingleRoute() {
-	s.fundAliceBalances(100, 0)
-
 	// GIVEN liquidity in pools A<>B, B<>C, C<>D,
 	s.SetupMultiplePools(
 		NewPoolSetup("TokenA", "TokenB", 0, 100, 0, 1),
@@ -20,17 +19,19 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapSingleRoute() {
 
 	// WHEN alice multihopswaps A<>B => B<>C => C<>D,
 	route := [][]string{{"TokenA", "TokenB", "TokenC", "TokenD"}}
-	coinOut := s.aliceEstimatesMultiHopSwap(route, 100, math_utils.MustNewPrecDecFromStr("0.9"), false)
+	coinOut := s.estimatesMultiHopSwap(route, 100, math_utils.MustNewPrecDecFromStr("0.9"), false)
 
 	// THEN alice would get out ~99 BIGTokenD
 	s.Assert().Equal(math.NewInt(99970003), coinOut.Amount)
-	s.assertAccountBalanceWithDenom(s.alice, "TokenA", 100)
-	s.assertAccountBalanceWithDenom(s.alice, "TokenD", 0)
 
+	// AND state is not altered
+	s.assertAccountBalanceWithDenom(s.alice, "TokenD", 0)
 	s.assertDexBalanceWithDenom("TokenA", 0)
 	s.assertDexBalanceWithDenom("TokenB", 100)
 	s.assertDexBalanceWithDenom("TokenC", 100)
 	s.assertDexBalanceWithDenom("TokenD", 100)
+
+	s.assertBobLimitSellFails(sdkerrors.ErrInsufficientFunds, "TokenA", -400_000, 100_000_000)
 }
 
 func (s *DexTestSuite) TestEstimateMultiHopSwapInsufficientLiquiditySingleRoute() {
@@ -45,7 +46,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapInsufficientLiquiditySingleRoute(
 
 	// THEN estimate multihopswap fails
 	route := [][]string{{"TokenA", "TokenB", "TokenC", "TokenD"}}
-	s.aliceEstimatesMultiHopSwapFails(
+	s.estimatesMultiHopSwapFails(
 		types.ErrInsufficientLiquidity,
 		route,
 		100,
@@ -66,7 +67,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapLimitPriceNotMetSingleRoute() {
 
 	// THEN estimate multihopswap fails
 	route := [][]string{{"TokenA", "TokenB", "TokenC", "TokenD"}}
-	s.aliceEstimatesMultiHopSwapFails(
+	s.estimatesMultiHopSwapFails(
 		types.ErrExitLimitPriceHit,
 		route,
 		50,
@@ -106,7 +107,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteOneGood() {
 		1,
 	)
 
-	coinOut := s.aliceEstimatesMultiHopSwap(routes, 100, math_utils.MustNewPrecDecFromStr("0.91"), false)
+	coinOut := s.estimatesMultiHopSwap(routes, 100, math_utils.MustNewPrecDecFromStr("0.91"), false)
 
 	// THEN swap estimation succeeds through route A<>B, B<>E, E<>X
 
@@ -205,7 +206,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteAllFail() {
 	}
 
 	// Then fails with findBestRoute
-	s.aliceEstimatesMultiHopSwapFails(
+	s.estimatesMultiHopSwapFails(
 		types.ErrExitLimitPriceHit,
 		routes,
 		100,
@@ -215,7 +216,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteAllFail() {
 
 	// and with findFirstRoute
 
-	s.aliceEstimatesMultiHopSwapFails(
+	s.estimatesMultiHopSwapFails(
 		types.ErrExitLimitPriceHit,
 		routes,
 		100,
@@ -244,7 +245,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteFindBestRoute() {
 		{"TokenA", "TokenB", "TokenD", "TokenX"},
 		{"TokenA", "TokenB", "TokenE", "TokenX"},
 	}
-	coinOut := s.aliceEstimatesMultiHopSwap(routes, 100, math_utils.MustNewPrecDecFromStr("0.9"), true)
+	coinOut := s.estimatesMultiHopSwap(routes, 100, math_utils.MustNewPrecDecFromStr("0.9"), true)
 
 	// THEN swap succeeds through route A<>B, B<>E, E<>X
 
@@ -336,7 +337,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapLongRouteWithCache() {
 			"TokenG", "TokenH", "TokenI", "TokenJ", "TokenK", "TokenM", "TokenX",
 		},
 	}
-	coinOut := s.aliceEstimatesMultiHopSwap(routes, 100, math_utils.MustNewPrecDecFromStr("0.8"), true)
+	coinOut := s.estimatesMultiHopSwap(routes, 100, math_utils.MustNewPrecDecFromStr("0.8"), true)
 
 	// THEN swap succeeds with second route
 	s.Assert().Equal(coinOut, sdk.NewCoin("TokenX", math.NewInt(99880066)))
@@ -359,7 +360,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapEventsEmitted() {
 	)
 
 	route := [][]string{{"TokenA", "TokenB", "TokenC"}}
-	_ = s.aliceEstimatesMultiHopSwap(route, 100, math_utils.MustNewPrecDecFromStr("0.9"), false)
+	_ = s.estimatesMultiHopSwap(route, 100, math_utils.MustNewPrecDecFromStr("0.9"), false)
 
 	// 8 tickUpdateEvents are emitted 4x for pool setup 4x for two swaps
 	s.AssertEventValueNotEmitted(types.TickUpdateEventKey, "Expected no events")
diff --git a/x/dex/keeper/grpc_query_estimate_place_limit_order.go b/x/dex/keeper/grpc_query_estimate_place_limit_order.go
index 6a4447d0f..293466206 100644
--- a/x/dex/keeper/grpc_query_estimate_place_limit_order.go
+++ b/x/dex/keeper/grpc_query_estimate_place_limit_order.go
@@ -3,20 +3,18 @@ package keeper
 import (
 	"context"
 
-	sdkerrors "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/neutron-org/neutron/v4/x/dex/types"
 )
 
-// TODO: This doesn't run ValidateBasic() checks.
 func (k Keeper) EstimatePlaceLimitOrder(
 	goCtx context.Context,
 	req *types.QueryEstimatePlaceLimitOrderRequest,
 ) (*types.QueryEstimatePlaceLimitOrderResponse, error) {
 	msg := types.MsgPlaceLimitOrder{
-		Creator:          req.Creator,
-		Receiver:         req.Receiver,
+		Creator:          "neutron1dft8nwxzr0u27wvr2cknpermjkreqvp9fdy0uz",
+		Receiver:         "neutron1dft8nwxzr0u27wvr2cknpermjkreqvp9fdy0uz",
 		TokenIn:          req.TokenIn,
 		TokenOut:         req.TokenOut,
 		TickIndexInToOut: req.TickIndexInToOut,
@@ -32,18 +30,13 @@ func (k Keeper) EstimatePlaceLimitOrder(
 	ctx := sdk.UnwrapSDKContext(goCtx)
 	cacheCtx, _ := ctx.CacheContext()
 
-	callerAddr := sdk.MustAccAddressFromBech32(req.Creator)
-	receiverAddr := sdk.MustAccAddressFromBech32(req.Receiver)
-
-	blockTime := cacheCtx.BlockTime()
-	if req.OrderType.IsGoodTil() && !req.ExpirationTime.After(blockTime) {
-		return nil, sdkerrors.Wrapf(types.ErrExpirationTimeInPast,
-			"Current BlockTime: %s; Provided ExpirationTime: %s",
-			blockTime.String(),
-			req.ExpirationTime.String(),
-		)
+	err := msg.ValidateGoodTilExpiration(ctx.BlockTime())
+	if err != nil {
+		return nil, err
 	}
 
+	oldBK := k.bankKeeper
+	k.bankKeeper = NewSimulationBankKeeper(k.bankKeeper)
 	_, totalInCoin, swapInCoin, swapOutCoin, err := k.PlaceLimitOrderCore(
 		cacheCtx,
 		req.TokenIn,
@@ -53,14 +46,15 @@ func (k Keeper) EstimatePlaceLimitOrder(
 		req.OrderType,
 		req.ExpirationTime,
 		req.MaxAmountOut,
-		callerAddr,
-		receiverAddr,
+		[]byte("caller"),
+		[]byte("receiver"),
 	)
 	if err != nil {
 		return nil, err
 	}
 
-	// NB: We're only using a cache context so we don't expect any writes to happen.
+	//nolint:staticcheck // Should be unnecessary but out of an abundance of caution we restore the old bankkeeper
+	k.bankKeeper = oldBK
 
 	return &types.QueryEstimatePlaceLimitOrderResponse{
 		TotalInCoin: totalInCoin,
diff --git a/x/dex/keeper/msg_server_test.go b/x/dex/keeper/msg_server_test.go
index d5e6894f2..7944d5c67 100644
--- a/x/dex/keeper/msg_server_test.go
+++ b/x/dex/keeper/msg_server_test.go
@@ -914,7 +914,7 @@ func (s *DexTestSuite) multiHopSwaps(
 	s.Assert().Nil(err)
 }
 
-func (s *DexTestSuite) aliceEstimatesMultiHopSwap(
+func (s *DexTestSuite) estimatesMultiHopSwap(
 	routes [][]string,
 	amountIn int,
 	exitLimitPrice math_utils.PrecDec,
@@ -925,8 +925,6 @@ func (s *DexTestSuite) aliceEstimatesMultiHopSwap(
 		multiHopRoutes[i] = &types.MultiHopRoute{Hops: hops}
 	}
 	msg := &types.QueryEstimateMultiHopSwapRequest{
-		Creator:        s.alice.String(),
-		Receiver:       s.alice.String(),
 		Routes:         multiHopRoutes,
 		AmountIn:       sdkmath.NewInt(int64(amountIn)).Mul(denomMultiple),
 		ExitLimitPrice: exitLimitPrice,
@@ -937,7 +935,7 @@ func (s *DexTestSuite) aliceEstimatesMultiHopSwap(
 	return res.CoinOut
 }
 
-func (s *DexTestSuite) aliceEstimatesMultiHopSwapFails(
+func (s *DexTestSuite) estimatesMultiHopSwapFails(
 	expectedErr error,
 	routes [][]string,
 	amountIn int,
@@ -949,8 +947,6 @@ func (s *DexTestSuite) aliceEstimatesMultiHopSwapFails(
 		multiHopRoutes[i] = &types.MultiHopRoute{Hops: hops}
 	}
 	msg := &types.QueryEstimateMultiHopSwapRequest{
-		Creator:        s.alice.String(),
-		Receiver:       s.alice.String(),
 		Routes:         multiHopRoutes,
 		AmountIn:       sdkmath.NewInt(int64(amountIn)).Mul(denomMultiple),
 		ExitLimitPrice: exitLimitPrice,
diff --git a/x/dex/keeper/simulation_bank_keeper.go b/x/dex/keeper/simulation_bank_keeper.go
new file mode 100644
index 000000000..f5c3c14cd
--- /dev/null
+++ b/x/dex/keeper/simulation_bank_keeper.go
@@ -0,0 +1,41 @@
+package keeper
+
+import (
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/neutron-org/neutron/v4/x/dex/types"
+)
+
+type SimulationBankKeeper struct {
+	originalBankKeeper types.BankKeeper
+}
+
+func (s SimulationBankKeeper) SendCoinsFromAccountToModule(_ context.Context, _ sdk.AccAddress, _ string, _ sdk.Coins) error {
+	return nil
+}
+
+func (s SimulationBankKeeper) SendCoinsFromModuleToAccount(_ context.Context, _ string, _ sdk.AccAddress, _ sdk.Coins) error {
+	return nil
+}
+
+func (s SimulationBankKeeper) MintCoins(_ context.Context, _ string, _ sdk.Coins) error {
+	return nil
+}
+
+func (s SimulationBankKeeper) BurnCoins(_ context.Context, _ string, _ sdk.Coins) error {
+	return nil
+}
+
+func (s SimulationBankKeeper) IterateAccountBalances(ctx context.Context, addr sdk.AccAddress, cb func(sdk.Coin) bool) {
+	s.originalBankKeeper.IterateAccountBalances(ctx, addr, cb)
+}
+
+func (s SimulationBankKeeper) GetSupply(ctx context.Context, denom string) sdk.Coin {
+	return s.originalBankKeeper.GetSupply(ctx, denom)
+}
+
+func NewSimulationBankKeeper(bk types.BankKeeper) types.BankKeeper {
+	return SimulationBankKeeper{originalBankKeeper: bk}
+}
diff --git a/x/dex/types/query.pb.go b/x/dex/types/query.pb.go
index 953d59f96..f7161a617 100644
--- a/x/dex/types/query.pb.go
+++ b/x/dex/types/query.pb.go
@@ -1329,14 +1329,12 @@ func (m *QueryGetPoolReservesResponse) GetPoolReserves() *PoolReserves {
 }
 
 type QueryEstimateMultiHopSwapRequest struct {
-	Creator        string                                               `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
-	Receiver       string                                               `protobuf:"bytes,2,opt,name=receiver,proto3" json:"receiver,omitempty"`
-	Routes         []*MultiHopRoute                                     `protobuf:"bytes,3,rep,name=routes,proto3" json:"routes,omitempty"`
-	AmountIn       cosmossdk_io_math.Int                                `protobuf:"bytes,4,opt,name=amount_in,json=amountIn,proto3,customtype=cosmossdk.io/math.Int" json:"amount_in" yaml:"amount_in"`
-	ExitLimitPrice github_com_neutron_org_neutron_v4_utils_math.PrecDec `protobuf:"bytes,5,opt,name=exit_limit_price,json=exitLimitPrice,proto3,customtype=github.com/neutron-org/neutron/v4/utils/math.PrecDec" json:"exit_limit_price" yaml:"exit_limit_price"`
+	Routes         []*MultiHopRoute                                     `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty"`
+	AmountIn       cosmossdk_io_math.Int                                `protobuf:"bytes,2,opt,name=amount_in,json=amountIn,proto3,customtype=cosmossdk.io/math.Int" json:"amount_in" yaml:"amount_in"`
+	ExitLimitPrice github_com_neutron_org_neutron_v4_utils_math.PrecDec `protobuf:"bytes,3,opt,name=exit_limit_price,json=exitLimitPrice,proto3,customtype=github.com/neutron-org/neutron/v4/utils/math.PrecDec" json:"exit_limit_price" yaml:"exit_limit_price"`
 	// If pickBestRoute == true then all routes are run and the route with the
 	// best price is chosen otherwise, the first succesful route is used.
-	PickBestRoute bool `protobuf:"varint,6,opt,name=pick_best_route,json=pickBestRoute,proto3" json:"pick_best_route,omitempty"`
+	PickBestRoute bool `protobuf:"varint,4,opt,name=pick_best_route,json=pickBestRoute,proto3" json:"pick_best_route,omitempty"`
 }
 
 func (m *QueryEstimateMultiHopSwapRequest) Reset()         { *m = QueryEstimateMultiHopSwapRequest{} }
@@ -1372,20 +1370,6 @@ func (m *QueryEstimateMultiHopSwapRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryEstimateMultiHopSwapRequest proto.InternalMessageInfo
 
-func (m *QueryEstimateMultiHopSwapRequest) GetCreator() string {
-	if m != nil {
-		return m.Creator
-	}
-	return ""
-}
-
-func (m *QueryEstimateMultiHopSwapRequest) GetReceiver() string {
-	if m != nil {
-		return m.Receiver
-	}
-	return ""
-}
-
 func (m *QueryEstimateMultiHopSwapRequest) GetRoutes() []*MultiHopRoute {
 	if m != nil {
 		return m.Routes
@@ -1438,16 +1422,14 @@ func (m *QueryEstimateMultiHopSwapResponse) XXX_DiscardUnknown() {
 var xxx_messageInfo_QueryEstimateMultiHopSwapResponse proto.InternalMessageInfo
 
 type QueryEstimatePlaceLimitOrderRequest struct {
-	Creator          string                `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
-	Receiver         string                `protobuf:"bytes,2,opt,name=receiver,proto3" json:"receiver,omitempty"`
-	TokenIn          string                `protobuf:"bytes,3,opt,name=token_in,json=tokenIn,proto3" json:"token_in,omitempty"`
-	TokenOut         string                `protobuf:"bytes,4,opt,name=token_out,json=tokenOut,proto3" json:"token_out,omitempty"`
-	TickIndexInToOut int64                 `protobuf:"varint,5,opt,name=tick_index_in_to_out,json=tickIndexInToOut,proto3" json:"tick_index_in_to_out,omitempty"`
-	AmountIn         cosmossdk_io_math.Int `protobuf:"bytes,6,opt,name=amount_in,json=amountIn,proto3,customtype=cosmossdk.io/math.Int" json:"amount_in" yaml:"amount_in"`
-	OrderType        LimitOrderType        `protobuf:"varint,7,opt,name=order_type,json=orderType,proto3,enum=neutron.dex.LimitOrderType" json:"order_type,omitempty"`
+	TokenIn          string                `protobuf:"bytes,1,opt,name=token_in,json=tokenIn,proto3" json:"token_in,omitempty"`
+	TokenOut         string                `protobuf:"bytes,2,opt,name=token_out,json=tokenOut,proto3" json:"token_out,omitempty"`
+	TickIndexInToOut int64                 `protobuf:"varint,3,opt,name=tick_index_in_to_out,json=tickIndexInToOut,proto3" json:"tick_index_in_to_out,omitempty"`
+	AmountIn         cosmossdk_io_math.Int `protobuf:"bytes,4,opt,name=amount_in,json=amountIn,proto3,customtype=cosmossdk.io/math.Int" json:"amount_in" yaml:"amount_in"`
+	OrderType        LimitOrderType        `protobuf:"varint,5,opt,name=order_type,json=orderType,proto3,enum=neutron.dex.LimitOrderType" json:"order_type,omitempty"`
 	// expirationTime is only valid iff orderType == GOOD_TIL_TIME.
-	ExpirationTime *time.Time             `protobuf:"bytes,8,opt,name=expiration_time,json=expirationTime,proto3,stdtime" json:"expiration_time,omitempty"`
-	MaxAmountOut   *cosmossdk_io_math.Int `protobuf:"bytes,9,opt,name=maxAmount_out,json=maxAmountOut,proto3,customtype=cosmossdk.io/math.Int" json:"max_amount_out" yaml:"max_amount_out"`
+	ExpirationTime *time.Time             `protobuf:"bytes,9,opt,name=expiration_time,json=expirationTime,proto3,stdtime" json:"expiration_time,omitempty"`
+	MaxAmountOut   *cosmossdk_io_math.Int `protobuf:"bytes,6,opt,name=max_amount_out,json=maxAmountOut,proto3,customtype=cosmossdk.io/math.Int" json:"max_amount_out" yaml:"max_amount_out"`
 }
 
 func (m *QueryEstimatePlaceLimitOrderRequest) Reset()         { *m = QueryEstimatePlaceLimitOrderRequest{} }
@@ -1483,20 +1465,6 @@ func (m *QueryEstimatePlaceLimitOrderRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryEstimatePlaceLimitOrderRequest proto.InternalMessageInfo
 
-func (m *QueryEstimatePlaceLimitOrderRequest) GetCreator() string {
-	if m != nil {
-		return m.Creator
-	}
-	return ""
-}
-
-func (m *QueryEstimatePlaceLimitOrderRequest) GetReceiver() string {
-	if m != nil {
-		return m.Receiver
-	}
-	return ""
-}
-
 func (m *QueryEstimatePlaceLimitOrderRequest) GetTokenIn() string {
 	if m != nil {
 		return m.TokenIn
@@ -1952,153 +1920,151 @@ func init() {
 func init() { proto.RegisterFile("neutron/dex/query.proto", fileDescriptor_b6613ea5fce61e9c) }
 
 var fileDescriptor_b6613ea5fce61e9c = []byte{
-	// 2332 bytes of a gzipped FileDescriptorProto
+	// 2302 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0x4d, 0x6c, 0x1c, 0x49,
-	0x15, 0x4e, 0x7b, 0x1c, 0xc7, 0x2e, 0x3b, 0xb1, 0x5d, 0xb6, 0x37, 0x93, 0xb1, 0xe3, 0xb1, 0x7b,
-	0x37, 0xb1, 0x63, 0xf0, 0x74, 0x6c, 0x36, 0xbb, 0xab, 0x2c, 0x0b, 0x78, 0xf0, 0xae, 0x33, 0xec,
-	0x46, 0x31, 0xbd, 0x66, 0x7f, 0xc2, 0x4a, 0xad, 0xf6, 0x74, 0xc5, 0x6e, 0xb9, 0xa7, 0xbb, 0xd3,
-	0x5d, 0x63, 0x7b, 0x14, 0xe5, 0xb2, 0xdc, 0x10, 0x87, 0xc0, 0xf2, 0x23, 0x16, 0x69, 0x39, 0x20,
-	0x0e, 0x08, 0x21, 0x40, 0x42, 0xdc, 0xb8, 0x20, 0x81, 0x56, 0x08, 0xa1, 0x95, 0xf6, 0x82, 0x40,
-	0x1a, 0x50, 0xc2, 0x29, 0x5c, 0x90, 0x0f, 0x9c, 0x51, 0x55, 0xbf, 0x9e, 0xe9, 0x9e, 0xa9, 0x9e,
-	0x1e, 0x3b, 0xc3, 0x6a, 0x4f, 0xee, 0xae, 0x7a, 0xaf, 0xdf, 0xf7, 0xbe, 0x7a, 0xf5, 0x5e, 0xd5,
-	0x1b, 0xa3, 0xf3, 0x36, 0xa9, 0x52, 0xcf, 0xb1, 0x15, 0x83, 0x1c, 0x2a, 0x77, 0xab, 0xc4, 0xab,
-	0x15, 0x5c, 0xcf, 0xa1, 0x0e, 0x1e, 0x86, 0x89, 0x82, 0x41, 0x0e, 0x73, 0x4b, 0x65, 0xc7, 0xaf,
-	0x38, 0xbe, 0xb2, 0xad, 0xfb, 0x24, 0x90, 0x52, 0xf6, 0x57, 0xb6, 0x09, 0xd5, 0x57, 0x14, 0x57,
-	0xdf, 0x31, 0x6d, 0x9d, 0x9a, 0x8e, 0x1d, 0x28, 0xe6, 0x66, 0xa3, 0xb2, 0xa1, 0x54, 0xd9, 0x31,
-	0xc3, 0xf9, 0xc9, 0x1d, 0x67, 0xc7, 0xe1, 0x8f, 0x0a, 0x7b, 0x82, 0xd1, 0x99, 0x1d, 0xc7, 0xd9,
-	0xb1, 0x88, 0xa2, 0xbb, 0xa6, 0xa2, 0xdb, 0xb6, 0x43, 0xf9, 0x27, 0x7d, 0x98, 0xcd, 0xc3, 0x2c,
-	0x7f, 0xdb, 0xae, 0xde, 0x51, 0xa8, 0x59, 0x21, 0x3e, 0xd5, 0x2b, 0x2e, 0x08, 0xcc, 0x45, 0xdd,
-	0x30, 0x88, 0xeb, 0xf8, 0x26, 0xd5, 0x3c, 0x52, 0x76, 0x3c, 0x03, 0x24, 0x2e, 0x45, 0x25, 0x2c,
-	0xb3, 0x62, 0x52, 0xcd, 0xf1, 0x0c, 0xe2, 0x69, 0xd4, 0xd3, 0xed, 0xf2, 0x2e, 0x01, 0xb1, 0xa5,
-	0x14, 0x31, 0xad, 0xea, 0x13, 0x0f, 0x64, 0xb3, 0x51, 0x59, 0x57, 0xf7, 0xf4, 0x4a, 0x88, 0xf7,
-	0xa9, 0xd8, 0x8c, 0xe3, 0x58, 0xa1, 0x1f, 0xad, 0xe3, 0x5a, 0x85, 0x50, 0xdd, 0xd0, 0xa9, 0x9e,
-	0x28, 0xe0, 0x11, 0x9f, 0x78, 0xfb, 0xc4, 0x17, 0x39, 0x4a, 0xcd, 0xf2, 0x9e, 0x66, 0x99, 0x77,
-	0xab, 0xa6, 0x61, 0xd2, 0x5a, 0xc8, 0x6f, 0x4c, 0xe2, 0x30, 0x18, 0x95, 0x27, 0x11, 0xfe, 0x2a,
-	0x5b, 0xb7, 0x4d, 0x0e, 0x53, 0x25, 0x77, 0xab, 0xc4, 0xa7, 0xf2, 0x0d, 0x34, 0x11, 0x1b, 0xf5,
-	0x5d, 0xc7, 0xf6, 0x09, 0x5e, 0x41, 0x03, 0x81, 0x3b, 0x59, 0x69, 0x4e, 0x5a, 0x1c, 0x5e, 0x9d,
-	0x28, 0x44, 0x82, 0xa1, 0x10, 0x08, 0x17, 0xfb, 0x3f, 0xac, 0xe7, 0x4f, 0xa9, 0x20, 0x28, 0xff,
-	0x48, 0x42, 0xcf, 0xf0, 0x4f, 0x6d, 0x10, 0xfa, 0x1a, 0xa3, 0xed, 0x16, 0x63, 0x6d, 0x2b, 0x20,
-	0xed, 0x6b, 0x3e, 0xf1, 0xc0, 0x24, 0xce, 0xa2, 0x33, 0xba, 0x61, 0x78, 0xc4, 0x0f, 0x3e, 0x3e,
-	0xa4, 0x86, 0xaf, 0x38, 0x8f, 0x86, 0x43, 0x92, 0xf7, 0x48, 0x2d, 0xdb, 0xc7, 0x67, 0x11, 0x0c,
-	0xbd, 0x4a, 0x6a, 0xf8, 0x05, 0x94, 0x2d, 0xeb, 0x56, 0x59, 0x3b, 0x30, 0xe9, 0xae, 0xe1, 0xe9,
-	0x07, 0xfa, 0xb6, 0x45, 0x34, 0x7f, 0x57, 0xf7, 0x88, 0x9f, 0xcd, 0xcc, 0x49, 0x8b, 0x83, 0xea,
-	0x53, 0x6c, 0xfe, 0xcd, 0xc8, 0xf4, 0xeb, 0x7c, 0x56, 0x7e, 0xd0, 0x87, 0x2e, 0xa5, 0xa0, 0x03,
-	0xd7, 0x75, 0x94, 0x4d, 0x5a, 0x75, 0x20, 0x43, 0x8e, 0x91, 0x21, 0xfc, 0x1a, 0xe7, 0x46, 0x52,
-	0xa7, 0x2c, 0xd1, 0x24, 0xfe, 0x86, 0x84, 0x26, 0x44, 0x2e, 0x70, 0x87, 0x8b, 0x2a, 0x53, 0xfd,
-	0x5b, 0x3d, 0x3f, 0x15, 0x6c, 0x23, 0xdf, 0xd8, 0x2b, 0x98, 0x8e, 0x52, 0xd1, 0xe9, 0x6e, 0xa1,
-	0x64, 0xd3, 0xc7, 0xf5, 0xbc, 0x48, 0xf7, 0xa8, 0x9e, 0xcf, 0xd5, 0xf4, 0x8a, 0x75, 0x5d, 0x16,
-	0x4c, 0xca, 0x2a, 0x3e, 0x68, 0xa7, 0xc4, 0x86, 0xf5, 0x5a, 0xb3, 0xac, 0x8e, 0xeb, 0xf5, 0x0a,
-	0x42, 0xcd, 0x2d, 0x0e, 0x14, 0x5c, 0x2e, 0x04, 0xe0, 0x0a, 0x6c, 0x8f, 0x17, 0x82, 0xac, 0x01,
-	0x3b, 0xbd, 0xb0, 0xa9, 0xef, 0x10, 0xd0, 0x55, 0x23, 0x9a, 0xf2, 0xc7, 0x12, 0x2c, 0x41, 0xb2,
-	0xc1, 0xae, 0x96, 0x20, 0xd3, 0x8b, 0x25, 0xd8, 0x88, 0x39, 0xd5, 0xc7, 0x9d, 0x5a, 0x48, 0x75,
-	0x2a, 0xc0, 0x17, 0xf3, 0xea, 0xfb, 0x12, 0x9a, 0x4b, 0x0c, 0xac, 0x90, 0xc2, 0xf3, 0xe8, 0x8c,
-	0xab, 0x9b, 0x9e, 0x66, 0x1a, 0x10, 0xf2, 0x03, 0xec, 0xb5, 0x64, 0xe0, 0x8b, 0x08, 0xf1, 0x2d,
-	0x6c, 0xda, 0x06, 0x39, 0xe4, 0x30, 0x32, 0xea, 0x10, 0x1b, 0x29, 0xb1, 0x01, 0x7c, 0x01, 0x0d,
-	0x52, 0x67, 0x8f, 0xd8, 0x9a, 0x69, 0xf3, 0xf8, 0x1e, 0x52, 0xcf, 0xf0, 0xf7, 0x92, 0xdd, 0xba,
-	0x57, 0xfa, 0x5b, 0xf7, 0x8a, 0x5c, 0x43, 0xf3, 0x1d, 0x70, 0x01, 0xd3, 0x5b, 0x68, 0x42, 0xc0,
-	0x34, 0x2c, 0xf2, 0x6c, 0x67, 0x92, 0x81, 0xe0, 0xf1, 0x36, 0x82, 0xe5, 0x0f, 0x42, 0x4e, 0x44,
-	0x2b, 0x9d, 0xca, 0x49, 0xd4, 0xe9, 0xbe, 0xb8, 0xd3, 0xf1, 0x50, 0xcc, 0x9c, 0x38, 0x14, 0x7f,
-	0x2f, 0x01, 0x39, 0x62, 0x80, 0x69, 0xe4, 0x64, 0x9e, 0x80, 0x9c, 0xde, 0x45, 0xde, 0xcf, 0x25,
-	0x34, 0x1d, 0x3a, 0xc1, 0x62, 0x7a, 0x3d, 0x28, 0x7a, 0x7e, 0x7a, 0x9e, 0x7d, 0x45, 0x00, 0xe1,
-	0x04, 0x34, 0xe2, 0x25, 0x34, 0x6e, 0xda, 0x65, 0xab, 0x6a, 0x10, 0x8d, 0x57, 0x2a, 0x56, 0xc6,
-	0x20, 0x0f, 0x8f, 0xc2, 0xc4, 0xa6, 0xe3, 0x58, 0xeb, 0x3a, 0xd5, 0xe5, 0x9f, 0x4a, 0x68, 0x46,
-	0x8c, 0x16, 0xd8, 0xfe, 0x3c, 0x1a, 0x84, 0xb2, 0xed, 0x03, 0xc5, 0xb9, 0x18, 0xc5, 0xa0, 0xa0,
-	0xf2, 0x92, 0x0e, 0xf4, 0x36, 0x34, 0x7a, 0xc7, 0xea, 0xb7, 0x25, 0xb4, 0xdc, 0x31, 0x4b, 0x15,
-	0x6b, 0x6b, 0x01, 0x8d, 0x9f, 0x18, 0xcf, 0xf2, 0x1f, 0x25, 0x54, 0xe8, 0x16, 0x13, 0xb0, 0xf9,
-	0x2a, 0x1a, 0x89, 0xc4, 0xae, 0x7f, 0xec, 0xb4, 0x39, 0xdc, 0x0c, 0xdc, 0x1e, 0x92, 0xfb, 0x7e,
-	0x24, 0x08, 0xb6, 0xcc, 0xf2, 0xde, 0x6b, 0xe1, 0xc9, 0xe5, 0xd3, 0x90, 0x14, 0x7e, 0x2d, 0xa1,
-	0x8b, 0x09, 0xe0, 0x80, 0xd4, 0x0d, 0x74, 0x2e, 0x7e, 0xe0, 0x12, 0x06, 0x6a, 0x4c, 0x17, 0xe8,
-	0x3c, 0x4b, 0xa3, 0x83, 0xbd, 0x23, 0xf4, 0x03, 0x09, 0x2d, 0x86, 0x59, 0xbe, 0x64, 0xeb, 0x65,
-	0x6a, 0xee, 0x93, 0x9e, 0x66, 0xdc, 0x78, 0x81, 0xca, 0xb4, 0x16, 0xa8, 0xd4, 0x2a, 0xf4, 0x1d,
-	0x09, 0x5d, 0xe9, 0x02, 0x20, 0x10, 0x4c, 0xd0, 0x8c, 0x09, 0x42, 0xda, 0x93, 0xd6, 0xa5, 0x0b,
-	0x66, 0x92, 0x39, 0xd9, 0x03, 0xd2, 0xd6, 0x2c, 0x2b, 0x95, 0xb4, 0x5e, 0x9d, 0x7e, 0xfe, 0x1e,
-	0x12, 0xd1, 0xd9, 0x68, 0xd7, 0x44, 0x64, 0x7a, 0x40, 0x44, 0xef, 0xe2, 0xf0, 0x87, 0x91, 0x5a,
-	0xc4, 0x52, 0xbe, 0x0a, 0x77, 0x96, 0x4f, 0xc3, 0xbe, 0xfe, 0x45, 0x24, 0xe9, 0xc4, 0xb1, 0x01,
-	0xd9, 0xeb, 0xe8, 0x6c, 0xec, 0xa2, 0x05, 0xec, 0x5e, 0x88, 0xdf, 0x79, 0x22, 0x9a, 0x40, 0xec,
-	0x88, 0x1b, 0x19, 0xeb, 0x1d, 0x97, 0xef, 0x86, 0x5c, 0x6e, 0x10, 0xda, 0x2b, 0x2e, 0x53, 0xb6,
-	0xf1, 0x18, 0xca, 0xdc, 0x21, 0x84, 0x6f, 0xdf, 0x7e, 0x95, 0x3d, 0xca, 0x06, 0x70, 0xd6, 0x86,
-	0x21, 0x99, 0x33, 0xe9, 0xd8, 0x9c, 0xc9, 0x3f, 0xcb, 0xc0, 0x41, 0xf1, 0x65, 0x9f, 0x9a, 0x15,
-	0x9d, 0x92, 0x9b, 0x55, 0x8b, 0x9a, 0x37, 0x1c, 0xf7, 0xf5, 0x03, 0xdd, 0x8d, 0xd4, 0xd7, 0xb2,
-	0x47, 0x74, 0xea, 0x78, 0x61, 0x7d, 0x85, 0x57, 0x9c, 0x43, 0x83, 0x1e, 0x29, 0x13, 0x73, 0x9f,
-	0x78, 0xe0, 0x70, 0xe3, 0x1d, 0xaf, 0xa2, 0x01, 0xcf, 0xa9, 0x52, 0x7e, 0x31, 0x6c, 0xcf, 0xd1,
-	0xa1, 0x1d, 0x95, 0x89, 0xa8, 0x20, 0x89, 0xbf, 0x8e, 0x86, 0xf4, 0x8a, 0x53, 0xb5, 0x29, 0x63,
-	0x90, 0xe7, 0xb2, 0xe2, 0x17, 0xd8, 0x1d, 0xb7, 0xd3, 0x65, 0xac, 0xa9, 0x71, 0x54, 0xcf, 0x8f,
-	0x05, 0x57, 0xb0, 0xc6, 0x90, 0xac, 0x0e, 0x06, 0xcf, 0x25, 0x1b, 0x7f, 0x4f, 0x42, 0x63, 0xe4,
-	0xd0, 0xa4, 0xb0, 0x9f, 0x5d, 0xcf, 0x2c, 0x93, 0xec, 0x69, 0x6e, 0x64, 0x0f, 0x8c, 0x3c, 0xbb,
-	0x63, 0xd2, 0xdd, 0xea, 0x76, 0xa1, 0xec, 0x54, 0x14, 0x40, 0xbb, 0xec, 0x78, 0x3b, 0xe1, 0xb3,
-	0xb2, 0xff, 0xac, 0x52, 0xa5, 0xa6, 0xe5, 0x07, 0xf6, 0x37, 0x3d, 0x52, 0x5e, 0x27, 0xe5, 0xc7,
-	0xf5, 0x7c, 0xdb, 0x77, 0x8f, 0xea, 0xf9, 0xf3, 0x01, 0x94, 0xd6, 0x19, 0x59, 0x3d, 0xc7, 0x86,
-	0x78, 0x2a, 0xd8, 0x64, 0x03, 0xf8, 0x32, 0x1a, 0x75, 0x59, 0x68, 0x6c, 0x13, 0x9f, 0x6a, 0x9c,
-	0x88, 0xec, 0x00, 0x3f, 0xc2, 0x9d, 0x65, 0xc3, 0x45, 0xb6, 0x9b, 0xd8, 0x20, 0xbb, 0xe8, 0xcc,
-	0x77, 0x58, 0x2b, 0x88, 0x8b, 0xbb, 0x68, 0xb0, 0xec, 0x98, 0xb6, 0xe6, 0x54, 0x69, 0x23, 0x24,
-	0xa2, 0x7b, 0x20, 0x8c, 0xfe, 0x2f, 0x3b, 0xa6, 0x5d, 0x7c, 0x11, 0xfc, 0x5e, 0x88, 0xf8, 0x0d,
-	0xbd, 0xa3, 0xe0, 0xcf, 0xb2, 0x6f, 0xec, 0x29, 0xb4, 0xe6, 0x12, 0x9f, 0x2b, 0x3c, 0xae, 0xe7,
-	0x1b, 0x5f, 0x57, 0xcf, 0xb0, 0xa7, 0x5b, 0x55, 0x2a, 0xbf, 0xdf, 0x8f, 0x9e, 0x8e, 0x01, 0xdb,
-	0xb4, 0xf4, 0x72, 0x24, 0xd9, 0x3d, 0x59, 0x1c, 0x75, 0xb8, 0x82, 0x4d, 0xa3, 0xa1, 0x60, 0x8a,
-	0x39, 0x1b, 0x94, 0xbe, 0x40, 0xf6, 0x56, 0x95, 0xe2, 0x02, 0x9a, 0x6c, 0xee, 0x38, 0xcd, 0xb4,
-	0x35, 0xea, 0x70, 0xb9, 0xd3, 0x7c, 0xef, 0x8d, 0x35, 0xf6, 0x5e, 0xc9, 0xde, 0x72, 0x98, 0x7c,
-	0x2c, 0xf6, 0x06, 0x7a, 0x1c, 0x7b, 0xd7, 0x11, 0x82, 0xfa, 0x51, 0x73, 0x49, 0xf6, 0xcc, 0x9c,
-	0xb4, 0x78, 0x6e, 0x75, 0x3a, 0xa9, 0x78, 0xd4, 0x5c, 0xa2, 0x0e, 0x39, 0xe1, 0x23, 0xbe, 0x89,
-	0x46, 0xc9, 0xa1, 0x6b, 0x7a, 0x3c, 0x39, 0x69, 0xd4, 0xac, 0x90, 0xec, 0x20, 0x5f, 0xd8, 0x5c,
-	0x21, 0xe8, 0xc9, 0x15, 0xc2, 0x9e, 0x5c, 0x61, 0x2b, 0xec, 0xc9, 0x15, 0x07, 0xd9, 0x66, 0x7f,
-	0xf0, 0x8f, 0xbc, 0xc4, 0xc2, 0x2d, 0x54, 0x66, 0xd3, 0xb8, 0x82, 0xce, 0x56, 0xf4, 0xc3, 0xb5,
-	0x00, 0x25, 0x23, 0x64, 0x88, 0xfb, 0x7a, 0x23, 0xad, 0xe9, 0x71, 0xae, 0xa2, 0x1f, 0x6a, 0x7a,
-	0x43, 0xed, 0xa8, 0x9e, 0x9f, 0x0a, 0x1c, 0x8e, 0x8f, 0xcb, 0xea, 0x48, 0xe3, 0xf3, 0x2c, 0x38,
-	0xfe, 0x93, 0x81, 0x2e, 0x47, 0x62, 0x70, 0x40, 0xe0, 0xfe, 0x40, 0x42, 0x67, 0xa9, 0x43, 0x75,
-	0x8b, 0xad, 0x15, 0x0b, 0xad, 0xf4, 0xf0, 0x7d, 0xeb, 0xf8, 0xe1, 0x1b, 0x37, 0x71, 0x54, 0xcf,
-	0x4f, 0x06, 0x4e, 0xc4, 0x86, 0x65, 0x75, 0x98, 0xbf, 0x97, 0x6c, 0xa6, 0x85, 0xdf, 0x93, 0xd0,
-	0x88, 0x7f, 0xa0, 0xbb, 0x0d, 0x60, 0x7d, 0x69, 0xc0, 0xde, 0x38, 0x3e, 0xb0, 0x98, 0x85, 0xa3,
-	0x7a, 0x7e, 0x22, 0xc0, 0x15, 0x1d, 0x95, 0x55, 0xc4, 0x5e, 0x01, 0x15, 0xe3, 0x8b, 0xcf, 0x3a,
-	0x55, 0x1a, 0xc0, 0xca, 0xfc, 0x3f, 0xf8, 0x8a, 0x99, 0x68, 0xf2, 0x15, 0x1b, 0x96, 0xd5, 0x61,
-	0xf6, 0x7e, 0xab, 0x4a, 0x99, 0x96, 0xfc, 0x0e, 0x1a, 0x0b, 0x5a, 0x9a, 0xbc, 0xd2, 0x3c, 0x59,
-	0x03, 0x06, 0x0a, 0x63, 0xa6, 0x59, 0x18, 0x15, 0x34, 0xd9, 0xf8, 0x7a, 0xb1, 0x56, 0x5a, 0x8f,
-	0x5a, 0x60, 0x05, 0x11, 0x2c, 0xf4, 0xab, 0x03, 0xec, 0xb5, 0x64, 0xc8, 0x5f, 0x42, 0xe3, 0x11,
-	0x38, 0x10, 0x6d, 0x9f, 0x41, 0xfd, 0x6c, 0x1a, 0x62, 0x6c, 0xbc, 0xad, 0x6a, 0x42, 0xb5, 0xe4,
-	0x42, 0xf2, 0x72, 0xfc, 0x3c, 0x70, 0x13, 0x1a, 0xc6, 0xa1, 0xe5, 0x73, 0xa8, 0xaf, 0x61, 0xb4,
-	0xcf, 0x34, 0x5a, 0x4b, 0x77, 0x53, 0xbc, 0x59, 0xba, 0x37, 0xa3, 0x8d, 0xe7, 0xc4, 0xd2, 0x1d,
-	0x6a, 0x42, 0xa3, 0x77, 0x24, 0x3a, 0x26, 0x93, 0xf8, 0x81, 0xaf, 0x15, 0x54, 0xaf, 0x8e, 0xcd,
-	0xad, 0x87, 0x37, 0x91, 0x37, 0x6e, 0x8b, 0x37, 0x99, 0xae, 0xbc, 0x71, 0x23, 0x63, 0x3d, 0x3b,
-	0xbc, 0xad, 0xfe, 0x37, 0x8b, 0x4e, 0x73, 0xbc, 0x78, 0x17, 0x0d, 0x04, 0x7d, 0x72, 0x9c, 0x8f,
-	0x61, 0x69, 0x6f, 0xc2, 0xe7, 0xe6, 0x92, 0x05, 0x02, 0x13, 0xf2, 0xf4, 0xbb, 0x1f, 0xff, 0xeb,
-	0xbd, 0xbe, 0x29, 0x3c, 0xa1, 0xb4, 0xff, 0xe2, 0x80, 0xff, 0x20, 0xa1, 0x29, 0xe1, 0x5d, 0x1e,
-	0xaf, 0xb4, 0x7f, 0x38, 0xa5, 0x3b, 0x9f, 0x5b, 0x3d, 0x8e, 0x0a, 0xa0, 0x7b, 0x99, 0xa3, 0xfb,
-	0x22, 0x7e, 0x49, 0xe9, 0xe6, 0xb7, 0x13, 0xe5, 0x1e, 0xf4, 0x47, 0xee, 0x2b, 0xf7, 0x22, 0x97,
-	0xc7, 0xfb, 0xf8, 0x57, 0x12, 0xca, 0x0a, 0x0d, 0xad, 0x59, 0x96, 0xc8, 0x95, 0x94, 0xc6, 0xb5,
-	0xc8, 0x95, 0xb4, 0xd6, 0xb3, 0xbc, 0xcc, 0x5d, 0x59, 0xc0, 0x97, 0xba, 0x72, 0x05, 0xff, 0x45,
-	0x42, 0xf3, 0x49, 0x90, 0x1b, 0x4d, 0x19, 0x7c, 0xbd, 0x7b, 0x20, 0xad, 0xdd, 0xa5, 0xdc, 0x8b,
-	0x27, 0xd2, 0x05, 0x6f, 0xae, 0x72, 0x6f, 0x96, 0xf0, 0x62, 0xcc, 0x1b, 0xbe, 0x08, 0xd1, 0xee,
-	0x50, 0x73, 0x45, 0xf0, 0x9f, 0x25, 0x34, 0xde, 0x7e, 0x4f, 0x5c, 0xee, 0x2e, 0x28, 0x42, 0xcc,
-	0x85, 0x6e, 0xc5, 0x01, 0xe6, 0x5b, 0x1c, 0xa6, 0x8a, 0x37, 0xd3, 0x48, 0x57, 0xee, 0x41, 0x16,
-	0x67, 0xa1, 0x03, 0xa7, 0x32, 0xf6, 0xd8, 0xc8, 0xe0, 0xad, 0x21, 0xf5, 0x1b, 0x09, 0x4d, 0xb6,
-	0xd9, 0x65, 0xe1, 0xb4, 0xdc, 0x1d, 0xad, 0x1d, 0x3c, 0xea, 0xd4, 0x3a, 0x96, 0x5f, 0xe2, 0x1e,
-	0x3d, 0x8f, 0xaf, 0x9d, 0xc8, 0x23, 0xfc, 0x5d, 0x09, 0x8d, 0x46, 0x9b, 0xa4, 0x0c, 0xf1, 0xa2,
-	0x10, 0x82, 0xa0, 0xf1, 0x9b, 0xbb, 0xd2, 0x85, 0x24, 0xe0, 0xfc, 0x2c, 0xc7, 0x79, 0x19, 0x3f,
-	0xd3, 0x1e, 0x20, 0x61, 0x6b, 0x35, 0x12, 0x1c, 0x3f, 0x91, 0xd0, 0x58, 0xac, 0xbb, 0xc5, 0x70,
-	0x89, 0xad, 0x89, 0xba, 0x7b, 0xb9, 0xa5, 0x6e, 0x44, 0x01, 0xd9, 0x0b, 0x1c, 0xd9, 0x2a, 0xbe,
-	0xaa, 0x24, 0xff, 0xde, 0x29, 0x26, 0xef, 0x4f, 0x7d, 0xe8, 0x42, 0x62, 0x87, 0x05, 0x5f, 0x13,
-	0xc6, 0x66, 0x5a, 0x1b, 0x28, 0xf7, 0xdc, 0x71, 0xd5, 0xc0, 0x8d, 0xdf, 0x49, 0xdc, 0x8f, 0xdf,
-	0x4a, 0xb7, 0xdf, 0xc6, 0x6f, 0xc6, 0x5c, 0xb9, 0x63, 0x5a, 0x16, 0x31, 0xb4, 0x5e, 0x44, 0xf9,
-	0xdb, 0xb1, 0x0f, 0x77, 0x6a, 0x1c, 0x1d, 0xfb, 0xd3, 0xff, 0x96, 0xd0, 0x4c, 0xa2, 0x97, 0x6c,
-	0xf9, 0xaf, 0x09, 0xd7, 0xf4, 0x24, 0x7c, 0x76, 0xd3, 0x18, 0x93, 0xdf, 0xe1, 0x74, 0xbe, 0x71,
-	0xfb, 0x0a, 0x5e, 0xe8, 0x92, 0x4d, 0x7c, 0xa5, 0x6b, 0x76, 0xf0, 0x8f, 0x25, 0x34, 0x1a, 0x6d,
-	0x5a, 0x24, 0xef, 0x3b, 0x41, 0x63, 0x26, 0x61, 0xdf, 0x89, 0xda, 0x27, 0xf2, 0xf3, 0xdc, 0x8d,
-	0x15, 0xac, 0x28, 0x89, 0x3f, 0xf7, 0x8b, 0x83, 0xfb, 0x97, 0x12, 0x1a, 0x89, 0x7e, 0x51, 0x04,
-	0x4f, 0xdc, 0x37, 0x12, 0xc1, 0x4b, 0xe8, 0xee, 0xc8, 0x5f, 0xe1, 0xf0, 0xd6, 0x71, 0xf1, 0x98,
-	0xf0, 0x5a, 0x22, 0xe9, 0x0e, 0x21, 0x3c, 0x69, 0x4c, 0x8a, 0x5a, 0x06, 0xa2, 0x14, 0xdc, 0xa1,
-	0x0d, 0x24, 0x4a, 0xc1, 0x9d, 0x3a, 0x11, 0x09, 0xa9, 0x8d, 0x80, 0x8a, 0x56, 0x61, 0x3a, 0xda,
-	0xae, 0xe3, 0x6a, 0xec, 0xee, 0xc0, 0x78, 0x3d, 0x9f, 0x70, 0x45, 0xc4, 0x57, 0x93, 0x2d, 0x8b,
-	0x5b, 0x0d, 0xb9, 0x95, 0x63, 0x68, 0x00, 0x5c, 0x85, 0xc3, 0x6d, 0x0d, 0xeb, 0x06, 0x5c, 0x97,
-	0xa9, 0x45, 0x63, 0x16, 0xdf, 0x47, 0xfd, 0x6c, 0xed, 0xf0, 0x45, 0xc1, 0xe1, 0xb1, 0x79, 0xf3,
-	0xc9, 0xcd, 0x26, 0x4d, 0x83, 0xdd, 0xe7, 0xb8, 0xdd, 0xab, 0xb8, 0xd0, 0xb6, 0xd4, 0xb1, 0x15,
-	0x6e, 0x5b, 0x56, 0x0f, 0x0d, 0x86, 0x57, 0x20, 0x3c, 0x2f, 0xb6, 0x11, 0xb9, 0x1e, 0xa5, 0xc2,
-	0x78, 0x9a, 0xc3, 0xb8, 0x88, 0xa7, 0x45, 0x30, 0x82, 0x7b, 0xd5, 0x7d, 0xfc, 0x2d, 0x08, 0xfe,
-	0xc6, 0xb1, 0x3d, 0x39, 0xf8, 0x5b, 0xee, 0x23, 0x1d, 0x82, 0xbf, 0xf5, 0x46, 0x21, 0x2f, 0x70,
-	0x28, 0xf3, 0x38, 0xaf, 0x24, 0xfe, 0xaf, 0x8e, 0x72, 0x8f, 0xc1, 0xf9, 0x26, 0x64, 0x8b, 0xf0,
-	0x0b, 0x9d, 0xb3, 0x45, 0x17, 0x88, 0x12, 0xee, 0x38, 0xb2, 0xcc, 0x11, 0xcd, 0xe0, 0x5c, 0x32,
-	0xa2, 0xe2, 0xc6, 0x87, 0x0f, 0x67, 0xa5, 0x8f, 0x1e, 0xce, 0x4a, 0xff, 0x7c, 0x38, 0x2b, 0x3d,
-	0x78, 0x34, 0x7b, 0xea, 0xa3, 0x47, 0xb3, 0xa7, 0xfe, 0xfa, 0x68, 0xf6, 0xd4, 0xed, 0xe5, 0xf4,
-	0xae, 0xe2, 0x61, 0x50, 0x5c, 0xd9, 0xcd, 0x7b, 0x7b, 0x80, 0xb7, 0x73, 0x3e, 0xf7, 0xbf, 0x00,
-	0x00, 0x00, 0xff, 0xff, 0x80, 0xda, 0x02, 0xc7, 0x18, 0x26, 0x00, 0x00,
+	0xf5, 0x4f, 0xcf, 0x78, 0x1d, 0xbb, 0xec, 0xc4, 0x76, 0xd9, 0xde, 0x4c, 0xc6, 0x8e, 0xc7, 0xee,
+	0xdd, 0xc4, 0x8e, 0xff, 0x7f, 0x4f, 0xc7, 0x66, 0xb3, 0xbb, 0xca, 0xb2, 0x80, 0x07, 0xef, 0x3a,
+	0xc3, 0x6e, 0x14, 0xd3, 0x6b, 0xf6, 0x23, 0xac, 0xd4, 0x6a, 0x4f, 0x57, 0xec, 0x96, 0x7b, 0xba,
+	0x3b, 0xdd, 0x35, 0xb1, 0x47, 0x51, 0x2e, 0xcb, 0x0d, 0x71, 0x08, 0x2c, 0x1f, 0x02, 0xa4, 0xe5,
+	0x80, 0x38, 0x21, 0x04, 0x48, 0x88, 0x1b, 0x17, 0x24, 0xd0, 0x0a, 0x21, 0xb4, 0xd2, 0x5e, 0x10,
+	0x48, 0x03, 0x4a, 0xe0, 0x12, 0x2e, 0xc8, 0x48, 0x9c, 0x51, 0x55, 0xbf, 0x9e, 0xe9, 0x9e, 0xa9,
+	0x9e, 0x1e, 0x3b, 0x03, 0xda, 0x93, 0xbb, 0xab, 0xde, 0xeb, 0xfa, 0xbd, 0xdf, 0x7b, 0xf5, 0xaa,
+	0xde, 0x1b, 0xa3, 0x73, 0x36, 0xa9, 0x51, 0xcf, 0xb1, 0x15, 0x83, 0x1c, 0x2a, 0x77, 0x6a, 0xc4,
+	0xab, 0x17, 0x5d, 0xcf, 0xa1, 0x0e, 0x1e, 0x81, 0x89, 0xa2, 0x41, 0x0e, 0xf3, 0xcb, 0x15, 0xc7,
+	0xaf, 0x3a, 0xbe, 0xb2, 0xa3, 0xfb, 0x24, 0x90, 0x52, 0xee, 0xae, 0xee, 0x10, 0xaa, 0xaf, 0x2a,
+	0xae, 0xbe, 0x6b, 0xda, 0x3a, 0x35, 0x1d, 0x3b, 0x50, 0xcc, 0xcf, 0x45, 0x65, 0x43, 0xa9, 0x8a,
+	0x63, 0x86, 0xf3, 0x53, 0xbb, 0xce, 0xae, 0xc3, 0x1f, 0x15, 0xf6, 0x04, 0xa3, 0xb3, 0xbb, 0x8e,
+	0xb3, 0x6b, 0x11, 0x45, 0x77, 0x4d, 0x45, 0xb7, 0x6d, 0x87, 0xf2, 0x4f, 0xfa, 0x30, 0x5b, 0x80,
+	0x59, 0xfe, 0xb6, 0x53, 0xbb, 0xad, 0x50, 0xb3, 0x4a, 0x7c, 0xaa, 0x57, 0x5d, 0x10, 0x98, 0x8f,
+	0x9a, 0x61, 0x10, 0xd7, 0xf1, 0x4d, 0xaa, 0x79, 0xa4, 0xe2, 0x78, 0x06, 0x48, 0x5c, 0x8c, 0x4a,
+	0x58, 0x66, 0xd5, 0xa4, 0x9a, 0xe3, 0x19, 0xc4, 0xd3, 0xa8, 0xa7, 0xdb, 0x95, 0x3d, 0x02, 0x62,
+	0xcb, 0x29, 0x62, 0x5a, 0xcd, 0x27, 0x1e, 0xc8, 0xe6, 0xa2, 0xb2, 0xae, 0xee, 0xe9, 0xd5, 0x10,
+	0xef, 0xd3, 0xb1, 0x19, 0xc7, 0xb1, 0x42, 0x3b, 0xda, 0xc7, 0xb5, 0x2a, 0xa1, 0xba, 0xa1, 0x53,
+	0x3d, 0x51, 0xc0, 0x23, 0x3e, 0xf1, 0xee, 0x12, 0x5f, 0x64, 0x28, 0x35, 0x2b, 0xfb, 0x9a, 0x65,
+	0xde, 0xa9, 0x99, 0x86, 0x49, 0xeb, 0x21, 0xbf, 0x31, 0x89, 0xc3, 0x60, 0x54, 0x9e, 0x42, 0xf8,
+	0x8b, 0xcc, 0x6f, 0x5b, 0x1c, 0xa6, 0x4a, 0xee, 0xd4, 0x88, 0x4f, 0xe5, 0xeb, 0x68, 0x32, 0x36,
+	0xea, 0xbb, 0x8e, 0xed, 0x13, 0xbc, 0x8a, 0x06, 0x03, 0x73, 0x72, 0xd2, 0xbc, 0xb4, 0x34, 0xb2,
+	0x36, 0x59, 0x8c, 0x04, 0x43, 0x31, 0x10, 0x2e, 0x0d, 0x7c, 0xd8, 0x28, 0x9c, 0x52, 0x41, 0x50,
+	0xfe, 0xbe, 0x84, 0x9e, 0xe5, 0x9f, 0xda, 0x24, 0xf4, 0x75, 0x46, 0xdb, 0x4d, 0xc6, 0xda, 0x76,
+	0x40, 0xda, 0x97, 0x7c, 0xe2, 0xc1, 0x92, 0x38, 0x87, 0x4e, 0xeb, 0x86, 0xe1, 0x11, 0x3f, 0xf8,
+	0xf8, 0xb0, 0x1a, 0xbe, 0xe2, 0x02, 0x1a, 0x09, 0x49, 0xde, 0x27, 0xf5, 0x5c, 0x86, 0xcf, 0x22,
+	0x18, 0x7a, 0x8d, 0xd4, 0xf1, 0x8b, 0x28, 0x57, 0xd1, 0xad, 0x8a, 0x76, 0x60, 0xd2, 0x3d, 0xc3,
+	0xd3, 0x0f, 0xf4, 0x1d, 0x8b, 0x68, 0xfe, 0x9e, 0xee, 0x11, 0x3f, 0x97, 0x9d, 0x97, 0x96, 0x86,
+	0xd4, 0xa7, 0xd9, 0xfc, 0x5b, 0x91, 0xe9, 0x37, 0xf8, 0xac, 0xfc, 0x20, 0x83, 0x2e, 0xa6, 0xa0,
+	0x03, 0xd3, 0x75, 0x94, 0x4b, 0xf2, 0x3a, 0x90, 0x21, 0xc7, 0xc8, 0x10, 0x7e, 0x8d, 0x73, 0x23,
+	0xa9, 0xd3, 0x96, 0x68, 0x12, 0x7f, 0x45, 0x42, 0x93, 0x22, 0x13, 0xb8, 0xc1, 0x25, 0x95, 0xa9,
+	0xfe, 0xa9, 0x51, 0x98, 0x0e, 0xb6, 0x91, 0x6f, 0xec, 0x17, 0x4d, 0x47, 0xa9, 0xea, 0x74, 0xaf,
+	0x58, 0xb6, 0xe9, 0xe3, 0x46, 0x41, 0xa4, 0x7b, 0xd4, 0x28, 0xe4, 0xeb, 0x7a, 0xd5, 0xba, 0x26,
+	0x0b, 0x26, 0x65, 0x15, 0x1f, 0x74, 0x52, 0x62, 0x83, 0xbf, 0xd6, 0x2d, 0xab, 0xab, 0xbf, 0x5e,
+	0x45, 0xa8, 0xb5, 0xc5, 0x81, 0x82, 0x4b, 0xc5, 0x00, 0x5c, 0x91, 0xed, 0xf1, 0x62, 0x90, 0x35,
+	0x60, 0xa7, 0x17, 0xb7, 0xf4, 0x5d, 0x02, 0xba, 0x6a, 0x44, 0x53, 0xfe, 0x58, 0x02, 0x17, 0x24,
+	0x2f, 0xd8, 0x93, 0x0b, 0xb2, 0xfd, 0x70, 0xc1, 0x66, 0xcc, 0xa8, 0x0c, 0x37, 0x6a, 0x31, 0xd5,
+	0xa8, 0x00, 0x5f, 0xcc, 0xaa, 0x6f, 0x4b, 0x68, 0x3e, 0x31, 0xb0, 0x42, 0x0a, 0xcf, 0xa1, 0xd3,
+	0xae, 0x6e, 0x7a, 0x9a, 0x69, 0x40, 0xc8, 0x0f, 0xb2, 0xd7, 0xb2, 0x81, 0x2f, 0x20, 0xc4, 0xb7,
+	0xb0, 0x69, 0x1b, 0xe4, 0x90, 0xc3, 0xc8, 0xaa, 0xc3, 0x6c, 0xa4, 0xcc, 0x06, 0xf0, 0x79, 0x34,
+	0x44, 0x9d, 0x7d, 0x62, 0x6b, 0xa6, 0xcd, 0xe3, 0x7b, 0x58, 0x3d, 0xcd, 0xdf, 0xcb, 0x76, 0xfb,
+	0x5e, 0x19, 0x68, 0xdf, 0x2b, 0x72, 0x1d, 0x2d, 0x74, 0xc1, 0x05, 0x4c, 0x6f, 0xa3, 0x49, 0x01,
+	0xd3, 0xe0, 0xe4, 0xb9, 0xee, 0x24, 0x03, 0xc1, 0x13, 0x1d, 0x04, 0xcb, 0x1f, 0x84, 0x9c, 0x88,
+	0x3c, 0x9d, 0xca, 0x49, 0xd4, 0xe8, 0x4c, 0xdc, 0xe8, 0x78, 0x28, 0x66, 0x4f, 0x1c, 0x8a, 0xbf,
+	0x96, 0x80, 0x1c, 0x31, 0xc0, 0x34, 0x72, 0xb2, 0x4f, 0x40, 0x4e, 0xff, 0x22, 0xef, 0xc7, 0x12,
+	0x9a, 0x09, 0x8d, 0x60, 0x31, 0xbd, 0x11, 0x1c, 0x7a, 0x7e, 0x7a, 0x9e, 0x7d, 0x55, 0x00, 0xe1,
+	0x04, 0x34, 0xe2, 0x65, 0x34, 0x61, 0xda, 0x15, 0xab, 0x66, 0x10, 0x8d, 0x9f, 0x54, 0xec, 0x18,
+	0x83, 0x3c, 0x3c, 0x06, 0x13, 0x5b, 0x8e, 0x63, 0x6d, 0xe8, 0x54, 0x97, 0x7f, 0x24, 0xa1, 0x59,
+	0x31, 0x5a, 0x60, 0xfb, 0xd3, 0x68, 0x08, 0x8e, 0x6d, 0x1f, 0x28, 0xce, 0xc7, 0x28, 0x06, 0x05,
+	0x95, 0x1f, 0xe9, 0x40, 0x6f, 0x53, 0xa3, 0x7f, 0xac, 0x7e, 0x5d, 0x42, 0x2b, 0x5d, 0xb3, 0x54,
+	0xa9, 0xbe, 0x1e, 0xd0, 0xf8, 0x3f, 0xe3, 0x59, 0xfe, 0xad, 0x84, 0x8a, 0xbd, 0x62, 0x02, 0x36,
+	0x5f, 0x43, 0xa3, 0x91, 0xd8, 0xf5, 0x8f, 0x9d, 0x36, 0x47, 0x5a, 0x81, 0xdb, 0x47, 0x72, 0xbf,
+	0x17, 0x09, 0x82, 0x6d, 0xb3, 0xb2, 0xff, 0x7a, 0x78, 0x73, 0xf9, 0x24, 0x24, 0x85, 0x9f, 0x4b,
+	0xe8, 0x42, 0x02, 0x38, 0x20, 0x75, 0x13, 0x9d, 0x8d, 0x5f, 0xb8, 0x84, 0x81, 0x1a, 0xd3, 0x05,
+	0x3a, 0xcf, 0xd0, 0xe8, 0x60, 0xff, 0x08, 0xfd, 0x40, 0x42, 0x4b, 0x61, 0x96, 0x2f, 0xdb, 0x7a,
+	0x85, 0x9a, 0x77, 0x49, 0x5f, 0x33, 0x6e, 0xfc, 0x80, 0xca, 0xb6, 0x1f, 0x50, 0xa9, 0xa7, 0xd0,
+	0x37, 0x24, 0x74, 0xb9, 0x07, 0x80, 0x40, 0x30, 0x41, 0xb3, 0x26, 0x08, 0x69, 0x4f, 0x7a, 0x2e,
+	0x9d, 0x37, 0x93, 0x96, 0x93, 0x3d, 0x20, 0x6d, 0xdd, 0xb2, 0x52, 0x49, 0xeb, 0xd7, 0xed, 0xe7,
+	0xcf, 0x21, 0x11, 0xdd, 0x17, 0xed, 0x99, 0x88, 0x6c, 0x1f, 0x88, 0xe8, 0x5f, 0x1c, 0x7e, 0x37,
+	0x72, 0x16, 0xb1, 0x94, 0xaf, 0x42, 0xcd, 0xf2, 0x49, 0xd8, 0xd7, 0x3f, 0x89, 0x24, 0x9d, 0x38,
+	0x36, 0x20, 0x7b, 0x03, 0x9d, 0x89, 0x15, 0x5a, 0xc0, 0xee, 0xf9, 0x78, 0xcd, 0x13, 0xd1, 0x04,
+	0x62, 0x47, 0xdd, 0xc8, 0x58, 0xff, 0xb8, 0x7c, 0x2f, 0xe4, 0x72, 0x93, 0xd0, 0x7e, 0x71, 0x99,
+	0xb2, 0x8d, 0xc7, 0x51, 0xf6, 0x36, 0x21, 0x7c, 0xfb, 0x0e, 0xa8, 0xec, 0x51, 0x36, 0x80, 0xb3,
+	0x0e, 0x0c, 0xc9, 0x9c, 0x49, 0xc7, 0xe6, 0x4c, 0xfe, 0x57, 0x06, 0x2e, 0x8a, 0xaf, 0xf8, 0xd4,
+	0xac, 0xea, 0x94, 0xdc, 0xa8, 0x59, 0xd4, 0xbc, 0xee, 0xb8, 0x6f, 0x1c, 0xe8, 0x6e, 0x68, 0xef,
+	0x1a, 0x1a, 0xf4, 0x9c, 0x1a, 0x25, 0xe2, 0x6b, 0x41, 0xa8, 0xa1, 0x32, 0x11, 0x15, 0x24, 0xf1,
+	0x97, 0xd1, 0xb0, 0x5e, 0x75, 0x6a, 0x36, 0x6d, 0x72, 0x51, 0xfa, 0x0c, 0xab, 0x56, 0xbb, 0x95,
+	0x55, 0x2d, 0x8d, 0xa3, 0x46, 0x61, 0x3c, 0x28, 0xa6, 0x9a, 0x43, 0xb2, 0x3a, 0x14, 0x3c, 0x97,
+	0x6d, 0xfc, 0x2d, 0x09, 0x8d, 0x93, 0x43, 0x93, 0xc2, 0xce, 0x74, 0x3d, 0xb3, 0x42, 0x82, 0xeb,
+	0x79, 0x69, 0x1f, 0x16, 0x79, 0x6e, 0xd7, 0xa4, 0x7b, 0xb5, 0x9d, 0x62, 0xc5, 0xa9, 0x2a, 0x80,
+	0x76, 0xc5, 0xf1, 0x76, 0xc3, 0x67, 0xe5, 0xee, 0x73, 0x4a, 0x8d, 0x9a, 0x96, 0x1f, 0xac, 0xbf,
+	0xe5, 0x91, 0xca, 0x06, 0xa9, 0x3c, 0x6e, 0x14, 0x3a, 0xbe, 0x7b, 0xd4, 0x28, 0x9c, 0x0b, 0xa0,
+	0xb4, 0xcf, 0xc8, 0xea, 0x59, 0x36, 0xc4, 0x37, 0xf5, 0x16, 0x1b, 0xc0, 0x97, 0xd0, 0x98, 0xcb,
+	0x9c, 0xbc, 0x43, 0x7c, 0xaa, 0x71, 0x22, 0xb8, 0x47, 0x87, 0xd4, 0x33, 0x6c, 0xb8, 0xc4, 0xf6,
+	0x05, 0x1b, 0x64, 0x25, 0xcb, 0x42, 0x17, 0xd6, 0xc1, 0xc3, 0x77, 0xd0, 0x50, 0xc5, 0x31, 0x6d,
+	0xcd, 0xa9, 0xd1, 0xa6, 0x73, 0xa3, 0xd1, 0x1c, 0xc6, 0xf1, 0xe7, 0x1d, 0xd3, 0x2e, 0xbd, 0x04,
+	0x76, 0x2f, 0x46, 0xec, 0x86, 0x2e, 0x50, 0xf0, 0x67, 0xc5, 0x37, 0xf6, 0x15, 0x5a, 0x77, 0x89,
+	0xcf, 0x15, 0x1e, 0x37, 0x0a, 0xcd, 0xaf, 0xab, 0xa7, 0xd9, 0xd3, 0xcd, 0x1a, 0x95, 0xff, 0x9e,
+	0x45, 0xcf, 0xc4, 0x80, 0x6d, 0x59, 0x7a, 0x25, 0x92, 0xb6, 0xc2, 0x88, 0x88, 0x06, 0xba, 0x14,
+	0x0f, 0xf4, 0x19, 0x34, 0x1c, 0x4c, 0x31, 0xd8, 0xc1, 0x26, 0x08, 0x64, 0x6f, 0xd6, 0x28, 0x2e,
+	0xa2, 0xa9, 0xd6, 0x2e, 0xd0, 0x4c, 0x5b, 0xa3, 0x0e, 0x97, 0x0b, 0xf6, 0xc3, 0x78, 0x73, 0x3f,
+	0x94, 0xed, 0x6d, 0x87, 0xc9, 0xc7, 0xa2, 0x68, 0xa0, 0xcf, 0x51, 0x74, 0x0d, 0x21, 0xc8, 0xe9,
+	0x75, 0x97, 0xe4, 0x9e, 0x9a, 0x97, 0x96, 0xce, 0xae, 0xcd, 0x24, 0x25, 0xf4, 0xba, 0x4b, 0xd4,
+	0x61, 0x27, 0x7c, 0xc4, 0x37, 0xd0, 0x18, 0x39, 0x74, 0x4d, 0x8f, 0x27, 0x0c, 0x8d, 0x9a, 0x55,
+	0x92, 0x1b, 0xe6, 0x2e, 0xca, 0x17, 0x83, 0x3e, 0x59, 0x31, 0xec, 0x93, 0x15, 0xb7, 0xc3, 0x3e,
+	0x59, 0x69, 0x88, 0x6d, 0xc0, 0x07, 0x7f, 0x29, 0x48, 0x2c, 0x70, 0x42, 0x65, 0x36, 0x8d, 0x6d,
+	0x74, 0xb6, 0xaa, 0x1f, 0x6a, 0x00, 0x93, 0x31, 0x32, 0xc8, 0x8d, 0xbd, 0x9e, 0xd6, 0x89, 0x68,
+	0x53, 0x3b, 0x6a, 0x14, 0xa6, 0x03, 0x8b, 0xe3, 0xe3, 0xb2, 0x3a, 0x5a, 0xd5, 0x0f, 0xd7, 0xf9,
+	0x3b, 0xf3, 0xf3, 0x3f, 0xb3, 0xd0, 0x7a, 0x48, 0xf4, 0x33, 0xc4, 0xe0, 0x77, 0x24, 0x74, 0x86,
+	0x3a, 0x54, 0xb7, 0x98, 0xb3, 0x58, 0x94, 0xa4, 0x47, 0xe2, 0xdb, 0xc7, 0x8f, 0xc4, 0xf8, 0x12,
+	0x47, 0x8d, 0xc2, 0x54, 0x60, 0x44, 0x6c, 0x58, 0x56, 0x47, 0xf8, 0x7b, 0xd9, 0x66, 0x5a, 0xf8,
+	0x7d, 0x09, 0x8d, 0xfa, 0x07, 0xba, 0xdb, 0x04, 0x96, 0x49, 0x03, 0xf6, 0xe6, 0xf1, 0x81, 0xc5,
+	0x56, 0x38, 0x6a, 0x14, 0x26, 0x03, 0x5c, 0xd1, 0x51, 0x59, 0x45, 0xec, 0x15, 0x50, 0x31, 0xbe,
+	0xf8, 0xac, 0x53, 0xa3, 0x01, 0xac, 0xec, 0x7f, 0x83, 0xaf, 0xd8, 0x12, 0x2d, 0xbe, 0x62, 0xc3,
+	0xb2, 0x3a, 0xc2, 0xde, 0x6f, 0xd6, 0x28, 0xd3, 0x92, 0xdf, 0x45, 0xe3, 0x41, 0x9f, 0x91, 0xa7,
+	0xff, 0x27, 0xeb, 0x8a, 0xc0, 0x69, 0x95, 0x6d, 0x9d, 0x56, 0x0a, 0x9a, 0x6a, 0x7e, 0xbd, 0x54,
+	0x2f, 0x6f, 0x44, 0x57, 0x60, 0xa7, 0x14, 0xac, 0x30, 0xa0, 0x0e, 0xb2, 0xd7, 0xb2, 0x21, 0x7f,
+	0x0e, 0x4d, 0x44, 0xe0, 0x40, 0xb4, 0xfd, 0x1f, 0x1a, 0x60, 0xd3, 0x10, 0x63, 0x13, 0x1d, 0x47,
+	0x19, 0x1c, 0x61, 0x5c, 0x48, 0x5e, 0x89, 0x1f, 0xd2, 0x37, 0xa0, 0x8b, 0x1b, 0xae, 0x7c, 0x16,
+	0x65, 0x9a, 0x8b, 0x66, 0x4c, 0xa3, 0xfd, 0x3c, 0x6d, 0x89, 0xb7, 0xce, 0xd3, 0xad, 0x68, 0x37,
+	0x38, 0xf1, 0x3c, 0x0d, 0x35, 0xa1, 0xfb, 0x3a, 0x1a, 0x1d, 0x93, 0x49, 0xfc, 0x16, 0xd6, 0x0e,
+	0xaa, 0x5f, 0x77, 0xd9, 0xf6, 0x1b, 0x95, 0xc8, 0x1a, 0xb7, 0xcd, 0x9a, 0x6c, 0x4f, 0xd6, 0xb8,
+	0x91, 0xb1, 0xbe, 0xdd, 0xa8, 0xd6, 0xfe, 0x9d, 0x43, 0x4f, 0x71, 0xbc, 0x78, 0x0f, 0x0d, 0x06,
+	0xcd, 0x6b, 0x5c, 0x88, 0x61, 0xe9, 0xec, 0x8c, 0xe7, 0xe7, 0x93, 0x05, 0x82, 0x25, 0xe4, 0x99,
+	0xf7, 0x3e, 0xfe, 0xdb, 0xfb, 0x99, 0x69, 0x3c, 0xa9, 0x74, 0xfe, 0x0c, 0x80, 0x7f, 0x23, 0xa1,
+	0x69, 0x61, 0x81, 0x8d, 0x57, 0x3b, 0x3f, 0x9c, 0xd2, 0x32, 0xcf, 0xaf, 0x1d, 0x47, 0x05, 0xd0,
+	0xbd, 0xc2, 0xd1, 0x7d, 0x16, 0xbf, 0xac, 0xf4, 0xf2, 0x83, 0x86, 0x72, 0x0f, 0x9a, 0x16, 0xf7,
+	0x95, 0x7b, 0x91, 0x8a, 0xee, 0x3e, 0xfe, 0x99, 0x84, 0x72, 0xc2, 0x85, 0xd6, 0x2d, 0x4b, 0x64,
+	0x4a, 0x4a, 0x37, 0x59, 0x64, 0x4a, 0x5a, 0x3f, 0x58, 0x5e, 0xe1, 0xa6, 0x2c, 0xe2, 0x8b, 0x3d,
+	0x99, 0x82, 0xff, 0x20, 0xa1, 0x85, 0x24, 0xc8, 0xcd, 0x4e, 0x09, 0xbe, 0xd6, 0x3b, 0x90, 0xf6,
+	0x96, 0x4f, 0xfe, 0xa5, 0x13, 0xe9, 0x82, 0x35, 0x57, 0xb8, 0x35, 0xcb, 0x78, 0x29, 0x66, 0x0d,
+	0x77, 0x42, 0xb4, 0x65, 0xd3, 0xf2, 0x08, 0xfe, 0xbd, 0x84, 0x26, 0x3a, 0x8b, 0xb7, 0x95, 0xde,
+	0x82, 0x22, 0xc4, 0x5c, 0xec, 0x55, 0x1c, 0x60, 0xbe, 0xcd, 0x61, 0xaa, 0x78, 0x2b, 0x8d, 0x74,
+	0xe5, 0x1e, 0x64, 0x71, 0x16, 0x3a, 0x70, 0x2d, 0x63, 0x8f, 0xcd, 0x0c, 0xde, 0x1e, 0x52, 0xbf,
+	0x90, 0xd0, 0x54, 0xc7, 0xba, 0x2c, 0x9c, 0x56, 0x7a, 0xa3, 0xb5, 0x8b, 0x45, 0xdd, 0xfa, 0xb9,
+	0xf2, 0xcb, 0xdc, 0xa2, 0x17, 0xf0, 0xd5, 0x13, 0x59, 0x84, 0xbf, 0x29, 0xa1, 0xb1, 0x68, 0xe7,
+	0x92, 0x21, 0x5e, 0x12, 0x42, 0x10, 0x74, 0x63, 0xf3, 0x97, 0x7b, 0x90, 0x04, 0x9c, 0xff, 0xcf,
+	0x71, 0x5e, 0xc2, 0xcf, 0x76, 0x06, 0x48, 0xd8, 0xef, 0x8c, 0x04, 0xc7, 0x0f, 0x25, 0x34, 0x1e,
+	0x6b, 0x39, 0x31, 0x5c, 0xe2, 0xd5, 0x44, 0x2d, 0xb7, 0xfc, 0x72, 0x2f, 0xa2, 0x80, 0xec, 0x45,
+	0x8e, 0x6c, 0x0d, 0x5f, 0x51, 0x92, 0x7f, 0x84, 0x14, 0x93, 0xf7, 0xbb, 0x0c, 0x3a, 0x9f, 0xd8,
+	0xf6, 0xc0, 0x57, 0x85, 0xb1, 0x99, 0xd6, 0x9b, 0xc9, 0x3f, 0x7f, 0x5c, 0x35, 0x30, 0xe3, 0x57,
+	0x12, 0xb7, 0xe3, 0x97, 0xd2, 0xad, 0x77, 0xf0, 0x5b, 0x31, 0x53, 0x6e, 0x9b, 0x96, 0x45, 0x0c,
+	0xad, 0x1f, 0x51, 0xfe, 0x4e, 0xec, 0xc3, 0xdd, 0xba, 0x39, 0xc7, 0xfe, 0xf4, 0x3f, 0x24, 0x34,
+	0x9b, 0x68, 0x25, 0x73, 0xff, 0x55, 0xa1, 0x4f, 0x4f, 0xc2, 0x67, 0x2f, 0xdd, 0x2a, 0xf9, 0x5d,
+	0x4e, 0xe7, 0x9b, 0xb7, 0x2e, 0xe3, 0xc5, 0x1e, 0xd9, 0xc4, 0x97, 0x7b, 0x66, 0x07, 0xff, 0x40,
+	0x42, 0x63, 0xd1, 0x4e, 0x42, 0xf2, 0xbe, 0x13, 0x74, 0x4b, 0x12, 0xf6, 0x9d, 0xa8, 0xa7, 0x21,
+	0xbf, 0xc0, 0xcd, 0x58, 0xc5, 0x8a, 0x92, 0xf8, 0x1b, 0xbc, 0x38, 0xb8, 0x7f, 0x2a, 0xa1, 0xd1,
+	0xe8, 0x17, 0x45, 0xf0, 0xc4, 0xcd, 0x1c, 0x11, 0xbc, 0x84, 0x96, 0x8b, 0xfc, 0x05, 0x0e, 0x6f,
+	0x03, 0x97, 0x8e, 0x09, 0xaf, 0x2d, 0x92, 0x6e, 0x13, 0xc2, 0x93, 0xc6, 0x94, 0xa8, 0xfa, 0x17,
+	0xa5, 0xe0, 0x2e, 0xbd, 0x19, 0x51, 0x0a, 0xee, 0xd6, 0x54, 0x48, 0x48, 0x6d, 0x04, 0x54, 0xb4,
+	0x2a, 0xd3, 0xd1, 0xf6, 0x1c, 0x57, 0x63, 0xb5, 0x03, 0xe3, 0xf5, 0x5c, 0x42, 0x89, 0x88, 0xaf,
+	0x24, 0xaf, 0x2c, 0xee, 0x1a, 0xe4, 0x57, 0x8f, 0xa1, 0x01, 0x70, 0x15, 0x0e, 0xb7, 0x3d, 0xac,
+	0x9b, 0x70, 0x5d, 0xa6, 0x16, 0x8d, 0x59, 0x7c, 0x1f, 0x0d, 0x30, 0xdf, 0xe1, 0x0b, 0x82, 0xcb,
+	0x63, 0xab, 0xf2, 0xc9, 0xcf, 0x25, 0x4d, 0xc3, 0xba, 0xcf, 0xf3, 0x75, 0xaf, 0xe0, 0x62, 0x87,
+	0xab, 0x63, 0x1e, 0xee, 0x70, 0xab, 0x87, 0x86, 0xc2, 0x12, 0x08, 0x2f, 0x88, 0xd7, 0x88, 0x94,
+	0x47, 0xa9, 0x30, 0x9e, 0xe1, 0x30, 0x2e, 0xe0, 0x19, 0x11, 0x8c, 0xa0, 0xae, 0xba, 0x8f, 0xbf,
+	0x06, 0xc1, 0xdf, 0xbc, 0xb6, 0x27, 0x07, 0x7f, 0x5b, 0x3d, 0xd2, 0x25, 0xf8, 0xdb, 0x2b, 0x0a,
+	0x79, 0x91, 0x43, 0x59, 0xc0, 0x05, 0x25, 0xf1, 0x1f, 0x68, 0x94, 0x7b, 0x0c, 0xce, 0x57, 0x21,
+	0x5b, 0x84, 0x5f, 0xe8, 0x9e, 0x2d, 0x7a, 0x40, 0x94, 0x50, 0xe3, 0xc8, 0x32, 0x47, 0x34, 0x8b,
+	0xf3, 0xc9, 0x88, 0x4a, 0x9b, 0x1f, 0x3e, 0x9c, 0x93, 0x3e, 0x7a, 0x38, 0x27, 0xfd, 0xf5, 0xe1,
+	0x9c, 0xf4, 0xe0, 0xd1, 0xdc, 0xa9, 0x8f, 0x1e, 0xcd, 0x9d, 0xfa, 0xe3, 0xa3, 0xb9, 0x53, 0xb7,
+	0x56, 0xd2, 0x1b, 0x84, 0x87, 0xc1, 0xe1, 0xca, 0x2a, 0xef, 0x9d, 0x41, 0xde, 0xcf, 0xf9, 0xd4,
+	0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x90, 0x59, 0x64, 0x4a, 0xad, 0x25, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3913,7 +3879,7 @@ func (m *QueryEstimateMultiHopSwapRequest) MarshalToSizedBuffer(dAtA []byte) (in
 			dAtA[i] = 0
 		}
 		i--
-		dAtA[i] = 0x30
+		dAtA[i] = 0x20
 	}
 	{
 		size := m.ExitLimitPrice.Size()
@@ -3924,7 +3890,7 @@ func (m *QueryEstimateMultiHopSwapRequest) MarshalToSizedBuffer(dAtA []byte) (in
 		i = encodeVarintQuery(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x2a
+	dAtA[i] = 0x1a
 	{
 		size := m.AmountIn.Size()
 		i -= size
@@ -3934,7 +3900,7 @@ func (m *QueryEstimateMultiHopSwapRequest) MarshalToSizedBuffer(dAtA []byte) (in
 		i = encodeVarintQuery(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x22
+	dAtA[i] = 0x12
 	if len(m.Routes) > 0 {
 		for iNdEx := len(m.Routes) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -3946,23 +3912,9 @@ func (m *QueryEstimateMultiHopSwapRequest) MarshalToSizedBuffer(dAtA []byte) (in
 				i = encodeVarintQuery(dAtA, i, uint64(size))
 			}
 			i--
-			dAtA[i] = 0x1a
+			dAtA[i] = 0xa
 		}
 	}
-	if len(m.Receiver) > 0 {
-		i -= len(m.Receiver)
-		copy(dAtA[i:], m.Receiver)
-		i = encodeVarintQuery(dAtA, i, uint64(len(m.Receiver)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.Creator) > 0 {
-		i -= len(m.Creator)
-		copy(dAtA[i:], m.Creator)
-		i = encodeVarintQuery(dAtA, i, uint64(len(m.Creator)))
-		i--
-		dAtA[i] = 0xa
-	}
 	return len(dAtA) - i, nil
 }
 
@@ -4019,6 +3971,16 @@ func (m *QueryEstimatePlaceLimitOrderRequest) MarshalToSizedBuffer(dAtA []byte)
 	_ = i
 	var l int
 	_ = l
+	if m.ExpirationTime != nil {
+		n21, err21 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(*m.ExpirationTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime):])
+		if err21 != nil {
+			return 0, err21
+		}
+		i -= n21
+		i = encodeVarintQuery(dAtA, i, uint64(n21))
+		i--
+		dAtA[i] = 0x4a
+	}
 	if m.MaxAmountOut != nil {
 		{
 			size := m.MaxAmountOut.Size()
@@ -4029,22 +3991,12 @@ func (m *QueryEstimatePlaceLimitOrderRequest) MarshalToSizedBuffer(dAtA []byte)
 			i = encodeVarintQuery(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x4a
-	}
-	if m.ExpirationTime != nil {
-		n21, err21 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(*m.ExpirationTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime):])
-		if err21 != nil {
-			return 0, err21
-		}
-		i -= n21
-		i = encodeVarintQuery(dAtA, i, uint64(n21))
-		i--
-		dAtA[i] = 0x42
+		dAtA[i] = 0x32
 	}
 	if m.OrderType != 0 {
 		i = encodeVarintQuery(dAtA, i, uint64(m.OrderType))
 		i--
-		dAtA[i] = 0x38
+		dAtA[i] = 0x28
 	}
 	{
 		size := m.AmountIn.Size()
@@ -4055,38 +4007,24 @@ func (m *QueryEstimatePlaceLimitOrderRequest) MarshalToSizedBuffer(dAtA []byte)
 		i = encodeVarintQuery(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x32
+	dAtA[i] = 0x22
 	if m.TickIndexInToOut != 0 {
 		i = encodeVarintQuery(dAtA, i, uint64(m.TickIndexInToOut))
 		i--
-		dAtA[i] = 0x28
+		dAtA[i] = 0x18
 	}
 	if len(m.TokenOut) > 0 {
 		i -= len(m.TokenOut)
 		copy(dAtA[i:], m.TokenOut)
 		i = encodeVarintQuery(dAtA, i, uint64(len(m.TokenOut)))
 		i--
-		dAtA[i] = 0x22
+		dAtA[i] = 0x12
 	}
 	if len(m.TokenIn) > 0 {
 		i -= len(m.TokenIn)
 		copy(dAtA[i:], m.TokenIn)
 		i = encodeVarintQuery(dAtA, i, uint64(len(m.TokenIn)))
 		i--
-		dAtA[i] = 0x1a
-	}
-	if len(m.Receiver) > 0 {
-		i -= len(m.Receiver)
-		copy(dAtA[i:], m.Receiver)
-		i = encodeVarintQuery(dAtA, i, uint64(len(m.Receiver)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.Creator) > 0 {
-		i -= len(m.Creator)
-		copy(dAtA[i:], m.Creator)
-		i = encodeVarintQuery(dAtA, i, uint64(len(m.Creator)))
-		i--
 		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
@@ -4836,14 +4774,6 @@ func (m *QueryEstimateMultiHopSwapRequest) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = len(m.Creator)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	l = len(m.Receiver)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
 	if len(m.Routes) > 0 {
 		for _, e := range m.Routes {
 			l = e.Size()
@@ -4877,14 +4807,6 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = len(m.Creator)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	l = len(m.Receiver)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
 	l = len(m.TokenIn)
 	if l > 0 {
 		n += 1 + l + sovQuery(uint64(l))
@@ -4901,14 +4823,14 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Size() (n int) {
 	if m.OrderType != 0 {
 		n += 1 + sovQuery(uint64(m.OrderType))
 	}
-	if m.ExpirationTime != nil {
-		l = github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime)
-		n += 1 + l + sovQuery(uint64(l))
-	}
 	if m.MaxAmountOut != nil {
 		l = m.MaxAmountOut.Size()
 		n += 1 + l + sovQuery(uint64(l))
 	}
+	if m.ExpirationTime != nil {
+		l = github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime)
+		n += 1 + l + sovQuery(uint64(l))
+	}
 	return n
 }
 
@@ -7909,70 +7831,6 @@ func (m *QueryEstimateMultiHopSwapRequest) Unmarshal(dAtA []byte) error {
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Creator = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Receiver = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Routes", wireType)
 			}
@@ -8006,7 +7864,7 @@ func (m *QueryEstimateMultiHopSwapRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 4:
+		case 2:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", wireType)
 			}
@@ -8040,7 +7898,7 @@ func (m *QueryEstimateMultiHopSwapRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 5:
+		case 3:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field ExitLimitPrice", wireType)
 			}
@@ -8074,7 +7932,7 @@ func (m *QueryEstimateMultiHopSwapRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 6:
+		case 4:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field PickBestRoute", wireType)
 			}
@@ -8229,7 +8087,7 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field TokenIn", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -8257,11 +8115,11 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Creator = string(dAtA[iNdEx:postIndex])
+			m.TokenIn = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field TokenOut", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -8289,13 +8147,13 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Receiver = string(dAtA[iNdEx:postIndex])
+			m.TokenOut = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TokenIn", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TickIndexInToOut", wireType)
 			}
-			var stringLen uint64
+			m.TickIndexInToOut = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -8305,27 +8163,14 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.TickIndexInToOut |= 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
-			}
-			m.TokenIn = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		case 4:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TokenOut", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -8353,13 +8198,15 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.TokenOut = string(dAtA[iNdEx:postIndex])
+			if err := m.AmountIn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		case 5:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TickIndexInToOut", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field OrderType", wireType)
 			}
-			m.TickIndexInToOut = 0
+			m.OrderType = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -8369,14 +8216,14 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.TickIndexInToOut |= int64(b&0x7F) << shift
+				m.OrderType |= LimitOrderType(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 6:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxAmountOut", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -8404,30 +8251,13 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.AmountIn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			var v cosmossdk_io_math.Int
+			m.MaxAmountOut = &v
+			if err := m.MaxAmountOut.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 7:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field OrderType", wireType)
-			}
-			m.OrderType = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.OrderType |= LimitOrderType(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 8:
+		case 9:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType)
 			}
@@ -8463,42 +8293,6 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 9:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxAmountOut", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			var v cosmossdk_io_math.Int
-			m.MaxAmountOut = &v
-			if err := m.MaxAmountOut.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])

From 33b55490d7e8f7082724f078d5e1563f4deffed7 Mon Sep 17 00:00:00 2001
From: Julian Compagni Portis <jcompagni@gmail.com>
Date: Wed, 29 May 2024 19:09:07 -0400
Subject: [PATCH 02/10] misc cleanup

---
 .../grpc_query_estimate_multi_hop_swap.go     |  4 +--
 ...grpc_query_estimate_multi_hop_swap_test.go | 35 +++++++------------
 .../grpc_query_estimate_place_limit_order.go  |  4 +--
 x/dex/keeper/msg_server_test.go               |  4 +--
 x/dex/keeper/simulation_bank_keeper.go        |  2 ++
 5 files changed, 20 insertions(+), 29 deletions(-)

diff --git a/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go b/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go
index 6eb3e9fee..d6b6e944d 100644
--- a/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go
+++ b/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go
@@ -27,7 +27,7 @@ func (k Keeper) EstimateMultiHopSwap(
 	ctx := sdk.UnwrapSDKContext(goCtx)
 	cacheCtx, _ := ctx.CacheContext()
 
-	oldBK := k.bankKeeper
+	oldBk := k.bankKeeper
 	k.bankKeeper = NewSimulationBankKeeper(k.bankKeeper)
 	coinOut, err := k.MultiHopSwapCore(
 		cacheCtx,
@@ -43,7 +43,7 @@ func (k Keeper) EstimateMultiHopSwap(
 	}
 
 	//nolint:staticcheck // Should be unnecessary but out of an abundance of caution we restore the old bankkeeper
-	k.bankKeeper = oldBK
+	k.bankKeeper = oldBk
 
 	return &types.QueryEstimateMultiHopSwapResponse{CoinOut: coinOut}, nil
 }
diff --git a/x/dex/keeper/grpc_query_estimate_multi_hop_swap_test.go b/x/dex/keeper/grpc_query_estimate_multi_hop_swap_test.go
index 0df412dfd..2c9fb7b40 100644
--- a/x/dex/keeper/grpc_query_estimate_multi_hop_swap_test.go
+++ b/x/dex/keeper/grpc_query_estimate_multi_hop_swap_test.go
@@ -19,7 +19,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapSingleRoute() {
 
 	// WHEN alice multihopswaps A<>B => B<>C => C<>D,
 	route := [][]string{{"TokenA", "TokenB", "TokenC", "TokenD"}}
-	coinOut := s.estimatesMultiHopSwap(route, 100, math_utils.MustNewPrecDecFromStr("0.9"), false)
+	coinOut := s.estimateMultiHopSwap(route, 100, math_utils.MustNewPrecDecFromStr("0.9"), false)
 
 	// THEN alice would get out ~99 BIGTokenD
 	s.Assert().Equal(math.NewInt(99970003), coinOut.Amount)
@@ -31,6 +31,10 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapSingleRoute() {
 	s.assertDexBalanceWithDenom("TokenC", 100)
 	s.assertDexBalanceWithDenom("TokenD", 100)
 
+	// No events are emitted
+	s.AssertEventValueNotEmitted(types.TickUpdateEventKey, "Expected no events")
+
+	// Subsequent transactions use the original BankKeeper
 	s.assertBobLimitSellFails(sdkerrors.ErrInsufficientFunds, "TokenA", -400_000, 100_000_000)
 }
 
@@ -46,7 +50,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapInsufficientLiquiditySingleRoute(
 
 	// THEN estimate multihopswap fails
 	route := [][]string{{"TokenA", "TokenB", "TokenC", "TokenD"}}
-	s.estimatesMultiHopSwapFails(
+	s.estimateMultiHopSwapFails(
 		types.ErrInsufficientLiquidity,
 		route,
 		100,
@@ -67,7 +71,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapLimitPriceNotMetSingleRoute() {
 
 	// THEN estimate multihopswap fails
 	route := [][]string{{"TokenA", "TokenB", "TokenC", "TokenD"}}
-	s.estimatesMultiHopSwapFails(
+	s.estimateMultiHopSwapFails(
 		types.ErrExitLimitPriceHit,
 		route,
 		50,
@@ -107,7 +111,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteOneGood() {
 		1,
 	)
 
-	coinOut := s.estimatesMultiHopSwap(routes, 100, math_utils.MustNewPrecDecFromStr("0.91"), false)
+	coinOut := s.estimateMultiHopSwap(routes, 100, math_utils.MustNewPrecDecFromStr("0.91"), false)
 
 	// THEN swap estimation succeeds through route A<>B, B<>E, E<>X
 
@@ -206,7 +210,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteAllFail() {
 	}
 
 	// Then fails with findBestRoute
-	s.estimatesMultiHopSwapFails(
+	s.estimateMultiHopSwapFails(
 		types.ErrExitLimitPriceHit,
 		routes,
 		100,
@@ -216,7 +220,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteAllFail() {
 
 	// and with findFirstRoute
 
-	s.estimatesMultiHopSwapFails(
+	s.estimateMultiHopSwapFails(
 		types.ErrExitLimitPriceHit,
 		routes,
 		100,
@@ -245,7 +249,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteFindBestRoute() {
 		{"TokenA", "TokenB", "TokenD", "TokenX"},
 		{"TokenA", "TokenB", "TokenE", "TokenX"},
 	}
-	coinOut := s.estimatesMultiHopSwap(routes, 100, math_utils.MustNewPrecDecFromStr("0.9"), true)
+	coinOut := s.estimateMultiHopSwap(routes, 100, math_utils.MustNewPrecDecFromStr("0.9"), true)
 
 	// THEN swap succeeds through route A<>B, B<>E, E<>X
 
@@ -337,7 +341,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapLongRouteWithCache() {
 			"TokenG", "TokenH", "TokenI", "TokenJ", "TokenK", "TokenM", "TokenX",
 		},
 	}
-	coinOut := s.estimatesMultiHopSwap(routes, 100, math_utils.MustNewPrecDecFromStr("0.8"), true)
+	coinOut := s.estimateMultiHopSwap(routes, 100, math_utils.MustNewPrecDecFromStr("0.8"), true)
 
 	// THEN swap succeeds with second route
 	s.Assert().Equal(coinOut, sdk.NewCoin("TokenX", math.NewInt(99880066)))
@@ -350,18 +354,3 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapLongRouteWithCache() {
 		1,
 	)
 }
-
-func (s *DexTestSuite) TestEstimateMultiHopSwapEventsEmitted() {
-	s.fundAliceBalances(100, 0)
-
-	s.SetupMultiplePools(
-		NewPoolSetup("TokenA", "TokenB", 0, 100, 0, 1),
-		NewPoolSetup("TokenB", "TokenC", 0, 100, 0, 1),
-	)
-
-	route := [][]string{{"TokenA", "TokenB", "TokenC"}}
-	_ = s.estimatesMultiHopSwap(route, 100, math_utils.MustNewPrecDecFromStr("0.9"), false)
-
-	// 8 tickUpdateEvents are emitted 4x for pool setup 4x for two swaps
-	s.AssertEventValueNotEmitted(types.TickUpdateEventKey, "Expected no events")
-}
diff --git a/x/dex/keeper/grpc_query_estimate_place_limit_order.go b/x/dex/keeper/grpc_query_estimate_place_limit_order.go
index 293466206..ebc2a77af 100644
--- a/x/dex/keeper/grpc_query_estimate_place_limit_order.go
+++ b/x/dex/keeper/grpc_query_estimate_place_limit_order.go
@@ -35,7 +35,7 @@ func (k Keeper) EstimatePlaceLimitOrder(
 		return nil, err
 	}
 
-	oldBK := k.bankKeeper
+	oldBk := k.bankKeeper
 	k.bankKeeper = NewSimulationBankKeeper(k.bankKeeper)
 	_, totalInCoin, swapInCoin, swapOutCoin, err := k.PlaceLimitOrderCore(
 		cacheCtx,
@@ -54,7 +54,7 @@ func (k Keeper) EstimatePlaceLimitOrder(
 	}
 
 	//nolint:staticcheck // Should be unnecessary but out of an abundance of caution we restore the old bankkeeper
-	k.bankKeeper = oldBK
+	k.bankKeeper = oldBk
 
 	return &types.QueryEstimatePlaceLimitOrderResponse{
 		TotalInCoin: totalInCoin,
diff --git a/x/dex/keeper/msg_server_test.go b/x/dex/keeper/msg_server_test.go
index 7944d5c67..031a0bef8 100644
--- a/x/dex/keeper/msg_server_test.go
+++ b/x/dex/keeper/msg_server_test.go
@@ -914,7 +914,7 @@ func (s *DexTestSuite) multiHopSwaps(
 	s.Assert().Nil(err)
 }
 
-func (s *DexTestSuite) estimatesMultiHopSwap(
+func (s *DexTestSuite) estimateMultiHopSwap(
 	routes [][]string,
 	amountIn int,
 	exitLimitPrice math_utils.PrecDec,
@@ -935,7 +935,7 @@ func (s *DexTestSuite) estimatesMultiHopSwap(
 	return res.CoinOut
 }
 
-func (s *DexTestSuite) estimatesMultiHopSwapFails(
+func (s *DexTestSuite) estimateMultiHopSwapFails(
 	expectedErr error,
 	routes [][]string,
 	amountIn int,
diff --git a/x/dex/keeper/simulation_bank_keeper.go b/x/dex/keeper/simulation_bank_keeper.go
index f5c3c14cd..3d5f06da3 100644
--- a/x/dex/keeper/simulation_bank_keeper.go
+++ b/x/dex/keeper/simulation_bank_keeper.go
@@ -8,6 +8,8 @@ import (
 	"github.com/neutron-org/neutron/v4/x/dex/types"
 )
 
+// SimulationBankKeeper can be used by queries that require running a transaction but don't need to check bank balances
+// ie. EstimateMultiHopSwap & EstimatePlaceLimitOrder
 type SimulationBankKeeper struct {
 	originalBankKeeper types.BankKeeper
 }

From 8ff24d2e938e5e82a20da9c43152b9d97490b9de Mon Sep 17 00:00:00 2001
From: Julian Compagni Portis <jcompagni@gmail.com>
Date: Wed, 29 May 2024 20:13:17 -0400
Subject: [PATCH 03/10] Add tests for EstimatePlaceLimitOrder

---
 .../grpc_estimate_place_limit_order_test.go   | 104 ++++++++++++++++++
 ...grpc_query_estimate_multi_hop_swap_test.go |  29 ++---
 2 files changed, 111 insertions(+), 22 deletions(-)
 create mode 100644 x/dex/keeper/grpc_estimate_place_limit_order_test.go

diff --git a/x/dex/keeper/grpc_estimate_place_limit_order_test.go b/x/dex/keeper/grpc_estimate_place_limit_order_test.go
new file mode 100644
index 000000000..8cc870289
--- /dev/null
+++ b/x/dex/keeper/grpc_estimate_place_limit_order_test.go
@@ -0,0 +1,104 @@
+package keeper_test
+
+import (
+	"cosmossdk.io/math"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/neutron-org/neutron/v4/x/dex/types"
+)
+
+func (s *DexTestSuite) TestEstimatePlaceLimitOrderGTC() {
+	// GIVEN liquidity  A<>B
+	s.SetupMultiplePools(
+		NewPoolSetup("TokenA", "TokenB", 0, 1, 0, 1),
+		NewPoolSetup("TokenA", "TokenB", 0, 1, 1, 1),
+	)
+
+	// WHEN estimate GTC Limit order selling "TokenA"
+	resp, err := s.App.DexKeeper.EstimatePlaceLimitOrder(s.Ctx, &types.QueryEstimatePlaceLimitOrderRequest{
+		TokenIn:          "TokenA",
+		TokenOut:         "TokenB",
+		TickIndexInToOut: 4,
+		AmountIn:         math.NewInt(3_000_000),
+		OrderType:        types.LimitOrderType_GOOD_TIL_CANCELLED,
+	})
+	s.NoError(err)
+
+	// Then estimate is 3 BIG TokenA in with 2 BIG TokenB out from swap
+	s.True(math.NewInt(3_000_000).Equal(resp.TotalInCoin.Amount), "Got %v", resp.TotalInCoin.Amount)
+	s.Equal("TokenA", resp.TotalInCoin.Denom)
+
+	s.True(math.NewInt(2_000_301).Equal(resp.SwapInCoin.Amount), "Got %v", resp.SwapInCoin.Amount)
+	s.Equal("TokenA", resp.SwapInCoin.Denom)
+
+	s.True(math.NewInt(2_000_000).Equal(resp.SwapOutCoin.Amount), "Got %v", resp.SwapOutCoin.Amount)
+	s.Equal("TokenB", resp.SwapOutCoin.Denom)
+
+	// AND state is not altered
+	s.assertDexBalanceWithDenom("TokenA", 0)
+	s.assertDexBalanceWithDenom("TokenB", 2)
+
+	// No events are emitted
+	s.AssertEventValueNotEmitted(types.TickUpdateEventKey, "Expected no events")
+
+	// Subsequent transactions use the original BankKeeper
+	// ie. The simulation bankkeeper is not retained giving users unlimited funds
+	s.assertBobLimitSellFails(sdkerrors.ErrInsufficientFunds, "TokenA", -400_000, 100_000_000)
+}
+
+func (s *DexTestSuite) TestEstimatePlaceLimitOrderFoK() {
+	// GIVEN liquidity TokenB
+	s.SetupMultiplePools(
+		NewPoolSetup("TokenA", "TokenB", 0, 1, 0, 1),
+		NewPoolSetup("TokenA", "TokenB", 0, 1, 1, 1),
+	)
+
+	// WHEN estimate FoK Limit order selling "TokenA"
+	resp, err := s.App.DexKeeper.EstimatePlaceLimitOrder(s.Ctx, &types.QueryEstimatePlaceLimitOrderRequest{
+		TokenIn:          "TokenA",
+		TokenOut:         "TokenB",
+		TickIndexInToOut: 4,
+		AmountIn:         math.NewInt(1_500_000),
+		OrderType:        types.LimitOrderType_FILL_OR_KILL,
+	})
+	s.NoError(err)
+
+	// Then estimate is 1.5 BIG TokenA in with 1.5 BIG TokenB out from swap
+	s.True(math.NewInt(1_500_000).Equal(resp.TotalInCoin.Amount), "Got %v", resp.TotalInCoin.Amount)
+	s.Equal("TokenA", resp.TotalInCoin.Denom)
+
+	s.True(math.NewInt(1_500_000).Equal(resp.SwapInCoin.Amount), "Got %v", resp.SwapInCoin.Amount)
+	s.Equal("TokenA", resp.SwapInCoin.Denom)
+
+	s.True(math.NewInt(1_499_800).Equal(resp.SwapOutCoin.Amount), "Got %v", resp.SwapOutCoin.Amount)
+	s.Equal("TokenB", resp.SwapOutCoin.Denom)
+
+	// AND state is not altered
+	s.assertDexBalanceWithDenom("TokenA", 0)
+	s.assertDexBalanceWithDenom("TokenB", 2)
+
+	// No events are emitted
+	s.AssertEventValueNotEmitted(types.TickUpdateEventKey, "Expected no events")
+
+	// Subsequent transactions use the original BankKeeper
+	s.assertBobLimitSellFails(sdkerrors.ErrInsufficientFunds, "TokenA", -400_000, 100_000_000)
+}
+
+func (s *DexTestSuite) TestEstimatePlaceLimitOrderFoKFails() {
+	// GIVEN no liquidity
+
+	// WHEN estimate placeLimitOrder
+	resp, err := s.App.DexKeeper.EstimatePlaceLimitOrder(s.Ctx, &types.QueryEstimatePlaceLimitOrderRequest{
+		TokenIn:          "TokenA",
+		TokenOut:         "TokenB",
+		TickIndexInToOut: 4,
+		AmountIn:         math.NewInt(1_500_000),
+		OrderType:        types.LimitOrderType_IMMEDIATE_OR_CANCEL,
+	})
+
+	//THEN error is returned
+	s.ErrorIs(err, types.ErrLimitPriceNotSatisfied)
+	s.Nil(resp)
+
+	// Subsequent transactions use the original BankKeeper
+	s.assertBobLimitSellFails(sdkerrors.ErrInsufficientFunds, "TokenA", -400_000, 100_000_000)
+}
diff --git a/x/dex/keeper/grpc_query_estimate_multi_hop_swap_test.go b/x/dex/keeper/grpc_query_estimate_multi_hop_swap_test.go
index f49c14ad4..5f30dc8aa 100644
--- a/x/dex/keeper/grpc_query_estimate_multi_hop_swap_test.go
+++ b/x/dex/keeper/grpc_query_estimate_multi_hop_swap_test.go
@@ -17,15 +17,14 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapSingleRoute() {
 		NewPoolSetup("TokenC", "TokenD", 0, 100, 0, 1),
 	)
 
-	// WHEN alice multihopswaps A<>B => B<>C => C<>D,
+	// WHEN estimate multihopswaps A<>B => B<>C => C<>D,
 	route := [][]string{{"TokenA", "TokenB", "TokenC", "TokenD"}}
 	coinOut := s.estimateMultiHopSwap(route, 100, math_utils.MustNewPrecDecFromStr("0.9"), false)
 
-	// THEN alice would get out ~99 BIGTokenD
+	// THEN estimation returns ~99 BIGTokenD
 	s.Assert().Equal(math.NewInt(99970003), coinOut.Amount)
 
 	// AND state is not altered
-	s.assertAccountBalanceWithDenom(s.alice, "TokenD", 0)
 	s.assertDexBalanceWithDenom("TokenA", 0)
 	s.assertDexBalanceWithDenom("TokenB", 100)
 	s.assertDexBalanceWithDenom("TokenC", 100)
@@ -35,12 +34,11 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapSingleRoute() {
 	s.AssertEventValueNotEmitted(types.TickUpdateEventKey, "Expected no events")
 
 	// Subsequent transactions use the original BankKeeper
+	// ie. The simulation bankkeeper is not retained giving users unlimited funds
 	s.assertBobLimitSellFails(sdkerrors.ErrInsufficientFunds, "TokenA", -400_000, 100_000_000)
 }
 
 func (s *DexTestSuite) TestEstimateMultiHopSwapInsufficientLiquiditySingleRoute() {
-	s.fundAliceBalances(100, 0)
-
 	// GIVEN liquidity in pools A<>B, B<>C, C<>D with insufficient liquidity in C<>D
 	s.SetupMultiplePools(
 		NewPoolSetup("TokenA", "TokenB", 0, 100, 0, 1),
@@ -60,8 +58,6 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapInsufficientLiquiditySingleRoute(
 }
 
 func (s *DexTestSuite) TestEstimateMultiHopSwapLimitPriceNotMetSingleRoute() {
-	s.fundAliceBalances(100, 0)
-
 	// GIVEN liquidity in pools A<>B, B<>C, C<>D with insufficient liquidity in C<>D
 	s.SetupMultiplePools(
 		NewPoolSetup("TokenA", "TokenB", 0, 100, 0, 1),
@@ -81,8 +77,6 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapLimitPriceNotMetSingleRoute() {
 }
 
 func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteOneGood() {
-	s.fundAliceBalances(100, 0)
-
 	// GIVEN viable liquidity in pools A<>B, B<>E, E<>X
 	s.SetupMultiplePools(
 		NewPoolSetup("TokenA", "TokenB", 0, 100, 0, 1),
@@ -117,9 +111,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteOneGood() {
 
 	s.Assert().Equal(math.NewInt(99970003), coinOut.Amount)
 
-	// pools and accounts are unaffected
-	s.assertAccountBalanceWithDenom(s.alice, "TokenA", 100)
-	s.assertAccountBalanceWithDenom(s.alice, "TokenX", 0)
+	// pools are unaffected
 	s.assertLiquidityAtTickWithDenom(
 		&types.PairID{Token0: "TokenA", Token1: "TokenB"},
 		0,
@@ -187,8 +179,6 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteOneGood() {
 }
 
 func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteAllFail() {
-	s.fundAliceBalances(100, 0)
-
 	// GIVEN liquidity in sufficient liquidity but inadequate prices
 	s.SetupMultiplePools(
 		NewPoolSetup("TokenA", "TokenB", 0, 100, 0, 1),
@@ -202,7 +192,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteAllFail() {
 		NewPoolSetup("TokenE", "TokenX", 0, 50, 2200, 1),
 	)
 
-	// WHEN alice multihopswaps with three routes they all fail
+	// WHEN estimate multihopswap with three routes they all fail
 	routes := [][]string{
 		{"TokenA", "TokenB", "TokenC", "TokenX"},
 		{"TokenA", "TokenB", "TokenD", "TokenX"},
@@ -230,8 +220,6 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteAllFail() {
 }
 
 func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteFindBestRoute() {
-	s.fundAliceBalances(100, 0)
-
 	// GIVEN viable liquidity in pools but with a best route through E<>X
 	s.SetupMultiplePools(
 		NewPoolSetup("TokenA", "TokenB", 0, 100, 0, 1),
@@ -243,7 +231,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteFindBestRoute() {
 		NewPoolSetup("TokenE", "TokenX", 0, 1000, -3000, 1),
 	)
 
-	// WHEN alice multihopswaps with three routes
+	// WHEN estimate multihopswaps with three routes
 	routes := [][]string{
 		{"TokenA", "TokenB", "TokenC", "TokenX"},
 		{"TokenA", "TokenB", "TokenD", "TokenX"},
@@ -308,8 +296,6 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapMultiRouteFindBestRoute() {
 }
 
 func (s *DexTestSuite) TestEstimateMultiHopSwapLongRouteWithCache() {
-	s.fundAliceBalances(100, 0)
-
 	// GIVEN viable route from A->B->C...->L but last leg to X only possible through K->M->X
 	s.SetupMultiplePools(
 		NewPoolSetup("TokenA", "TokenB", 0, 100, 0, 1),
@@ -330,7 +316,7 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapLongRouteWithCache() {
 		NewPoolSetup("TokenM", "TokenX", 0, 100, 0, 1),
 	)
 
-	// WHEN alice multihopswaps with two overlapping routes with only the last leg different
+	// WHEN estimate multihopswaps with two overlapping routes with only the last leg different
 	routes := [][]string{
 		{
 			"TokenA", "TokenB", "TokenC", "TokenD", "TokenE", "TokenF",
@@ -345,7 +331,6 @@ func (s *DexTestSuite) TestEstimateMultiHopSwapLongRouteWithCache() {
 
 	// THEN swap succeeds with second route
 	s.Assert().Equal(coinOut, sdk.NewCoin("TokenX", math.NewInt(99880066)))
-	s.assertAccountBalanceWithDenom(s.alice, "TokenA", 100)
 	s.assertLiquidityAtTickWithDenom(
 		&types.PairID{Token0: "TokenM", Token1: "TokenX"},
 		0,

From cf0ccf63dfcca8c68584d41cf6b4fb206d65749e Mon Sep 17 00:00:00 2001
From: Julian Compagni Portis <jcompagni@gmail.com>
Date: Wed, 29 May 2024 20:48:44 -0400
Subject: [PATCH 04/10] lint

---
 x/dex/keeper/grpc_estimate_place_limit_order_test.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/x/dex/keeper/grpc_estimate_place_limit_order_test.go b/x/dex/keeper/grpc_estimate_place_limit_order_test.go
index 8cc870289..c1bde3d8f 100644
--- a/x/dex/keeper/grpc_estimate_place_limit_order_test.go
+++ b/x/dex/keeper/grpc_estimate_place_limit_order_test.go
@@ -3,6 +3,7 @@ package keeper_test
 import (
 	"cosmossdk.io/math"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+
 	"github.com/neutron-org/neutron/v4/x/dex/types"
 )
 
@@ -95,7 +96,7 @@ func (s *DexTestSuite) TestEstimatePlaceLimitOrderFoKFails() {
 		OrderType:        types.LimitOrderType_IMMEDIATE_OR_CANCEL,
 	})
 
-	//THEN error is returned
+	// THEN error is returned
 	s.ErrorIs(err, types.ErrLimitPriceNotSatisfied)
 	s.Nil(resp)
 

From fe1ab28a4466f5ed5372fa0b58d17cf6f9ab0d3e Mon Sep 17 00:00:00 2001
From: Julian Compagni Portis <jcompagni@gmail.com>
Date: Thu, 30 May 2024 15:57:38 -0400
Subject: [PATCH 05/10] keep wire numbers consistent

---
 proto/neutron/dex/query.proto |  20 +-
 x/dex/types/query.pb.go       | 348 +++++++++++++++++-----------------
 2 files changed, 184 insertions(+), 184 deletions(-)

diff --git a/proto/neutron/dex/query.proto b/proto/neutron/dex/query.proto
index f72e99c59..7581e1d73 100644
--- a/proto/neutron/dex/query.proto
+++ b/proto/neutron/dex/query.proto
@@ -260,14 +260,14 @@ message QueryGetPoolReservesResponse {
 }
 
 message QueryEstimateMultiHopSwapRequest {
-  repeated MultiHopRoute routes = 1;
-  string amount_in = 2 [
+  repeated MultiHopRoute routes = 3;
+  string amount_in = 4 [
     (gogoproto.moretags) = "yaml:\"amount_in\"",
     (gogoproto.customtype) = "cosmossdk.io/math.Int",
     (gogoproto.nullable) = false,
     (gogoproto.jsontag) = "amount_in"
   ];
-  string exit_limit_price = 3 [
+  string exit_limit_price = 5 [
     (gogoproto.moretags) = "yaml:\"exit_limit_price\"",
     (gogoproto.customtype) = "github.com/neutron-org/neutron/v4/utils/math.PrecDec",
     (gogoproto.nullable) = false,
@@ -275,7 +275,7 @@ message QueryEstimateMultiHopSwapRequest {
   ];
   // If pickBestRoute == true then all routes are run and the route with the
   // best price is chosen otherwise, the first succesful route is used.
-  bool pick_best_route = 4;
+  bool pick_best_route = 6;
 }
 
 message QueryEstimateMultiHopSwapResponse {
@@ -287,22 +287,22 @@ message QueryEstimateMultiHopSwapResponse {
 }
 
 message QueryEstimatePlaceLimitOrderRequest {
-  string token_in = 1;
-  string token_out = 2;
-  int64 tick_index_in_to_out = 3;
-  string amount_in = 4 [
+  string token_in = 3;
+  string token_out = 4;
+  int64 tick_index_in_to_out = 5;
+  string amount_in = 6 [
     (gogoproto.moretags) = "yaml:\"amount_in\"",
     (gogoproto.customtype) = "cosmossdk.io/math.Int",
     (gogoproto.nullable) = false,
     (gogoproto.jsontag) = "amount_in"
   ];
-  LimitOrderType order_type = 5;
+  LimitOrderType order_type = 7;
   // expirationTime is only valid iff orderType == GOOD_TIL_TIME.
   google.protobuf.Timestamp expiration_time = 9 [
     (gogoproto.stdtime) = true,
     (gogoproto.nullable) = true
   ];
-  string max_amount_out = 6 [
+  string max_amount_out = 8 [
     (gogoproto.moretags) = "yaml:\"max_amount_out\"",
     (gogoproto.customtype) = "cosmossdk.io/math.Int",
     (gogoproto.nullable) = true,
diff --git a/x/dex/types/query.pb.go b/x/dex/types/query.pb.go
index f7161a617..a29eb9aca 100644
--- a/x/dex/types/query.pb.go
+++ b/x/dex/types/query.pb.go
@@ -1329,12 +1329,12 @@ func (m *QueryGetPoolReservesResponse) GetPoolReserves() *PoolReserves {
 }
 
 type QueryEstimateMultiHopSwapRequest struct {
-	Routes         []*MultiHopRoute                                     `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty"`
-	AmountIn       cosmossdk_io_math.Int                                `protobuf:"bytes,2,opt,name=amount_in,json=amountIn,proto3,customtype=cosmossdk.io/math.Int" json:"amount_in" yaml:"amount_in"`
-	ExitLimitPrice github_com_neutron_org_neutron_v4_utils_math.PrecDec `protobuf:"bytes,3,opt,name=exit_limit_price,json=exitLimitPrice,proto3,customtype=github.com/neutron-org/neutron/v4/utils/math.PrecDec" json:"exit_limit_price" yaml:"exit_limit_price"`
+	Routes         []*MultiHopRoute                                     `protobuf:"bytes,3,rep,name=routes,proto3" json:"routes,omitempty"`
+	AmountIn       cosmossdk_io_math.Int                                `protobuf:"bytes,4,opt,name=amount_in,json=amountIn,proto3,customtype=cosmossdk.io/math.Int" json:"amount_in" yaml:"amount_in"`
+	ExitLimitPrice github_com_neutron_org_neutron_v4_utils_math.PrecDec `protobuf:"bytes,5,opt,name=exit_limit_price,json=exitLimitPrice,proto3,customtype=github.com/neutron-org/neutron/v4/utils/math.PrecDec" json:"exit_limit_price" yaml:"exit_limit_price"`
 	// If pickBestRoute == true then all routes are run and the route with the
 	// best price is chosen otherwise, the first succesful route is used.
-	PickBestRoute bool `protobuf:"varint,4,opt,name=pick_best_route,json=pickBestRoute,proto3" json:"pick_best_route,omitempty"`
+	PickBestRoute bool `protobuf:"varint,6,opt,name=pick_best_route,json=pickBestRoute,proto3" json:"pick_best_route,omitempty"`
 }
 
 func (m *QueryEstimateMultiHopSwapRequest) Reset()         { *m = QueryEstimateMultiHopSwapRequest{} }
@@ -1422,14 +1422,14 @@ func (m *QueryEstimateMultiHopSwapResponse) XXX_DiscardUnknown() {
 var xxx_messageInfo_QueryEstimateMultiHopSwapResponse proto.InternalMessageInfo
 
 type QueryEstimatePlaceLimitOrderRequest struct {
-	TokenIn          string                `protobuf:"bytes,1,opt,name=token_in,json=tokenIn,proto3" json:"token_in,omitempty"`
-	TokenOut         string                `protobuf:"bytes,2,opt,name=token_out,json=tokenOut,proto3" json:"token_out,omitempty"`
-	TickIndexInToOut int64                 `protobuf:"varint,3,opt,name=tick_index_in_to_out,json=tickIndexInToOut,proto3" json:"tick_index_in_to_out,omitempty"`
-	AmountIn         cosmossdk_io_math.Int `protobuf:"bytes,4,opt,name=amount_in,json=amountIn,proto3,customtype=cosmossdk.io/math.Int" json:"amount_in" yaml:"amount_in"`
-	OrderType        LimitOrderType        `protobuf:"varint,5,opt,name=order_type,json=orderType,proto3,enum=neutron.dex.LimitOrderType" json:"order_type,omitempty"`
+	TokenIn          string                `protobuf:"bytes,3,opt,name=token_in,json=tokenIn,proto3" json:"token_in,omitempty"`
+	TokenOut         string                `protobuf:"bytes,4,opt,name=token_out,json=tokenOut,proto3" json:"token_out,omitempty"`
+	TickIndexInToOut int64                 `protobuf:"varint,5,opt,name=tick_index_in_to_out,json=tickIndexInToOut,proto3" json:"tick_index_in_to_out,omitempty"`
+	AmountIn         cosmossdk_io_math.Int `protobuf:"bytes,6,opt,name=amount_in,json=amountIn,proto3,customtype=cosmossdk.io/math.Int" json:"amount_in" yaml:"amount_in"`
+	OrderType        LimitOrderType        `protobuf:"varint,7,opt,name=order_type,json=orderType,proto3,enum=neutron.dex.LimitOrderType" json:"order_type,omitempty"`
 	// expirationTime is only valid iff orderType == GOOD_TIL_TIME.
 	ExpirationTime *time.Time             `protobuf:"bytes,9,opt,name=expiration_time,json=expirationTime,proto3,stdtime" json:"expiration_time,omitempty"`
-	MaxAmountOut   *cosmossdk_io_math.Int `protobuf:"bytes,6,opt,name=max_amount_out,json=maxAmountOut,proto3,customtype=cosmossdk.io/math.Int" json:"max_amount_out" yaml:"max_amount_out"`
+	MaxAmountOut   *cosmossdk_io_math.Int `protobuf:"bytes,8,opt,name=max_amount_out,json=maxAmountOut,proto3,customtype=cosmossdk.io/math.Int" json:"max_amount_out" yaml:"max_amount_out"`
 }
 
 func (m *QueryEstimatePlaceLimitOrderRequest) Reset()         { *m = QueryEstimatePlaceLimitOrderRequest{} }
@@ -1920,151 +1920,151 @@ func init() {
 func init() { proto.RegisterFile("neutron/dex/query.proto", fileDescriptor_b6613ea5fce61e9c) }
 
 var fileDescriptor_b6613ea5fce61e9c = []byte{
-	// 2302 bytes of a gzipped FileDescriptorProto
+	// 2304 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0x4d, 0x6c, 0x1c, 0x49,
-	0xf5, 0x4f, 0xcf, 0x78, 0x1d, 0xbb, 0xec, 0xc4, 0x76, 0xd9, 0xde, 0x4c, 0xc6, 0x8e, 0xc7, 0xee,
-	0xdd, 0xc4, 0x8e, 0xff, 0x7f, 0x4f, 0xc7, 0x66, 0xb3, 0xbb, 0xca, 0xb2, 0x80, 0x07, 0xef, 0x3a,
-	0xc3, 0x6e, 0x14, 0xd3, 0x6b, 0xf6, 0x23, 0xac, 0xd4, 0x6a, 0x4f, 0x57, 0xec, 0x96, 0x7b, 0xba,
-	0x3b, 0xdd, 0x35, 0xb1, 0x47, 0x51, 0x2e, 0xcb, 0x0d, 0x71, 0x08, 0x2c, 0x1f, 0x02, 0xa4, 0xe5,
-	0x80, 0x38, 0x21, 0x04, 0x48, 0x88, 0x1b, 0x17, 0x24, 0xd0, 0x0a, 0x21, 0xb4, 0xd2, 0x5e, 0x10,
-	0x48, 0x03, 0x4a, 0xe0, 0x12, 0x2e, 0xc8, 0x48, 0x9c, 0x51, 0x55, 0xbf, 0x9e, 0xe9, 0x9e, 0xa9,
-	0x9e, 0x1e, 0x3b, 0x03, 0xda, 0x93, 0xbb, 0xab, 0xde, 0xeb, 0xfa, 0xbd, 0xdf, 0x7b, 0xf5, 0xaa,
-	0xde, 0x1b, 0xa3, 0x73, 0x36, 0xa9, 0x51, 0xcf, 0xb1, 0x15, 0x83, 0x1c, 0x2a, 0x77, 0x6a, 0xc4,
-	0xab, 0x17, 0x5d, 0xcf, 0xa1, 0x0e, 0x1e, 0x81, 0x89, 0xa2, 0x41, 0x0e, 0xf3, 0xcb, 0x15, 0xc7,
-	0xaf, 0x3a, 0xbe, 0xb2, 0xa3, 0xfb, 0x24, 0x90, 0x52, 0xee, 0xae, 0xee, 0x10, 0xaa, 0xaf, 0x2a,
-	0xae, 0xbe, 0x6b, 0xda, 0x3a, 0x35, 0x1d, 0x3b, 0x50, 0xcc, 0xcf, 0x45, 0x65, 0x43, 0xa9, 0x8a,
-	0x63, 0x86, 0xf3, 0x53, 0xbb, 0xce, 0xae, 0xc3, 0x1f, 0x15, 0xf6, 0x04, 0xa3, 0xb3, 0xbb, 0x8e,
-	0xb3, 0x6b, 0x11, 0x45, 0x77, 0x4d, 0x45, 0xb7, 0x6d, 0x87, 0xf2, 0x4f, 0xfa, 0x30, 0x5b, 0x80,
-	0x59, 0xfe, 0xb6, 0x53, 0xbb, 0xad, 0x50, 0xb3, 0x4a, 0x7c, 0xaa, 0x57, 0x5d, 0x10, 0x98, 0x8f,
-	0x9a, 0x61, 0x10, 0xd7, 0xf1, 0x4d, 0xaa, 0x79, 0xa4, 0xe2, 0x78, 0x06, 0x48, 0x5c, 0x8c, 0x4a,
-	0x58, 0x66, 0xd5, 0xa4, 0x9a, 0xe3, 0x19, 0xc4, 0xd3, 0xa8, 0xa7, 0xdb, 0x95, 0x3d, 0x02, 0x62,
-	0xcb, 0x29, 0x62, 0x5a, 0xcd, 0x27, 0x1e, 0xc8, 0xe6, 0xa2, 0xb2, 0xae, 0xee, 0xe9, 0xd5, 0x10,
-	0xef, 0xd3, 0xb1, 0x19, 0xc7, 0xb1, 0x42, 0x3b, 0xda, 0xc7, 0xb5, 0x2a, 0xa1, 0xba, 0xa1, 0x53,
-	0x3d, 0x51, 0xc0, 0x23, 0x3e, 0xf1, 0xee, 0x12, 0x5f, 0x64, 0x28, 0x35, 0x2b, 0xfb, 0x9a, 0x65,
-	0xde, 0xa9, 0x99, 0x86, 0x49, 0xeb, 0x21, 0xbf, 0x31, 0x89, 0xc3, 0x60, 0x54, 0x9e, 0x42, 0xf8,
-	0x8b, 0xcc, 0x6f, 0x5b, 0x1c, 0xa6, 0x4a, 0xee, 0xd4, 0x88, 0x4f, 0xe5, 0xeb, 0x68, 0x32, 0x36,
-	0xea, 0xbb, 0x8e, 0xed, 0x13, 0xbc, 0x8a, 0x06, 0x03, 0x73, 0x72, 0xd2, 0xbc, 0xb4, 0x34, 0xb2,
-	0x36, 0x59, 0x8c, 0x04, 0x43, 0x31, 0x10, 0x2e, 0x0d, 0x7c, 0xd8, 0x28, 0x9c, 0x52, 0x41, 0x50,
-	0xfe, 0xbe, 0x84, 0x9e, 0xe5, 0x9f, 0xda, 0x24, 0xf4, 0x75, 0x46, 0xdb, 0x4d, 0xc6, 0xda, 0x76,
-	0x40, 0xda, 0x97, 0x7c, 0xe2, 0xc1, 0x92, 0x38, 0x87, 0x4e, 0xeb, 0x86, 0xe1, 0x11, 0x3f, 0xf8,
-	0xf8, 0xb0, 0x1a, 0xbe, 0xe2, 0x02, 0x1a, 0x09, 0x49, 0xde, 0x27, 0xf5, 0x5c, 0x86, 0xcf, 0x22,
-	0x18, 0x7a, 0x8d, 0xd4, 0xf1, 0x8b, 0x28, 0x57, 0xd1, 0xad, 0x8a, 0x76, 0x60, 0xd2, 0x3d, 0xc3,
-	0xd3, 0x0f, 0xf4, 0x1d, 0x8b, 0x68, 0xfe, 0x9e, 0xee, 0x11, 0x3f, 0x97, 0x9d, 0x97, 0x96, 0x86,
-	0xd4, 0xa7, 0xd9, 0xfc, 0x5b, 0x91, 0xe9, 0x37, 0xf8, 0xac, 0xfc, 0x20, 0x83, 0x2e, 0xa6, 0xa0,
-	0x03, 0xd3, 0x75, 0x94, 0x4b, 0xf2, 0x3a, 0x90, 0x21, 0xc7, 0xc8, 0x10, 0x7e, 0x8d, 0x73, 0x23,
-	0xa9, 0xd3, 0x96, 0x68, 0x12, 0x7f, 0x45, 0x42, 0x93, 0x22, 0x13, 0xb8, 0xc1, 0x25, 0x95, 0xa9,
-	0xfe, 0xa9, 0x51, 0x98, 0x0e, 0xb6, 0x91, 0x6f, 0xec, 0x17, 0x4d, 0x47, 0xa9, 0xea, 0x74, 0xaf,
-	0x58, 0xb6, 0xe9, 0xe3, 0x46, 0x41, 0xa4, 0x7b, 0xd4, 0x28, 0xe4, 0xeb, 0x7a, 0xd5, 0xba, 0x26,
-	0x0b, 0x26, 0x65, 0x15, 0x1f, 0x74, 0x52, 0x62, 0x83, 0xbf, 0xd6, 0x2d, 0xab, 0xab, 0xbf, 0x5e,
-	0x45, 0xa8, 0xb5, 0xc5, 0x81, 0x82, 0x4b, 0xc5, 0x00, 0x5c, 0x91, 0xed, 0xf1, 0x62, 0x90, 0x35,
-	0x60, 0xa7, 0x17, 0xb7, 0xf4, 0x5d, 0x02, 0xba, 0x6a, 0x44, 0x53, 0xfe, 0x58, 0x02, 0x17, 0x24,
-	0x2f, 0xd8, 0x93, 0x0b, 0xb2, 0xfd, 0x70, 0xc1, 0x66, 0xcc, 0xa8, 0x0c, 0x37, 0x6a, 0x31, 0xd5,
-	0xa8, 0x00, 0x5f, 0xcc, 0xaa, 0x6f, 0x4b, 0x68, 0x3e, 0x31, 0xb0, 0x42, 0x0a, 0xcf, 0xa1, 0xd3,
-	0xae, 0x6e, 0x7a, 0x9a, 0x69, 0x40, 0xc8, 0x0f, 0xb2, 0xd7, 0xb2, 0x81, 0x2f, 0x20, 0xc4, 0xb7,
-	0xb0, 0x69, 0x1b, 0xe4, 0x90, 0xc3, 0xc8, 0xaa, 0xc3, 0x6c, 0xa4, 0xcc, 0x06, 0xf0, 0x79, 0x34,
-	0x44, 0x9d, 0x7d, 0x62, 0x6b, 0xa6, 0xcd, 0xe3, 0x7b, 0x58, 0x3d, 0xcd, 0xdf, 0xcb, 0x76, 0xfb,
-	0x5e, 0x19, 0x68, 0xdf, 0x2b, 0x72, 0x1d, 0x2d, 0x74, 0xc1, 0x05, 0x4c, 0x6f, 0xa3, 0x49, 0x01,
-	0xd3, 0xe0, 0xe4, 0xb9, 0xee, 0x24, 0x03, 0xc1, 0x13, 0x1d, 0x04, 0xcb, 0x1f, 0x84, 0x9c, 0x88,
-	0x3c, 0x9d, 0xca, 0x49, 0xd4, 0xe8, 0x4c, 0xdc, 0xe8, 0x78, 0x28, 0x66, 0x4f, 0x1c, 0x8a, 0xbf,
-	0x96, 0x80, 0x1c, 0x31, 0xc0, 0x34, 0x72, 0xb2, 0x4f, 0x40, 0x4e, 0xff, 0x22, 0xef, 0xc7, 0x12,
-	0x9a, 0x09, 0x8d, 0x60, 0x31, 0xbd, 0x11, 0x1c, 0x7a, 0x7e, 0x7a, 0x9e, 0x7d, 0x55, 0x00, 0xe1,
-	0x04, 0x34, 0xe2, 0x65, 0x34, 0x61, 0xda, 0x15, 0xab, 0x66, 0x10, 0x8d, 0x9f, 0x54, 0xec, 0x18,
-	0x83, 0x3c, 0x3c, 0x06, 0x13, 0x5b, 0x8e, 0x63, 0x6d, 0xe8, 0x54, 0x97, 0x7f, 0x24, 0xa1, 0x59,
-	0x31, 0x5a, 0x60, 0xfb, 0xd3, 0x68, 0x08, 0x8e, 0x6d, 0x1f, 0x28, 0xce, 0xc7, 0x28, 0x06, 0x05,
-	0x95, 0x1f, 0xe9, 0x40, 0x6f, 0x53, 0xa3, 0x7f, 0xac, 0x7e, 0x5d, 0x42, 0x2b, 0x5d, 0xb3, 0x54,
-	0xa9, 0xbe, 0x1e, 0xd0, 0xf8, 0x3f, 0xe3, 0x59, 0xfe, 0xad, 0x84, 0x8a, 0xbd, 0x62, 0x02, 0x36,
-	0x5f, 0x43, 0xa3, 0x91, 0xd8, 0xf5, 0x8f, 0x9d, 0x36, 0x47, 0x5a, 0x81, 0xdb, 0x47, 0x72, 0xbf,
-	0x17, 0x09, 0x82, 0x6d, 0xb3, 0xb2, 0xff, 0x7a, 0x78, 0x73, 0xf9, 0x24, 0x24, 0x85, 0x9f, 0x4b,
-	0xe8, 0x42, 0x02, 0x38, 0x20, 0x75, 0x13, 0x9d, 0x8d, 0x5f, 0xb8, 0x84, 0x81, 0x1a, 0xd3, 0x05,
-	0x3a, 0xcf, 0xd0, 0xe8, 0x60, 0xff, 0x08, 0xfd, 0x40, 0x42, 0x4b, 0x61, 0x96, 0x2f, 0xdb, 0x7a,
-	0x85, 0x9a, 0x77, 0x49, 0x5f, 0x33, 0x6e, 0xfc, 0x80, 0xca, 0xb6, 0x1f, 0x50, 0xa9, 0xa7, 0xd0,
-	0x37, 0x24, 0x74, 0xb9, 0x07, 0x80, 0x40, 0x30, 0x41, 0xb3, 0x26, 0x08, 0x69, 0x4f, 0x7a, 0x2e,
-	0x9d, 0x37, 0x93, 0x96, 0x93, 0x3d, 0x20, 0x6d, 0xdd, 0xb2, 0x52, 0x49, 0xeb, 0xd7, 0xed, 0xe7,
-	0xcf, 0x21, 0x11, 0xdd, 0x17, 0xed, 0x99, 0x88, 0x6c, 0x1f, 0x88, 0xe8, 0x5f, 0x1c, 0x7e, 0x37,
-	0x72, 0x16, 0xb1, 0x94, 0xaf, 0x42, 0xcd, 0xf2, 0x49, 0xd8, 0xd7, 0x3f, 0x89, 0x24, 0x9d, 0x38,
-	0x36, 0x20, 0x7b, 0x03, 0x9d, 0x89, 0x15, 0x5a, 0xc0, 0xee, 0xf9, 0x78, 0xcd, 0x13, 0xd1, 0x04,
-	0x62, 0x47, 0xdd, 0xc8, 0x58, 0xff, 0xb8, 0x7c, 0x2f, 0xe4, 0x72, 0x93, 0xd0, 0x7e, 0x71, 0x99,
-	0xb2, 0x8d, 0xc7, 0x51, 0xf6, 0x36, 0x21, 0x7c, 0xfb, 0x0e, 0xa8, 0xec, 0x51, 0x36, 0x80, 0xb3,
-	0x0e, 0x0c, 0xc9, 0x9c, 0x49, 0xc7, 0xe6, 0x4c, 0xfe, 0x57, 0x06, 0x2e, 0x8a, 0xaf, 0xf8, 0xd4,
-	0xac, 0xea, 0x94, 0xdc, 0xa8, 0x59, 0xd4, 0xbc, 0xee, 0xb8, 0x6f, 0x1c, 0xe8, 0x6e, 0x68, 0xef,
-	0x1a, 0x1a, 0xf4, 0x9c, 0x1a, 0x25, 0xe2, 0x6b, 0x41, 0xa8, 0xa1, 0x32, 0x11, 0x15, 0x24, 0xf1,
-	0x97, 0xd1, 0xb0, 0x5e, 0x75, 0x6a, 0x36, 0x6d, 0x72, 0x51, 0xfa, 0x0c, 0xab, 0x56, 0xbb, 0x95,
-	0x55, 0x2d, 0x8d, 0xa3, 0x46, 0x61, 0x3c, 0x28, 0xa6, 0x9a, 0x43, 0xb2, 0x3a, 0x14, 0x3c, 0x97,
-	0x6d, 0xfc, 0x2d, 0x09, 0x8d, 0x93, 0x43, 0x93, 0xc2, 0xce, 0x74, 0x3d, 0xb3, 0x42, 0x82, 0xeb,
-	0x79, 0x69, 0x1f, 0x16, 0x79, 0x6e, 0xd7, 0xa4, 0x7b, 0xb5, 0x9d, 0x62, 0xc5, 0xa9, 0x2a, 0x80,
-	0x76, 0xc5, 0xf1, 0x76, 0xc3, 0x67, 0xe5, 0xee, 0x73, 0x4a, 0x8d, 0x9a, 0x96, 0x1f, 0xac, 0xbf,
-	0xe5, 0x91, 0xca, 0x06, 0xa9, 0x3c, 0x6e, 0x14, 0x3a, 0xbe, 0x7b, 0xd4, 0x28, 0x9c, 0x0b, 0xa0,
-	0xb4, 0xcf, 0xc8, 0xea, 0x59, 0x36, 0xc4, 0x37, 0xf5, 0x16, 0x1b, 0xc0, 0x97, 0xd0, 0x98, 0xcb,
-	0x9c, 0xbc, 0x43, 0x7c, 0xaa, 0x71, 0x22, 0xb8, 0x47, 0x87, 0xd4, 0x33, 0x6c, 0xb8, 0xc4, 0xf6,
-	0x05, 0x1b, 0x64, 0x25, 0xcb, 0x42, 0x17, 0xd6, 0xc1, 0xc3, 0x77, 0xd0, 0x50, 0xc5, 0x31, 0x6d,
-	0xcd, 0xa9, 0xd1, 0xa6, 0x73, 0xa3, 0xd1, 0x1c, 0xc6, 0xf1, 0xe7, 0x1d, 0xd3, 0x2e, 0xbd, 0x04,
-	0x76, 0x2f, 0x46, 0xec, 0x86, 0x2e, 0x50, 0xf0, 0x67, 0xc5, 0x37, 0xf6, 0x15, 0x5a, 0x77, 0x89,
-	0xcf, 0x15, 0x1e, 0x37, 0x0a, 0xcd, 0xaf, 0xab, 0xa7, 0xd9, 0xd3, 0xcd, 0x1a, 0x95, 0xff, 0x9e,
-	0x45, 0xcf, 0xc4, 0x80, 0x6d, 0x59, 0x7a, 0x25, 0x92, 0xb6, 0xc2, 0x88, 0x88, 0x06, 0xba, 0x14,
-	0x0f, 0xf4, 0x19, 0x34, 0x1c, 0x4c, 0x31, 0xd8, 0xc1, 0x26, 0x08, 0x64, 0x6f, 0xd6, 0x28, 0x2e,
-	0xa2, 0xa9, 0xd6, 0x2e, 0xd0, 0x4c, 0x5b, 0xa3, 0x0e, 0x97, 0x0b, 0xf6, 0xc3, 0x78, 0x73, 0x3f,
-	0x94, 0xed, 0x6d, 0x87, 0xc9, 0xc7, 0xa2, 0x68, 0xa0, 0xcf, 0x51, 0x74, 0x0d, 0x21, 0xc8, 0xe9,
-	0x75, 0x97, 0xe4, 0x9e, 0x9a, 0x97, 0x96, 0xce, 0xae, 0xcd, 0x24, 0x25, 0xf4, 0xba, 0x4b, 0xd4,
-	0x61, 0x27, 0x7c, 0xc4, 0x37, 0xd0, 0x18, 0x39, 0x74, 0x4d, 0x8f, 0x27, 0x0c, 0x8d, 0x9a, 0x55,
-	0x92, 0x1b, 0xe6, 0x2e, 0xca, 0x17, 0x83, 0x3e, 0x59, 0x31, 0xec, 0x93, 0x15, 0xb7, 0xc3, 0x3e,
-	0x59, 0x69, 0x88, 0x6d, 0xc0, 0x07, 0x7f, 0x29, 0x48, 0x2c, 0x70, 0x42, 0x65, 0x36, 0x8d, 0x6d,
-	0x74, 0xb6, 0xaa, 0x1f, 0x6a, 0x00, 0x93, 0x31, 0x32, 0xc8, 0x8d, 0xbd, 0x9e, 0xd6, 0x89, 0x68,
-	0x53, 0x3b, 0x6a, 0x14, 0xa6, 0x03, 0x8b, 0xe3, 0xe3, 0xb2, 0x3a, 0x5a, 0xd5, 0x0f, 0xd7, 0xf9,
-	0x3b, 0xf3, 0xf3, 0x3f, 0xb3, 0xd0, 0x7a, 0x48, 0xf4, 0x33, 0xc4, 0xe0, 0x77, 0x24, 0x74, 0x86,
-	0x3a, 0x54, 0xb7, 0x98, 0xb3, 0x58, 0x94, 0xa4, 0x47, 0xe2, 0xdb, 0xc7, 0x8f, 0xc4, 0xf8, 0x12,
-	0x47, 0x8d, 0xc2, 0x54, 0x60, 0x44, 0x6c, 0x58, 0x56, 0x47, 0xf8, 0x7b, 0xd9, 0x66, 0x5a, 0xf8,
-	0x7d, 0x09, 0x8d, 0xfa, 0x07, 0xba, 0xdb, 0x04, 0x96, 0x49, 0x03, 0xf6, 0xe6, 0xf1, 0x81, 0xc5,
-	0x56, 0x38, 0x6a, 0x14, 0x26, 0x03, 0x5c, 0xd1, 0x51, 0x59, 0x45, 0xec, 0x15, 0x50, 0x31, 0xbe,
-	0xf8, 0xac, 0x53, 0xa3, 0x01, 0xac, 0xec, 0x7f, 0x83, 0xaf, 0xd8, 0x12, 0x2d, 0xbe, 0x62, 0xc3,
-	0xb2, 0x3a, 0xc2, 0xde, 0x6f, 0xd6, 0x28, 0xd3, 0x92, 0xdf, 0x45, 0xe3, 0x41, 0x9f, 0x91, 0xa7,
-	0xff, 0x27, 0xeb, 0x8a, 0xc0, 0x69, 0x95, 0x6d, 0x9d, 0x56, 0x0a, 0x9a, 0x6a, 0x7e, 0xbd, 0x54,
-	0x2f, 0x6f, 0x44, 0x57, 0x60, 0xa7, 0x14, 0xac, 0x30, 0xa0, 0x0e, 0xb2, 0xd7, 0xb2, 0x21, 0x7f,
-	0x0e, 0x4d, 0x44, 0xe0, 0x40, 0xb4, 0xfd, 0x1f, 0x1a, 0x60, 0xd3, 0x10, 0x63, 0x13, 0x1d, 0x47,
-	0x19, 0x1c, 0x61, 0x5c, 0x48, 0x5e, 0x89, 0x1f, 0xd2, 0x37, 0xa0, 0x8b, 0x1b, 0xae, 0x7c, 0x16,
-	0x65, 0x9a, 0x8b, 0x66, 0x4c, 0xa3, 0xfd, 0x3c, 0x6d, 0x89, 0xb7, 0xce, 0xd3, 0xad, 0x68, 0x37,
-	0x38, 0xf1, 0x3c, 0x0d, 0x35, 0xa1, 0xfb, 0x3a, 0x1a, 0x1d, 0x93, 0x49, 0xfc, 0x16, 0xd6, 0x0e,
-	0xaa, 0x5f, 0x77, 0xd9, 0xf6, 0x1b, 0x95, 0xc8, 0x1a, 0xb7, 0xcd, 0x9a, 0x6c, 0x4f, 0xd6, 0xb8,
-	0x91, 0xb1, 0xbe, 0xdd, 0xa8, 0xd6, 0xfe, 0x9d, 0x43, 0x4f, 0x71, 0xbc, 0x78, 0x0f, 0x0d, 0x06,
-	0xcd, 0x6b, 0x5c, 0x88, 0x61, 0xe9, 0xec, 0x8c, 0xe7, 0xe7, 0x93, 0x05, 0x82, 0x25, 0xe4, 0x99,
-	0xf7, 0x3e, 0xfe, 0xdb, 0xfb, 0x99, 0x69, 0x3c, 0xa9, 0x74, 0xfe, 0x0c, 0x80, 0x7f, 0x23, 0xa1,
-	0x69, 0x61, 0x81, 0x8d, 0x57, 0x3b, 0x3f, 0x9c, 0xd2, 0x32, 0xcf, 0xaf, 0x1d, 0x47, 0x05, 0xd0,
-	0xbd, 0xc2, 0xd1, 0x7d, 0x16, 0xbf, 0xac, 0xf4, 0xf2, 0x83, 0x86, 0x72, 0x0f, 0x9a, 0x16, 0xf7,
-	0x95, 0x7b, 0x91, 0x8a, 0xee, 0x3e, 0xfe, 0x99, 0x84, 0x72, 0xc2, 0x85, 0xd6, 0x2d, 0x4b, 0x64,
-	0x4a, 0x4a, 0x37, 0x59, 0x64, 0x4a, 0x5a, 0x3f, 0x58, 0x5e, 0xe1, 0xa6, 0x2c, 0xe2, 0x8b, 0x3d,
-	0x99, 0x82, 0xff, 0x20, 0xa1, 0x85, 0x24, 0xc8, 0xcd, 0x4e, 0x09, 0xbe, 0xd6, 0x3b, 0x90, 0xf6,
-	0x96, 0x4f, 0xfe, 0xa5, 0x13, 0xe9, 0x82, 0x35, 0x57, 0xb8, 0x35, 0xcb, 0x78, 0x29, 0x66, 0x0d,
-	0x77, 0x42, 0xb4, 0x65, 0xd3, 0xf2, 0x08, 0xfe, 0xbd, 0x84, 0x26, 0x3a, 0x8b, 0xb7, 0x95, 0xde,
-	0x82, 0x22, 0xc4, 0x5c, 0xec, 0x55, 0x1c, 0x60, 0xbe, 0xcd, 0x61, 0xaa, 0x78, 0x2b, 0x8d, 0x74,
-	0xe5, 0x1e, 0x64, 0x71, 0x16, 0x3a, 0x70, 0x2d, 0x63, 0x8f, 0xcd, 0x0c, 0xde, 0x1e, 0x52, 0xbf,
-	0x90, 0xd0, 0x54, 0xc7, 0xba, 0x2c, 0x9c, 0x56, 0x7a, 0xa3, 0xb5, 0x8b, 0x45, 0xdd, 0xfa, 0xb9,
-	0xf2, 0xcb, 0xdc, 0xa2, 0x17, 0xf0, 0xd5, 0x13, 0x59, 0x84, 0xbf, 0x29, 0xa1, 0xb1, 0x68, 0xe7,
-	0x92, 0x21, 0x5e, 0x12, 0x42, 0x10, 0x74, 0x63, 0xf3, 0x97, 0x7b, 0x90, 0x04, 0x9c, 0xff, 0xcf,
-	0x71, 0x5e, 0xc2, 0xcf, 0x76, 0x06, 0x48, 0xd8, 0xef, 0x8c, 0x04, 0xc7, 0x0f, 0x25, 0x34, 0x1e,
-	0x6b, 0x39, 0x31, 0x5c, 0xe2, 0xd5, 0x44, 0x2d, 0xb7, 0xfc, 0x72, 0x2f, 0xa2, 0x80, 0xec, 0x45,
-	0x8e, 0x6c, 0x0d, 0x5f, 0x51, 0x92, 0x7f, 0x84, 0x14, 0x93, 0xf7, 0xbb, 0x0c, 0x3a, 0x9f, 0xd8,
-	0xf6, 0xc0, 0x57, 0x85, 0xb1, 0x99, 0xd6, 0x9b, 0xc9, 0x3f, 0x7f, 0x5c, 0x35, 0x30, 0xe3, 0x57,
-	0x12, 0xb7, 0xe3, 0x97, 0xd2, 0xad, 0x77, 0xf0, 0x5b, 0x31, 0x53, 0x6e, 0x9b, 0x96, 0x45, 0x0c,
-	0xad, 0x1f, 0x51, 0xfe, 0x4e, 0xec, 0xc3, 0xdd, 0xba, 0x39, 0xc7, 0xfe, 0xf4, 0x3f, 0x24, 0x34,
-	0x9b, 0x68, 0x25, 0x73, 0xff, 0x55, 0xa1, 0x4f, 0x4f, 0xc2, 0x67, 0x2f, 0xdd, 0x2a, 0xf9, 0x5d,
-	0x4e, 0xe7, 0x9b, 0xb7, 0x2e, 0xe3, 0xc5, 0x1e, 0xd9, 0xc4, 0x97, 0x7b, 0x66, 0x07, 0xff, 0x40,
-	0x42, 0x63, 0xd1, 0x4e, 0x42, 0xf2, 0xbe, 0x13, 0x74, 0x4b, 0x12, 0xf6, 0x9d, 0xa8, 0xa7, 0x21,
-	0xbf, 0xc0, 0xcd, 0x58, 0xc5, 0x8a, 0x92, 0xf8, 0x1b, 0xbc, 0x38, 0xb8, 0x7f, 0x2a, 0xa1, 0xd1,
-	0xe8, 0x17, 0x45, 0xf0, 0xc4, 0xcd, 0x1c, 0x11, 0xbc, 0x84, 0x96, 0x8b, 0xfc, 0x05, 0x0e, 0x6f,
-	0x03, 0x97, 0x8e, 0x09, 0xaf, 0x2d, 0x92, 0x6e, 0x13, 0xc2, 0x93, 0xc6, 0x94, 0xa8, 0xfa, 0x17,
-	0xa5, 0xe0, 0x2e, 0xbd, 0x19, 0x51, 0x0a, 0xee, 0xd6, 0x54, 0x48, 0x48, 0x6d, 0x04, 0x54, 0xb4,
-	0x2a, 0xd3, 0xd1, 0xf6, 0x1c, 0x57, 0x63, 0xb5, 0x03, 0xe3, 0xf5, 0x5c, 0x42, 0x89, 0x88, 0xaf,
-	0x24, 0xaf, 0x2c, 0xee, 0x1a, 0xe4, 0x57, 0x8f, 0xa1, 0x01, 0x70, 0x15, 0x0e, 0xb7, 0x3d, 0xac,
-	0x9b, 0x70, 0x5d, 0xa6, 0x16, 0x8d, 0x59, 0x7c, 0x1f, 0x0d, 0x30, 0xdf, 0xe1, 0x0b, 0x82, 0xcb,
-	0x63, 0xab, 0xf2, 0xc9, 0xcf, 0x25, 0x4d, 0xc3, 0xba, 0xcf, 0xf3, 0x75, 0xaf, 0xe0, 0x62, 0x87,
-	0xab, 0x63, 0x1e, 0xee, 0x70, 0xab, 0x87, 0x86, 0xc2, 0x12, 0x08, 0x2f, 0x88, 0xd7, 0x88, 0x94,
-	0x47, 0xa9, 0x30, 0x9e, 0xe1, 0x30, 0x2e, 0xe0, 0x19, 0x11, 0x8c, 0xa0, 0xae, 0xba, 0x8f, 0xbf,
-	0x06, 0xc1, 0xdf, 0xbc, 0xb6, 0x27, 0x07, 0x7f, 0x5b, 0x3d, 0xd2, 0x25, 0xf8, 0xdb, 0x2b, 0x0a,
-	0x79, 0x91, 0x43, 0x59, 0xc0, 0x05, 0x25, 0xf1, 0x1f, 0x68, 0x94, 0x7b, 0x0c, 0xce, 0x57, 0x21,
-	0x5b, 0x84, 0x5f, 0xe8, 0x9e, 0x2d, 0x7a, 0x40, 0x94, 0x50, 0xe3, 0xc8, 0x32, 0x47, 0x34, 0x8b,
-	0xf3, 0xc9, 0x88, 0x4a, 0x9b, 0x1f, 0x3e, 0x9c, 0x93, 0x3e, 0x7a, 0x38, 0x27, 0xfd, 0xf5, 0xe1,
-	0x9c, 0xf4, 0xe0, 0xd1, 0xdc, 0xa9, 0x8f, 0x1e, 0xcd, 0x9d, 0xfa, 0xe3, 0xa3, 0xb9, 0x53, 0xb7,
-	0x56, 0xd2, 0x1b, 0x84, 0x87, 0xc1, 0xe1, 0xca, 0x2a, 0xef, 0x9d, 0x41, 0xde, 0xcf, 0xf9, 0xd4,
-	0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x90, 0x59, 0x64, 0x4a, 0xad, 0x25, 0x00, 0x00,
+	0x15, 0x4e, 0xcf, 0x38, 0x8e, 0x5d, 0x76, 0x12, 0xbb, 0x6c, 0x6f, 0x26, 0x63, 0xc7, 0x63, 0xf7,
+	0x6e, 0x62, 0xc7, 0xe0, 0xe9, 0xd8, 0x6c, 0x76, 0x57, 0x59, 0x16, 0xf0, 0xe0, 0x5d, 0x67, 0xd8,
+	0x8d, 0x62, 0x7a, 0xcd, 0xfe, 0x84, 0x95, 0x5a, 0xed, 0xe9, 0x8a, 0xdd, 0x72, 0x4f, 0x77, 0xa7,
+	0xbb, 0x26, 0xf6, 0x28, 0xca, 0x65, 0xb9, 0x21, 0x0e, 0x81, 0xe5, 0x47, 0x80, 0xb4, 0x1c, 0x10,
+	0x27, 0x84, 0x00, 0x09, 0x71, 0xe3, 0x82, 0x04, 0x5a, 0x21, 0x84, 0x56, 0xda, 0x0b, 0x02, 0x69,
+	0x40, 0x09, 0x5c, 0xc2, 0x05, 0x19, 0x89, 0x33, 0xaa, 0xea, 0xd7, 0x33, 0xdd, 0x33, 0xd5, 0xd3,
+	0x63, 0x67, 0x58, 0xed, 0xc9, 0xdd, 0x55, 0xef, 0x75, 0x7d, 0xef, 0x7b, 0xaf, 0x5e, 0xd5, 0x7b,
+	0x63, 0x74, 0xce, 0x26, 0x35, 0xea, 0x39, 0xb6, 0x62, 0x90, 0x03, 0xe5, 0x4e, 0x8d, 0x78, 0xf5,
+	0xa2, 0xeb, 0x39, 0xd4, 0xc1, 0x23, 0x30, 0x51, 0x34, 0xc8, 0x41, 0x7e, 0xa9, 0xe2, 0xf8, 0x55,
+	0xc7, 0x57, 0xb6, 0x75, 0x9f, 0x04, 0x52, 0xca, 0xdd, 0x95, 0x6d, 0x42, 0xf5, 0x15, 0xc5, 0xd5,
+	0x77, 0x4c, 0x5b, 0xa7, 0xa6, 0x63, 0x07, 0x8a, 0xf9, 0xd9, 0xa8, 0x6c, 0x28, 0x55, 0x71, 0xcc,
+	0x70, 0x7e, 0x72, 0xc7, 0xd9, 0x71, 0xf8, 0xa3, 0xc2, 0x9e, 0x60, 0x74, 0x66, 0xc7, 0x71, 0x76,
+	0x2c, 0xa2, 0xe8, 0xae, 0xa9, 0xe8, 0xb6, 0xed, 0x50, 0xfe, 0x49, 0x1f, 0x66, 0x0b, 0x30, 0xcb,
+	0xdf, 0xb6, 0x6b, 0xb7, 0x15, 0x6a, 0x56, 0x89, 0x4f, 0xf5, 0xaa, 0x0b, 0x02, 0x73, 0x51, 0x33,
+	0x0c, 0xe2, 0x3a, 0xbe, 0x49, 0x35, 0x8f, 0x54, 0x1c, 0xcf, 0x00, 0x89, 0x8b, 0x51, 0x09, 0xcb,
+	0xac, 0x9a, 0x54, 0x73, 0x3c, 0x83, 0x78, 0x1a, 0xf5, 0x74, 0xbb, 0xb2, 0x4b, 0x40, 0x6c, 0x29,
+	0x45, 0x4c, 0xab, 0xf9, 0xc4, 0x03, 0xd9, 0x5c, 0x54, 0xd6, 0xd5, 0x3d, 0xbd, 0x1a, 0xe2, 0x7d,
+	0x2a, 0x36, 0xe3, 0x38, 0x56, 0x68, 0x47, 0xfb, 0xb8, 0x56, 0x25, 0x54, 0x37, 0x74, 0xaa, 0x27,
+	0x0a, 0x78, 0xc4, 0x27, 0xde, 0x5d, 0xe2, 0x8b, 0x0c, 0xa5, 0x66, 0x65, 0x4f, 0xb3, 0xcc, 0x3b,
+	0x35, 0xd3, 0x30, 0x69, 0x3d, 0xe4, 0x37, 0x26, 0x71, 0x10, 0x8c, 0xca, 0x93, 0x08, 0x7f, 0x99,
+	0xf9, 0x6d, 0x93, 0xc3, 0x54, 0xc9, 0x9d, 0x1a, 0xf1, 0xa9, 0x7c, 0x1d, 0x4d, 0xc4, 0x46, 0x7d,
+	0xd7, 0xb1, 0x7d, 0x82, 0x57, 0xd0, 0x60, 0x60, 0x4e, 0x4e, 0x9a, 0x93, 0x16, 0x47, 0x56, 0x27,
+	0x8a, 0x91, 0x60, 0x28, 0x06, 0xc2, 0xa5, 0x81, 0x0f, 0x1a, 0x85, 0x13, 0x2a, 0x08, 0xca, 0x3f,
+	0x94, 0xd0, 0x33, 0xfc, 0x53, 0x1b, 0x84, 0xbe, 0xc6, 0x68, 0xbb, 0xc9, 0x58, 0xdb, 0x0a, 0x48,
+	0xfb, 0x8a, 0x4f, 0x3c, 0x58, 0x12, 0xe7, 0xd0, 0x29, 0xdd, 0x30, 0x3c, 0xe2, 0x07, 0x1f, 0x1f,
+	0x56, 0xc3, 0x57, 0x5c, 0x40, 0x23, 0x21, 0xc9, 0x7b, 0xa4, 0x9e, 0xcb, 0xf0, 0x59, 0x04, 0x43,
+	0xaf, 0x92, 0x3a, 0x7e, 0x01, 0xe5, 0x2a, 0xba, 0x55, 0xd1, 0xf6, 0x4d, 0xba, 0x6b, 0x78, 0xfa,
+	0xbe, 0xbe, 0x6d, 0x11, 0xcd, 0xdf, 0xd5, 0x3d, 0xe2, 0xe7, 0xb2, 0x73, 0xd2, 0xe2, 0x90, 0xfa,
+	0x14, 0x9b, 0x7f, 0x33, 0x32, 0xfd, 0x3a, 0x9f, 0x95, 0x1f, 0x64, 0xd0, 0xc5, 0x14, 0x74, 0x60,
+	0xba, 0x8e, 0x72, 0x49, 0x5e, 0x07, 0x32, 0xe4, 0x18, 0x19, 0xc2, 0xaf, 0x71, 0x6e, 0x24, 0x75,
+	0xca, 0x12, 0x4d, 0xe2, 0xaf, 0x49, 0x68, 0x42, 0x64, 0x02, 0x37, 0xb8, 0xa4, 0x32, 0xd5, 0xbf,
+	0x34, 0x0a, 0x53, 0xc1, 0x36, 0xf2, 0x8d, 0xbd, 0xa2, 0xe9, 0x28, 0x55, 0x9d, 0xee, 0x16, 0xcb,
+	0x36, 0x7d, 0xdc, 0x28, 0x88, 0x74, 0x0f, 0x1b, 0x85, 0x7c, 0x5d, 0xaf, 0x5a, 0xd7, 0x64, 0xc1,
+	0xa4, 0xac, 0xe2, 0xfd, 0x4e, 0x4a, 0x6c, 0xf0, 0xd7, 0x9a, 0x65, 0x75, 0xf5, 0xd7, 0x2b, 0x08,
+	0xb5, 0xb6, 0x38, 0x50, 0x70, 0xa9, 0x18, 0x80, 0x2b, 0xb2, 0x3d, 0x5e, 0x0c, 0xb2, 0x06, 0xec,
+	0xf4, 0xe2, 0xa6, 0xbe, 0x43, 0x40, 0x57, 0x8d, 0x68, 0xca, 0x1f, 0x49, 0xe0, 0x82, 0xe4, 0x05,
+	0x7b, 0x72, 0x41, 0xb6, 0x1f, 0x2e, 0xd8, 0x88, 0x19, 0x95, 0xe1, 0x46, 0x2d, 0xa4, 0x1a, 0x15,
+	0xe0, 0x8b, 0x59, 0xf5, 0x5d, 0x09, 0xcd, 0x25, 0x06, 0x56, 0x48, 0xe1, 0x39, 0x74, 0xca, 0xd5,
+	0x4d, 0x4f, 0x33, 0x0d, 0x08, 0xf9, 0x41, 0xf6, 0x5a, 0x36, 0xf0, 0x05, 0x84, 0xf8, 0x16, 0x36,
+	0x6d, 0x83, 0x1c, 0x70, 0x18, 0x59, 0x75, 0x98, 0x8d, 0x94, 0xd9, 0x00, 0x3e, 0x8f, 0x86, 0xa8,
+	0xb3, 0x47, 0x6c, 0xcd, 0xb4, 0x79, 0x7c, 0x0f, 0xab, 0xa7, 0xf8, 0x7b, 0xd9, 0x6e, 0xdf, 0x2b,
+	0x03, 0xed, 0x7b, 0x45, 0xae, 0xa3, 0xf9, 0x2e, 0xb8, 0x80, 0xe9, 0x2d, 0x34, 0x21, 0x60, 0x1a,
+	0x9c, 0x3c, 0xdb, 0x9d, 0x64, 0x20, 0x78, 0xbc, 0x83, 0x60, 0xf9, 0xfd, 0x90, 0x13, 0x91, 0xa7,
+	0x53, 0x39, 0x89, 0x1a, 0x9d, 0x89, 0x1b, 0x1d, 0x0f, 0xc5, 0xec, 0xb1, 0x43, 0xf1, 0xb7, 0x12,
+	0x90, 0x23, 0x06, 0x98, 0x46, 0x4e, 0xf6, 0x09, 0xc8, 0xe9, 0x5f, 0xe4, 0xfd, 0x54, 0x42, 0xd3,
+	0xa1, 0x11, 0x2c, 0xa6, 0xd7, 0x83, 0x43, 0xcf, 0x4f, 0xcf, 0xb3, 0xaf, 0x08, 0x20, 0x1c, 0x83,
+	0x46, 0xbc, 0x84, 0xc6, 0x4d, 0xbb, 0x62, 0xd5, 0x0c, 0xa2, 0xf1, 0x93, 0x8a, 0x1d, 0x63, 0x90,
+	0x87, 0xcf, 0xc2, 0xc4, 0xa6, 0xe3, 0x58, 0xeb, 0x3a, 0xd5, 0xe5, 0x9f, 0x48, 0x68, 0x46, 0x8c,
+	0x16, 0xd8, 0xfe, 0x2c, 0x1a, 0x82, 0x63, 0xdb, 0x07, 0x8a, 0xf3, 0x31, 0x8a, 0x41, 0x41, 0xe5,
+	0x47, 0x3a, 0xd0, 0xdb, 0xd4, 0xe8, 0x1f, 0xab, 0xdf, 0x94, 0xd0, 0x72, 0xd7, 0x2c, 0x55, 0xaa,
+	0xaf, 0x05, 0x34, 0x7e, 0x6c, 0x3c, 0xcb, 0xbf, 0x97, 0x50, 0xb1, 0x57, 0x4c, 0xc0, 0xe6, 0xab,
+	0x68, 0x34, 0x12, 0xbb, 0xfe, 0x91, 0xd3, 0xe6, 0x48, 0x2b, 0x70, 0xfb, 0x48, 0xee, 0x0f, 0x22,
+	0x41, 0xb0, 0x65, 0x56, 0xf6, 0x5e, 0x0b, 0x6f, 0x2e, 0x9f, 0x84, 0xa4, 0xf0, 0x4b, 0x09, 0x5d,
+	0x48, 0x00, 0x07, 0xa4, 0x6e, 0xa0, 0x33, 0xf1, 0x0b, 0x97, 0x30, 0x50, 0x63, 0xba, 0x40, 0xe7,
+	0x69, 0x1a, 0x1d, 0xec, 0x1f, 0xa1, 0xef, 0x4b, 0x68, 0x31, 0xcc, 0xf2, 0x65, 0x5b, 0xaf, 0x50,
+	0xf3, 0x2e, 0xe9, 0x6b, 0xc6, 0x8d, 0x1f, 0x50, 0xd9, 0xf6, 0x03, 0x2a, 0xf5, 0x14, 0xfa, 0x96,
+	0x84, 0x2e, 0xf7, 0x00, 0x10, 0x08, 0x26, 0x68, 0xc6, 0x04, 0x21, 0xed, 0x49, 0xcf, 0xa5, 0xf3,
+	0x66, 0xd2, 0x72, 0xb2, 0x07, 0xa4, 0xad, 0x59, 0x56, 0x2a, 0x69, 0xfd, 0xba, 0xfd, 0xfc, 0x35,
+	0x24, 0xa2, 0xfb, 0xa2, 0x3d, 0x13, 0x91, 0xed, 0x03, 0x11, 0xfd, 0x8b, 0xc3, 0xef, 0x47, 0xce,
+	0x22, 0x96, 0xf2, 0x55, 0xa8, 0x59, 0x3e, 0x09, 0xfb, 0xfa, 0x67, 0x91, 0xa4, 0x13, 0xc7, 0x06,
+	0x64, 0xaf, 0xa3, 0xd3, 0xb1, 0x42, 0x0b, 0xd8, 0x3d, 0x1f, 0xaf, 0x79, 0x22, 0x9a, 0x40, 0xec,
+	0xa8, 0x1b, 0x19, 0xeb, 0x1f, 0x97, 0xef, 0x86, 0x5c, 0x6e, 0x10, 0xda, 0x2f, 0x2e, 0x53, 0xb6,
+	0xf1, 0x18, 0xca, 0xde, 0x26, 0x84, 0x6f, 0xdf, 0x01, 0x95, 0x3d, 0xca, 0x06, 0x70, 0xd6, 0x81,
+	0x21, 0x99, 0x33, 0xe9, 0xc8, 0x9c, 0xc9, 0xff, 0xc9, 0xc0, 0x45, 0xf1, 0x65, 0x9f, 0x9a, 0x55,
+	0x9d, 0x92, 0x1b, 0x35, 0x8b, 0x9a, 0xd7, 0x1d, 0xf7, 0xf5, 0x7d, 0xdd, 0x0d, 0xed, 0x5d, 0x45,
+	0x83, 0x9e, 0x53, 0xa3, 0xbc, 0xc4, 0xeb, 0xcc, 0xb6, 0xa1, 0x86, 0xca, 0x44, 0x54, 0x90, 0xc4,
+	0x5f, 0x45, 0xc3, 0x7a, 0xd5, 0xa9, 0xd9, 0x94, 0x71, 0xc1, 0xb3, 0x52, 0xe9, 0x73, 0xac, 0x5a,
+	0xed, 0x56, 0x56, 0xb5, 0x34, 0x0e, 0x1b, 0x85, 0xb1, 0xa0, 0x98, 0x6a, 0x0e, 0xc9, 0xea, 0x50,
+	0xf0, 0x5c, 0xb6, 0xf1, 0x77, 0x24, 0x34, 0x46, 0x0e, 0x4c, 0x0a, 0x3b, 0xd3, 0xf5, 0xcc, 0x0a,
+	0xc9, 0x9d, 0xe4, 0x8b, 0xec, 0xc1, 0x22, 0xcf, 0xee, 0x98, 0x74, 0xb7, 0xb6, 0x5d, 0xac, 0x38,
+	0x55, 0x05, 0xd0, 0x2e, 0x3b, 0xde, 0x4e, 0xf8, 0xac, 0xdc, 0x7d, 0x56, 0xa9, 0x51, 0xd3, 0xf2,
+	0x83, 0xf5, 0x37, 0x3d, 0x52, 0x59, 0x27, 0x95, 0xc7, 0x8d, 0x42, 0xc7, 0x77, 0x0f, 0x1b, 0x85,
+	0x73, 0x01, 0x94, 0xf6, 0x19, 0x59, 0x3d, 0xc3, 0x86, 0xf8, 0xa6, 0xde, 0x64, 0x03, 0xf8, 0x12,
+	0x3a, 0xeb, 0x32, 0x27, 0x6f, 0x13, 0x9f, 0x6a, 0x9c, 0x88, 0xdc, 0x20, 0xbf, 0x8c, 0x9d, 0x66,
+	0xc3, 0x25, 0xb6, 0x2f, 0xd8, 0x20, 0x2b, 0x59, 0xe6, 0xbb, 0xb0, 0x0e, 0x1e, 0xbe, 0x83, 0x86,
+	0x2a, 0x8e, 0x69, 0x6b, 0x4e, 0x8d, 0x36, 0x9d, 0x1b, 0x8d, 0xe6, 0x30, 0x8e, 0xbf, 0xe8, 0x98,
+	0x76, 0xe9, 0x45, 0xb0, 0x7b, 0x21, 0x62, 0x37, 0x74, 0x81, 0x82, 0x3f, 0xcb, 0xbe, 0xb1, 0xa7,
+	0xd0, 0xba, 0x4b, 0x7c, 0xae, 0xf0, 0xb8, 0x51, 0x68, 0x7e, 0x5d, 0x3d, 0xc5, 0x9e, 0x6e, 0xd6,
+	0xa8, 0xfc, 0xcf, 0x2c, 0x7a, 0x3a, 0x06, 0x6c, 0xd3, 0xd2, 0x2b, 0x91, 0xb4, 0x15, 0x46, 0x44,
+	0x97, 0xb2, 0x68, 0x1a, 0x0d, 0x07, 0x53, 0x0c, 0x76, 0x70, 0x1c, 0x05, 0xb2, 0x37, 0x6b, 0x14,
+	0x17, 0xd1, 0x64, 0x6b, 0x17, 0x68, 0xa6, 0xad, 0x51, 0x87, 0xcb, 0x9d, 0xe4, 0xfb, 0x61, 0xac,
+	0xb9, 0x1f, 0xca, 0xf6, 0x96, 0xc3, 0xe4, 0x63, 0x51, 0x34, 0xd8, 0xe7, 0x28, 0xba, 0x86, 0x10,
+	0xe4, 0xf4, 0xba, 0x4b, 0x72, 0xa7, 0xe6, 0xa4, 0xc5, 0x33, 0xab, 0xd3, 0x49, 0x09, 0xbd, 0xee,
+	0x12, 0x75, 0xd8, 0x09, 0x1f, 0xf1, 0x0d, 0x74, 0x96, 0x1c, 0xb8, 0xa6, 0xc7, 0x13, 0x86, 0x46,
+	0xcd, 0x2a, 0xc9, 0x0d, 0x73, 0x17, 0xe5, 0x8b, 0x41, 0x9f, 0xac, 0x18, 0xf6, 0xc9, 0x8a, 0x5b,
+	0x61, 0x9f, 0xac, 0x34, 0xc4, 0x36, 0xe0, 0x83, 0xbf, 0x15, 0x24, 0x16, 0x38, 0xa1, 0x32, 0x9b,
+	0xc6, 0x36, 0x3a, 0x53, 0xd5, 0x0f, 0x34, 0x80, 0xc9, 0x18, 0x19, 0xe2, 0xc6, 0x5e, 0x4f, 0xeb,
+	0x44, 0xb4, 0xa9, 0x1d, 0x36, 0x0a, 0x53, 0x81, 0xc5, 0xf1, 0x71, 0x59, 0x1d, 0xad, 0xea, 0x07,
+	0x6b, 0xfc, 0x9d, 0xf9, 0xf9, 0xdf, 0x59, 0x68, 0x3d, 0x24, 0xfa, 0x19, 0x62, 0xf0, 0x7b, 0x12,
+	0x3a, 0x4d, 0x1d, 0xaa, 0x5b, 0xcc, 0x59, 0x2c, 0x4a, 0xd2, 0x23, 0xf1, 0xad, 0xa3, 0x47, 0x62,
+	0x7c, 0x89, 0xc3, 0x46, 0x61, 0x32, 0x30, 0x22, 0x36, 0x2c, 0xab, 0x23, 0xfc, 0xbd, 0x6c, 0x33,
+	0x2d, 0xfc, 0x9e, 0x84, 0x46, 0xfd, 0x7d, 0xdd, 0x6d, 0x02, 0xcb, 0xa4, 0x01, 0x7b, 0xe3, 0xe8,
+	0xc0, 0x62, 0x2b, 0x1c, 0x36, 0x0a, 0x13, 0x01, 0xae, 0xe8, 0xa8, 0xac, 0x22, 0xf6, 0x0a, 0xa8,
+	0x18, 0x5f, 0x7c, 0xd6, 0xa9, 0xd1, 0x00, 0x56, 0xf6, 0xff, 0xc1, 0x57, 0x6c, 0x89, 0x16, 0x5f,
+	0xb1, 0x61, 0x59, 0x1d, 0x61, 0xef, 0x37, 0x6b, 0x94, 0x69, 0xc9, 0xef, 0xa0, 0xb1, 0xa0, 0xcf,
+	0xc8, 0xd3, 0xff, 0x93, 0x75, 0x45, 0xe0, 0xb4, 0xca, 0xb6, 0x4e, 0x2b, 0x05, 0x4d, 0x36, 0xbf,
+	0x5e, 0xaa, 0x97, 0xd7, 0xa3, 0x2b, 0xb0, 0x53, 0x0a, 0x56, 0x18, 0x50, 0x07, 0xd9, 0x6b, 0xd9,
+	0x90, 0xbf, 0x80, 0xc6, 0x23, 0x70, 0x20, 0xda, 0x3e, 0x85, 0x06, 0xd8, 0x34, 0xc4, 0xd8, 0x78,
+	0xc7, 0x51, 0x06, 0x47, 0x18, 0x17, 0x92, 0x97, 0xe3, 0x87, 0xf4, 0x0d, 0xe8, 0xe2, 0x86, 0x2b,
+	0x9f, 0x41, 0x99, 0xe6, 0xa2, 0x19, 0xd3, 0x68, 0x3f, 0x4f, 0x5b, 0xe2, 0xad, 0xf3, 0x74, 0x33,
+	0xda, 0x0d, 0x4e, 0x3c, 0x4f, 0x43, 0x4d, 0xe8, 0xbe, 0x8e, 0x46, 0xc7, 0x64, 0x12, 0xbf, 0x85,
+	0xb5, 0x83, 0xea, 0xd7, 0x5d, 0xb6, 0xfd, 0x46, 0x25, 0xb2, 0xc6, 0x6d, 0xb3, 0x26, 0xdb, 0x93,
+	0x35, 0x6e, 0x64, 0xac, 0x6f, 0x37, 0xaa, 0xd5, 0xff, 0xe6, 0xd0, 0x49, 0x8e, 0x17, 0xef, 0xa2,
+	0xc1, 0xa0, 0x79, 0x8d, 0x0b, 0x31, 0x2c, 0x9d, 0x9d, 0xf1, 0xfc, 0x5c, 0xb2, 0x40, 0xb0, 0x84,
+	0x3c, 0xfd, 0xee, 0x47, 0xff, 0x78, 0x2f, 0x33, 0x85, 0x27, 0x94, 0xce, 0x9f, 0x01, 0xf0, 0xef,
+	0x24, 0x34, 0x25, 0x2c, 0xb0, 0xf1, 0x4a, 0xe7, 0x87, 0x53, 0x5a, 0xe6, 0xf9, 0xd5, 0xa3, 0xa8,
+	0x00, 0xba, 0x97, 0x39, 0xba, 0xcf, 0xe3, 0x97, 0x94, 0x5e, 0x7e, 0xd0, 0x50, 0xee, 0x41, 0xd3,
+	0xe2, 0xbe, 0x72, 0x2f, 0x52, 0xd1, 0xdd, 0xc7, 0xbf, 0x90, 0x50, 0x4e, 0xb8, 0xd0, 0x9a, 0x65,
+	0x89, 0x4c, 0x49, 0xe9, 0x26, 0x8b, 0x4c, 0x49, 0xeb, 0x07, 0xcb, 0xcb, 0xdc, 0x94, 0x05, 0x7c,
+	0xb1, 0x27, 0x53, 0xf0, 0x9f, 0x24, 0x34, 0x9f, 0x04, 0xb9, 0xd9, 0x29, 0xc1, 0xd7, 0x7a, 0x07,
+	0xd2, 0xde, 0xf2, 0xc9, 0xbf, 0x78, 0x2c, 0x5d, 0xb0, 0xe6, 0x0a, 0xb7, 0x66, 0x09, 0x2f, 0xc6,
+	0xac, 0xe1, 0x4e, 0x88, 0xb6, 0x6c, 0x5a, 0x1e, 0xc1, 0x7f, 0x94, 0xd0, 0x78, 0x67, 0xf1, 0xb6,
+	0xdc, 0x5b, 0x50, 0x84, 0x98, 0x8b, 0xbd, 0x8a, 0x03, 0xcc, 0xb7, 0x38, 0x4c, 0x15, 0x6f, 0xa6,
+	0x91, 0xae, 0xdc, 0x83, 0x2c, 0xce, 0x42, 0x07, 0xae, 0x65, 0xec, 0xb1, 0x99, 0xc1, 0xdb, 0x43,
+	0xea, 0x57, 0x12, 0x9a, 0xec, 0x58, 0x97, 0x85, 0xd3, 0x72, 0x6f, 0xb4, 0x76, 0xb1, 0xa8, 0x5b,
+	0x3f, 0x57, 0x7e, 0x89, 0x5b, 0xf4, 0x3c, 0xbe, 0x7a, 0x2c, 0x8b, 0xf0, 0xb7, 0x25, 0x74, 0x36,
+	0xda, 0xb9, 0x64, 0x88, 0x17, 0x85, 0x10, 0x04, 0xdd, 0xd8, 0xfc, 0xe5, 0x1e, 0x24, 0x01, 0xe7,
+	0xa7, 0x39, 0xce, 0x4b, 0xf8, 0x99, 0xce, 0x00, 0x09, 0xfb, 0x9d, 0x91, 0xe0, 0xf8, 0xb1, 0x84,
+	0xc6, 0x62, 0x2d, 0x27, 0x86, 0x4b, 0xbc, 0x9a, 0xa8, 0xe5, 0x96, 0x5f, 0xea, 0x45, 0x14, 0x90,
+	0xbd, 0xc0, 0x91, 0xad, 0xe2, 0x2b, 0x4a, 0xf2, 0x8f, 0x90, 0x62, 0xf2, 0xfe, 0x90, 0x41, 0xe7,
+	0x13, 0xdb, 0x1e, 0xf8, 0xaa, 0x30, 0x36, 0xd3, 0x7a, 0x33, 0xf9, 0xe7, 0x8e, 0xaa, 0x06, 0x66,
+	0xfc, 0x46, 0xe2, 0x76, 0xfc, 0x5a, 0xba, 0xf5, 0x36, 0x7e, 0x33, 0x66, 0xca, 0x6d, 0xd3, 0xb2,
+	0x88, 0xa1, 0xf5, 0x23, 0xca, 0xdf, 0x8e, 0x7d, 0xb8, 0x5b, 0x37, 0xe7, 0xc8, 0x9f, 0xfe, 0x97,
+	0x84, 0x66, 0x12, 0xad, 0x64, 0xee, 0xbf, 0x2a, 0xf4, 0xe9, 0x71, 0xf8, 0xec, 0xa5, 0x5b, 0x25,
+	0xbf, 0xc3, 0xe9, 0x7c, 0xe3, 0xd6, 0x65, 0xbc, 0xd0, 0x23, 0x9b, 0xf8, 0x72, 0xcf, 0xec, 0xe0,
+	0x1f, 0x49, 0xe8, 0x6c, 0xb4, 0x93, 0x90, 0xbc, 0xef, 0x04, 0xdd, 0x92, 0x84, 0x7d, 0x27, 0xea,
+	0x69, 0xc8, 0xcf, 0x73, 0x33, 0x56, 0xb0, 0xa2, 0x24, 0xfe, 0x06, 0x2f, 0x0e, 0xee, 0x9f, 0x4b,
+	0x68, 0x34, 0xfa, 0x45, 0x11, 0x3c, 0x71, 0x33, 0x47, 0x04, 0x2f, 0xa1, 0xe5, 0x22, 0x7f, 0x89,
+	0xc3, 0x5b, 0xc7, 0xa5, 0x23, 0xc2, 0x6b, 0x8b, 0xa4, 0xdb, 0x84, 0xf0, 0xa4, 0x31, 0x29, 0xaa,
+	0xfe, 0x45, 0x29, 0xb8, 0x4b, 0x6f, 0x46, 0x94, 0x82, 0xbb, 0x35, 0x15, 0x12, 0x52, 0x1b, 0x01,
+	0x15, 0xad, 0xca, 0x74, 0xb4, 0x5d, 0xc7, 0xd5, 0x58, 0xed, 0xc0, 0x78, 0x3d, 0x97, 0x50, 0x22,
+	0xe2, 0x2b, 0xc9, 0x2b, 0x8b, 0xbb, 0x06, 0xf9, 0x95, 0x23, 0x68, 0x00, 0x5c, 0x85, 0xc3, 0x6d,
+	0x0f, 0xeb, 0x26, 0x5c, 0x97, 0xa9, 0x45, 0x63, 0x16, 0xdf, 0x47, 0x03, 0xcc, 0x77, 0xf8, 0x82,
+	0xe0, 0xf2, 0xd8, 0xaa, 0x7c, 0xf2, 0xb3, 0x49, 0xd3, 0xb0, 0xee, 0x73, 0x7c, 0xdd, 0x2b, 0xb8,
+	0xd8, 0xe1, 0xea, 0x98, 0x87, 0x3b, 0xdc, 0xea, 0xa1, 0xa1, 0xb0, 0x04, 0xc2, 0xf3, 0xe2, 0x35,
+	0x22, 0xe5, 0x51, 0x2a, 0x8c, 0xa7, 0x39, 0x8c, 0x0b, 0x78, 0x5a, 0x04, 0x23, 0xa8, 0xab, 0xee,
+	0xe3, 0x6f, 0x40, 0xf0, 0x37, 0xaf, 0xed, 0xc9, 0xc1, 0xdf, 0x56, 0x8f, 0x74, 0x09, 0xfe, 0xf6,
+	0x8a, 0x42, 0x5e, 0xe0, 0x50, 0xe6, 0x71, 0x41, 0x49, 0xfc, 0x07, 0x1a, 0xe5, 0x1e, 0x83, 0xf3,
+	0x75, 0xc8, 0x16, 0xe1, 0x17, 0xba, 0x67, 0x8b, 0x1e, 0x10, 0x25, 0xd4, 0x38, 0xb2, 0xcc, 0x11,
+	0xcd, 0xe0, 0x7c, 0x32, 0xa2, 0xd2, 0xc6, 0x07, 0x0f, 0x67, 0xa5, 0x0f, 0x1f, 0xce, 0x4a, 0x7f,
+	0x7f, 0x38, 0x2b, 0x3d, 0x78, 0x34, 0x7b, 0xe2, 0xc3, 0x47, 0xb3, 0x27, 0xfe, 0xfc, 0x68, 0xf6,
+	0xc4, 0xad, 0xe5, 0xf4, 0x06, 0xe1, 0x41, 0x70, 0xb8, 0xb2, 0xca, 0x7b, 0x7b, 0x90, 0xf7, 0x73,
+	0x3e, 0xf3, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x95, 0x3b, 0x6f, 0x5f, 0xad, 0x25, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3879,7 +3879,7 @@ func (m *QueryEstimateMultiHopSwapRequest) MarshalToSizedBuffer(dAtA []byte) (in
 			dAtA[i] = 0
 		}
 		i--
-		dAtA[i] = 0x20
+		dAtA[i] = 0x30
 	}
 	{
 		size := m.ExitLimitPrice.Size()
@@ -3890,7 +3890,7 @@ func (m *QueryEstimateMultiHopSwapRequest) MarshalToSizedBuffer(dAtA []byte) (in
 		i = encodeVarintQuery(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x1a
+	dAtA[i] = 0x2a
 	{
 		size := m.AmountIn.Size()
 		i -= size
@@ -3900,7 +3900,7 @@ func (m *QueryEstimateMultiHopSwapRequest) MarshalToSizedBuffer(dAtA []byte) (in
 		i = encodeVarintQuery(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x12
+	dAtA[i] = 0x22
 	if len(m.Routes) > 0 {
 		for iNdEx := len(m.Routes) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -3912,7 +3912,7 @@ func (m *QueryEstimateMultiHopSwapRequest) MarshalToSizedBuffer(dAtA []byte) (in
 				i = encodeVarintQuery(dAtA, i, uint64(size))
 			}
 			i--
-			dAtA[i] = 0xa
+			dAtA[i] = 0x1a
 		}
 	}
 	return len(dAtA) - i, nil
@@ -3991,12 +3991,12 @@ func (m *QueryEstimatePlaceLimitOrderRequest) MarshalToSizedBuffer(dAtA []byte)
 			i = encodeVarintQuery(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x32
+		dAtA[i] = 0x42
 	}
 	if m.OrderType != 0 {
 		i = encodeVarintQuery(dAtA, i, uint64(m.OrderType))
 		i--
-		dAtA[i] = 0x28
+		dAtA[i] = 0x38
 	}
 	{
 		size := m.AmountIn.Size()
@@ -4007,25 +4007,25 @@ func (m *QueryEstimatePlaceLimitOrderRequest) MarshalToSizedBuffer(dAtA []byte)
 		i = encodeVarintQuery(dAtA, i, uint64(size))
 	}
 	i--
-	dAtA[i] = 0x22
+	dAtA[i] = 0x32
 	if m.TickIndexInToOut != 0 {
 		i = encodeVarintQuery(dAtA, i, uint64(m.TickIndexInToOut))
 		i--
-		dAtA[i] = 0x18
+		dAtA[i] = 0x28
 	}
 	if len(m.TokenOut) > 0 {
 		i -= len(m.TokenOut)
 		copy(dAtA[i:], m.TokenOut)
 		i = encodeVarintQuery(dAtA, i, uint64(len(m.TokenOut)))
 		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0x22
 	}
 	if len(m.TokenIn) > 0 {
 		i -= len(m.TokenIn)
 		copy(dAtA[i:], m.TokenIn)
 		i = encodeVarintQuery(dAtA, i, uint64(len(m.TokenIn)))
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x1a
 	}
 	return len(dAtA) - i, nil
 }
@@ -7830,7 +7830,7 @@ func (m *QueryEstimateMultiHopSwapRequest) Unmarshal(dAtA []byte) error {
 			return fmt.Errorf("proto: QueryEstimateMultiHopSwapRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
+		case 3:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Routes", wireType)
 			}
@@ -7864,7 +7864,7 @@ func (m *QueryEstimateMultiHopSwapRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 2:
+		case 4:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", wireType)
 			}
@@ -7898,7 +7898,7 @@ func (m *QueryEstimateMultiHopSwapRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 3:
+		case 5:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field ExitLimitPrice", wireType)
 			}
@@ -7932,7 +7932,7 @@ func (m *QueryEstimateMultiHopSwapRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 4:
+		case 6:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field PickBestRoute", wireType)
 			}
@@ -8085,7 +8085,7 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 			return fmt.Errorf("proto: QueryEstimatePlaceLimitOrderRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
+		case 3:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field TokenIn", wireType)
 			}
@@ -8117,7 +8117,7 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 			}
 			m.TokenIn = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 2:
+		case 4:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field TokenOut", wireType)
 			}
@@ -8149,7 +8149,7 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 			}
 			m.TokenOut = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 3:
+		case 5:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field TickIndexInToOut", wireType)
 			}
@@ -8168,7 +8168,7 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
-		case 4:
+		case 6:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field AmountIn", wireType)
 			}
@@ -8202,7 +8202,7 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 5:
+		case 7:
 			if wireType != 0 {
 				return fmt.Errorf("proto: wrong wireType = %d for field OrderType", wireType)
 			}
@@ -8221,7 +8221,7 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
-		case 6:
+		case 8:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field MaxAmountOut", wireType)
 			}

From fcf9feb3fab8d077950a5373c5a0dd7bf26e47c5 Mon Sep 17 00:00:00 2001
From: Julian Compagni Portis <jcompagni@gmail.com>
Date: Fri, 31 May 2024 10:17:52 -0400
Subject: [PATCH 06/10] fix query wire numbers

---
 proto/neutron/dex/query.proto | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/proto/neutron/dex/query.proto b/proto/neutron/dex/query.proto
index 7581e1d73..c852eed6d 100644
--- a/proto/neutron/dex/query.proto
+++ b/proto/neutron/dex/query.proto
@@ -298,11 +298,11 @@ message QueryEstimatePlaceLimitOrderRequest {
   ];
   LimitOrderType order_type = 7;
   // expirationTime is only valid iff orderType == GOOD_TIL_TIME.
-  google.protobuf.Timestamp expiration_time = 9 [
+  google.protobuf.Timestamp expiration_time = 8 [
     (gogoproto.stdtime) = true,
     (gogoproto.nullable) = true
   ];
-  string max_amount_out = 8 [
+  string max_amount_out = 9 [
     (gogoproto.moretags) = "yaml:\"max_amount_out\"",
     (gogoproto.customtype) = "cosmossdk.io/math.Int",
     (gogoproto.nullable) = true,

From d236ce9aeb7ca1e53d821231c2a67c49130a5782 Mon Sep 17 00:00:00 2001
From: Julian Compagni Portis <jcompagni@gmail.com>
Date: Fri, 31 May 2024 10:21:02 -0400
Subject: [PATCH 07/10] add comment explaining random address in EstimateXX

---
 x/dex/keeper/grpc_query_estimate_multi_hop_swap.go    | 1 +
 x/dex/keeper/grpc_query_estimate_place_limit_order.go | 1 +
 2 files changed, 2 insertions(+)

diff --git a/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go b/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go
index d6b6e944d..837dba82c 100644
--- a/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go
+++ b/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go
@@ -13,6 +13,7 @@ func (k Keeper) EstimateMultiHopSwap(
 	req *types.QueryEstimateMultiHopSwapRequest,
 ) (*types.QueryEstimateMultiHopSwapResponse, error) {
 	msg := types.MsgMultiHopSwap{
+		// Add a random address so that Validate passes. This address is not used for anything within the query
 		Creator:        "neutron1dft8nwxzr0u27wvr2cknpermjkreqvp9fdy0uz",
 		Receiver:       "neutron1dft8nwxzr0u27wvr2cknpermjkreqvp9fdy0uz",
 		Routes:         req.Routes,
diff --git a/x/dex/keeper/grpc_query_estimate_place_limit_order.go b/x/dex/keeper/grpc_query_estimate_place_limit_order.go
index ebc2a77af..40cf41fc6 100644
--- a/x/dex/keeper/grpc_query_estimate_place_limit_order.go
+++ b/x/dex/keeper/grpc_query_estimate_place_limit_order.go
@@ -13,6 +13,7 @@ func (k Keeper) EstimatePlaceLimitOrder(
 	req *types.QueryEstimatePlaceLimitOrderRequest,
 ) (*types.QueryEstimatePlaceLimitOrderResponse, error) {
 	msg := types.MsgPlaceLimitOrder{
+		// Add a random address so that Validate passes. This address is not used for anything within the query
 		Creator:          "neutron1dft8nwxzr0u27wvr2cknpermjkreqvp9fdy0uz",
 		Receiver:         "neutron1dft8nwxzr0u27wvr2cknpermjkreqvp9fdy0uz",
 		TokenIn:          req.TokenIn,

From 8a9aed708c77bc0859a500ef2d73b597aa82ada3 Mon Sep 17 00:00:00 2001
From: Julian Compagni Portis <jcompagni@gmail.com>
Date: Tue, 23 Jul 2024 10:52:03 -0400
Subject: [PATCH 08/10] use execute fns for simulation queries

---
 .../grpc_query_estimate_multi_hop_swap.go     | 11 +----
 .../grpc_query_estimate_place_limit_order.go  | 16 +++----
 x/dex/keeper/simulation_bank_keeper.go        | 43 -------------------
 3 files changed, 8 insertions(+), 62 deletions(-)
 delete mode 100644 x/dex/keeper/simulation_bank_keeper.go

diff --git a/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go b/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go
index 837dba82c..58decb578 100644
--- a/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go
+++ b/x/dex/keeper/grpc_query_estimate_multi_hop_swap.go
@@ -28,23 +28,16 @@ func (k Keeper) EstimateMultiHopSwap(
 	ctx := sdk.UnwrapSDKContext(goCtx)
 	cacheCtx, _ := ctx.CacheContext()
 
-	oldBk := k.bankKeeper
-	k.bankKeeper = NewSimulationBankKeeper(k.bankKeeper)
-	coinOut, err := k.MultiHopSwapCore(
+	bestRoute, _, err := k.CalulateMultiHopSwap(
 		cacheCtx,
 		req.AmountIn,
 		req.Routes,
 		req.ExitLimitPrice,
 		req.PickBestRoute,
-		[]byte("caller"),
-		[]byte("receiver"),
 	)
 	if err != nil {
 		return nil, err
 	}
 
-	//nolint:staticcheck // Should be unnecessary but out of an abundance of caution we restore the old bankkeeper
-	k.bankKeeper = oldBk
-
-	return &types.QueryEstimateMultiHopSwapResponse{CoinOut: coinOut}, nil
+	return &types.QueryEstimateMultiHopSwapResponse{CoinOut: bestRoute.coinOut}, nil
 }
diff --git a/x/dex/keeper/grpc_query_estimate_place_limit_order.go b/x/dex/keeper/grpc_query_estimate_place_limit_order.go
index 40cf41fc6..5cbc825ae 100644
--- a/x/dex/keeper/grpc_query_estimate_place_limit_order.go
+++ b/x/dex/keeper/grpc_query_estimate_place_limit_order.go
@@ -29,34 +29,30 @@ func (k Keeper) EstimatePlaceLimitOrder(
 	}
 
 	ctx := sdk.UnwrapSDKContext(goCtx)
-	cacheCtx, _ := ctx.CacheContext()
 
 	err := msg.ValidateGoodTilExpiration(ctx.BlockTime())
 	if err != nil {
 		return nil, err
 	}
 
-	oldBk := k.bankKeeper
-	k.bankKeeper = NewSimulationBankKeeper(k.bankKeeper)
-	_, totalInCoin, swapInCoin, swapOutCoin, err := k.PlaceLimitOrderCore(
+	takerTradePairID, err := types.NewTradePairID(req.TokenIn, req.TokenOut)
+
+	cacheCtx, _ := ctx.CacheContext()
+	_, totalIn, swapInCoin, swapOutCoin, _, err := k.ExecutePlaceLimitOrder(
 		cacheCtx,
-		req.TokenIn,
-		req.TokenOut,
+		takerTradePairID,
 		req.AmountIn,
 		req.TickIndexInToOut,
 		req.OrderType,
 		req.ExpirationTime,
 		req.MaxAmountOut,
-		[]byte("caller"),
 		[]byte("receiver"),
 	)
 	if err != nil {
 		return nil, err
 	}
 
-	//nolint:staticcheck // Should be unnecessary but out of an abundance of caution we restore the old bankkeeper
-	k.bankKeeper = oldBk
-
+	totalInCoin := sdk.NewCoin(req.TokenIn, totalIn)
 	return &types.QueryEstimatePlaceLimitOrderResponse{
 		TotalInCoin: totalInCoin,
 		SwapInCoin:  swapInCoin,
diff --git a/x/dex/keeper/simulation_bank_keeper.go b/x/dex/keeper/simulation_bank_keeper.go
deleted file mode 100644
index 3d5f06da3..000000000
--- a/x/dex/keeper/simulation_bank_keeper.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package keeper
-
-import (
-	"context"
-
-	sdk "github.com/cosmos/cosmos-sdk/types"
-
-	"github.com/neutron-org/neutron/v4/x/dex/types"
-)
-
-// SimulationBankKeeper can be used by queries that require running a transaction but don't need to check bank balances
-// ie. EstimateMultiHopSwap & EstimatePlaceLimitOrder
-type SimulationBankKeeper struct {
-	originalBankKeeper types.BankKeeper
-}
-
-func (s SimulationBankKeeper) SendCoinsFromAccountToModule(_ context.Context, _ sdk.AccAddress, _ string, _ sdk.Coins) error {
-	return nil
-}
-
-func (s SimulationBankKeeper) SendCoinsFromModuleToAccount(_ context.Context, _ string, _ sdk.AccAddress, _ sdk.Coins) error {
-	return nil
-}
-
-func (s SimulationBankKeeper) MintCoins(_ context.Context, _ string, _ sdk.Coins) error {
-	return nil
-}
-
-func (s SimulationBankKeeper) BurnCoins(_ context.Context, _ string, _ sdk.Coins) error {
-	return nil
-}
-
-func (s SimulationBankKeeper) IterateAccountBalances(ctx context.Context, addr sdk.AccAddress, cb func(sdk.Coin) bool) {
-	s.originalBankKeeper.IterateAccountBalances(ctx, addr, cb)
-}
-
-func (s SimulationBankKeeper) GetSupply(ctx context.Context, denom string) sdk.Coin {
-	return s.originalBankKeeper.GetSupply(ctx, denom)
-}
-
-func NewSimulationBankKeeper(bk types.BankKeeper) types.BankKeeper {
-	return SimulationBankKeeper{originalBankKeeper: bk}
-}

From ffcec4f87490e4652b311ed0d3e536cbf4ae4aa1 Mon Sep 17 00:00:00 2001
From: Julian Compagni Portis <jcompagni@gmail.com>
Date: Tue, 23 Jul 2024 12:16:29 -0400
Subject: [PATCH 09/10] add err return

---
 x/dex/keeper/grpc_query_estimate_place_limit_order.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/x/dex/keeper/grpc_query_estimate_place_limit_order.go b/x/dex/keeper/grpc_query_estimate_place_limit_order.go
index 5cbc825ae..4f6ca1d63 100644
--- a/x/dex/keeper/grpc_query_estimate_place_limit_order.go
+++ b/x/dex/keeper/grpc_query_estimate_place_limit_order.go
@@ -36,6 +36,9 @@ func (k Keeper) EstimatePlaceLimitOrder(
 	}
 
 	takerTradePairID, err := types.NewTradePairID(req.TokenIn, req.TokenOut)
+	if err != nil {
+		return nil, err
+	}
 
 	cacheCtx, _ := ctx.CacheContext()
 	_, totalIn, swapInCoin, swapOutCoin, _, err := k.ExecutePlaceLimitOrder(

From cd8d9e690a3f4233c685570c1bff37a20150867b Mon Sep 17 00:00:00 2001
From: Julian Compagni Portis <jcompagni@gmail.com>
Date: Wed, 31 Jul 2024 16:40:38 -0700
Subject: [PATCH 10/10] proto regen

---
 x/dex/types/query.pb.go | 74 ++++++++++++++++++++---------------------
 1 file changed, 37 insertions(+), 37 deletions(-)

diff --git a/x/dex/types/query.pb.go b/x/dex/types/query.pb.go
index 9053beb5b..b1cf4676b 100644
--- a/x/dex/types/query.pb.go
+++ b/x/dex/types/query.pb.go
@@ -1426,8 +1426,8 @@ type QueryEstimatePlaceLimitOrderRequest struct {
 	AmountIn         cosmossdk_io_math.Int `protobuf:"bytes,6,opt,name=amount_in,json=amountIn,proto3,customtype=cosmossdk.io/math.Int" json:"amount_in" yaml:"amount_in"`
 	OrderType        LimitOrderType        `protobuf:"varint,7,opt,name=order_type,json=orderType,proto3,enum=neutron.dex.LimitOrderType" json:"order_type,omitempty"`
 	// expirationTime is only valid iff orderType == GOOD_TIL_TIME.
-	ExpirationTime *time.Time             `protobuf:"bytes,9,opt,name=expiration_time,json=expirationTime,proto3,stdtime" json:"expiration_time,omitempty"`
-	MaxAmountOut   *cosmossdk_io_math.Int `protobuf:"bytes,8,opt,name=max_amount_out,json=maxAmountOut,proto3,customtype=cosmossdk.io/math.Int" json:"max_amount_out" yaml:"max_amount_out"`
+	ExpirationTime *time.Time             `protobuf:"bytes,8,opt,name=expiration_time,json=expirationTime,proto3,stdtime" json:"expiration_time,omitempty"`
+	MaxAmountOut   *cosmossdk_io_math.Int `protobuf:"bytes,9,opt,name=max_amount_out,json=maxAmountOut,proto3,customtype=cosmossdk.io/math.Int" json:"max_amount_out" yaml:"max_amount_out"`
 }
 
 func (m *QueryEstimatePlaceLimitOrderRequest) Reset()         { *m = QueryEstimatePlaceLimitOrderRequest{} }
@@ -2004,9 +2004,9 @@ var fileDescriptor_b6613ea5fce61e9c = []byte{
 	0xb9, 0x1f, 0xca, 0xf6, 0x96, 0xc3, 0xe4, 0x63, 0x51, 0x34, 0xd8, 0xe7, 0x28, 0xba, 0x86, 0x10,
 	0xe4, 0xf4, 0xba, 0x4b, 0x72, 0xa7, 0xe6, 0xa4, 0xc5, 0x33, 0xab, 0xd3, 0x49, 0x09, 0xbd, 0xee,
 	0x12, 0x75, 0xd8, 0x09, 0x1f, 0xf1, 0x0d, 0x74, 0x96, 0x1c, 0xb8, 0xa6, 0xc7, 0x13, 0x86, 0x46,
-	0xcd, 0x2a, 0xc9, 0x0d, 0x73, 0x17, 0xe5, 0x8b, 0x41, 0x9f, 0xac, 0x18, 0xf6, 0xc9, 0x8a, 0x5b,
+	0xcd, 0x2a, 0xc9, 0x0d, 0x71, 0x17, 0xe5, 0x8b, 0x41, 0x9f, 0xac, 0x18, 0xf6, 0xc9, 0x8a, 0x5b,
 	0x61, 0x9f, 0xac, 0x34, 0xc4, 0x36, 0xe0, 0x83, 0xbf, 0x15, 0x24, 0x16, 0x38, 0xa1, 0x32, 0x9b,
-	0xc6, 0x36, 0x3a, 0x53, 0xd5, 0x0f, 0x34, 0x80, 0xc9, 0x18, 0x19, 0xe2, 0xc6, 0x5e, 0x4f, 0xeb,
+	0xc6, 0x36, 0x3a, 0x53, 0xd5, 0x0f, 0x34, 0x80, 0xc9, 0x18, 0x19, 0xe6, 0xc6, 0x5e, 0x4f, 0xeb,
 	0x44, 0xb4, 0xa9, 0x1d, 0x36, 0x0a, 0x53, 0x81, 0xc5, 0xf1, 0x71, 0x59, 0x1d, 0xad, 0xea, 0x07,
 	0x6b, 0xfc, 0x9d, 0xf9, 0xf9, 0xdf, 0x59, 0x68, 0x3d, 0x24, 0xfa, 0x19, 0x62, 0xf0, 0x7b, 0x12,
 	0x3a, 0x4d, 0x1d, 0xaa, 0x5b, 0xcc, 0x59, 0x2c, 0x4a, 0xd2, 0x23, 0xf1, 0xad, 0xa3, 0x47, 0x62,
@@ -2062,7 +2062,7 @@ var fileDescriptor_b6613ea5fce61e9c = []byte{
 	0xcd, 0xe0, 0x7c, 0x32, 0xa2, 0xd2, 0xc6, 0x07, 0x0f, 0x67, 0xa5, 0x0f, 0x1f, 0xce, 0x4a, 0x7f,
 	0x7f, 0x38, 0x2b, 0x3d, 0x78, 0x34, 0x7b, 0xe2, 0xc3, 0x47, 0xb3, 0x27, 0xfe, 0xfc, 0x68, 0xf6,
 	0xc4, 0xad, 0xe5, 0xf4, 0x06, 0xe1, 0x41, 0x70, 0xb8, 0xb2, 0xca, 0x7b, 0x7b, 0x90, 0xf7, 0x73,
-	0x3e, 0xf3, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x95, 0x3b, 0x6f, 0x5f, 0xad, 0x25, 0x00, 0x00,
+	0x3e, 0xf3, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0b, 0x3f, 0x0c, 0xeb, 0xad, 0x25, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3969,16 +3969,6 @@ func (m *QueryEstimatePlaceLimitOrderRequest) MarshalToSizedBuffer(dAtA []byte)
 	_ = i
 	var l int
 	_ = l
-	if m.ExpirationTime != nil {
-		n21, err21 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(*m.ExpirationTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime):])
-		if err21 != nil {
-			return 0, err21
-		}
-		i -= n21
-		i = encodeVarintQuery(dAtA, i, uint64(n21))
-		i--
-		dAtA[i] = 0x4a
-	}
 	if m.MaxAmountOut != nil {
 		{
 			size := m.MaxAmountOut.Size()
@@ -3989,6 +3979,16 @@ func (m *QueryEstimatePlaceLimitOrderRequest) MarshalToSizedBuffer(dAtA []byte)
 			i = encodeVarintQuery(dAtA, i, uint64(size))
 		}
 		i--
+		dAtA[i] = 0x4a
+	}
+	if m.ExpirationTime != nil {
+		n21, err21 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(*m.ExpirationTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime):])
+		if err21 != nil {
+			return 0, err21
+		}
+		i -= n21
+		i = encodeVarintQuery(dAtA, i, uint64(n21))
+		i--
 		dAtA[i] = 0x42
 	}
 	if m.OrderType != 0 {
@@ -4821,14 +4821,14 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Size() (n int) {
 	if m.OrderType != 0 {
 		n += 1 + sovQuery(uint64(m.OrderType))
 	}
-	if m.MaxAmountOut != nil {
-		l = m.MaxAmountOut.Size()
-		n += 1 + l + sovQuery(uint64(l))
-	}
 	if m.ExpirationTime != nil {
 		l = github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime)
 		n += 1 + l + sovQuery(uint64(l))
 	}
+	if m.MaxAmountOut != nil {
+		l = m.MaxAmountOut.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
 	return n
 }
 
@@ -8221,9 +8221,9 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 			}
 		case 8:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxAmountOut", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -8233,33 +8233,33 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			var v cosmossdk_io_math.Int
-			m.MaxAmountOut = &v
-			if err := m.MaxAmountOut.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.ExpirationTime == nil {
+				m.ExpirationTime = new(time.Time)
+			}
+			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(m.ExpirationTime, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 9:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxAmountOut", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@@ -8269,25 +8269,25 @@ func (m *QueryEstimatePlaceLimitOrderRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.ExpirationTime == nil {
-				m.ExpirationTime = new(time.Time)
-			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(m.ExpirationTime, dAtA[iNdEx:postIndex]); err != nil {
+			var v cosmossdk_io_math.Int
+			m.MaxAmountOut = &v
+			if err := m.MaxAmountOut.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex