synapsecns/sanguine

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

import (
    "context"
    "fmt"
    "math"
    "os"
    "path/filepath"
    "strconv"
    "strings"
    "time"

    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
    "github.com/jftuga/ellipsis"
    "github.com/synapsecns/sanguine/core/metrics"
    "github.com/synapsecns/sanguine/ethergo/signer/config"
    submitterConfig "github.com/synapsecns/sanguine/ethergo/submitter/config"
    cctpConfig "github.com/synapsecns/sanguine/services/cctp-relayer/config"
    "github.com/synapsecns/sanguine/services/rfq/contracts/ierc20"
    "github.com/synapsecns/sanguine/services/rfq/util"
    "gopkg.in/yaml.v2"

    omniClient "github.com/synapsecns/sanguine/services/omnirpc/client"
)

// Config represents the configuration for the relayer.
type Config struct {
    // Chains is a map of chainID -> chain config.
    Chains map[int]ChainConfig `yaml:"chains"`
    // BaseChainConfig applies to all chains except those values that are overridden in Chains.
    BaseChainConfig ChainConfig `yaml:"base_chain_config"`
    // OmniRPCURL is the URL of the OmniRPC server.
    OmniRPCURL string `yaml:"omnirpc_url"`
    // RFQAPIURL is the URL of the RFQ API.
    RFQAPIURL string `yaml:"rfq_url"`
    // RelayerAPIPort is the port of the relayer API.
    RelayerAPIPort string `yaml:"relayer_api_port"`
    // Database is the database config.
    Database DatabaseConfig `yaml:"database"`
    // QuotableTokens is a map of token -> list of quotable tokens.
    QuotableTokens map[string][]string `yaml:"quotable_tokens"`
    // Signer is the signer config.
    Signer config.SignerConfig `yaml:"signer"`
    // SubmitterConfig is the submitter config.
    SubmitterConfig submitterConfig.Config `yaml:"submitter_config"`
    // FeePricer is the fee pricer config.
    FeePricer FeePricerConfig `yaml:"fee_pricer"`
    // ScreenerAPIUrl is the TRM API url.
    ScreenerAPIUrl string `yaml:"screener_api_url"`
    // DBSelectorInterval is the interval for the db selector.
    DBSelectorInterval time.Duration `yaml:"db_selector_interval"`
    // RebalanceInterval is the interval for rebalancing.
    RebalanceInterval time.Duration `yaml:"rebalance_interval"`
    // QuoteSubmissionTimeout is the timeout for submitting a quote.
    QuoteSubmissionTimeout time.Duration `yaml:"quote_submission_timeout"`
    // CCTPRelayerConfig is the embedded cctp relayer config (optional).
    CCTPRelayerConfig *cctpConfig.Config `yaml:"cctp_relayer_config"`
    // EnableAPIWithdrawals enables withdrawals via the API.
    EnableAPIWithdrawals bool `yaml:"enable_api_withdrawals"`
    // WithdrawalWhitelist is a list of addresses that are allowed to withdraw.
    WithdrawalWhitelist []string `yaml:"withdrawal_whitelist"`
    // UseEmbeddedGuard enables the embedded guard.
    UseEmbeddedGuard bool `yaml:"enable_guard"`
    // SubmitSingleQuotes enables submitting single quotes.
    SubmitSingleQuotes bool `yaml:"submit_single_quotes"`
    // VolumeLimit is the maximum dollar value of relayed transactions in the BlockWindow.
    VolumeLimit float64 `yaml:"volume_limit"`
    // SupportActiveQuoting enables support for active quoting.
    SupportActiveQuoting bool `yaml:"support_active_quoting"`
}

// 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"`
    // FinalityConfirmations is the number of required confirmations before proving.
    FinalityConfirmations uint64 `yaml:"prove_confirmations"`
    // Tokens is a map of token name -> token config.
    Tokens map[string]TokenConfig `yaml:"tokens"`
    // NativeToken is the native token of the chain (pays gas).
    NativeToken string `yaml:"native_token"`
    // DeadlineBufferSeconds is the deadline buffer for relaying a transaction.
    DeadlineBufferSeconds int `yaml:"deadline_buffer_seconds"`
    // OriginGasEstimate is the gas estimate to use for origin transactions (this will override base gas estimates).
    OriginGasEstimate int `yaml:"origin_gas_estimate"`
    // DestGasEstimate is the gas estimate to use for destination transactions (this will override base gas estimates).
    DestGasEstimate int `yaml:"dest_gas_estimate"`
    // L1FeeChainID indicates the chain ID for the L1 fee (if needed, for example on optimism).
    L1FeeChainID uint32 `yaml:"l1_fee_chain_id"`
    // L1FeeOriginGasEstimate is the gas estimate for the L1 fee on origin.
    L1FeeOriginGasEstimate int `yaml:"l1_fee_origin_gas_estimate"`
    // L1FeeDestGasEstimate is the gas estimate for the L1 fee on destination.
    L1FeeDestGasEstimate int `yaml:"l1_fee_dest_gas_estimate"`
    // MinGasToken is minimum amount of gas that should be leftover after bridging a gas token.
    MinGasToken string `yaml:"min_gas_token"`
    // QuotePct is the percent of balance to quote.
    QuotePct *float64 `yaml:"quote_pct"`
    // QuoteFixedFeeMultiplier is the multiplier for the fixed fee, applied when generating quotes.
    QuoteFixedFeeMultiplier *float64 `yaml:"quote_fixed_fee_multiplier"`
    // RelayFixedFeeMultiplier is the multiplier for the fixed fee, applied when relaying.
    RelayFixedFeeMultiplier *float64 `yaml:"relay_fixed_fee_multiplier"`
    // RebalanceStartBlock is the block at which the chain listener will listen for rebalance events.
    RebalanceStartBlock uint64 `yaml:"cctp_start_block"`
    // RebalanceConfigs is the rebalance configurations.
    RebalanceConfigs RebalanceConfigs `yaml:"rebalance_configs"`
    // LimitConfirmations is the number of confirmations to wait for before processing a quote.
    LimitConfirmations uint64 `yaml:"limit_confirmations"`
}

