explorer.go

package node

import (
	"context"
	"fmt"
	"net/http"
	"time"

	"github.com/synapsecns/sanguine/core/metrics"

	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/synapsecns/sanguine/services/explorer/backfill"
	indexerConfig "github.com/synapsecns/sanguine/services/explorer/config/indexer"
	gqlClient "github.com/synapsecns/sanguine/services/explorer/consumer/client"
	fetcherpkg "github.com/synapsecns/sanguine/services/explorer/consumer/fetcher"
	"github.com/synapsecns/sanguine/services/explorer/consumer/fetcher/tokenprice"
	"github.com/synapsecns/sanguine/services/explorer/consumer/parser"
	"github.com/synapsecns/sanguine/services/explorer/consumer/parser/tokendata"
	"github.com/synapsecns/sanguine/services/explorer/contracts/bridgeconfig"
	"github.com/synapsecns/sanguine/services/explorer/db"
	"github.com/synapsecns/sanguine/services/explorer/static"
	"golang.org/x/sync/errgroup"
)

// ExplorerBackfiller is a backfiller that aggregates all backfilling from ChainBackfillers.
type ExplorerBackfiller struct {

	// consumerDB is the database to store consumer data in.
	consumerDB db.ConsumerDB
	// clients is a mapping of chain IDs -> clients.
	clients map[uint32]bind.ContractBackend
	// ChainBackfillers is a mapping of chain IDs -> chain backfillers.
	ChainBackfillers map[uint32]*backfill.ChainBackfiller
	// config is the config for the backfiller.
	config indexerConfig.Config
}

// NewExplorerBackfiller creates a new backfiller for the explorer.
//
// nolint:gocognit
func NewExplorerBackfiller(consumerDB db.ConsumerDB, config indexerConfig.Config, clients map[uint32]bind.ContractBackend, handler metrics.Handler) (*ExplorerBackfiller, error) {
	chainBackfillers := make(map[uint32]*backfill.ChainBackfiller)
	httpClient := http.Client{
		Timeout: 10 * time.Second,
		Transport: &http.Transport{
			ResponseHeaderTimeout: 10 * time.Second,
		},
	}
	fetcher := fetcherpkg.NewFetcher(gqlClient.NewClient(&httpClient, config.ScribeURL), handler)
	bridgeConfigRef, err := bridgeconfig.NewBridgeConfigRef(common.HexToAddress(config.BridgeConfigAddress), clients[config.BridgeConfigChainID])
	if err != nil || bridgeConfigRef == nil {
		return nil, fmt.Errorf("could not create bridge config ScribeFetcher: %w", err)
	}
	priceDataService, err := tokenprice.NewPriceDataService()
	if err != nil {
		return nil, fmt.Errorf("could not create price data service: %w", err)
	}
	newConfigFetcher, err := fetcherpkg.NewBridgeConfigFetcher(common.HexToAddress(config.BridgeConfigAddress), bridgeConfigRef)
	if err != nil || newConfigFetcher == nil {
		return nil, fmt.Errorf("could not get bridge abi: %w", err)
	}
	tokenSymbolToIDs, err := parser.ParseYaml(static.GetTokenSymbolToTokenIDConfig())
	if err != nil {
		return nil, fmt.Errorf("could not open yaml file: %w", err)
	}
	tokenDataService, err := tokendata.NewTokenDataService(newConfigFetcher, tokenSymbolToIDs)
	if err != nil {
		return nil, fmt.Errorf("could not create token data service: %w", err)
	}

	// Initialize each chain backfiller.
	for _, chainConfig := range config.Chains {
		chainBackfiller, err := getChainBackfiller(consumerDB, chainConfig, fetcher, clients[chainConfig.ChainID], tokenDataService, priceDataService)
		if err != nil {
			return nil, fmt.Errorf("could not get chain backfiller: %w", err)
		}

		chainBackfillers[chainConfig.ChainID] = chainBackfiller
	}

	return &ExplorerBackfiller{
		consumerDB:       consumerDB,
		clients:          clients,
		ChainBackfillers: chainBackfillers,
		config:           config,
	}, nil
}

// Backfill iterates over each chain backfiller and calls Backfill concurrently on each one.
//
// nolint:cyclop
func (e ExplorerBackfiller) Backfill(ctx context.Context, livefill bool) error {
	refreshRate := e.config.DefaultRefreshRate

	if refreshRate == 0 {
		refreshRate = 1
	}

	g, groupCtx := errgroup.WithContext(ctx)

	for i := range e.config.Chains {
		chainConfig := e.config.Chains[i]
		chainBackfiller := e.ChainBackfillers[chainConfig.ChainID]
		g.Go(func() error {
			err := chainBackfiller.Backfill(groupCtx, livefill, refreshRate)
			if err != nil {
				return fmt.Errorf("could not backfill chain %d: %w", chainConfig.ChainID, err)
			}
			return nil
		})
	}
	if err := g.Wait(); err != nil {
		logger.Errorf("backfill completed: %v", err)

		return fmt.Errorf("could not livefill explorer: %w", err)
	}
	logger.Errorf("backfill completed with no errors")

	return nil
}

