ark/server/internal/config/config.go

package config

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

	"github.com/ark-network/ark/common"
	"github.com/spf13/viper"
)

type Config struct {
	WalletAddr            string
	RoundInterval         int64
	Port                  uint32
	EventDbType           string
	DbType                string
	DbDir                 string
	DbMigrationPath       string
	SchedulerType         string
	TxBuilderType         string
	BlockchainScannerType string
	NoTLS                 bool
	Network               common.Network
	LogLevel              int
	MinRelayFee           uint64
	RoundLifetime         int64
	UnilateralExitDelay   int64
	AuthUser              string
	AuthPass              string
	EsploraURL            string
	NeutrinoPeer          string
}

var (
	Datadir               = "DATADIR"
	WalletAddr            = "WALLET_ADDR"
	RoundInterval         = "ROUND_INTERVAL"
	Port                  = "PORT"
	EventDbType           = "EVENT_DB_TYPE"
	DbType                = "DB_TYPE"
	DbMigrationPath       = "DB_MIGRATION_PATH"
	SchedulerType         = "SCHEDULER_TYPE"
	TxBuilderType         = "TX_BUILDER_TYPE"
	BlockchainScannerType = "BC_SCANNER_TYPE"
	Insecure              = "INSECURE"
	LogLevel              = "LOG_LEVEL"
	Network               = "NETWORK"
	MinRelayFee           = "MIN_RELAY_FEE"
	RoundLifetime         = "ROUND_LIFETIME"
	UnilateralExitDelay   = "UNILATERAL_EXIT_DELAY"
	AuthUser              = "AUTH_USER"
	AuthPass              = "AUTH_PASS"
	EsploraURL            = "ESPLORA_URL"
	NeutrinoPeer          = "NEUTRINO_PEER"

	defaultDatadir               = common.AppDataDir("arkd", false)
	defaultRoundInterval         = 5
	defaultPort                  = 6000
	defaultWalletAddr            = "localhost:18000"
	defaultDbType                = "sqlite"
	defaultDbMigrationPath       = "file://internal/infrastructure/db/sqlite/migration"
	defaultEventDbType           = "badger"
	defaultSchedulerType         = "gocron"
	defaultTxBuilderType         = "covenant"
	defaultBlockchainScannerType = "ocean"
	defaultInsecure              = true
	defaultNetwork               = "liquid"
	defaultLogLevel              = 4
	defaultMinRelayFee           = 30 // 0.1 sat/vbyte on Liquid
	defaultRoundLifetime         = 604672
	defaultUnilateralExitDelay   = 1024
	defaultAuthUser              = "admin"
	defaultAuthPass              = "admin"
)

func LoadConfig() (*Config, error) {
	viper.SetEnvPrefix("ARK")
	viper.AutomaticEnv()

	viper.SetDefault(Datadir, defaultDatadir)
	viper.SetDefault(Port, defaultPort)
	viper.SetDefault(DbType, defaultDbType)
	viper.SetDefault(DbMigrationPath, defaultDbMigrationPath)
	viper.SetDefault(Insecure, defaultInsecure)
	viper.SetDefault(LogLevel, defaultLogLevel)
	viper.SetDefault(Network, defaultNetwork)
	viper.SetDefault(WalletAddr, defaultWalletAddr)
	viper.SetDefault(MinRelayFee, defaultMinRelayFee)
	viper.SetDefault(RoundInterval, defaultRoundInterval)
	viper.SetDefault(RoundLifetime, defaultRoundLifetime)
	viper.SetDefault(SchedulerType, defaultSchedulerType)
	viper.SetDefault(EventDbType, defaultEventDbType)
	viper.SetDefault(TxBuilderType, defaultTxBuilderType)
	viper.SetDefault(UnilateralExitDelay, defaultUnilateralExitDelay)
	viper.SetDefault(BlockchainScannerType, defaultBlockchainScannerType)
	viper.SetDefault(AuthUser, defaultAuthUser)
	viper.SetDefault(AuthPass, defaultAuthPass)

	net, err := getNetwork()
	if err != nil {
		return nil, err
	}

	if err := initDatadir(); err != nil {
		return nil, fmt.Errorf("error while creating datadir: %s", err)
	}

	return &Config{
		WalletAddr:            viper.GetString(WalletAddr),
		RoundInterval:         viper.GetInt64(RoundInterval),
		Port:                  viper.GetUint32(Port),
		EventDbType:           viper.GetString(EventDbType),
		DbType:                viper.GetString(DbType),
		DbMigrationPath:       viper.GetString(DbMigrationPath),
		SchedulerType:         viper.GetString(SchedulerType),
		TxBuilderType:         viper.GetString(TxBuilderType),
		BlockchainScannerType: viper.GetString(BlockchainScannerType),
		NoTLS:                 viper.GetBool(Insecure),
		DbDir:                 filepath.Join(viper.GetString(Datadir), "db"),
		LogLevel:              viper.GetInt(LogLevel),
		Network:               net,
		MinRelayFee:           viper.GetUint64(MinRelayFee),
		RoundLifetime:         viper.GetInt64(RoundLifetime),
		UnilateralExitDelay:   viper.GetInt64(UnilateralExitDelay),
		AuthUser:              viper.GetString(AuthUser),
		AuthPass:              viper.GetString(AuthPass),
		EsploraURL:            viper.GetString(EsploraURL),
		NeutrinoPeer:          viper.GetString(NeutrinoPeer),
	}, nil
}

func initDatadir() error {
	datadir := viper.GetString(Datadir)
	return makeDirectoryIfNotExists(datadir)
}

func makeDirectoryIfNotExists(path string) error {
	if _, err := os.Stat(path); os.IsNotExist(err) {
		return os.MkdirAll(path, os.ModeDir|0755)
	}
	return nil
}

func getNetwork() (common.Network, error) {
	switch strings.ToLower(viper.GetString(Network)) {
	case common.Liquid.Name:
		return common.Liquid, nil
	case common.LiquidTestNet.Name:
		return common.LiquidTestNet, nil
	case common.LiquidRegTest.Name:
		return common.LiquidRegTest, nil
	case common.Bitcoin.Name:
		return common.Bitcoin, nil
	case common.BitcoinTestNet.Name:
		return common.BitcoinTestNet, nil
	case common.BitcoinRegTest.Name:
		return common.BitcoinRegTest, nil
	default:
		return common.Network{}, fmt.Errorf("unknown network %s", viper.GetString(Network))
	}
}