feat: Reimplement & test GetCandidateRoute algorithm

app/sidecar_query_server.go

@@ -115,8 +115,11 @@ func NewSideCarQueryServer(appCodec codec.Codec, config domain.Config, logger lo
 	// Initialize pools repository, usecase and HTTP handler
 	poolsUseCase := poolsUseCase.NewPoolsUsecase(config.Pools, config.ChainGRPCGatewayEndpoint, routerRepository, tokensUseCase.GetChainScalingFactorByDenomMut)
 
+	// Initialize candidate route searcher
+	candidateRouteSearcher := routerUseCase.NewCandidateRouteFinder(routerRepository, logger)
+
 	// Initialize router repository, usecase
-	routerUsecase := routerUseCase.NewRouterUsecase(routerRepository, poolsUseCase, tokensUseCase, *config.Router, poolsUseCase.GetCosmWasmPoolConfig(), logger, cache.New(), cache.New())
+	routerUsecase := routerUseCase.NewRouterUsecase(routerRepository, poolsUseCase, candidateRouteSearcher, tokensUseCase, *config.Router, poolsUseCase.GetCosmWasmPoolConfig(), logger, cache.New(), cache.New())
 
 	// Initialize system handler
 	chainInfoRepository := chaininforepo.New()
@@ -125,7 +128,7 @@ func NewSideCarQueryServer(appCodec codec.Codec, config domain.Config, logger lo
 	cosmWasmPoolConfig := poolsUseCase.GetCosmWasmPoolConfig()
 
 	// Initialize chain pricing strategy
-	pricingSimpleRouterUsecase := routerUseCase.NewRouterUsecase(routerRepository, poolsUseCase, tokensUseCase, *config.Router, cosmWasmPoolConfig, logger, cache.New(), cache.New())
+	pricingSimpleRouterUsecase := routerUseCase.NewRouterUsecase(routerRepository, poolsUseCase, candidateRouteSearcher, tokensUseCase, *config.Router, cosmWasmPoolConfig, logger, cache.New(), cache.New())
 	chainPricingSource, err := pricing.NewPricingStrategy(*config.Pricing, tokensUseCase, pricingSimpleRouterUsecase)
 	if err != nil {
 		return nil, err

domain/candidate_routes.go

@@ -0,0 +1,24 @@
+package domain
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/osmosis-labs/sqs/sqsdomain"
+)
+
+// CandidateRouteSearchOptions represents the options for finding candidate routes.
+type CandidateRouteSearchOptions struct {
+	// MaxRoutes is the maximum number of routes to find.
+	MaxRoutes int
+	// MaxPoolsPerRoute is the maximum number of pools to consider for each route.
+	MaxPoolsPerRoute int
+	// MinPoolLiquidityCap is the minimum liquidity cap for a pool to be considered.
+	MinPoolLiquidityCap uint64
+}
+
+// CandidateRouteSearcher is the interface for finding candidate routes.
+type CandidateRouteSearcher interface {
+	// FindCandidateRoutes finds candidate routes for a given tokenIn and tokenOutDenom
+	// using the given options.
+	// Returns the candidate routes and an error if any.
+	FindCandidateRoutes(tokenIn sdk.Coin, tokenOutDenom string, options CandidateRouteSearchOptions) (sqsdomain.CandidateRoutes, error)
+}

domain/mocks/candidate_route_data_holder_mock.go

@@ -20,3 +20,12 @@ func (c *CandidateRouteSearchDataHolderMock) GetCandidateRouteSearchData() map[s
 func (c *CandidateRouteSearchDataHolderMock) SetCandidateRouteSearchData(candidateRouteSearchData map[string][]sqsdomain.PoolI) {
 	c.CandidateRouteSearchData = candidateRouteSearchData
 }
+
+// GetRankedPoolsByDenom implements mvc.CandidateRouteSearchDataHolder.
+func (c *CandidateRouteSearchDataHolderMock) GetRankedPoolsByDenom(denom string) ([]sqsdomain.PoolI, error) {
+	pools, ok := c.CandidateRouteSearchData[denom]
+	if !ok {
+		return []sqsdomain.PoolI{}, nil
+	}
+	return pools, nil
+}

domain/mocks/candidate_route_finder_mock.go

@@ -0,0 +1,19 @@
+package mocks
+
+import (
+	"github.com/cosmos/cosmos-sdk/types"
+	"github.com/osmosis-labs/sqs/domain"
+	"github.com/osmosis-labs/sqs/sqsdomain"
+)
+
+type CandidateRouteFinderMock struct {
+	Routes sqsdomain.CandidateRoutes
+	Error  error
+}
+
+var _ domain.CandidateRouteSearcher = CandidateRouteFinderMock{}
+
+// FindCandidateRoutes implements domain.CandidateRouteSearcher.
+func (c CandidateRouteFinderMock) FindCandidateRoutes(tokenIn types.Coin, tokenOutDenom string, options domain.CandidateRouteSearchOptions) (sqsdomain.CandidateRoutes, error) {
+	return c.Routes, c.Error
+}

domain/mvc/router.go

@@ -17,6 +17,11 @@ type CandidateRouteSearchDataHolder interface {
 
 	// GetCandidateRouteSearchData gets the candidate route search data from the holder
 	GetCandidateRouteSearchData() map[string][]sqsdomain.PoolI
+
+	// GetRankedPoolsByDenom returns the ranked candidate route search pools for a given denom.
+	// Returns an empty slice if the denom is not found.
+	// Returns error if retrieved pools are not of type sqsdomain.PoolI.
+	GetRankedPoolsByDenom(denom string) ([]sqsdomain.PoolI, error)
 }
 
 // RouterRepository represents the contract for a repository handling tokens information

router/repository/memory_router_repository.go

@@ -1,6 +1,7 @@
 package routerrepo
 
 import (
+	"fmt"
 	"sync"
 
 	"cosmossdk.io/math"
@@ -135,6 +136,21 @@ func (r *routerRepo) GetCandidateRouteSearchData() map[string][]sqsdomain.PoolI
 	return candidateRouteSearchData
 }
 
+// GetRankedPoolsByDenom implements mvc.CandidateRouteSearchDataHolder.
+func (r *routerRepo) GetRankedPoolsByDenom(denom string) ([]sqsdomain.PoolI, error) {
+	poolsData, ok := r.candidateRouteSearchData.Load(denom)
+	if !ok {
+		return []sqsdomain.PoolI{}, nil
+	}
+
+	pools, ok := poolsData.([]sqsdomain.PoolI)
+	if !ok {
+		return nil, fmt.Errorf("error casting value to []sqsdomain.PoolI in GetByDenom")
+	}
+
+	return pools, nil
+}
+
 // SetCandidateRouteSearchData implements mvc.RouterUsecase.
 func (r *routerRepo) SetCandidateRouteSearchData(candidateRouteSearchData map[string][]sqsdomain.PoolI) {
 	for denom, pools := range candidateRouteSearchData {

router/repository/memory_router_repository_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/alecthomas/assert/v2"
 	"github.com/osmosis-labs/osmosis/osmomath"
+	"github.com/osmosis-labs/sqs/domain/mocks"
 	"github.com/osmosis-labs/sqs/log"
 	routerrepo "github.com/osmosis-labs/sqs/router/repository"
 	"github.com/osmosis-labs/sqs/sqsdomain"
@@ -171,3 +172,54 @@ func (suite *RouteRepositoryChatGPTTestSuite) TestSetTakerFees() {
 		})
 	}
 }
+
+// Sanity checks validating the implementation of the GetRankedPoolsByDenom method
+func (suite *RouteRepositoryChatGPTTestSuite) TestGetRankedPoolsByDenom_HappyPath() {
+	const (
+		defaultPoolID = 1
+
+		denomA = "denomA"
+		denomB = "denomB"
+
+		denomNoPools = "denomNoPools"
+	)
+
+	var (
+		denomOnePools = []sqsdomain.PoolI{
+			&sqsdomain.PoolWrapper{
+				ChainModel: &mocks.ChainPoolMock{
+					ID: defaultPoolID,
+				},
+			}}
+
+		denomTwoPools = []sqsdomain.PoolI{
+			&sqsdomain.PoolWrapper{
+				ChainModel: &mocks.ChainPoolMock{
+					ID: defaultPoolID + 1,
+				},
+			}}
+	)
+
+	candidateRouteSearchData := map[string][]sqsdomain.PoolI{
+		denomA: denomOnePools,
+		denomB: denomTwoPools,
+	}
+
+	// System under test.
+	suite.repository.SetCandidateRouteSearchData(candidateRouteSearchData)
+
+	// Denom a has the expected pools.
+	actualDenomOnePools, err := suite.repository.GetRankedPoolsByDenom(denomA)
+	suite.Require().NoError(err)
+	suite.Require().Equal(denomOnePools, actualDenomOnePools)
+
+	// Denom b has the expected pools.
+	actualDenomTwoPools, err := suite.repository.GetRankedPoolsByDenom(denomB)
+	suite.Require().NoError(err)
+	suite.Require().Equal(denomTwoPools, actualDenomTwoPools)
+
+	// Denom with no pools returns an empty slice.
+	actualNoDenomPools, err := suite.repository.GetRankedPoolsByDenom(denomNoPools)
+	suite.Require().NoError(err)
+	suite.Require().Empty(actualNoDenomPools)
+}

router/usecase/candidate_routes.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/osmosis-labs/sqs/domain"
+	"github.com/osmosis-labs/sqs/domain/mvc"
 	"github.com/osmosis-labs/sqs/log"
 	"github.com/osmosis-labs/sqs/sqsdomain"
 	"go.uber.org/zap"
@@ -144,11 +146,23 @@ func GetCandidateRoutes(pools []sqsdomain.PoolI, tokenIn sdk.Coin, tokenOutDenom
 	return validateAndFilterRoutes(routes, tokenIn.Denom, logger)
 }
 
-// GetCandidateRoutesNew new algorithm for demo purposes.
-// Note: implementation is for demo purposes and is to be further optimized.
-// TODO: spec, unit tests via https://linear.app/osmosis/issue/DATA-250/[candidaterouteopt]-reimplement-and-test-getcandidateroute-algorithm
-func GetCandidateRoutesNew(poolsByDenom map[string][]sqsdomain.PoolI, tokenIn sdk.Coin, tokenOutDenom string, maxRoutes, maxPoolsPerRoute int, minPoolLiquidityCap uint64, logger log.Logger) (sqsdomain.CandidateRoutes, error) {
-	routes := make([][]candidatePoolWrapper, 0, maxRoutes)
+type candidateRouteFinder struct {
+	candidateRouteDataHolder mvc.CandidateRouteSearchDataHolder
+	logger                   log.Logger
+}
+
+var _ domain.CandidateRouteSearcher = candidateRouteFinder{}
+
+func NewCandidateRouteFinder(candidateRouteDataHolder mvc.CandidateRouteSearchDataHolder, logger log.Logger) candidateRouteFinder {
+	return candidateRouteFinder{
+		candidateRouteDataHolder: candidateRouteDataHolder,
+		logger:                   logger,
+	}
+}
+
+// FindCandidateRoutes implements domain.CandidateRouteFinder.
+func (c candidateRouteFinder) FindCandidateRoutes(tokenIn sdk.Coin, tokenOutDenom string, options domain.CandidateRouteSearchOptions) (sqsdomain.CandidateRoutes, error) {
+	routes := make([][]candidatePoolWrapper, 0, options.MaxRoutes)
 
 	// Preallocate constant visited map size to avoid reallocations.
 	// TODO: choose the best size for the visited map.
@@ -158,9 +172,9 @@ func GetCandidateRoutesNew(poolsByDenom map[string][]sqsdomain.PoolI, tokenIn sd
 	// Preallocate constant queue size to avoid dynamic reallocations.
 	// TODO: choose the best size for the queue.
 	queue := make([][]candidatePoolWrapper, 0, 100)
-	queue = append(queue, make([]candidatePoolWrapper, 0, maxPoolsPerRoute))
+	queue = append(queue, make([]candidatePoolWrapper, 0, options.MaxPoolsPerRoute))
 
-	for len(queue) > 0 && len(routes) < maxRoutes {
+	for len(queue) > 0 && len(routes) < options.MaxRoutes {
 		currentRoute := queue[0]
 		queue[0] = nil // Clear the slice to avoid holding onto references
 		queue = queue[1:]
@@ -173,12 +187,15 @@ func GetCandidateRoutesNew(poolsByDenom map[string][]sqsdomain.PoolI, tokenIn sd
 			currenTokenInDenom = lastPool.TokenOutDenom
 		}
 
-		rankedPools, ok := poolsByDenom[currenTokenInDenom]
-		if !ok {
+		rankedPools, err := c.candidateRouteDataHolder.GetRankedPoolsByDenom(currenTokenInDenom)
+		if err != nil {
+			return sqsdomain.CandidateRoutes{}, err
+		}
+		if len(rankedPools) == 0 {
 			return sqsdomain.CandidateRoutes{}, fmt.Errorf("no pools found for denom %s", currenTokenInDenom)
 		}
 
-		for i := 0; i < len(rankedPools) && len(routes) < maxRoutes; i++ {
+		for i := 0; i < len(rankedPools) && len(routes) < options.MaxRoutes; i++ {
 			// Unsafe cast for performance reasons.
 			// nolint: forcetypeassert
 			pool := (rankedPools[i]).(*sqsdomain.PoolWrapper)
@@ -188,7 +205,7 @@ func GetCandidateRoutesNew(poolsByDenom map[string][]sqsdomain.PoolI, tokenIn sd
 				continue
 			}
 
-			if pool.GetLiquidityCap().Uint64() < minPoolLiquidityCap {
+			if pool.GetLiquidityCap().Uint64() < options.MinPoolLiquidityCap {
 				visited[poolID] = struct{}{}
 				// Skip pools that have less liquidity than the minimum required.
 				continue
@@ -247,9 +264,12 @@ func GetCandidateRoutesNew(poolsByDenom map[string][]sqsdomain.PoolI, tokenIn sd
 					continue
 				}
 
-				_, ok := poolsByDenom[denom]
-				if !ok {
-					logger.Debug("no pools found for denom in candidate route search", zap.String("denom", denom))
+				rankedPools, err := c.candidateRouteDataHolder.GetRankedPoolsByDenom(currenTokenInDenom)
+				if err != nil {
+					return sqsdomain.CandidateRoutes{}, err
+				}
+				if len(rankedPools) == 0 {
+					c.logger.Debug("no pools found for denom in candidate route search", zap.String("denom", denom))
 					continue
 				}
 
@@ -267,7 +287,7 @@ func GetCandidateRoutesNew(poolsByDenom map[string][]sqsdomain.PoolI, tokenIn sd
 						Idx:        i,
 					})
 
-					if len(newPath) <= maxPoolsPerRoute {
+					if len(newPath) <= options.MaxPoolsPerRoute {
 						if hasTokenOut {
 							routes = append(routes, newPath)
 							break
@@ -284,7 +304,7 @@ func GetCandidateRoutesNew(poolsByDenom map[string][]sqsdomain.PoolI, tokenIn sd
 		}
 	}
 
-	return validateAndFilterRoutes(routes, tokenIn.Denom, logger)
+	return validateAndFilterRoutes(routes, tokenIn.Denom, c.logger)
 }
 
 // Pool represents a pool in the decentralized exchange.

router/usecase/candidate_routes_bench_test.go

@@ -0,0 +1,47 @@
+package usecase_test
+
+import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/osmosis-labs/osmosis/osmomath"
+	"github.com/osmosis-labs/sqs/domain"
+	"github.com/osmosis-labs/sqs/router/usecase/routertesting"
+)
+
+// Microbenchmark for the GetSplitQuote function.
+func BenchmarkCandidateRouteSearcher(b *testing.B) {
+	// This is a hack to be able to use test suite helpers with the benchmark.
+	// We need to set testing.T for assertings within the helpers. Otherwise, it would block
+	s := RouterTestSuite{}
+	s.SetT(&testing.T{})
+
+	mainnetState := s.SetupMainnetState()
+
+	usecase := s.SetupRouterAndPoolsUsecase(mainnetState, routertesting.WithLoggerDisabled())
+
+	var (
+		amountIn      = osmomath.NewInt(1_000_000)
+		tokenIn       = sdk.NewCoin(UOSMO, amountIn)
+		tokenOutDenom = ATOM
+	)
+
+	routerConfig := usecase.Router.GetConfig()
+	candidateRouteOptions := domain.CandidateRouteSearchOptions{
+		MaxRoutes:           routerConfig.MaxRoutes,
+		MaxPoolsPerRoute:    routerConfig.MaxPoolsPerRoute,
+		MinPoolLiquidityCap: 1,
+	}
+
+	b.ResetTimer()
+
+	// Run the benchmark
+	for i := 0; i < b.N; i++ {
+		// System under test
+		_, err := usecase.CandidateRouteSearcher.FindCandidateRoutes(tokenIn, tokenOutDenom, candidateRouteOptions)
+		s.Require().NoError(err)
+		if err != nil {
+			b.Errorf("FindCandidateRoutes returned an error: %v", err)
+		}
+	}
+}