// nolint gocognit,cyclop
func getChainBackfiller(consumerDB db.ConsumerDB, chainConfig indexerConfig.ChainConfig, fetcher fetcherpkg.ScribeFetcher, client bind.ContractBackend, tokenDataService tokendata.Service, priceDataService tokenprice.Service) (*backfill.ChainBackfiller, error) {
	var err error
	var bridgeParser *parser.BridgeParser
	var messageBusParser *parser.MessageBusParser
	var cctpParser *parser.CCTPParser
	var swapService fetcherpkg.SwapService
	var cctpService fetcherpkg.CCTPService
	var rfqParser *parser.RFQParser
	var rfqService fetcherpkg.RFQService

	swapParsers := make(map[common.Address]*parser.SwapParser)

	for i := range chainConfig.Contracts {
		switch chainConfig.Contracts[i].ContractType {
		case "bridge":
			bridgeParser, err = parser.NewBridgeParser(consumerDB, common.HexToAddress(chainConfig.Contracts[i].Address), tokenDataService, fetcher, priceDataService, false)
			if err != nil || bridgeParser == nil {
				return nil, fmt.Errorf("could not create bridge parser: %w", err)
			}
		case "swap":
			swapService, err = fetcherpkg.NewSwapFetcher(common.HexToAddress(chainConfig.Contracts[i].Address), client, false)
			if err != nil || swapService == nil {
				return nil, fmt.Errorf("could not create swapService: %w", err)
			}
			swapParser, err := parser.NewSwapParser(consumerDB, common.HexToAddress(chainConfig.Contracts[i].Address), false, fetcher, swapService, tokenDataService, priceDataService)
			if err != nil || swapParser == nil {
				return nil, fmt.Errorf("could not create swap parser: %w", err)
			}

			swapParsers[common.HexToAddress(chainConfig.Contracts[i].Address)] = swapParser
		case "metaswap":
			if swapService == nil {
				swapService, err := fetcherpkg.NewSwapFetcher(common.HexToAddress(chainConfig.Contracts[i].Address), client, true)
				if err != nil || swapService == nil {
					return nil, fmt.Errorf("could not create swapService: %w", err)
				}
			}
			swapParser, err := parser.NewSwapParser(consumerDB, common.HexToAddress(chainConfig.Contracts[i].Address), true, fetcher, swapService, tokenDataService, priceDataService)
			if err != nil || swapParser == nil {
				return nil, fmt.Errorf("could not create swap parser: %w", err)
			}

			swapParsers[common.HexToAddress(chainConfig.Contracts[i].Address)] = swapParser
		case "messagebus":
			messageBusParser, err = parser.NewMessageBusParser(consumerDB, common.HexToAddress(chainConfig.Contracts[i].Address), fetcher, priceDataService)
			if err != nil || messageBusParser == nil {
				return nil, fmt.Errorf("could not create message bus parser: %w", err)
			}
		case "cctp":
			cctpService, err = fetcherpkg.NewCCTPFetcher(common.HexToAddress(chainConfig.Contracts[i].Address), client)
			if err != nil || cctpService == nil {
				return nil, fmt.Errorf("could not create cctpService: %w", err)
			}
			cctpParser, err = parser.NewCCTPParser(consumerDB, common.HexToAddress(chainConfig.Contracts[i].Address), fetcher, cctpService, tokenDataService, priceDataService, false)
			if err != nil || cctpParser == nil {
				return nil, fmt.Errorf("could not create message bus parser: %w", err)
			}
		case "rfq":
			rfqService, err = fetcherpkg.NewRFQFetcher(common.HexToAddress(chainConfig.Contracts[i].Address), client)
			if err != nil || rfqService == nil {
				return nil, fmt.Errorf("could not create rfqService: %w", err)
			}
			rfqParser, err = parser.NewRFQParser(consumerDB, common.HexToAddress(chainConfig.Contracts[i].Address), fetcher, rfqService, tokenDataService, priceDataService, false)
			if err != nil || rfqParser == nil {
				return nil, fmt.Errorf("could not create message bus parser: %w", err)
			}
		}
	}

	chainBackfiller := backfill.NewChainBackfiller(consumerDB, bridgeParser, swapParsers, messageBusParser, cctpParser, rfqParser, fetcher, chainConfig)

	return chainBackfiller, nil
}