Add validation for enum types

Author: stringintech

kernel/chain_parameters.go

@@ -14,24 +14,11 @@ type ChainParameters struct {
 }
 
 func NewChainParameters(chainType ChainType) (*ChainParameters, error) {
-	var cChainType C.kernel_ChainType
-
-	switch chainType {
-	case ChainTypeMainnet:
-		cChainType = C.kernel_CHAIN_TYPE_MAINNET
-	case ChainTypeTestnet:
-		cChainType = C.kernel_CHAIN_TYPE_TESTNET
-	case ChainTypeTestnet4:
-		cChainType = C.kernel_CHAIN_TYPE_TESTNET_4
-	case ChainTypeSignet:
-		cChainType = C.kernel_CHAIN_TYPE_SIGNET
-	case ChainTypeRegtest:
-		cChainType = C.kernel_CHAIN_TYPE_REGTEST
-	default:
-		return nil, ErrInvalidChainType
+	cType, err := chainType.c()
+	if err != nil {
+		return nil, err
 	}
-
-	ptr := C.kernel_chain_parameters_create(cChainType)
+	ptr := C.kernel_chain_parameters_create(cType)
 	if ptr == nil {
 		return nil, ErrKernelChainParametersCreate
 	}
@@ -71,3 +58,10 @@ const (
 	ChainTypeSignet
 	ChainTypeRegtest
 )
+
+func (t ChainType) c() (C.kernel_ChainType, error) {
+	if t < ChainTypeMainnet || t > ChainTypeRegtest {
+		return 0, ErrInvalidChainType
+	}
+	return C.kernel_ChainType(t), nil
+}

kernel/errors.go

@@ -42,6 +42,8 @@ var (
 	ErrKernelContextOptionsCreate                   = &KernelError{Operation: "kernel_context_options_create"}
 
 	ErrInvalidChainType      = errors.New("invalid chain type")
+	ErrInvalidLogLevel       = errors.New("invalid log level")
+	ErrInvalidLogCategory    = errors.New("invalid log category")
 	ErrEmptyBlockData        = errors.New("empty block data")
 	ErrEmptyScriptPubkeyData = errors.New("empty script pubkey data")
 	ErrEmptyTransactionData  = errors.New("empty transaction data")

kernel/logging_connection.go

@@ -119,21 +119,21 @@ var loggingMutex = sync.RWMutex{}
 func AddLogLevelCategory(category LogCategory, level LogLevel) {
 	loggingMutex.Lock()
 	defer loggingMutex.Unlock()
-	C.kernel_add_log_level_category(C.kernel_LogCategory(category), C.kernel_LogLevel(level))
+	C.kernel_add_log_level_category(category.mustC(), level.mustC())
 }
 
 // EnableLogCategory enables logging for a specific category or all categories
 func EnableLogCategory(category LogCategory) {
 	loggingMutex.Lock()
 	defer loggingMutex.Unlock()
-	C.kernel_enable_log_category(C.kernel_LogCategory(category))
+	C.kernel_enable_log_category(category.mustC())
 }
 
 // DisableLogCategory disables logging for a specific category or all categories
 func DisableLogCategory(category LogCategory) {
 	loggingMutex.Lock()
 	defer loggingMutex.Unlock()
-	C.kernel_disable_log_category(C.kernel_LogCategory(category))
+	C.kernel_disable_log_category(category.mustC())
 }
 
 // LogLevel represents the logging level
@@ -145,6 +145,21 @@ const (
 	LogLevelInfo
 )
 
+func (l LogLevel) mustC() C.kernel_LogLevel {
+	c, err := l.c()
+	if err != nil {
+		panic(err)
+	}
+	return c
+}
+
+func (l LogLevel) c() (C.kernel_LogLevel, error) {
+	if l < LogLevelTrace || l > LogLevelInfo {
+		return 0, ErrInvalidLogLevel
+	}
+	return C.kernel_LogLevel(l), nil
+}
+
 // LogCategory represents a logging category
 type LogCategory int
 
@@ -162,6 +177,21 @@ const (
 	LogKernel
 )
 
+func (c LogCategory) mustC() C.kernel_LogCategory {
+	cType, err := c.c()
+	if err != nil {
+		panic(err)
+	}
+	return cType
+}
+
+func (c LogCategory) c() (C.kernel_LogCategory, error) {
+	if c < LogAll || c > LogKernel {
+		return 0, ErrInvalidLogCategory
+	}
+	return C.kernel_LogCategory(c), nil
+}
+
 // LoggingOptions configures the format of log messages
 type LoggingOptions struct {
 	LogTimestamps            bool // Prepend a timestamp to log messages