// TokenConfig represents the configuration for a token.
type TokenConfig struct {
    // Address is the token address.
    Address string `yaml:"address"`
    // Decimals is the token decimals.
    Decimals uint8 `yaml:"decimals"`
    // For now, specify the USD price of the token in the config.
    PriceUSD float64 `yaml:"price_usd"`
    // MinQuoteAmount is the minimum amount to quote for this token in human-readable units.
    MinQuoteAmount string `yaml:"min_quote_amount"`
    // MaxRelayAmount is the maximum amount to quote and relay for this token in human-readable units.
    MaxRelayAmount string `yaml:"max_relay_amount"`
    // RebalanceMethods are the supported methods for rebalancing.
    RebalanceMethods []string `yaml:"rebalance_methods"`
    // MaintenanceBalancePct is the percentage of the total balance under which a rebalance will be triggered.
    MaintenanceBalancePct float64 `yaml:"maintenance_balance_pct"`
    // InitialBalancePct is the percentage of the total balance to retain when triggering a rebalance.
    InitialBalancePct float64 `yaml:"initial_balance_pct"`
    // MinRebalanceAmount is the minimum amount to rebalance in human-readable units.
    // For USDC-through-cctp pairs this defaults to $1,000.
    MinRebalanceAmount string `yaml:"min_rebalance_amount"`
    // MaxRebalanceAmount is the maximum amount to rebalance in human-readable units.
    MaxRebalanceAmount string `yaml:"max_rebalance_amount"`
    // QuoteOffsetBps is the number of basis points to deduct from the dest amount,
    // and add to the origin amount for a given token,
    // Note that this value can be positive or negative; if positive it effectively increases the quoted price
    // of the given token, and vice versa.
    QuoteOffsetBps float64 `yaml:"quote_offset_bps"`
    // QuoteWidthBps is the number of basis points to deduct from the dest amount.
    // Note that this parameter must be positive.
    QuoteWidthBps float64 `yaml:"quote_width_bps"`
    // MaxBalance is the maximum balance that should be accumulated for this token on this chain (human-readable units)
    MaxBalance *string `yaml:"max_balance"`
}

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

// FeePricerConfig represents the configuration for the fee pricer.
type FeePricerConfig struct {
    // GasPriceCacheTTLSeconds is the TTL for the gas price cache.
    GasPriceCacheTTLSeconds int `yaml:"gas_price_cache_ttl"`
    // TokenPriceCacheTTLSeconds is the TTL for the token price cache.
    TokenPriceCacheTTLSeconds int `yaml:"token_price_cache_ttl"`
    // HTTPTimeoutMs is the number of milliseconds to timeout on a HTTP request.
    HTTPTimeoutMs int `yaml:"http_timeout_ms"`
}

// RebalanceConfigs represents the rebalance configurations.
type RebalanceConfigs struct {
    Synapse *SynapseCCTPRebalanceConfig `yaml:"synapse"`
    Circle  *CircleCCTPRebalanceConfig  `yaml:"circle"`
    Scroll  *ScrollRebalanceConfig      `yaml:"scroll"`
}

// SynapseCCTPRebalanceConfig represents the configuration for the SynapseCCTP rebalance.
type SynapseCCTPRebalanceConfig struct {
    // SynapseCCTPAddress is the SynapseCCTP address.
    SynapseCCTPAddress string `yaml:"synapse_cctp_address"`
}

// CircleCCTPRebalanceConfig represents the configuration for the CircleCCTP rebalance.
type CircleCCTPRebalanceConfig struct {
    // TokenMessengerAddress is the TokenMessenger address.
    TokenMessengerAddress string `yaml:"token_messenger_address"`
}

// ScrollRebalanceConfig represents the configuration for the Scroll rebalance.
type ScrollRebalanceConfig struct {
    // L1GatewayAddress is the L1Gateway address [scroll].
    L1GatewayAddress string `yaml:"l1_gateway_address"`
    // L1ScrollMessengerAddress is the L1ScrollMessenger address [scroll].
    L1ScrollMessengerAddress string `yaml:"l1_scroll_messenger_address"`
    // L2GatewayAddress is the L2Gateway address [scroll].
    L2GatewayAddress string `yaml:"l2_gateway_address"`
    // ScrollMessageFee is the scroll message fee.
    ScrollMessageFee *string `yaml:"scroll_message_fee"`
}

