diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2721cb65b8..f433a951c5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -46,11 +46,15 @@ Ref: https://keepachangelog.com/en/1.0.0/
 
 ## Unreleased
 
+### Features
+
+- [2369](https://github.com/umee-network/umee/pull/2369) Add query RegisteredTokenMarkets to fetch Registered Tokens and their Market Summaries for frontend in fewer queries.
+
 ## v6.2.0 - 2023-12-01
 
 ### Bug Fixes
 
-- [2315](https://github.com/umee-network/umee/pull/2215) Improve reliability of MaxBorrow, MaxWithdraw when special asset pairs present.
+- [2315](https://github.com/umee-network/umee/pull/2315) Improve reliability of MaxBorrow, MaxWithdraw when special asset pairs present.
 - [2346](https://github.com/umee-network/umee/pull/2346) Fix an issue where metokens were not included in historic data.
 
 ### Improvements
diff --git a/proto/umee/leverage/v1/query.proto b/proto/umee/leverage/v1/query.proto
index 7bb6cdc861..9d957c7ffb 100644
--- a/proto/umee/leverage/v1/query.proto
+++ b/proto/umee/leverage/v1/query.proto
@@ -24,6 +24,12 @@ service Query {
     option (google.api.http).get = "/umee/leverage/v1/registered_tokens";
   }
 
+  // RegisteredTokensWithMarkets queries for all the registered tokens and their market summaries.
+  rpc RegisteredTokensWithMarkets(QueryRegisteredTokensWithMarkets)
+      returns (QueryRegisteredTokensWithMarketsResponse) {
+    option (google.api.http).get = "/umee/leverage/v1/registered_tokens_with_markets";
+  }
+
   // SpecialAssets queries for all special asset pairs.
   rpc SpecialAssets(QuerySpecialAssets)
       returns (QuerySpecialAssetsResponse) {
@@ -112,6 +118,24 @@ message QueryRegisteredTokensResponse {
   repeated Token registry = 1 [(gogoproto.nullable) = false];
 }
 
+// QueryRegisteredTokensWithMarkets defines the request structure for the RegisteredTokenMarkets
+// gRPC service handler.
+message QueryRegisteredTokensWithMarkets {}
+
+// QueryRegisteredTokensWithMarketsResponse defines the response structure for the
+// RegisteredTokensWithMarkets gRPC service handler.
+message QueryRegisteredTokensWithMarketsResponse {
+  repeated TokenMarket markets = 1 [(gogoproto.nullable) = false];
+}
+
+// TokenMarket is a token and its market summary.
+message TokenMarket {
+  // Token is a registered token and its parameters.
+  Token token = 1 [(gogoproto.nullable) = false];
+  // Market is the market summary for the token.
+  QueryMarketSummaryResponse market = 2 [(gogoproto.nullable) = false];
+}
+
 // QuerySpecialAssets defines the request structure for the SpecialAssets
 // gRPC service handler.
 message QuerySpecialAssets {
diff --git a/x/leverage/keeper/grpc_query.go b/x/leverage/keeper/grpc_query.go
index 6042f66c6f..782788653f 100644
--- a/x/leverage/keeper/grpc_query.go
+++ b/x/leverage/keeper/grpc_query.go
@@ -62,6 +62,35 @@ func (q Querier) RegisteredTokens(
 	}, nil
 }
 
+func (q Querier) RegisteredTokensWithMarkets(
+	goCtx context.Context,
+	req *types.QueryRegisteredTokensWithMarkets,
+) (*types.QueryRegisteredTokensWithMarketsResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+
+	ctx := sdk.UnwrapSDKContext(goCtx)
+	tokens := q.Keeper.GetAllRegisteredTokens(ctx)
+	markets := []types.TokenMarket{}
+
+	for _, token := range tokens {
+		marketSumnmary, err := q.MarketSummary(goCtx, &types.QueryMarketSummary{Denom: token.BaseDenom})
+		if err != nil {
+			// absorb overall query error into struct, which may be empty, but proceed with this query
+			marketSumnmary.Errors += err.Error()
+		}
+		markets = append(markets, types.TokenMarket{
+			Token:  token,
+			Market: *marketSumnmary,
+		})
+	}
+
+	return &types.QueryRegisteredTokensWithMarketsResponse{
+		Markets: markets,
+	}, nil
+}
+
 func (q Querier) SpecialAssets(
 	goCtx context.Context,
 	req *types.QuerySpecialAssets,
diff --git a/x/leverage/keeper/grpc_query_test.go b/x/leverage/keeper/grpc_query_test.go
index 41057ba60c..e819596ec5 100644
--- a/x/leverage/keeper/grpc_query_test.go
+++ b/x/leverage/keeper/grpc_query_test.go
@@ -99,6 +99,29 @@ func (s *IntegrationTestSuite) TestQuerier_MarketSummary() {
 	require.Equal(expected, *resp)
 }
 
+func (s *IntegrationTestSuite) TestQuerier_TokenMarkets() {
+	require := s.Require()
+
+	req := &types.QueryRegisteredTokensWithMarkets{}
+	resp, err := s.queryClient.RegisteredTokensWithMarkets(context.Background(), req)
+	require.NoError(err)
+
+	expected := types.QueryRegisteredTokensWithMarketsResponse{
+		Markets: []types.TokenMarket{},
+	}
+	tokens := s.tk.GetAllRegisteredTokens(s.ctx)
+	for _, token := range tokens {
+		ms, err := s.queryClient.MarketSummary(context.Background(), &types.QueryMarketSummary{Denom: token.BaseDenom})
+		require.NoError(err)
+		expected.Markets = append(expected.Markets, types.TokenMarket{
+			Token:  token,
+			Market: *ms,
+		})
+	}
+
+	require.Equal(expected, *resp)
+}
+
 func (s *IntegrationTestSuite) TestQuerier_AccountBalances() {
 	ctx, require := s.ctx, s.Require()
 
diff --git a/x/leverage/types/query.pb.go b/x/leverage/types/query.pb.go
index 2ebcd0967c..06c1acf7fa 100644
--- a/x/leverage/types/query.pb.go
+++ b/x/leverage/types/query.pb.go
@@ -187,6 +187,126 @@ func (m *QueryRegisteredTokensResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryRegisteredTokensResponse proto.InternalMessageInfo
 
+// QueryRegisteredTokensWithMarkets defines the request structure for the RegisteredTokenMarkets
+// gRPC service handler.
+type QueryRegisteredTokensWithMarkets struct {
+}
+
+func (m *QueryRegisteredTokensWithMarkets) Reset()         { *m = QueryRegisteredTokensWithMarkets{} }
+func (m *QueryRegisteredTokensWithMarkets) String() string { return proto.CompactTextString(m) }
+func (*QueryRegisteredTokensWithMarkets) ProtoMessage()    {}
+func (*QueryRegisteredTokensWithMarkets) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1e8137dcabb0ccc7, []int{4}
+}
+func (m *QueryRegisteredTokensWithMarkets) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryRegisteredTokensWithMarkets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryRegisteredTokensWithMarkets.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryRegisteredTokensWithMarkets) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryRegisteredTokensWithMarkets.Merge(m, src)
+}
+func (m *QueryRegisteredTokensWithMarkets) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryRegisteredTokensWithMarkets) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryRegisteredTokensWithMarkets.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryRegisteredTokensWithMarkets proto.InternalMessageInfo
+
+// QueryRegisteredTokensWithMarketsResponse defines the response structure for the
+// RegisteredTokensWithMarkets gRPC service handler.
+type QueryRegisteredTokensWithMarketsResponse struct {
+	Markets []TokenMarket `protobuf:"bytes,1,rep,name=markets,proto3" json:"markets"`
+}
+
+func (m *QueryRegisteredTokensWithMarketsResponse) Reset() {
+	*m = QueryRegisteredTokensWithMarketsResponse{}
+}
+func (m *QueryRegisteredTokensWithMarketsResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryRegisteredTokensWithMarketsResponse) ProtoMessage()    {}
+func (*QueryRegisteredTokensWithMarketsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1e8137dcabb0ccc7, []int{5}
+}
+func (m *QueryRegisteredTokensWithMarketsResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryRegisteredTokensWithMarketsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryRegisteredTokensWithMarketsResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryRegisteredTokensWithMarketsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryRegisteredTokensWithMarketsResponse.Merge(m, src)
+}
+func (m *QueryRegisteredTokensWithMarketsResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryRegisteredTokensWithMarketsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryRegisteredTokensWithMarketsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryRegisteredTokensWithMarketsResponse proto.InternalMessageInfo
+
+// TokenMarket is a token and its market summary.
+type TokenMarket struct {
+	// Token is a registered token and its parameters.
+	Token Token `protobuf:"bytes,1,opt,name=token,proto3" json:"token"`
+	// Market is the market summary for the token.
+	Market QueryMarketSummaryResponse `protobuf:"bytes,2,opt,name=market,proto3" json:"market"`
+}
+
+func (m *TokenMarket) Reset()         { *m = TokenMarket{} }
+func (m *TokenMarket) String() string { return proto.CompactTextString(m) }
+func (*TokenMarket) ProtoMessage()    {}
+func (*TokenMarket) Descriptor() ([]byte, []int) {
+	return fileDescriptor_1e8137dcabb0ccc7, []int{6}
+}
+func (m *TokenMarket) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *TokenMarket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_TokenMarket.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *TokenMarket) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TokenMarket.Merge(m, src)
+}
+func (m *TokenMarket) XXX_Size() int {
+	return m.Size()
+}
+func (m *TokenMarket) XXX_DiscardUnknown() {
+	xxx_messageInfo_TokenMarket.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TokenMarket proto.InternalMessageInfo
+
 // QuerySpecialAssets defines the request structure for the SpecialAssets
 // gRPC service handler.
 type QuerySpecialAssets struct {
@@ -198,7 +318,7 @@ func (m *QuerySpecialAssets) Reset()         { *m = QuerySpecialAssets{} }
 func (m *QuerySpecialAssets) String() string { return proto.CompactTextString(m) }
 func (*QuerySpecialAssets) ProtoMessage()    {}
 func (*QuerySpecialAssets) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{4}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{7}
 }
 func (m *QuerySpecialAssets) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -237,7 +357,7 @@ func (m *QuerySpecialAssetsResponse) Reset()         { *m = QuerySpecialAssetsRe
 func (m *QuerySpecialAssetsResponse) String() string { return proto.CompactTextString(m) }
 func (*QuerySpecialAssetsResponse) ProtoMessage()    {}
 func (*QuerySpecialAssetsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{5}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{8}
 }
 func (m *QuerySpecialAssetsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -275,7 +395,7 @@ func (m *QueryMarketSummary) Reset()         { *m = QueryMarketSummary{} }
 func (m *QueryMarketSummary) String() string { return proto.CompactTextString(m) }
 func (*QueryMarketSummary) ProtoMessage()    {}
 func (*QueryMarketSummary) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{6}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{9}
 }
 func (m *QueryMarketSummary) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -351,7 +471,7 @@ func (m *QueryMarketSummaryResponse) Reset()         { *m = QueryMarketSummaryRe
 func (m *QueryMarketSummaryResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryMarketSummaryResponse) ProtoMessage()    {}
 func (*QueryMarketSummaryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{7}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{10}
 }
 func (m *QueryMarketSummaryResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -389,7 +509,7 @@ func (m *QueryAccountBalances) Reset()         { *m = QueryAccountBalances{} }
 func (m *QueryAccountBalances) String() string { return proto.CompactTextString(m) }
 func (*QueryAccountBalances) ProtoMessage()    {}
 func (*QueryAccountBalances) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{8}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{11}
 }
 func (m *QueryAccountBalances) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -432,7 +552,7 @@ func (m *QueryAccountBalancesResponse) Reset()         { *m = QueryAccountBalanc
 func (m *QueryAccountBalancesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryAccountBalancesResponse) ProtoMessage()    {}
 func (*QueryAccountBalancesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{9}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{12}
 }
 func (m *QueryAccountBalancesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -470,7 +590,7 @@ func (m *QueryAccountSummary) Reset()         { *m = QueryAccountSummary{} }
 func (m *QueryAccountSummary) String() string { return proto.CompactTextString(m) }
 func (*QueryAccountSummary) ProtoMessage()    {}
 func (*QueryAccountSummary) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{10}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{13}
 }
 func (m *QueryAccountSummary) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -539,7 +659,7 @@ func (m *QueryAccountSummaryResponse) Reset()         { *m = QueryAccountSummary
 func (m *QueryAccountSummaryResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryAccountSummaryResponse) ProtoMessage()    {}
 func (*QueryAccountSummaryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{11}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{14}
 }
 func (m *QueryAccountSummaryResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -576,7 +696,7 @@ func (m *QueryLiquidationTargets) Reset()         { *m = QueryLiquidationTargets
 func (m *QueryLiquidationTargets) String() string { return proto.CompactTextString(m) }
 func (*QueryLiquidationTargets) ProtoMessage()    {}
 func (*QueryLiquidationTargets) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{12}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{15}
 }
 func (m *QueryLiquidationTargets) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -615,7 +735,7 @@ func (m *QueryLiquidationTargetsResponse) Reset()         { *m = QueryLiquidatio
 func (m *QueryLiquidationTargetsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryLiquidationTargetsResponse) ProtoMessage()    {}
 func (*QueryLiquidationTargetsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{13}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{16}
 }
 func (m *QueryLiquidationTargetsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -653,7 +773,7 @@ func (m *QueryBadDebts) Reset()         { *m = QueryBadDebts{} }
 func (m *QueryBadDebts) String() string { return proto.CompactTextString(m) }
 func (*QueryBadDebts) ProtoMessage()    {}
 func (*QueryBadDebts) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{14}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{17}
 }
 func (m *QueryBadDebts) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -692,7 +812,7 @@ func (m *QueryBadDebtsResponse) Reset()         { *m = QueryBadDebtsResponse{} }
 func (m *QueryBadDebtsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryBadDebtsResponse) ProtoMessage()    {}
 func (*QueryBadDebtsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{15}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{18}
 }
 func (m *QueryBadDebtsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -733,7 +853,7 @@ func (m *QueryMaxWithdraw) Reset()         { *m = QueryMaxWithdraw{} }
 func (m *QueryMaxWithdraw) String() string { return proto.CompactTextString(m) }
 func (*QueryMaxWithdraw) ProtoMessage()    {}
 func (*QueryMaxWithdraw) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{16}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{19}
 }
 func (m *QueryMaxWithdraw) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -774,7 +894,7 @@ func (m *QueryMaxWithdrawResponse) Reset()         { *m = QueryMaxWithdrawRespon
 func (m *QueryMaxWithdrawResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryMaxWithdrawResponse) ProtoMessage()    {}
 func (*QueryMaxWithdrawResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{17}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{20}
 }
 func (m *QueryMaxWithdrawResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -815,7 +935,7 @@ func (m *QueryMaxBorrow) Reset()         { *m = QueryMaxBorrow{} }
 func (m *QueryMaxBorrow) String() string { return proto.CompactTextString(m) }
 func (*QueryMaxBorrow) ProtoMessage()    {}
 func (*QueryMaxBorrow) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{18}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{21}
 }
 func (m *QueryMaxBorrow) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -854,7 +974,7 @@ func (m *QueryMaxBorrowResponse) Reset()         { *m = QueryMaxBorrowResponse{}
 func (m *QueryMaxBorrowResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryMaxBorrowResponse) ProtoMessage()    {}
 func (*QueryMaxBorrowResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{19}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{22}
 }
 func (m *QueryMaxBorrowResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -902,7 +1022,7 @@ func (m *QueryInspect) Reset()         { *m = QueryInspect{} }
 func (m *QueryInspect) String() string { return proto.CompactTextString(m) }
 func (*QueryInspect) ProtoMessage()    {}
 func (*QueryInspect) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{20}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{23}
 }
 func (m *QueryInspect) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -940,7 +1060,7 @@ func (m *QueryInspectAccount) Reset()         { *m = QueryInspectAccount{} }
 func (m *QueryInspectAccount) String() string { return proto.CompactTextString(m) }
 func (*QueryInspectAccount) ProtoMessage()    {}
 func (*QueryInspectAccount) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{21}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{24}
 }
 func (m *QueryInspectAccount) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -980,7 +1100,7 @@ func (m *QueryInspectResponse) Reset()         { *m = QueryInspectResponse{} }
 func (m *QueryInspectResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryInspectResponse) ProtoMessage()    {}
 func (*QueryInspectResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{22}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{25}
 }
 func (m *QueryInspectResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1018,7 +1138,7 @@ func (m *QueryInspectAccountResponse) Reset()         { *m = QueryInspectAccount
 func (m *QueryInspectAccountResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryInspectAccountResponse) ProtoMessage()    {}
 func (*QueryInspectAccountResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{23}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{26}
 }
 func (m *QueryInspectAccountResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1064,7 +1184,7 @@ func (m *InspectAccount) Reset()         { *m = InspectAccount{} }
 func (m *InspectAccount) String() string { return proto.CompactTextString(m) }
 func (*InspectAccount) ProtoMessage()    {}
 func (*InspectAccount) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{24}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{27}
 }
 func (m *InspectAccount) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1107,7 +1227,7 @@ func (m *RiskInfo) Reset()         { *m = RiskInfo{} }
 func (m *RiskInfo) String() string { return proto.CompactTextString(m) }
 func (*RiskInfo) ProtoMessage()    {}
 func (*RiskInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{25}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{28}
 }
 func (m *RiskInfo) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1148,7 +1268,7 @@ func (m *DecBalances) Reset()         { *m = DecBalances{} }
 func (m *DecBalances) String() string { return proto.CompactTextString(m) }
 func (*DecBalances) ProtoMessage()    {}
 func (*DecBalances) Descriptor() ([]byte, []int) {
-	return fileDescriptor_1e8137dcabb0ccc7, []int{26}
+	return fileDescriptor_1e8137dcabb0ccc7, []int{29}
 }
 func (m *DecBalances) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1182,6 +1302,9 @@ func init() {
 	proto.RegisterType((*QueryParamsResponse)(nil), "umee.leverage.v1.QueryParamsResponse")
 	proto.RegisterType((*QueryRegisteredTokens)(nil), "umee.leverage.v1.QueryRegisteredTokens")
 	proto.RegisterType((*QueryRegisteredTokensResponse)(nil), "umee.leverage.v1.QueryRegisteredTokensResponse")
+	proto.RegisterType((*QueryRegisteredTokensWithMarkets)(nil), "umee.leverage.v1.QueryRegisteredTokensWithMarkets")
+	proto.RegisterType((*QueryRegisteredTokensWithMarketsResponse)(nil), "umee.leverage.v1.QueryRegisteredTokensWithMarketsResponse")
+	proto.RegisterType((*TokenMarket)(nil), "umee.leverage.v1.TokenMarket")
 	proto.RegisterType((*QuerySpecialAssets)(nil), "umee.leverage.v1.QuerySpecialAssets")
 	proto.RegisterType((*QuerySpecialAssetsResponse)(nil), "umee.leverage.v1.QuerySpecialAssetsResponse")
 	proto.RegisterType((*QueryMarketSummary)(nil), "umee.leverage.v1.QueryMarketSummary")
@@ -1210,125 +1333,131 @@ func init() {
 func init() { proto.RegisterFile("umee/leverage/v1/query.proto", fileDescriptor_1e8137dcabb0ccc7) }
 
 var fileDescriptor_1e8137dcabb0ccc7 = []byte{
-	// 1885 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0x4f, 0x6f, 0x1b, 0xc7,
-	0x15, 0xd7, 0x4a, 0x36, 0x45, 0x3d, 0x8a, 0x92, 0x3c, 0x96, 0xed, 0x35, 0x2d, 0x93, 0xf4, 0xda,
-	0xb2, 0x15, 0xa7, 0x22, 0x6d, 0x05, 0x30, 0x10, 0xb4, 0x68, 0x6b, 0x5a, 0x2d, 0xea, 0xc2, 0x09,
-	0xe4, 0x75, 0x9c, 0xc2, 0x49, 0x1b, 0x62, 0xb8, 0x1c, 0x53, 0x0b, 0x2d, 0x77, 0xe9, 0x99, 0xa5,
-	0x4c, 0x16, 0xc8, 0x25, 0x40, 0x6f, 0x2d, 0x50, 0xa3, 0xe8, 0xa1, 0xc7, 0x5e, 0x7b, 0xeb, 0xb7,
-	0xf0, 0x31, 0x40, 0x2f, 0x45, 0x81, 0xaa, 0xad, 0x5d, 0xf4, 0x90, 0x4b, 0xbf, 0x40, 0x0f, 0xc5,
-	0xfc, 0xd9, 0xe1, 0x92, 0xcb, 0x95, 0xa9, 0x45, 0x74, 0x12, 0x67, 0xe7, 0xbd, 0xdf, 0xfb, 0xcd,
-	0x9b, 0x79, 0x7f, 0x66, 0x04, 0x1b, 0xfd, 0x2e, 0x21, 0x75, 0x8f, 0x1c, 0x12, 0x8a, 0x3b, 0xa4,
-	0x7e, 0x78, 0xb7, 0xfe, 0xa2, 0x4f, 0xe8, 0xb0, 0xd6, 0xa3, 0x41, 0x18, 0xa0, 0x35, 0x3e, 0x5b,
-	0x8b, 0x66, 0x6b, 0x87, 0x77, 0x4b, 0x1b, 0x9d, 0x20, 0xe8, 0x78, 0xa4, 0x8e, 0x7b, 0x6e, 0x1d,
-	0xfb, 0x7e, 0x10, 0xe2, 0xd0, 0x0d, 0x7c, 0x26, 0xe5, 0x4b, 0xe5, 0x04, 0x5a, 0x87, 0xf8, 0x84,
-	0xb9, 0xd1, 0x7c, 0x25, 0x31, 0xaf, 0xb1, 0xa5, 0xc0, 0x7a, 0x27, 0xe8, 0x04, 0xe2, 0x67, 0x9d,
-	0xff, 0x8a, 0x60, 0x9d, 0x80, 0x75, 0x03, 0x56, 0x6f, 0x61, 0xc6, 0x95, 0x5a, 0x24, 0xc4, 0x77,
-	0xeb, 0x4e, 0xe0, 0xfa, 0x72, 0xde, 0x2a, 0x42, 0xe1, 0x31, 0x67, 0xbd, 0x87, 0x29, 0xee, 0x32,
-	0xeb, 0x23, 0x38, 0x1f, 0x1b, 0xda, 0x84, 0xf5, 0x02, 0x9f, 0x11, 0x74, 0x0f, 0x72, 0x3d, 0xf1,
-	0xc5, 0x34, 0xaa, 0xc6, 0x56, 0x61, 0xc7, 0xac, 0x4d, 0xae, 0xae, 0x26, 0x35, 0x1a, 0x67, 0x5e,
-	0x1f, 0x55, 0xe6, 0x6c, 0x25, 0x6d, 0xdd, 0x83, 0x0b, 0x02, 0xce, 0x26, 0x1d, 0x97, 0x85, 0x84,
-	0x92, 0xf6, 0x27, 0xc1, 0x01, 0xf1, 0x19, 0xba, 0x0a, 0xc0, 0x19, 0x35, 0xdb, 0xc4, 0x0f, 0xba,
-	0x02, 0x74, 0xc9, 0x5e, 0xe2, 0x5f, 0x76, 0xf9, 0x07, 0xeb, 0x33, 0xb8, 0x3a, 0x55, 0x4f, 0x13,
-	0xfa, 0x10, 0xf2, 0x54, 0xcc, 0xd1, 0xa1, 0x69, 0x54, 0x17, 0xb6, 0x0a, 0x3b, 0x97, 0x92, 0x94,
-	0x84, 0x8e, 0x62, 0xa4, 0xc5, 0xad, 0xdb, 0x80, 0x04, 0xf6, 0x93, 0x1e, 0x71, 0x5c, 0xec, 0xdd,
-	0x67, 0x8c, 0x84, 0x0c, 0xad, 0xc3, 0xd9, 0x38, 0x17, 0x39, 0xb0, 0x7e, 0x0e, 0xa5, 0xa4, 0xac,
-	0x26, 0xf1, 0x7d, 0x38, 0xdb, 0xc3, 0x2e, 0x65, 0x8a, 0x81, 0x95, 0x64, 0x10, 0xd7, 0xdb, 0xc3,
-	0x2e, 0x55, 0x64, 0xa4, 0x9a, 0x66, 0xf2, 0x11, 0xa6, 0x07, 0x24, 0x7c, 0xd2, 0xef, 0x76, 0x31,
-	0x1d, 0xa6, 0x30, 0xf9, 0xdf, 0xb2, 0xa2, 0x32, 0x26, 0xac, 0xa9, 0x5c, 0x83, 0x65, 0x36, 0xec,
-	0xb6, 0x02, 0x6f, 0xcc, 0xa3, 0x05, 0xf9, 0x4d, 0xf8, 0x14, 0x95, 0x20, 0x4f, 0x06, 0xbd, 0xc0,
-	0x27, 0x7e, 0x68, 0xce, 0x57, 0x8d, 0xad, 0xa2, 0xad, 0xc7, 0xe8, 0x31, 0x2c, 0x07, 0x14, 0x3b,
-	0x1e, 0x69, 0xf6, 0xa8, 0xeb, 0x10, 0x73, 0x81, 0xab, 0x37, 0x6a, 0xaf, 0x8f, 0x2a, 0xc6, 0xdf,
-	0x8e, 0x2a, 0x37, 0x3b, 0x6e, 0xb8, 0xdf, 0x6f, 0xd5, 0x9c, 0xa0, 0x5b, 0x57, 0xc7, 0x49, 0xfe,
-	0xd9, 0x66, 0xed, 0x83, 0x7a, 0x38, 0xec, 0x11, 0x56, 0xdb, 0x25, 0x8e, 0x5d, 0x90, 0x18, 0x7b,
-	0x1c, 0x02, 0x0d, 0x60, 0xbd, 0x2f, 0x36, 0xa0, 0x49, 0x06, 0xce, 0x3e, 0xf6, 0x3b, 0xa4, 0x49,
-	0x71, 0x48, 0xcc, 0x33, 0x02, 0xfa, 0xc7, 0xdc, 0x0f, 0xb3, 0x43, 0x7f, 0x73, 0x54, 0x59, 0xef,
-	0x87, 0x49, 0x34, 0x1b, 0x49, 0x1b, 0x3f, 0x52, 0x1f, 0x6d, 0x1c, 0x12, 0xf4, 0x39, 0x00, 0xeb,
-	0xf7, 0x7a, 0xde, 0xb0, 0x79, 0x7f, 0xef, 0x99, 0x79, 0x56, 0xd8, 0xfb, 0xde, 0x89, 0xed, 0x45,
-	0x18, 0xb8, 0x37, 0xb4, 0x97, 0xe4, 0xef, 0xfb, 0x7b, 0xcf, 0x38, 0x78, 0x2b, 0xa0, 0x34, 0x78,
-	0x29, 0xc0, 0x73, 0x59, 0xc1, 0x15, 0x86, 0x00, 0x97, 0xbf, 0x39, 0xf8, 0x4f, 0x21, 0x2f, 0x2c,
-	0xb9, 0xa4, 0x6d, 0x2e, 0xea, 0x2d, 0x98, 0x15, 0xfa, 0xa1, 0x1f, 0xda, 0x5a, 0x9f, 0x63, 0x51,
-	0xc2, 0x08, 0x3d, 0x24, 0x6d, 0x33, 0x9f, 0x0d, 0x2b, 0xd2, 0x47, 0x1f, 0x03, 0x38, 0x81, 0xe7,
-	0xe1, 0x90, 0x50, 0xec, 0x99, 0x4b, 0x99, 0xd0, 0x62, 0x08, 0x9c, 0x9b, 0x5c, 0x34, 0x69, 0x9b,
-	0x90, 0x8d, 0x5b, 0xa4, 0x8f, 0x1e, 0xc1, 0x92, 0xe7, 0xbe, 0xe8, 0xbb, 0x6d, 0x37, 0x1c, 0x9a,
-	0x85, 0x4c, 0x60, 0x23, 0x00, 0xf4, 0x14, 0x56, 0xba, 0x78, 0xe0, 0x76, 0xfb, 0xdd, 0xa6, 0xb4,
-	0x60, 0x2e, 0x67, 0x82, 0x2c, 0x2a, 0x94, 0x86, 0x00, 0x41, 0xbf, 0x00, 0x14, 0xc1, 0xc6, 0x1c,
-	0x59, 0xcc, 0x04, 0x7d, 0x4e, 0x21, 0x3d, 0x18, 0xf9, 0xf3, 0x73, 0x38, 0xd7, 0x75, 0x7d, 0x01,
-	0x3f, 0xf2, 0xc5, 0x4a, 0x26, 0xf4, 0x35, 0x05, 0xf4, 0x48, 0xbb, 0xa4, 0x0d, 0x45, 0x15, 0xc8,
-	0x32, 0x0a, 0xcc, 0x55, 0x01, 0xfc, 0x83, 0x93, 0x01, 0x7f, 0x73, 0x54, 0x29, 0xaa, 0x08, 0x96,
-	0x30, 0xf6, 0xb2, 0x44, 0x7d, 0x22, 0x46, 0xe8, 0x19, 0xac, 0xe1, 0x43, 0xec, 0x7a, 0xb8, 0xe5,
-	0x91, 0xc8, 0xf5, 0x6b, 0x99, 0x56, 0xb0, 0xaa, 0x71, 0x46, 0xce, 0x1f, 0x41, 0xbf, 0x74, 0xc3,
-	0xfd, 0x36, 0xc5, 0x2f, 0xcd, 0x73, 0xd9, 0x9c, 0xaf, 0x91, 0x7e, 0xa6, 0x80, 0x50, 0x07, 0x2e,
-	0x8d, 0xe0, 0x47, 0xbb, 0xeb, 0xfe, 0x92, 0x98, 0x28, 0x93, 0x8d, 0x8b, 0x1a, 0xee, 0x41, 0x1c,
-	0x0d, 0xb5, 0xe0, 0x82, 0x4a, 0xd2, 0xfb, 0x2e, 0x0b, 0x03, 0xea, 0x3a, 0x2a, 0x5b, 0x9f, 0xcf,
-	0x94, 0xad, 0xcf, 0x4b, 0xb0, 0x9f, 0x28, 0x2c, 0x99, 0xb5, 0x2f, 0x42, 0x8e, 0x50, 0x1a, 0x50,
-	0x66, 0xae, 0x8b, 0x0a, 0xa2, 0x46, 0xd6, 0x1d, 0x58, 0x17, 0xd5, 0xe7, 0xbe, 0xe3, 0x04, 0x7d,
-	0x3f, 0x6c, 0x60, 0x0f, 0xfb, 0x0e, 0x61, 0xc8, 0x84, 0x45, 0xdc, 0x6e, 0x53, 0xc2, 0x98, 0x2a,
-	0x39, 0xd1, 0xd0, 0xfa, 0xfb, 0x3c, 0x6c, 0x4c, 0x53, 0xd1, 0x25, 0xab, 0x13, 0x4b, 0x76, 0xb2,
-	0x80, 0x5e, 0xae, 0x49, 0xa2, 0x35, 0xde, 0x08, 0xd4, 0x54, 0xb3, 0x52, 0x7b, 0x10, 0xb8, 0x7e,
-	0xe3, 0x0e, 0xf7, 0xe1, 0x9f, 0xfe, 0x51, 0xd9, 0x9a, 0x61, 0x71, 0x5c, 0x81, 0xc5, 0x32, 0xe1,
-	0xc1, 0x58, 0xf6, 0x9a, 0xff, 0xf6, 0x4d, 0xc5, 0x53, 0x5b, 0x27, 0x96, 0xda, 0x16, 0x4e, 0x61,
-	0x55, 0x11, 0xb8, 0x55, 0x57, 0x9d, 0x9a, 0x72, 0x6f, 0xd4, 0x3d, 0xa4, 0x6f, 0xc8, 0x57, 0x39,
-	0xb8, 0x32, 0x45, 0x43, 0xef, 0xc7, 0x53, 0x58, 0x89, 0x5c, 0xd6, 0x3c, 0xc4, 0x5e, 0x9f, 0x48,
-	0x80, 0x13, 0x1d, 0x5f, 0x7e, 0xae, 0x8a, 0x11, 0xca, 0xa7, 0x1c, 0x84, 0x07, 0xf6, 0xc8, 0x3d,
-	0x0a, 0x78, 0x3e, 0x13, 0xf0, 0xea, 0x08, 0x47, 0x42, 0x3f, 0x85, 0x95, 0xc8, 0x1d, 0x0a, 0x78,
-	0x21, 0x1b, 0xe3, 0x08, 0x45, 0xc2, 0x3e, 0x86, 0x65, 0x55, 0x9e, 0x3d, 0xb7, 0xeb, 0x86, 0xaa,
-	0x63, 0x39, 0x71, 0x33, 0x24, 0x31, 0x1e, 0x71, 0x08, 0xe4, 0xc0, 0x05, 0x99, 0x98, 0x45, 0xcb,
-	0xdf, 0x0c, 0xf7, 0x29, 0x61, 0xfb, 0x81, 0xd7, 0x56, 0xdd, 0xc9, 0x49, 0xb1, 0xd7, 0x63, 0x60,
-	0x9f, 0x44, 0x58, 0xe8, 0x0b, 0x38, 0xcf, 0x7a, 0x41, 0xd8, 0x9c, 0xd8, 0xc5, 0x5c, 0x26, 0x9f,
-	0x9c, 0xe3, 0x50, 0x4f, 0xc6, 0x76, 0xb2, 0x05, 0x17, 0x04, 0x7e, 0x62, 0x3b, 0x17, 0x33, 0x59,
-	0x10, 0x64, 0x1f, 0x4c, 0x6c, 0x69, 0xb4, 0x86, 0x89, 0x7d, 0xcd, 0x67, 0x5f, 0x43, 0x23, 0xbe,
-	0xb7, 0xd6, 0x65, 0xb8, 0x24, 0x62, 0xe0, 0x51, 0xcc, 0x81, 0x98, 0x76, 0x48, 0xc8, 0xac, 0xef,
-	0x42, 0x25, 0x65, 0x4a, 0x87, 0x88, 0x09, 0x8b, 0xa1, 0xfc, 0x24, 0x32, 0xd6, 0x92, 0x1d, 0x0d,
-	0xad, 0x55, 0x28, 0x0a, 0xe5, 0x06, 0x6e, 0xef, 0x92, 0x56, 0xc8, 0x2c, 0x5b, 0xdd, 0x7c, 0xa2,
-	0x0f, 0xb1, 0x9b, 0xcb, 0x18, 0x06, 0xcf, 0x0f, 0x89, 0x6b, 0x83, 0x52, 0x52, 0xb7, 0x05, 0x6d,
-	0xa4, 0x01, 0x6b, 0xea, 0x0a, 0x30, 0xd0, 0xd5, 0x27, 0x35, 0xde, 0x47, 0xf7, 0x88, 0xf9, 0xf8,
-	0x3d, 0xe2, 0x3f, 0x06, 0x98, 0x93, 0x20, 0x9a, 0x1b, 0x81, 0x45, 0x59, 0x94, 0xd9, 0x69, 0x64,
-	0xe4, 0x08, 0x1b, 0x39, 0x90, 0x0b, 0xa5, 0x95, 0x53, 0x48, 0xc6, 0x0a, 0xda, 0xfa, 0x21, 0xac,
-	0x44, 0xeb, 0x54, 0x7d, 0xc0, 0x49, 0x5d, 0xf5, 0x25, 0x5c, 0x1c, 0x47, 0xd0, 0x7e, 0x1a, 0x2d,
-	0xc0, 0x38, 0xbd, 0x05, 0xfc, 0xda, 0x80, 0x65, 0x61, 0xff, 0xa1, 0xcf, 0x7a, 0xc4, 0x09, 0x79,
-	0x6d, 0x96, 0xf7, 0x39, 0x45, 0x5f, 0x8d, 0xf8, 0xc5, 0x4e, 0x97, 0x1c, 0xbe, 0x00, 0x23, 0xd6,
-	0x1d, 0x97, 0xc7, 0x6a, 0xdf, 0x82, 0x98, 0x8d, 0x97, 0xab, 0x8b, 0x90, 0x6b, 0xf3, 0x8b, 0x13,
-	0x15, 0x59, 0xce, 0xb0, 0xd5, 0x08, 0xad, 0xc1, 0x82, 0x17, 0x1e, 0x8a, 0xf4, 0x64, 0xd8, 0xfc,
-	0xa7, 0xae, 0x37, 0x8a, 0x8d, 0x2a, 0x22, 0xc7, 0xd4, 0x9b, 0x81, 0x6a, 0x19, 0x94, 0x82, 0x76,
-	0xde, 0x2e, 0xa8, 0x1b, 0x0f, 0xd1, 0x37, 0xe7, 0x6a, 0x32, 0x04, 0xc6, 0xcd, 0xa8, 0x48, 0x18,
-	0x29, 0xf2, 0x45, 0x3f, 0xc7, 0xae, 0xd7, 0xa7, 0x44, 0x9e, 0xa2, 0x25, 0x5b, 0x8f, 0x2d, 0xac,
-	0x0a, 0xdd, 0x38, 0x86, 0x26, 0xd0, 0xd0, 0xfe, 0xa2, 0xea, 0x39, 0x63, 0x56, 0xfb, 0x5a, 0xcf,
-	0xfa, 0xb3, 0x01, 0x2b, 0xb3, 0x7a, 0x02, 0xdd, 0x83, 0x3c, 0xf6, 0xb1, 0x37, 0x64, 0x2e, 0x13,
-	0x1b, 0x54, 0xd8, 0x29, 0x25, 0x0d, 0xda, 0x2e, 0x3b, 0x78, 0xe8, 0x3f, 0x0f, 0x6c, 0x2d, 0x8b,
-	0x3e, 0x84, 0x7c, 0x2f, 0x60, 0x2e, 0xcf, 0x44, 0x62, 0xeb, 0x0a, 0x3b, 0x57, 0x93, 0x7a, 0xbb,
-	0xc4, 0xd1, 0xad, 0x95, 0x16, 0x47, 0x08, 0xce, 0xb8, 0xfe, 0xf3, 0x40, 0xd6, 0x2e, 0x5b, 0xfc,
-	0xb6, 0xbe, 0x80, 0x7c, 0x64, 0x84, 0xbb, 0x2f, 0x4a, 0x8c, 0x82, 0xad, 0x61, 0xeb, 0x31, 0xaa,
-	0x42, 0x21, 0x96, 0x03, 0xd5, 0x91, 0x8a, 0x7f, 0xe2, 0xf1, 0xf2, 0xa9, 0xae, 0xb7, 0x86, 0x2d,
-	0x07, 0xd6, 0x7f, 0x0d, 0x28, 0xc4, 0xd8, 0xa0, 0x17, 0x63, 0x67, 0x4f, 0xee, 0xf4, 0xc6, 0xd4,
-	0x48, 0xd9, 0x25, 0x8e, 0x08, 0x96, 0x0f, 0x54, 0xb0, 0xbc, 0x3f, 0x5b, 0x82, 0x4f, 0x76, 0x5f,
-	0xdd, 0xb1, 0x50, 0x38, 0x25, 0x83, 0xda, 0xc4, 0xce, 0xab, 0x22, 0x9c, 0x15, 0x27, 0x0d, 0xf5,
-	0x20, 0x27, 0x1f, 0xc0, 0xd0, 0x94, 0x2d, 0x8a, 0xbd, 0xa8, 0x95, 0x36, 0x8f, 0x9d, 0x8e, 0xce,
-	0xa8, 0x55, 0xfd, 0xea, 0x2f, 0xff, 0xfe, 0xdd, 0x7c, 0x09, 0x99, 0xf5, 0xc4, 0xb3, 0x9f, 0x7c,
-	0x5a, 0x43, 0x7f, 0x30, 0x60, 0x2d, 0xf1, 0xac, 0x76, 0x2b, 0x05, 0x7d, 0x52, 0xb0, 0x54, 0x9f,
-	0x51, 0x50, 0x13, 0x7a, 0x5f, 0x10, 0xda, 0x44, 0xd7, 0x93, 0x84, 0xa8, 0xd6, 0x69, 0xca, 0xd4,
-	0x85, 0x7e, 0x63, 0x40, 0x71, 0xfc, 0x79, 0xed, 0x46, 0x8a, 0xbd, 0x31, 0xa9, 0xd2, 0x77, 0x66,
-	0x91, 0xd2, 0x94, 0xb6, 0x04, 0x25, 0x0b, 0x55, 0x93, 0x94, 0x98, 0x54, 0x68, 0x62, 0x69, 0x9d,
-	0xf3, 0x19, 0x7f, 0x64, 0x4b, 0xe3, 0x33, 0x26, 0x95, 0xca, 0x67, 0xea, 0x1b, 0xdc, 0x71, 0x7c,
-	0xba, 0x42, 0xa1, 0xc9, 0x94, 0xf5, 0xdf, 0x1b, 0xb0, 0x3a, 0x79, 0x93, 0xba, 0x99, 0x62, 0x6b,
-	0x42, 0xae, 0x54, 0x9b, 0x4d, 0x4e, 0xb3, 0xba, 0x2d, 0x58, 0xdd, 0x40, 0x56, 0x92, 0x15, 0x96,
-	0x2a, 0xcd, 0x56, 0xc4, 0xe1, 0x95, 0x01, 0x2b, 0x13, 0xf7, 0x89, 0xcd, 0xe3, 0xcd, 0x45, 0x9e,
-	0xda, 0x9e, 0x49, 0x4c, 0x93, 0x7a, 0x4f, 0x90, 0xba, 0x8e, 0xae, 0xa5, 0x93, 0x8a, 0x7c, 0xf5,
-	0x47, 0x03, 0x50, 0xb2, 0x25, 0x43, 0xef, 0xa5, 0x18, 0x4c, 0x8a, 0x96, 0xee, 0xce, 0x2c, 0xaa,
-	0xf9, 0x6d, 0x0b, 0x7e, 0xb7, 0xd0, 0x66, 0x92, 0xdf, 0x58, 0x1f, 0xaf, 0xc8, 0x0c, 0x21, 0x1f,
-	0xf5, 0x79, 0xa8, 0x92, 0x62, 0x2d, 0x12, 0x28, 0xdd, 0x7a, 0x87, 0x80, 0x26, 0x71, 0x5d, 0x90,
-	0xb8, 0x8a, 0xae, 0x24, 0x49, 0xb4, 0x70, 0xbb, 0xd9, 0x16, 0xe6, 0x7e, 0x65, 0x40, 0x21, 0xde,
-	0x0f, 0x5a, 0xa9, 0x47, 0x56, 0xcb, 0x94, 0x6e, 0xbf, 0x5b, 0x46, 0x93, 0xb8, 0x29, 0x48, 0x54,
-	0x51, 0x79, 0xda, 0xa1, 0x1e, 0xe8, 0xe7, 0x14, 0xf4, 0x25, 0x2c, 0x8d, 0x3a, 0xad, 0x6a, 0xba,
-	0x01, 0x29, 0x51, 0xda, 0x7a, 0x97, 0x84, 0x26, 0x70, 0x43, 0x10, 0x28, 0xa3, 0x8d, 0xe9, 0x04,
-	0x64, 0x2e, 0x46, 0x21, 0x2c, 0x46, 0x6d, 0x52, 0x39, 0x05, 0x5a, 0xcd, 0x97, 0x6e, 0x1e, 0x3f,
-	0xaf, 0x0d, 0x5f, 0x13, 0x86, 0xaf, 0xa0, 0xcb, 0x49, 0xc3, 0xae, 0x32, 0xf5, 0x2a, 0xd9, 0x05,
-	0x6c, 0x1e, 0x8f, 0xae, 0xc4, 0x52, 0xe3, 0x65, 0x7a, 0xcb, 0x72, 0x5c, 0xbc, 0x28, 0x2e, 0xdb,
-	0x2a, 0x6e, 0x1a, 0x1f, 0xbf, 0xfe, 0x57, 0x79, 0xee, 0xf5, 0x9b, 0xb2, 0xf1, 0xf5, 0x9b, 0xb2,
-	0xf1, 0xcf, 0x37, 0x65, 0xe3, 0xb7, 0x6f, 0xcb, 0x73, 0x5f, 0xbf, 0x2d, 0xcf, 0xfd, 0xf5, 0x6d,
-	0x79, 0xee, 0xb3, 0x3b, 0xb1, 0x42, 0xc7, 0xa1, 0xb6, 0x7d, 0x12, 0xbe, 0x0c, 0xe8, 0x81, 0xc4,
-	0x3d, 0xbc, 0x57, 0x1f, 0x8c, 0xc0, 0x45, 0xd9, 0x6b, 0xe5, 0xc4, 0xff, 0x89, 0x3e, 0xf8, 0x7f,
-	0x00, 0x00, 0x00, 0xff, 0xff, 0xa5, 0x99, 0x5f, 0x64, 0xee, 0x1a, 0x00, 0x00,
+	// 1984 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x99, 0xcf, 0x6f, 0x1b, 0xc7,
+	0x15, 0xc7, 0xb5, 0x92, 0x45, 0x51, 0x8f, 0xa2, 0x24, 0x8f, 0x65, 0x7b, 0x4d, 0x4b, 0x24, 0xbd,
+	0xb6, 0x6c, 0xc5, 0x89, 0x48, 0x5b, 0x06, 0x8c, 0xa6, 0xbf, 0x4d, 0xab, 0x45, 0x1d, 0x38, 0x81,
+	0xbc, 0x8e, 0x13, 0x38, 0x69, 0x43, 0x0c, 0x97, 0x63, 0x6a, 0xa1, 0xe5, 0x2e, 0xbd, 0xb3, 0x94,
+	0xc5, 0x02, 0xb9, 0x04, 0xe8, 0xad, 0x2d, 0x1a, 0x14, 0x3d, 0xf4, 0xd8, 0x6b, 0x6f, 0xfd, 0x2b,
+	0xaa, 0x63, 0x80, 0x5e, 0x8a, 0x16, 0x55, 0x5b, 0xbb, 0xe8, 0x21, 0x97, 0xfe, 0x03, 0x3d, 0x14,
+	0xf3, 0x93, 0x4b, 0x2e, 0x29, 0x51, 0x8b, 0xea, 0x24, 0xce, 0xce, 0x7b, 0x9f, 0xf7, 0x9d, 0x37,
+	0xbf, 0x47, 0xb0, 0xda, 0x6d, 0x13, 0x52, 0xf5, 0xc8, 0x3e, 0x09, 0x71, 0x8b, 0x54, 0xf7, 0xef,
+	0x56, 0x5f, 0x76, 0x49, 0xd8, 0xab, 0x74, 0xc2, 0x20, 0x0a, 0xd0, 0x32, 0xab, 0xad, 0xa8, 0xda,
+	0xca, 0xfe, 0xdd, 0xc2, 0x6a, 0x2b, 0x08, 0x5a, 0x1e, 0xa9, 0xe2, 0x8e, 0x5b, 0xc5, 0xbe, 0x1f,
+	0x44, 0x38, 0x72, 0x03, 0x9f, 0x0a, 0xfb, 0x42, 0x31, 0x41, 0x6b, 0x11, 0x9f, 0x50, 0x57, 0xd5,
+	0x97, 0x12, 0xf5, 0x9a, 0x2d, 0x0c, 0x56, 0x5a, 0x41, 0x2b, 0xe0, 0x3f, 0xab, 0xec, 0x97, 0xc2,
+	0x3a, 0x01, 0x6d, 0x07, 0xb4, 0xda, 0xc0, 0x94, 0x39, 0x35, 0x48, 0x84, 0xef, 0x56, 0x9d, 0xc0,
+	0xf5, 0x45, 0xbd, 0x95, 0x87, 0xdc, 0x13, 0xa6, 0x7a, 0x07, 0x87, 0xb8, 0x4d, 0xad, 0xf7, 0xe1,
+	0x42, 0xac, 0x68, 0x13, 0xda, 0x09, 0x7c, 0x4a, 0xd0, 0x7d, 0xc8, 0x74, 0xf8, 0x17, 0xd3, 0x28,
+	0x1b, 0x1b, 0xb9, 0x2d, 0xb3, 0x32, 0xdc, 0xba, 0x8a, 0xf0, 0xa8, 0x9d, 0x3b, 0x3c, 0x2a, 0x4d,
+	0xd9, 0xd2, 0xda, 0xba, 0x0f, 0x17, 0x39, 0xce, 0x26, 0x2d, 0x97, 0x46, 0x24, 0x24, 0xcd, 0x0f,
+	0x83, 0x3d, 0xe2, 0x53, 0xb4, 0x06, 0xc0, 0x14, 0xd5, 0x9b, 0xc4, 0x0f, 0xda, 0x1c, 0x3a, 0x6f,
+	0xcf, 0xb3, 0x2f, 0xdb, 0xec, 0x83, 0xf5, 0x09, 0xac, 0x8d, 0xf4, 0xd3, 0x82, 0xde, 0x85, 0x6c,
+	0xc8, 0xeb, 0xc2, 0x9e, 0x69, 0x94, 0x67, 0x36, 0x72, 0x5b, 0x97, 0x93, 0x92, 0xb8, 0x8f, 0x54,
+	0xa4, 0xcd, 0x2d, 0x0b, 0xca, 0x23, 0xd9, 0x1f, 0xbb, 0xd1, 0xee, 0xfb, 0x38, 0xdc, 0x23, 0x11,
+	0xb5, 0x5c, 0xd8, 0x38, 0xc9, 0x46, 0x4b, 0xf9, 0x0e, 0xcc, 0xb5, 0xc5, 0x27, 0xa9, 0x64, 0x6d,
+	0x8c, 0x12, 0xe1, 0x28, 0xf5, 0x28, 0x1f, 0xeb, 0x97, 0x06, 0xe4, 0x62, 0xd5, 0xe8, 0x1e, 0xcc,
+	0x46, 0xac, 0x28, 0x33, 0x7d, 0x42, 0xb3, 0x84, 0x2d, 0x7a, 0x0f, 0x32, 0x82, 0x67, 0x4e, 0x73,
+	0xaf, 0x77, 0x92, 0x5e, 0xbc, 0x3d, 0x22, 0xc6, 0xd3, 0x6e, 0xbb, 0x8d, 0x59, 0xe3, 0x44, 0x0b,
+	0x54, 0x9f, 0x09, 0x82, 0x75, 0x1b, 0x10, 0xb7, 0x7d, 0xda, 0x21, 0x8e, 0x8b, 0xbd, 0x07, 0x94,
+	0x92, 0x88, 0xa2, 0x15, 0x98, 0x8d, 0xf7, 0x95, 0x28, 0x58, 0x3f, 0x86, 0x42, 0xd2, 0x56, 0x67,
+	0xe6, 0xbb, 0x30, 0xdb, 0xc1, 0x6e, 0xa8, 0xf2, 0x62, 0x25, 0x45, 0xc5, 0xfd, 0x76, 0xb0, 0x1b,
+	0xaa, 0x56, 0x71, 0x37, 0xad, 0x64, 0x40, 0xf5, 0x18, 0x25, 0xff, 0x5d, 0x90, 0x52, 0x46, 0x36,
+	0x11, 0x5d, 0x83, 0x05, 0xda, 0x6b, 0x37, 0x02, 0x6f, 0x60, 0xc4, 0xe5, 0xc4, 0x37, 0x3e, 0xe6,
+	0x50, 0x01, 0xb2, 0xe4, 0xa0, 0x13, 0xf8, 0xc4, 0x17, 0x59, 0xcc, 0xdb, 0xba, 0x8c, 0x9e, 0xc0,
+	0x42, 0x10, 0x62, 0xc7, 0x23, 0xf5, 0x4e, 0xe8, 0x3a, 0xc4, 0x9c, 0x61, 0xee, 0xb5, 0xca, 0xe1,
+	0x51, 0xc9, 0xf8, 0xcb, 0x51, 0xe9, 0x66, 0xcb, 0x8d, 0x76, 0xbb, 0x8d, 0x8a, 0x13, 0xb4, 0xab,
+	0x72, 0xba, 0x89, 0x3f, 0x9b, 0xb4, 0xb9, 0x57, 0x8d, 0x7a, 0x1d, 0x42, 0x2b, 0xdb, 0xc4, 0xb1,
+	0x73, 0x82, 0xb1, 0xc3, 0x10, 0xe8, 0x00, 0x56, 0xba, 0xbc, 0x27, 0xeb, 0xe4, 0xc0, 0xd9, 0xc5,
+	0x7e, 0x8b, 0xd4, 0x43, 0x1c, 0x11, 0xf3, 0x1c, 0x47, 0xff, 0x90, 0xe5, 0x61, 0x72, 0xf4, 0xd7,
+	0x47, 0xa5, 0x95, 0x6e, 0x94, 0xa4, 0xd9, 0x48, 0xc4, 0xf8, 0x81, 0xfc, 0x68, 0xe3, 0x88, 0xa0,
+	0x4f, 0x01, 0x68, 0xb7, 0xd3, 0xf1, 0x7a, 0xf5, 0x07, 0x3b, 0xcf, 0xcd, 0x59, 0x1e, 0xef, 0xdb,
+	0xa7, 0x8e, 0xa7, 0x18, 0xb8, 0xd3, 0xb3, 0xe7, 0xc5, 0xef, 0x07, 0x3b, 0xcf, 0x19, 0xbc, 0x11,
+	0x84, 0x61, 0xf0, 0x8a, 0xc3, 0x33, 0x69, 0xe1, 0x92, 0xc1, 0xe1, 0xe2, 0x37, 0x83, 0xbf, 0x07,
+	0x59, 0x1e, 0xc9, 0x25, 0x4d, 0x73, 0x4e, 0x77, 0xc1, 0xa4, 0xe8, 0x47, 0x7e, 0x64, 0x6b, 0x7f,
+	0xc6, 0x0a, 0x09, 0x25, 0xe1, 0x3e, 0x69, 0x9a, 0xd9, 0x74, 0x2c, 0xe5, 0x8f, 0x3e, 0x00, 0x70,
+	0x02, 0xcf, 0xc3, 0x11, 0x09, 0xb1, 0x67, 0xce, 0xa7, 0xa2, 0xc5, 0x08, 0x4c, 0x9b, 0x68, 0x34,
+	0x69, 0x9a, 0x90, 0x4e, 0x9b, 0xf2, 0x47, 0x8f, 0x61, 0xde, 0x73, 0x5f, 0x76, 0xdd, 0xa6, 0x1b,
+	0xf5, 0xcc, 0x5c, 0x2a, 0x58, 0x1f, 0x80, 0x9e, 0xc1, 0x62, 0x1b, 0x1f, 0xb8, 0xed, 0x6e, 0xbb,
+	0x2e, 0x22, 0x98, 0x0b, 0xa9, 0x90, 0x79, 0x49, 0xa9, 0x71, 0x08, 0xfa, 0x09, 0x20, 0x85, 0x8d,
+	0x25, 0x32, 0x9f, 0x0a, 0x7d, 0x5e, 0x92, 0x1e, 0xf6, 0xf3, 0xf9, 0x29, 0x9c, 0x6f, 0xbb, 0x3e,
+	0xc7, 0xf7, 0x73, 0xb1, 0x98, 0x8a, 0xbe, 0x2c, 0x41, 0x8f, 0x75, 0x4a, 0x9a, 0x90, 0x97, 0x13,
+	0x59, 0xcc, 0x02, 0x73, 0x89, 0x83, 0xbf, 0x77, 0x3a, 0xf0, 0xd7, 0x47, 0xa5, 0xbc, 0x9c, 0xc1,
+	0x02, 0x63, 0x2f, 0x08, 0xea, 0x53, 0x5e, 0x42, 0xcf, 0x61, 0x19, 0xef, 0x63, 0xd7, 0xc3, 0x0d,
+	0x8f, 0xa8, 0xd4, 0x2f, 0xa7, 0x6a, 0xc1, 0x92, 0xe6, 0xf4, 0x93, 0xdf, 0x47, 0xbf, 0x72, 0xa3,
+	0xdd, 0x66, 0x88, 0x5f, 0x99, 0xe7, 0xd3, 0x25, 0x5f, 0x93, 0x3e, 0x96, 0x20, 0xd4, 0x82, 0xcb,
+	0x7d, 0x7c, 0xbf, 0x77, 0xdd, 0x9f, 0x12, 0x13, 0xa5, 0x8a, 0x71, 0x49, 0xe3, 0x1e, 0xc6, 0x69,
+	0xa8, 0x01, 0x17, 0xe5, 0x22, 0xbd, 0xeb, 0xd2, 0x28, 0x08, 0x5d, 0x47, 0xae, 0xd6, 0x17, 0x52,
+	0xad, 0xd6, 0x17, 0x04, 0xec, 0x47, 0x92, 0x25, 0x56, 0xed, 0x4b, 0x90, 0x21, 0x61, 0x18, 0x84,
+	0xd4, 0x5c, 0xe1, 0x3b, 0x88, 0x2c, 0x59, 0x77, 0x60, 0x85, 0xef, 0x3e, 0x0f, 0x1c, 0x27, 0xe8,
+	0xfa, 0x51, 0x0d, 0x7b, 0xd8, 0x77, 0x08, 0x45, 0x26, 0xcc, 0xe1, 0x66, 0x33, 0x24, 0x94, 0xca,
+	0x2d, 0x47, 0x15, 0xad, 0xbf, 0x4d, 0xc3, 0xea, 0x28, 0x17, 0xbd, 0x65, 0xb5, 0x62, 0x8b, 0x9d,
+	0xd8, 0x40, 0xaf, 0x54, 0x84, 0xd0, 0x0a, 0x3b, 0x28, 0x55, 0xe4, 0x61, 0xae, 0xf2, 0x30, 0x70,
+	0xfd, 0xda, 0x1d, 0x96, 0xc3, 0xdf, 0xff, 0xbd, 0xb4, 0x31, 0x41, 0xe3, 0x98, 0x03, 0x8d, 0xad,
+	0x84, 0x7b, 0x03, 0xab, 0xd7, 0xf4, 0xff, 0x3f, 0x54, 0x7c, 0x69, 0x6b, 0xc5, 0x96, 0xb6, 0x99,
+	0x33, 0x68, 0x95, 0x82, 0x5b, 0x55, 0x79, 0x92, 0x95, 0xe9, 0x55, 0xa7, 0x87, 0xf1, 0x1d, 0xf2,
+	0x45, 0x06, 0xae, 0x8e, 0xf0, 0xd0, 0xfd, 0xf1, 0x0c, 0x16, 0x55, 0xca, 0xea, 0xfb, 0xd8, 0xeb,
+	0x12, 0x01, 0x38, 0xd5, 0xf0, 0x65, 0xe3, 0x2a, 0xaf, 0x28, 0x1f, 0x31, 0x08, 0x9b, 0xd8, 0xfd,
+	0xf4, 0x48, 0xf0, 0x74, 0x2a, 0xf0, 0x52, 0x9f, 0x23, 0xd0, 0xcf, 0x60, 0x51, 0xa5, 0x43, 0x82,
+	0x67, 0xd2, 0x29, 0x56, 0x14, 0x81, 0x7d, 0x02, 0x0b, 0x72, 0x7b, 0xf6, 0xdc, 0xb6, 0x1b, 0xc9,
+	0x13, 0xcb, 0xa9, 0x0f, 0x43, 0x82, 0xf1, 0x98, 0x21, 0x90, 0x03, 0x17, 0xc5, 0xc2, 0xcc, 0xaf,
+	0x44, 0xf5, 0x68, 0x37, 0x24, 0x74, 0x37, 0xf0, 0x9a, 0xf2, 0x74, 0x72, 0x5a, 0xf6, 0x4a, 0x0c,
+	0xf6, 0xa1, 0x62, 0xa1, 0xcf, 0xe0, 0x02, 0xed, 0x04, 0x51, 0x7d, 0xa8, 0x17, 0x33, 0xa9, 0x72,
+	0x72, 0x9e, 0xa1, 0x9e, 0x0e, 0xf4, 0x64, 0x03, 0x2e, 0x72, 0x7e, 0xa2, 0x3b, 0xe7, 0x52, 0x45,
+	0xe0, 0x62, 0x1f, 0x0e, 0x75, 0xa9, 0x6a, 0xc3, 0x50, 0xbf, 0x66, 0xd3, 0xb7, 0xa1, 0x16, 0xef,
+	0x5b, 0xeb, 0x0a, 0x5c, 0xe6, 0x73, 0xe0, 0x71, 0x2c, 0x81, 0x38, 0x6c, 0xb1, 0x8b, 0xca, 0xb7,
+	0xa0, 0x34, 0xa6, 0x4a, 0x4f, 0x11, 0x13, 0xe6, 0x22, 0xf1, 0x89, 0xaf, 0x58, 0xf3, 0xb6, 0x2a,
+	0x5a, 0x4b, 0x90, 0xe7, 0xce, 0x35, 0xdc, 0xdc, 0x26, 0x8d, 0x88, 0x5a, 0xb6, 0xbc, 0x19, 0xaa,
+	0x0f, 0xb1, 0x9b, 0xdd, 0x00, 0x83, 0xad, 0x0f, 0x89, 0x6b, 0x83, 0x74, 0x52, 0x57, 0x29, 0x15,
+	0xa4, 0x06, 0xcb, 0xf2, 0x0a, 0x70, 0xa0, 0x77, 0x9f, 0xb1, 0xf3, 0xbd, 0x7f, 0x8f, 0x98, 0x8e,
+	0xdf, 0x23, 0xfe, 0x6d, 0x80, 0x39, 0x0c, 0xd1, 0xda, 0x08, 0xcc, 0x89, 0x4d, 0x99, 0x9e, 0xc5,
+	0x8a, 0xac, 0xd8, 0xc8, 0x81, 0x4c, 0x24, 0xa2, 0x9c, 0xc1, 0x62, 0x2c, 0xd1, 0xd6, 0xf7, 0x61,
+	0x51, 0xb5, 0x53, 0x9e, 0x03, 0x4e, 0x9b, 0xaa, 0xcf, 0xe1, 0xd2, 0x20, 0x41, 0xe7, 0xa9, 0xdf,
+	0x00, 0xe3, 0xec, 0x1a, 0xf0, 0x73, 0x03, 0x16, 0x78, 0xfc, 0x47, 0x3e, 0xed, 0x10, 0x27, 0x62,
+	0x7b, 0xb3, 0xb8, 0xcf, 0x49, 0xf9, 0xb2, 0xc4, 0x2e, 0x76, 0x7a, 0xcb, 0x61, 0x0d, 0x30, 0x62,
+	0xa7, 0xe3, 0xe2, 0xc0, 0xde, 0x37, 0xc3, 0x6b, 0xe3, 0xdb, 0xd5, 0x25, 0xc8, 0x34, 0xd9, 0xc5,
+	0x29, 0xe4, 0xab, 0x9c, 0x61, 0xcb, 0x12, 0x5a, 0x86, 0x19, 0x2f, 0xda, 0xe7, 0xcb, 0x93, 0x61,
+	0xb3, 0x9f, 0x7a, 0xbf, 0x91, 0x6a, 0xe4, 0x26, 0x72, 0xcc, 0x7e, 0x73, 0x20, 0x8f, 0x0c, 0xd2,
+	0x41, 0x27, 0x6f, 0x1b, 0xe4, 0x8d, 0x87, 0xe8, 0x9b, 0x73, 0x39, 0x39, 0x05, 0x06, 0xc3, 0xc8,
+	0x99, 0xd0, 0x77, 0x64, 0x8d, 0x7e, 0x81, 0x5d, 0xaf, 0x1b, 0x12, 0x31, 0x8a, 0xe6, 0x6d, 0x5d,
+	0xb6, 0xb0, 0xdc, 0xe8, 0x06, 0x19, 0x5a, 0x40, 0x4d, 0xe7, 0x2b, 0x94, 0x8f, 0x10, 0x93, 0xc6,
+	0xd7, 0x7e, 0xd6, 0x1f, 0x0c, 0x58, 0x9c, 0x34, 0x13, 0xe8, 0x3e, 0x64, 0xb1, 0x8f, 0xbd, 0x1e,
+	0x75, 0xa9, 0x7c, 0xbf, 0x28, 0x24, 0x03, 0xda, 0x2e, 0xdd, 0x7b, 0xe4, 0xbf, 0x08, 0x6c, 0x6d,
+	0x8b, 0xde, 0x85, 0x6c, 0x27, 0xa0, 0x2e, 0x5b, 0x89, 0x78, 0xd7, 0x8d, 0x7c, 0x7a, 0xd9, 0x26,
+	0x8e, 0x3e, 0x5a, 0x69, 0x73, 0x84, 0xe0, 0x9c, 0xeb, 0xbf, 0x08, 0xc4, 0xde, 0x65, 0xf3, 0xdf,
+	0xd6, 0x67, 0x90, 0x55, 0x41, 0x58, 0xfa, 0xd4, 0xc2, 0xc8, 0xd5, 0x1a, 0xb6, 0x2e, 0xa3, 0x32,
+	0xe4, 0x62, 0x6b, 0xa0, 0x1c, 0x52, 0xf1, 0x4f, 0x6c, 0xbe, 0x7c, 0xa4, 0xf7, 0x5b, 0xc3, 0x16,
+	0x05, 0xeb, 0x3f, 0x06, 0xe4, 0x62, 0x6a, 0xd0, 0xcb, 0x81, 0xb1, 0x27, 0x7a, 0x7a, 0x75, 0xe4,
+	0x4c, 0xd9, 0x26, 0x0e, 0x9f, 0x2c, 0xf7, 0xe4, 0x64, 0x79, 0x7b, 0xb2, 0x05, 0x3e, 0x79, 0xfa,
+	0x6a, 0x0f, 0x4c, 0x85, 0x33, 0x0a, 0xa8, 0x43, 0x6c, 0xfd, 0x75, 0x11, 0x66, 0xf9, 0x48, 0x43,
+	0x1d, 0xc8, 0x88, 0x07, 0x42, 0xb4, 0x36, 0xe6, 0x69, 0x4a, 0x54, 0x17, 0xd6, 0x8f, 0xad, 0x56,
+	0x63, 0xd4, 0x2a, 0x7f, 0xf1, 0xa7, 0x7f, 0xfd, 0x7a, 0xba, 0x80, 0xcc, 0x6a, 0xe2, 0x59, 0x54,
+	0x3c, 0x3d, 0xa2, 0xdf, 0x1a, 0xb0, 0x9c, 0x78, 0x76, 0xbc, 0x35, 0x86, 0x3e, 0x6c, 0x58, 0xa8,
+	0x4e, 0x68, 0xa8, 0x05, 0xbd, 0xcd, 0x05, 0xad, 0xa3, 0xeb, 0x49, 0x41, 0xa1, 0xf6, 0xa9, 0x8b,
+	0xa5, 0x0b, 0xfd, 0xd1, 0x80, 0xab, 0xc7, 0x3c, 0x2d, 0xa2, 0xad, 0x09, 0xa3, 0xc7, 0x7c, 0x0a,
+	0xdf, 0x3c, 0xbd, 0x8f, 0x16, 0xff, 0x0d, 0x2e, 0x7e, 0x0b, 0xdd, 0x99, 0x40, 0x3c, 0xbf, 0x21,
+	0xd6, 0xe5, 0xeb, 0x25, 0xfa, 0x85, 0x01, 0xf9, 0xc1, 0x87, 0xc2, 0x1b, 0x63, 0x74, 0x0c, 0x58,
+	0x15, 0xde, 0x99, 0xc4, 0x4a, 0xeb, 0xdb, 0xe0, 0xfa, 0x2c, 0x54, 0x4e, 0xea, 0xa3, 0xc2, 0xa1,
+	0x8e, 0x45, 0x74, 0xa6, 0x67, 0xf0, 0xb9, 0xf0, 0xc6, 0x24, 0x4f, 0xa1, 0x85, 0x53, 0x3d, 0x98,
+	0x1e, 0xa7, 0x47, 0x24, 0xa6, 0x4e, 0x65, 0xf4, 0xdf, 0x18, 0xb0, 0x34, 0x7c, 0x27, 0xbc, 0x39,
+	0x26, 0xd6, 0x90, 0x5d, 0xa1, 0x32, 0x99, 0x9d, 0x56, 0x75, 0x9b, 0xab, 0xba, 0x81, 0xac, 0xa4,
+	0x2a, 0x2c, 0x5c, 0xea, 0x0d, 0xa5, 0xe1, 0x4b, 0x03, 0x16, 0x87, 0x6e, 0x46, 0xeb, 0xc7, 0x87,
+	0x53, 0x99, 0xda, 0x9c, 0xc8, 0x4c, 0x8b, 0x7a, 0x8b, 0x8b, 0xba, 0x8e, 0xae, 0x8d, 0x17, 0xa5,
+	0x72, 0xf5, 0x3b, 0x03, 0x50, 0xf2, 0x70, 0x89, 0xde, 0x1a, 0x13, 0x30, 0x69, 0x5a, 0xb8, 0x3b,
+	0xb1, 0xa9, 0xd6, 0xb7, 0xc9, 0xf5, 0xdd, 0x42, 0xeb, 0x49, 0x7d, 0x03, 0x37, 0x12, 0x29, 0xa6,
+	0x07, 0x59, 0x75, 0x62, 0x45, 0xa5, 0x31, 0xd1, 0x94, 0x41, 0xe1, 0xd6, 0x09, 0x06, 0x5a, 0xc4,
+	0x75, 0x2e, 0x62, 0x0d, 0x5d, 0x4d, 0x8a, 0x68, 0xe0, 0x66, 0xbd, 0xc9, 0xc3, 0xfd, 0xcc, 0x80,
+	0x5c, 0xfc, 0x64, 0x6b, 0x8d, 0x1d, 0xb2, 0xda, 0xa6, 0x70, 0xfb, 0x64, 0x1b, 0x2d, 0xe2, 0x26,
+	0x17, 0x51, 0x46, 0xc5, 0x51, 0x83, 0xfa, 0x40, 0x3f, 0x0c, 0xa1, 0xcf, 0x61, 0xbe, 0x7f, 0x66,
+	0x2c, 0x8f, 0x0f, 0x20, 0x2c, 0x0a, 0x1b, 0x27, 0x59, 0x68, 0x01, 0x37, 0xb8, 0x80, 0x22, 0x5a,
+	0x1d, 0x2d, 0x40, 0xec, 0x2a, 0x28, 0x82, 0x39, 0x75, 0xe0, 0x2b, 0x8e, 0x41, 0xcb, 0xfa, 0xc2,
+	0xcd, 0xe3, 0xeb, 0x75, 0xe0, 0x6b, 0x3c, 0xf0, 0x55, 0x74, 0x25, 0x19, 0xd8, 0x95, 0xa1, 0xbe,
+	0x4c, 0x9e, 0x67, 0xd6, 0x8f, 0xa7, 0x4b, 0xb3, 0xb1, 0xf3, 0x65, 0xf4, 0xe1, 0xeb, 0xb8, 0xf9,
+	0x22, 0xb5, 0x6c, 0xca, 0x79, 0x53, 0xfb, 0xe0, 0xf0, 0x9f, 0xc5, 0xa9, 0xc3, 0xd7, 0x45, 0xe3,
+	0xab, 0xd7, 0x45, 0xe3, 0x1f, 0xaf, 0x8b, 0xc6, 0xaf, 0xde, 0x14, 0xa7, 0xbe, 0x7a, 0x53, 0x9c,
+	0xfa, 0xf3, 0x9b, 0xe2, 0xd4, 0x27, 0x77, 0x62, 0x5b, 0x36, 0x43, 0x6d, 0xfa, 0x24, 0x7a, 0x15,
+	0x84, 0x7b, 0x82, 0xbb, 0x7f, 0xbf, 0x7a, 0xd0, 0x87, 0xf3, 0x0d, 0xbc, 0x91, 0xe1, 0xff, 0x11,
+	0xbc, 0xf7, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xab, 0x99, 0xab, 0x86, 0xd8, 0x1c, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1347,6 +1476,8 @@ type QueryClient interface {
 	Params(ctx context.Context, in *QueryParams, opts ...grpc.CallOption) (*QueryParamsResponse, error)
 	// RegisteredTokens queries for all the registered tokens.
 	RegisteredTokens(ctx context.Context, in *QueryRegisteredTokens, opts ...grpc.CallOption) (*QueryRegisteredTokensResponse, error)
+	// RegisteredTokensWithMarkets queries for all the registered tokens and their market summaries.
+	RegisteredTokensWithMarkets(ctx context.Context, in *QueryRegisteredTokensWithMarkets, opts ...grpc.CallOption) (*QueryRegisteredTokensWithMarketsResponse, error)
 	// SpecialAssets queries for all special asset pairs.
 	SpecialAssets(ctx context.Context, in *QuerySpecialAssets, opts ...grpc.CallOption) (*QuerySpecialAssetsResponse, error)
 	// MarketSummary queries a base asset's current borrowing and supplying conditions.
@@ -1400,6 +1531,15 @@ func (c *queryClient) RegisteredTokens(ctx context.Context, in *QueryRegisteredT
 	return out, nil
 }
 
+func (c *queryClient) RegisteredTokensWithMarkets(ctx context.Context, in *QueryRegisteredTokensWithMarkets, opts ...grpc.CallOption) (*QueryRegisteredTokensWithMarketsResponse, error) {
+	out := new(QueryRegisteredTokensWithMarketsResponse)
+	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Query/RegisteredTokensWithMarkets", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *queryClient) SpecialAssets(ctx context.Context, in *QuerySpecialAssets, opts ...grpc.CallOption) (*QuerySpecialAssetsResponse, error) {
 	out := new(QuerySpecialAssetsResponse)
 	err := c.cc.Invoke(ctx, "/umee.leverage.v1.Query/SpecialAssets", in, out, opts...)
@@ -1496,6 +1636,8 @@ type QueryServer interface {
 	Params(context.Context, *QueryParams) (*QueryParamsResponse, error)
 	// RegisteredTokens queries for all the registered tokens.
 	RegisteredTokens(context.Context, *QueryRegisteredTokens) (*QueryRegisteredTokensResponse, error)
+	// RegisteredTokensWithMarkets queries for all the registered tokens and their market summaries.
+	RegisteredTokensWithMarkets(context.Context, *QueryRegisteredTokensWithMarkets) (*QueryRegisteredTokensWithMarketsResponse, error)
 	// SpecialAssets queries for all special asset pairs.
 	SpecialAssets(context.Context, *QuerySpecialAssets) (*QuerySpecialAssetsResponse, error)
 	// MarketSummary queries a base asset's current borrowing and supplying conditions.
@@ -1533,6 +1675,9 @@ func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParams) (
 func (*UnimplementedQueryServer) RegisteredTokens(ctx context.Context, req *QueryRegisteredTokens) (*QueryRegisteredTokensResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method RegisteredTokens not implemented")
 }
+func (*UnimplementedQueryServer) RegisteredTokensWithMarkets(ctx context.Context, req *QueryRegisteredTokensWithMarkets) (*QueryRegisteredTokensWithMarketsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RegisteredTokensWithMarkets not implemented")
+}
 func (*UnimplementedQueryServer) SpecialAssets(ctx context.Context, req *QuerySpecialAssets) (*QuerySpecialAssetsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SpecialAssets not implemented")
 }
@@ -1604,6 +1749,24 @@ func _Query_RegisteredTokens_Handler(srv interface{}, ctx context.Context, dec f
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_RegisteredTokensWithMarkets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryRegisteredTokensWithMarkets)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).RegisteredTokensWithMarkets(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/umee.leverage.v1.Query/RegisteredTokensWithMarkets",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).RegisteredTokensWithMarkets(ctx, req.(*QueryRegisteredTokensWithMarkets))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Query_SpecialAssets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QuerySpecialAssets)
 	if err := dec(in); err != nil {
@@ -1796,6 +1959,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "RegisteredTokens",
 			Handler:    _Query_RegisteredTokens_Handler,
 		},
+		{
+			MethodName: "RegisteredTokensWithMarkets",
+			Handler:    _Query_RegisteredTokensWithMarkets_Handler,
+		},
 		{
 			MethodName: "SpecialAssets",
 			Handler:    _Query_SpecialAssets_Handler,
@@ -1964,6 +2131,109 @@ func (m *QueryRegisteredTokensResponse) MarshalToSizedBuffer(dAtA []byte) (int,
 	return len(dAtA) - i, nil
 }
 
+func (m *QueryRegisteredTokensWithMarkets) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryRegisteredTokensWithMarkets) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryRegisteredTokensWithMarkets) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryRegisteredTokensWithMarketsResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryRegisteredTokensWithMarketsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryRegisteredTokensWithMarketsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Markets) > 0 {
+		for iNdEx := len(m.Markets) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Markets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintQuery(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *TokenMarket) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *TokenMarket) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TokenMarket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size, err := m.Market.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintQuery(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	{
+		size, err := m.Token.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintQuery(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
 func (m *QuerySpecialAssets) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -3171,6 +3441,43 @@ func (m *QueryRegisteredTokensResponse) Size() (n int) {
 	return n
 }
 
+func (m *QueryRegisteredTokensWithMarkets) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func (m *QueryRegisteredTokensWithMarketsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Markets) > 0 {
+		for _, e := range m.Markets {
+			l = e.Size()
+			n += 1 + l + sovQuery(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *TokenMarket) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Token.Size()
+	n += 1 + l + sovQuery(uint64(l))
+	l = m.Market.Size()
+	n += 1 + l + sovQuery(uint64(l))
+	return n
+}
+
 func (m *QuerySpecialAssets) Size() (n int) {
 	if m == nil {
 		return 0
@@ -3909,6 +4216,256 @@ func (m *QueryRegisteredTokensResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *QueryRegisteredTokensWithMarkets) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryRegisteredTokensWithMarkets: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryRegisteredTokensWithMarkets: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryRegisteredTokensWithMarketsResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryRegisteredTokensWithMarketsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryRegisteredTokensWithMarketsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Markets", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Markets = append(m.Markets, TokenMarket{})
+			if err := m.Markets[len(m.Markets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *TokenMarket) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: TokenMarket: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TokenMarket: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Token.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Market", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Market.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *QuerySpecialAssets) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/x/leverage/types/query.pb.gw.go b/x/leverage/types/query.pb.gw.go
index 4d4d6a5591..1e9f7ccf3d 100644
--- a/x/leverage/types/query.pb.gw.go
+++ b/x/leverage/types/query.pb.gw.go
@@ -87,6 +87,24 @@ func local_request_Query_RegisteredTokens_0(ctx context.Context, marshaler runti
 
 }
 
+func request_Query_RegisteredTokensWithMarkets_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryRegisteredTokensWithMarkets
+	var metadata runtime.ServerMetadata
+
+	msg, err := client.RegisteredTokensWithMarkets(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_RegisteredTokensWithMarkets_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryRegisteredTokensWithMarkets
+	var metadata runtime.ServerMetadata
+
+	msg, err := server.RegisteredTokensWithMarkets(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 var (
 	filter_Query_SpecialAssets_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
 )
@@ -463,6 +481,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 
 	})
 
+	mux.Handle("GET", pattern_Query_RegisteredTokensWithMarkets_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_RegisteredTokensWithMarkets_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_RegisteredTokensWithMarkets_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_SpecialAssets_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -774,6 +815,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_RegisteredTokensWithMarkets_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_RegisteredTokensWithMarkets_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_RegisteredTokensWithMarkets_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_SpecialAssets_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -982,6 +1043,8 @@ var (
 
 	pattern_Query_RegisteredTokens_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"umee", "leverage", "v1", "registered_tokens"}, "", runtime.AssumeColonVerbOpt(false)))
 
+	pattern_Query_RegisteredTokensWithMarkets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"umee", "leverage", "v1", "registered_tokens_with_markets"}, "", runtime.AssumeColonVerbOpt(false)))
+
 	pattern_Query_SpecialAssets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"umee", "leverage", "v1", "special_assets"}, "", runtime.AssumeColonVerbOpt(false)))
 
 	pattern_Query_MarketSummary_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"umee", "leverage", "v1", "market_summary"}, "", runtime.AssumeColonVerbOpt(false)))
@@ -1008,6 +1071,8 @@ var (
 
 	forward_Query_RegisteredTokens_0 = runtime.ForwardResponseMessage
 
+	forward_Query_RegisteredTokensWithMarkets_0 = runtime.ForwardResponseMessage
+
 	forward_Query_SpecialAssets_0 = runtime.ForwardResponseMessage
 
 	forward_Query_MarketSummary_0 = runtime.ForwardResponseMessage
diff --git a/x/uibc/uibc.pb.go b/x/uibc/uibc.pb.go
index 7cc9fef99b..934783d454 100644
--- a/x/uibc/uibc.pb.go
+++ b/x/uibc/uibc.pb.go
@@ -73,21 +73,21 @@ func init() {
 func init() { proto.RegisterFile("umee/uibc/v1/uibc.proto", fileDescriptor_963b2b690b6cd9dd) }
 
 var fileDescriptor_963b2b690b6cd9dd = []byte{
-	// 219 bytes of a gzipped FileDescriptorProto
+	// 220 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2f, 0xcd, 0x4d, 0x4d,
 	0xd5, 0x2f, 0xcd, 0x4c, 0x4a, 0xd6, 0x2f, 0x33, 0x04, 0xd3, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9,
-	0x42, 0x3c, 0x20, 0x09, 0x3d, 0xb0, 0x40, 0x99, 0xa1, 0x94, 0x48, 0x7a, 0x7e, 0x7a, 0x3e, 0x58,
-	0x42, 0x1f, 0xc4, 0x82, 0xa8, 0x91, 0x92, 0x4c, 0xcf, 0xcf, 0x4f, 0xcf, 0x49, 0xd5, 0x07, 0xf3,
-	0x92, 0x4a, 0xd3, 0xf4, 0x13, 0xf3, 0x2a, 0x61, 0x52, 0xc9, 0xf9, 0xc5, 0xb9, 0xf9, 0xc5, 0xf1,
-	0x10, 0x3d, 0x10, 0x0e, 0x44, 0x4a, 0xc9, 0x96, 0x8b, 0xd3, 0xd3, 0x39, 0xd8, 0xc8, 0xc0, 0x37,
-	0x35, 0x37, 0x5f, 0xc8, 0x80, 0x8b, 0x23, 0x37, 0xb5, 0xb8, 0x38, 0x31, 0x3d, 0xb5, 0x58, 0x82,
-	0x51, 0x81, 0x59, 0x83, 0xdb, 0x48, 0x44, 0x0f, 0x62, 0xaa, 0x1e, 0xcc, 0x54, 0x3d, 0xc7, 0xbc,
-	0xca, 0x20, 0xb8, 0x2a, 0x27, 0x8f, 0x13, 0x0f, 0xe5, 0x18, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0,
-	0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x4e, 0x3c, 0x96, 0x63, 0xbc,
-	0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0xb5, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24,
-	0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0x90, 0x2f, 0x74, 0xf3, 0x52, 0x4b, 0xca, 0xf3, 0x8b, 0xb2, 0xc1,
-	0x1c, 0xfd, 0x32, 0x33, 0xfd, 0x0a, 0xb0, 0x47, 0x93, 0xd8, 0xc0, 0x36, 0x18, 0x03, 0x02, 0x00,
-	0x00, 0xff, 0xff, 0xb9, 0x78, 0x7f, 0x06, 0x04, 0x01, 0x00, 0x00,
+	0x42, 0x3c, 0x20, 0x09, 0x3d, 0xb0, 0x40, 0x99, 0xa1, 0x94, 0x64, 0x72, 0x7e, 0x71, 0x6e, 0x7e,
+	0x71, 0x3c, 0x58, 0x4e, 0x1f, 0xc2, 0x81, 0x28, 0x94, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x87, 0x88,
+	0x83, 0x58, 0x50, 0x51, 0xc9, 0xf4, 0xfc, 0xfc, 0xf4, 0x9c, 0x54, 0x7d, 0x30, 0x2f, 0xa9, 0x34,
+	0x4d, 0x3f, 0x31, 0xaf, 0x12, 0x22, 0xa5, 0x64, 0xcb, 0xc5, 0xe9, 0xe9, 0x1c, 0x6c, 0x64, 0xe0,
+	0x9b, 0x9a, 0x9b, 0x2f, 0x64, 0xc0, 0xc5, 0x91, 0x9b, 0x5a, 0x5c, 0x9c, 0x98, 0x9e, 0x5a, 0x2c,
+	0xc1, 0xa8, 0xc0, 0xac, 0xc1, 0x6d, 0x24, 0xa2, 0x07, 0xd1, 0xaa, 0x07, 0xd3, 0xaa, 0xe7, 0x98,
+	0x57, 0x19, 0x04, 0x57, 0xe5, 0xe4, 0x71, 0xe2, 0xa1, 0x1c, 0xc3, 0x89, 0x47, 0x72, 0x8c, 0x17,
+	0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x89, 0xc7, 0x72, 0x8c,
+	0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xa5, 0x96, 0x9e, 0x59, 0x92, 0x51, 0x9a,
+	0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x0f, 0xf2, 0x85, 0x6e, 0x5e, 0x6a, 0x49, 0x79, 0x7e, 0x51, 0x36,
+	0x98, 0xa3, 0x5f, 0x66, 0xa6, 0x5f, 0x01, 0xf6, 0x68, 0x12, 0x1b, 0xd8, 0x06, 0x63, 0x40, 0x00,
+	0x00, 0x00, 0xff, 0xff, 0xfe, 0xac, 0x4d, 0xe5, 0x04, 0x01, 0x00, 0x00,
 }
 
 func (m *ICS20Memo) Marshal() (dAtA []byte, err error) {