Implement the caching logic to the pools query experimentally

go.mod

@@ -10,6 +10,7 @@ require (
 	github.com/golang/protobuf v1.5.2
 	github.com/gorilla/mux v1.8.0
 	github.com/grpc-ecosystem/grpc-gateway v1.16.0
+	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/pkg/errors v0.9.1
 	github.com/rakyll/statik v0.1.7
 	github.com/regen-network/cosmos-proto v0.3.1

go.sum

@@ -416,6 +416,9 @@ github.com/pact-foundation/pact-go v1.0.4/go.mod h1:uExwJY4kCzNPcHRj+hCR/HBbOOIw
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0MwY=
 github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
+github.com/patrickmn/go-cache v1.0.0 h1:3gD5McaYs9CxjyK5AXGcq8gdeCARtd/9gJDUvVeaZ0Y=
+github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
+github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
 github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pelletier/go-toml v1.8.1 h1:1Nf83orprkJyknT6h7zbuEGUEjcyVlCxSUGTENmNCRM=

x/gamm/keeper/grpc_query.go

@@ -4,6 +4,9 @@ import (
 	"context"
 	"fmt"
 	"math/big"
+	"time"
+
+	"github.com/patrickmn/go-cache"
 
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 
@@ -20,6 +23,8 @@ import (
 
 var (
 	sdkIntMaxValue = sdk.NewInt(0)
+
+	queryPoolsCache = cache.New(1*time.Second, 5*time.Second)
 )
 
 func init() {
@@ -72,6 +77,16 @@ func (k Keeper) Pools(
 	store := sdkCtx.KVStore(k.storeKey)
 	poolStore := prefix.NewStore(store, types.KeyPrefixPools)
 
+	cacheKey := "PoolsPagination/" + req.Pagination.String()
+
+	cached, cacheFound := queryPoolsCache.Get(cacheKey)
+	if cached != nil && cacheFound {
+		cachedRes, ok := cached.(*types.QueryPoolsResponse)
+		if ok {
+			return cachedRes, nil
+		}
+	}
+
 	var anys []*codectypes.Any
 	pageRes, err := query.Paginate(poolStore, req.Pagination, func(_, value []byte) error {
 		poolI, err := k.UnmarshalPool(value)
@@ -102,10 +117,14 @@ func (k Keeper) Pools(
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 
-	return &types.QueryPoolsResponse{
+	response := &types.QueryPoolsResponse{
 		Pools:      anys,
 		Pagination: pageRes,
-	}, nil
+	}
+
+	queryPoolsCache.Set(cacheKey, response, cache.DefaultExpiration)
+
+	return response, nil
 }
 
 func (k Keeper) NumPools(

x/gamm/keeper/grpc_query_test.go

@@ -2,6 +2,7 @@ package keeper_test
 
 import (
 	gocontext "context"
+	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
@@ -257,3 +258,88 @@ func (suite *KeeperTestSuite) TestQuerySpotPrice() {
 	suite.NoError(err)
 	suite.Equal(sdk.NewDec(1).Quo(sdk.NewDec(3)).String(), res.SpotPrice)
 }
+
+func (suite *KeeperTestSuite) TestQueryPoolsCaching() {
+	queryClient := suite.queryClient
+
+	// Ceate 1 pool
+	suite.preparePool()
+
+	res, err := queryClient.Pools(gocontext.Background(), &types.QueryPoolsRequest{
+		Pagination: &query.PageRequest{
+			Key:        nil,
+			Limit:      2,
+			CountTotal: false,
+		},
+	})
+	suite.Require().NoError(err)
+	suite.Require().Equal(1, len(res.Pools))
+	for i, r := range res.Pools {
+		var pool types.PoolI
+		err = suite.app.InterfaceRegistry().UnpackAny(r, &pool)
+		suite.Require().NoError(err)
+		suite.Require().Equal(types.NewPoolAddress(uint64(i+1)).String(), pool.GetAddress().String())
+		suite.Require().Equal(uint64(i+1), pool.GetId())
+	}
+
+	// Ceate 1 more pool
+	suite.preparePool()
+
+	// In this time, actually the two pools exists.
+	// But, due to the caching logic, this should return the same response with above.
+	res, err = queryClient.Pools(gocontext.Background(), &types.QueryPoolsRequest{
+		Pagination: &query.PageRequest{
+			Key:        nil,
+			Limit:      2,
+			CountTotal: false,
+		},
+	})
+	suite.Require().NoError(err)
+	suite.Require().Equal(1, len(res.Pools))
+	for i, r := range res.Pools {
+		var pool types.PoolI
+		err = suite.app.InterfaceRegistry().UnpackAny(r, &pool)
+		suite.Require().NoError(err)
+		suite.Require().Equal(types.NewPoolAddress(uint64(i+1)).String(), pool.GetAddress().String())
+		suite.Require().Equal(uint64(i+1), pool.GetId())
+	}
+
+	// The response is cached per the pagination options,
+	// so querying with the pagination with different limit should return new response.
+	res, err = queryClient.Pools(gocontext.Background(), &types.QueryPoolsRequest{
+		Pagination: &query.PageRequest{
+			Key:        nil,
+			Limit:      3,
+			CountTotal: false,
+		},
+	})
+	suite.Require().NoError(err)
+	suite.Require().Equal(2, len(res.Pools))
+	for i, r := range res.Pools {
+		var pool types.PoolI
+		err = suite.app.InterfaceRegistry().UnpackAny(r, &pool)
+		suite.Require().NoError(err)
+		suite.Require().Equal(types.NewPoolAddress(uint64(i+1)).String(), pool.GetAddress().String())
+		suite.Require().Equal(uint64(i+1), pool.GetId())
+	}
+
+	// And, because the caching lifetime is only 1 second,
+	// it should return new response after 1 second.
+	time.Sleep(time.Second)
+	res, err = queryClient.Pools(gocontext.Background(), &types.QueryPoolsRequest{
+		Pagination: &query.PageRequest{
+			Key:        nil,
+			Limit:      2,
+			CountTotal: false,
+		},
+	})
+	suite.Require().NoError(err)
+	suite.Require().Equal(2, len(res.Pools))
+	for i, r := range res.Pools {
+		var pool types.PoolI
+		err = suite.app.InterfaceRegistry().UnpackAny(r, &pool)
+		suite.Require().NoError(err)
+		suite.Require().Equal(types.NewPoolAddress(uint64(i+1)).String(), pool.GetAddress().String())
+		suite.Require().Equal(uint64(i+1), pool.GetId())
+	}
+}