// TokenIDDelimiter is the delimiter for token IDs.
const TokenIDDelimiter = "-"

// SanitizeTokenID takes a raw string, makes sure it is a valid token ID,
// and returns the token ID as string with a checksummed address.
func SanitizeTokenID(id string) (sanitized string, err error) {
    split := strings.Split(id, TokenIDDelimiter)
    if len(split) != 2 {
        return sanitized, fmt.Errorf("invalid token ID: %s", id)
    }
    chainID, err := strconv.Atoi(split[0])
    if err != nil {
        return sanitized, fmt.Errorf("invalid chain ID: %s", split[0])
    }
    addr := common.HexToAddress(split[1])
    sanitized = fmt.Sprintf("%d%s%s", chainID, TokenIDDelimiter, addr.Hex())
    return sanitized, nil
}

// DecodeTokenID decodes a token ID into a chain ID and address.
func DecodeTokenID(id string) (chainID int, addr common.Address, err error) {
    // defensive coding, first check if the token ID is valid
    _, err = SanitizeTokenID(id)
    if err != nil {
        return chainID, addr, err
    }

    split := strings.Split(id, TokenIDDelimiter)
    if len(split) != 2 {
        return chainID, addr, fmt.Errorf("invalid token ID: %s", id)
    }
    chainID, err = strconv.Atoi(split[0])
    if err != nil {
        return chainID, addr, fmt.Errorf("invalid chain ID: %s", split[0])
    }
    if !common.IsHexAddress(split[1]) {
        return chainID, addr, fmt.Errorf("invalid address: %s", split[1])
    }

    addr = common.HexToAddress(split[1])
    return chainID, addr, nil
}

// 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)
    }
    omniClient := omniClient.NewOmnirpcClient(config.OmniRPCURL, metrics.NewNullHandler(), omniClient.WithCaptureReqRes())
    err = config.Validate(context.Background(), omniClient)
    if err != nil {
        return Config{}, fmt.Errorf("config validation failed: %w", err)
    }

    return config, nil
}

// Validate validates the config. Omniclient may be nil, but if not then it will also check the chain to see if the decimals
// match the actual token decimals.
func (c Config) Validate(ctx context.Context, omniclient omniClient.RPCClient) (err error) {
    maintenancePctSums := map[string]float64{}
    initialPctSums := map[string]float64{}
    for _, chainCfg := range c.Chains {
        for tokenName, tokenCfg := range chainCfg.Tokens {
            if len(tokenCfg.RebalanceMethods) != 0 {
                maintenancePctSums[tokenName] += tokenCfg.MaintenanceBalancePct
                initialPctSums[tokenName] += tokenCfg.InitialBalancePct
            }
        }
    }
    for token, sum := range maintenancePctSums {
        if sum > 100 {
            return fmt.Errorf("total maintenance percent exceeds 100 for %s: %f", token, sum)
        }
    }
    for token, sum := range initialPctSums {
        if math.Round(sum) != 100 {
            return fmt.Errorf("total initial percent does not total 100 for %s: %f", token, sum)
        }
    }

    if omniclient != nil {
        err = c.validateTokenDecimals(ctx, omniclient)
        if err != nil {
            return fmt.Errorf("error validating token decimals: %w", err)
        }
    }

    return nil
}

// ValidateTokenDecimals calls decimals() on the ERC20s to ensure that the decimals in the config match the actual token decimals.
func (c Config) validateTokenDecimals(ctx context.Context, omniClient omniClient.RPCClient) (err error) {
    for chainID, chainCfg := range c.Chains {
        for tokenName, tokenCFG := range chainCfg.Tokens {
            chainClient, err := omniClient.GetChainClient(ctx, chainID)
            if err != nil {
                return fmt.Errorf("could not get chain client for chain %d: %w", chainID, err)
            }

            // Check if the token is the gas token. SHOULD BE 18.
            if tokenCFG.Address == util.EthAddress.String() {
                if tokenCFG.Decimals != 18 {
                    return fmt.Errorf("decimals mismatch for token %s on chain %d: expected 18, got %d", tokenName, chainID, tokenCFG.Decimals)
                }
                continue
            }

            ierc20, err := ierc20.NewIERC20(common.HexToAddress(tokenCFG.Address), chainClient)
            if err != nil {
                return fmt.Errorf("could not create caller for token %s at address %s on chain %d: %w", tokenName, tokenCFG.Address, chainID, err)
            }

            actualDecimals, err := ierc20.Decimals(&bind.CallOpts{Context: ctx})
            if err != nil {
                return fmt.Errorf("could not get decimals for token %s on chain %d: %w", tokenName, chainID, err)
            }

            if actualDecimals != tokenCFG.Decimals {
                return fmt.Errorf("decimals mismatch for token %s on chain %d: expected %d, got %d", tokenName, chainID, tokenCFG.Decimals, actualDecimals)
            }
        }
    }

    return nil
}