refactor: Provider Ticker Interface (PR1)

cmd/slinky-config/main.go

@@ -34,7 +34,7 @@ import (
 	"github.com/skip-mev/slinky/providers/websockets/mexc"
 	"github.com/skip-mev/slinky/providers/websockets/okx"
 	mmclienttypes "github.com/skip-mev/slinky/service/clients/marketmap/types"
-	mmtypes "github.com/skip-mev/slinky/x/marketmap/types"
+	mmtypes "github.com/skip-mev/slinky/x/mm2/types"
 )
 
 const (
@@ -86,16 +86,13 @@ var (
 	updateInterval time.Duration
 	// maxPriceAge is the maximum age of a price that the oracle will accept.
 	maxPriceAge time.Duration
-
 	// raydium-enabled determine whether or not the raydium defi provider will be configured.
 	raydiumEnabled bool
-
 	// solana node url is the solana node that the raydium provider will connect to.
 	solanaNodeURLs []string
-
 	// ProviderToMarkets defines a map of provider names to their respective market
 	// configurations. This is used to generate the local market config file.
-	ProviderToMarkets = map[string]types.TickerToProviderConfig{
+	ProviderToMarkets = map[string]types.CurrencyPairsToProviderTickers{
 		// -----------------------------------------------------------	//
 		// ---------------------Start API Providers--------------------	//
 		// -----------------------------------------------------------	//
@@ -344,10 +341,8 @@ func createOracleConfig() error {
 	if strings.ToLower(chain) == constants.DYDX {
 		// Filter out the providers that are not supported by the dYdX chain.
 		validProviders := make(map[string]struct{})
-		for _, providers := range dydx.ProviderMapping {
-			for _, provider := range providers {
-				validProviders[provider] = struct{}{}
-			}
+		for _, slinkyProvider := range dydx.ProviderMapping {
+			validProviders[slinkyProvider] = struct{}{}
 		}
 
 		ps := make([]config.ProviderConfig, 0)
@@ -444,11 +439,9 @@ func createMarketMap() error {
 	var (
 		// Tickers defines a map of tickers to their respective ticker configurations. This
 		// contains all of the tickers that are supported by the oracle.
-		tickers = make(map[string]mmtypes.Ticker)
-		// TickersToProviders defines a map of tickers to their respective providers. This
-		// contains all of the providers that are supported per ticker.
-		tickersToProviders = make(map[string]mmtypes.Providers)
-		tickersToPaths     = make(map[string]mmtypes.Paths)
+		marketMap = mmtypes.MarketMap{
+			Markets: make(map[string]mmtypes.Market),
+		}
 	)
 
 	// if raydium is enabled, configure the raydium markets based on the local raydium_pairs fixture
@@ -458,50 +451,32 @@ func createMarketMap() error {
 
 	// Iterate through all of the provider ticker configurations and update the
 	// tickers and tickers to providers maps.
-	for name, providerConfig := range ProviderToMarkets {
-		for ticker, config := range providerConfig {
-			tickerStr := ticker.String()
-
-			// Add the ticker to the tickers map iff the ticker does not already exist. If the
-			// ticker already exists, ensure that the ticker configuration is the same.
-			if t, ok := tickers[tickerStr]; !ok {
-				tickers[tickerStr] = ticker
-			} else if t != ticker {
-				return fmt.Errorf("ticker %s already exists with different configuration for provider %s", tickerStr, name)
+	for _, providerConfig := range ProviderToMarkets {
+		for cp, config := range providerConfig {
+			ticker := mmtypes.Ticker{
+				CurrencyPair:     cp,
+				Decimals:         18,
+				MinProviderCount: 1,
 			}
 
-			// Instantiate the providers for a given ticker.
-			if _, ok := tickersToProviders[tickerStr]; !ok {
-				tickersToProviders[tickerStr] = mmtypes.Providers{}
+			// Add the ticker to the tickers map iff the ticker does not already exist.
+			if _, ok := marketMap.Markets[ticker.String()]; !ok {
+				marketMap.Markets[ticker.String()] = mmtypes.Market{
+					Ticker:          ticker,
+					ProviderConfigs: make([]mmtypes.ProviderConfig, 0),
+				}
 			}
 
-			// Add the provider to the tickers to providers map.
-			providers := tickersToProviders[tickerStr].Providers
-			providers = append(providers, config)
-			tickersToProviders[tickerStr] = mmtypes.Providers{Providers: providers}
-
-			if _, ok := tickersToPaths[tickerStr]; !ok {
-				tickersToPaths[tickerStr] = mmtypes.Paths{}
-			}
-			paths := tickersToPaths[tickerStr].Paths
-			paths = append(paths, mmtypes.Path{Operations: []mmtypes.Operation{
-				{
-					CurrencyPair: ticker.CurrencyPair,
-					Invert:       false,
-					Provider:     config.Name,
-				},
-			}})
-			tickersToPaths[tickerStr] = mmtypes.Paths{Paths: paths}
+			market := marketMap.Markets[ticker.String()]
+			market.ProviderConfigs = append(market.ProviderConfigs, mmtypes.ProviderConfig{
+				Name:           config.Name,
+				OffChainTicker: config.OffChainTicker,
+				Metadata_JSON:  config.JSON,
+			})
+			marketMap.Markets[ticker.String()] = market
 		}
 	}
 
-	// Create a new market map from the provider to market map.
-	marketMap := mmtypes.MarketMap{
-		Tickers:   tickers,
-		Providers: tickersToProviders,
-		Paths:     tickersToPaths,
-	}
-
 	// Validate the market map.
 	if err := marketMap.ValidateBasic(); err != nil {
 		return fmt.Errorf("error validating the market map: %w", err)
@@ -538,7 +513,7 @@ type TickerMetaData struct {
 	TickerMetaData raydium.TickerMetadata   `json:"ticker_metadata"`
 }
 
-func addRaydiumMarkets(providerToMarkets map[string]map[mmtypes.Ticker]mmtypes.ProviderConfig) map[string]map[mmtypes.Ticker]mmtypes.ProviderConfig {
+func addRaydiumMarkets(providerToMarkets map[string]types.CurrencyPairsToProviderTickers) map[string]types.CurrencyPairsToProviderTickers {
 	// read the raydium_pairs fixture
 	if !raydiumEnabled {
 		return providerToMarkets
@@ -565,17 +540,12 @@ func addRaydiumMarkets(providerToMarkets map[string]map[mmtypes.Ticker]mmtypes.P
 	}
 
 	// add the raydium markets to the provider to markets map
-	providerToMarkets[raydium.Name] = make(map[mmtypes.Ticker]mmtypes.ProviderConfig)
+	providerToMarkets[raydium.Name] = make(types.CurrencyPairsToProviderTickers)
 	for _, pair := range raydiumPairs {
-		providerToMarkets[raydium.Name][mmtypes.Ticker{
-			CurrencyPair:     pair.Cp,
-			Decimals:         18,
-			MinProviderCount: 1,
-			Enabled:          true,
-			Metadata_JSON:    marshalToJSONString(pair.TickerMetaData),
-		}] = mmtypes.ProviderConfig{
+		providerToMarkets[raydium.Name][pair.Cp] = types.DefaultProviderTicker{
 			Name:           raydium.Name,
 			OffChainTicker: pair.Cp.String(),
+			JSON:           marshalToJSONString(pair.TickerMetaData),
 		}
 	}
 

cmd/slinky/main.go

@@ -17,12 +17,11 @@ import (
 	"github.com/skip-mev/slinky/oracle/config"
 	oraclemetrics "github.com/skip-mev/slinky/oracle/metrics"
 	"github.com/skip-mev/slinky/oracle/orchestrator"
-	"github.com/skip-mev/slinky/oracle/types"
 	oraclemath "github.com/skip-mev/slinky/pkg/math/oracle"
 	oraclefactory "github.com/skip-mev/slinky/providers/factories/oracle"
 	oracleserver "github.com/skip-mev/slinky/service/servers/oracle"
 	promserver "github.com/skip-mev/slinky/service/servers/prometheus"
-	mmtypes "github.com/skip-mev/slinky/x/marketmap/types"
+	mmtypes "github.com/skip-mev/slinky/x/mm2/types"
 )
 
 var (
@@ -104,7 +103,7 @@ func runOracle() error {
 
 	var marketCfg mmtypes.MarketMap
 	if marketCfgPath != "" {
-		marketCfg, err = types.ReadMarketConfigFromFile(marketCfgPath)
+		marketCfg, err = mmtypes.ReadMarketConfigFromFile(marketCfgPath)
 		if err != nil {
 			return fmt.Errorf("failed to read market config file: %s", err.Error())
 		}