synapsecns/sanguine

// Package indexerconfig is the config loader for the indexer
package indexerconfig

import (
    "fmt"
    "os"
    "path/filepath"

    "github.com/richardwilkes/toolbox/collection"
    "github.com/synapsecns/sanguine/services/explorer/config"

    "github.com/ethereum/go-ethereum/common"
    "github.com/jftuga/ellipsis"
    "gopkg.in/yaml.v2"
)

// ContractType is the type of contract specified by the config and used for selecting the correct parser.
type ContractType int

const (
    // BridgeContractType is the ContractType for the bridge contract.
    BridgeContractType ContractType = iota
    // SwapContractType is the ContractType for the swap contract.
    SwapContractType
    // MessageBusContractType is the ContractType for the message bus contract.
    MessageBusContractType
    // MetaSwapContractType is the ContractType for the meta swap contract.
    MetaSwapContractType
    // CCTPContractType is the ContractType for the cctp contract.
    CCTPContractType
    // RFQContractType is the ContractType for the rfq contract.
    RFQContractType
)

func (c ContractType) String() string {
    return [...]string{"bridge", "swap", "messagebus", "metaswap", "cctp", "rfq"}[c]
}

// ContractTypeFromString converts a string (intended to be from parsed config) into the ContractType type.
func ContractTypeFromString(s string) (ContractType, error) {
    switch s {
    case "bridge":
        return BridgeContractType, nil
    case "swap":
        return SwapContractType, nil
    case "messagebus":
        return MessageBusContractType, nil
    case "metaswap":
        return MetaSwapContractType, nil
    case "cctp":
        return CCTPContractType, nil
    case "rfq":
        return RFQContractType, nil
    default:
        return -1, fmt.Errorf("unknown contract type: %s", s)
    }
}

// Config is used to configure the explorer's data consumption.
type Config struct {
    // DefaultRefreshRate is the default rate at which data is refreshed.
    DefaultRefreshRate int `yaml:"default_refresh_rate"`
    // ScribeURL is the URL of the Scribe server.
    ScribeURL string `yaml:"scribe_url"`
    // RPCURL is the URL of the RPC server.
    RPCURL string `yaml:"rpc_url"`
    // BridgeConfigAddress is the address of BridgeConfig contract.
    BridgeConfigAddress string `yaml:"bridge_config_address"`
    // BridgeConfigChainID is the ChainID of BridgeConfig contract.
    BridgeConfigChainID uint32 `yaml:"bridge_config_chain_id"`
    // Chains stores the chain configurations.
    Chains []ChainConfig `yaml:"chains"`
}

// ChainConfig is the configuration for a chain.
type ChainConfig struct {
    // ChainID is the ID of the chain.
    ChainID uint32 `yaml:"chain_id"`
    // RPCURL is the RPC of the chain.
    RPCURL string `yaml:"rpc_url"`
    // FetchBlockIncrement is the number of blocks to fetch at a time.
    FetchBlockIncrement uint64 `yaml:"fetch_block_increment"`
    // MaxGoroutines is the maximum number of goroutines that can be spawned.
    MaxGoroutines int `yaml:"max_goroutines"`
    // Contracts are the contracts.
    Contracts []ContractConfig `yaml:"contracts"`
}

// ContractConfig is the configuration for a contract.
type ContractConfig struct {
    // ContractType is the type of contract.
    ContractType string `yaml:"contract_type"`
    // Addresses are the addresses of the contracts
    Address string `yaml:"address"`
    // StartBlock is where to start backfilling this address from.
    StartBlock int64 `yaml:"start_block"`
}

// IsValid makes sure the config is valid. This is done by calling IsValid() on each
// submodule. If any method returns an error that is returned here and the entirety
// of IsValid returns false. Any warnings are logged by the submodules respective loggers.
func (c *Config) IsValid() error {
    switch {
    case c.BridgeConfigAddress == "":
        return fmt.Errorf("bridge_config_address, %w", config.ErrRequiredGlobalField)
    case c.ScribeURL == "":
        return fmt.Errorf("scribe_url, %w", config.ErrRequiredGlobalField)
    case c.RPCURL == "":
        return fmt.Errorf("rpc_url, %w", config.ErrRequiredGlobalField)
    case c.BridgeConfigChainID == 0:
        return fmt.Errorf("chain_id cannot be 0")
    }
    if len(c.BridgeConfigAddress) != (common.AddressLength*2)+2 {
        return fmt.Errorf("field Address: %w", config.ErrAddressLength)
    }
    if len(c.Chains) == 0 {
        return fmt.Errorf("no chains specified for indexing")
    }

    for _, chain := range c.Chains {
        err := chain.IsValid()
        if err != nil {
            return fmt.Errorf("chain with ID %d is invalid: %w", chain.ChainID, err)
        }
    }

    return nil
}

// IsValid validates the chain config.
func (c ChainConfig) IsValid() error {
    switch {
    case c.ChainID == 0:
        return fmt.Errorf("chain_id, %w", config.ErrRequiredGlobalField)
    case c.MaxGoroutines == 0:
        return fmt.Errorf("max_goroutines, %w", config.ErrRequiredGlobalField)
    }

    intSet := collection.Set[string]{}
    for _, contract := range c.Contracts {
        err := contract.IsValid()
        if err != nil {
            return fmt.Errorf("contract with address %s is invalid: %w", contract.Address, err)
        }
        if intSet.Contains(contract.Address) {
            return fmt.Errorf("address %s appears twice", contract.Address)
        }
        intSet.Add(contract.Address)
    }

    return nil
}

// IsValid validates the chain config.
func (c ContractConfig) IsValid() error {
    _, err := ContractTypeFromString(c.ContractType)
    if err != nil {
        return fmt.Errorf("contract_type %s invalid for address %s", c.ContractType, c.Address)
    }

    switch {
    case c.StartBlock == 0:
        return fmt.Errorf("start_block, %w", config.ErrRequiredContractField)
    case c.Address == "":
        return fmt.Errorf("address, %w", config.ErrRequiredContractField)
    }
    return nil
}

// DecodeConfig parses in a config from a file.
func DecodeConfig(filePath string) (cfg Config, err error) {
    if _, err := os.Stat(filePath); os.IsNotExist(err) {
        return Config{}, fmt.Errorf("config file does not exist: %w", err)
    }
    input, err := os.ReadFile(filepath.Clean(filePath))
    if err != nil {
        return Config{}, fmt.Errorf("failed to read file: %w", err)
    }
    err = yaml.Unmarshal(input, &cfg)
    if err != nil {
        return Config{}, fmt.Errorf("could not unmarshall config %s: %w", ellipsis.Shorten(string(input), 30), err)
    }
    err = cfg.IsValid()
    if err != nil {
        return cfg, err
    }

    return cfg, nil
}