synapsecns/sanguine

// Package guardconfig contains the config yaml object for the relayer.
package guardconfig

import (
    "fmt"
    "os"
    "time"

    "github.com/ethereum/go-ethereum/common"
    "github.com/jftuga/ellipsis"
    "github.com/synapsecns/sanguine/ethergo/signer/config"
    submitterConfig "github.com/synapsecns/sanguine/ethergo/submitter/config"
    "github.com/synapsecns/sanguine/services/rfq/relayer/relconfig"
    "gopkg.in/yaml.v2"

    "path/filepath"
)

// Config represents the configuration for the relayer.
type Config struct {
    // Chains is a map of chainID -> chain config.
    Chains map[int]ChainConfig `yaml:"chains"`
    // OmniRPCURL is the URL of the OmniRPC server.
    OmniRPCURL string `yaml:"omnirpc_url"`
    // Database is the database config.
    Database DatabaseConfig `yaml:"database"`
    // Signer is the signer config.
    Signer config.SignerConfig `yaml:"signer"`
    // SubmitterConfig is the submitter config.
    SubmitterConfig submitterConfig.Config `yaml:"submitter_config"`
    // DBSelectorInterval is the interval for the db selector.
    DBSelectorInterval time.Duration `yaml:"db_selector_interval"`
}

// ChainConfig represents the configuration for a chain.
type ChainConfig struct {
    // Bridge is the rfq bridge contract address.
    RFQAddress string `yaml:"rfq_address"`
    // Confirmations is the number of required confirmations.
    Confirmations uint64 `yaml:"confirmations"`
}

// DatabaseConfig represents the configuration for the database.
type DatabaseConfig struct {
    Type string `yaml:"type"`
    DSN  string `yaml:"dsn"` // Data Source Name
}

// LoadConfig loads the config from the given path.
func LoadConfig(path string) (config Config, err error) {
    input, err := os.ReadFile(filepath.Clean(path))
    if err != nil {
        return Config{}, fmt.Errorf("failed to read file: %w", err)
    }
    err = yaml.Unmarshal(input, &config)
    if err != nil {
        return Config{}, fmt.Errorf("could not unmarshall config %s: %w", ellipsis.Shorten(string(input), 30), err)
    }
    err = config.Validate()
    if err != nil {
        return config, fmt.Errorf("error validating config: %w", err)
    }
    return config, nil
}

// Validate validates the config.
func (c Config) Validate() (err error) {
    for chainID := range c.Chains {
        addr, err := c.GetRFQAddress(chainID)
        if err != nil {
            return fmt.Errorf("could not get rfq address: %w", err)
        }
        if !common.IsHexAddress(addr) {
            return fmt.Errorf("invalid rfq address: %s", addr)
        }
    }

    return nil
}

// GetChains returns the chains config.
func (c Config) GetChains() map[int]ChainConfig {
    return c.Chains
}

// GetRFQAddress returns the RFQ address for the given chain.
func (c Config) GetRFQAddress(chainID int) (string, error) {
    chainCfg, ok := c.Chains[chainID]
    if !ok {
        return "", fmt.Errorf("chain config not found for chain %d", chainID)
    }
    return chainCfg.RFQAddress, nil
}

const defaultDBSelectorIntervalSeconds = 1

// GetDBSelectorInterval returns the interval for the DB selector.
func (c Config) GetDBSelectorInterval() time.Duration {
    interval := c.DBSelectorInterval
    if interval <= 0 {
        interval = time.Duration(defaultDBSelectorIntervalSeconds) * time.Second
    }
    return interval
}

// NewGuardConfigFromRelayer creates a new guard config from a relayer config.
func NewGuardConfigFromRelayer(relayerCfg relconfig.Config) Config {
    cfg := Config{
        Chains:             make(map[int]ChainConfig),
        OmniRPCURL:         relayerCfg.OmniRPCURL,
        Database:           DatabaseConfig(relayerCfg.Database),
        Signer:             relayerCfg.Signer,
        SubmitterConfig:    relayerCfg.SubmitterConfig,
        DBSelectorInterval: relayerCfg.DBSelectorInterval,
    }
    for chainID, chainCfg := range relayerCfg.GetChains() {
        cfg.Chains[chainID] = ChainConfig{
            RFQAddress:    chainCfg.RFQAddress,
            Confirmations: chainCfg.FinalityConfirmations,
        }
    }
    return cfg
}