Merge pull request #12 from dan13ram/dev

incorporate audit findings

Author: dan13ram

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.19 as base
+FROM golang:1.21 as base
 
 WORKDIR /app
 
@@ -14,7 +14,7 @@ COPY main.go ./
 COPY defaults.yml ./
 
 # build
-RUN CGO_ENABLED=0 GOOS=linux go build -o /validator
+RUN CGO_ENABLED=0 GOOS=linux go build -o /bin/validator
 
 # set environment variables
 # mongodb
@@ -80,5 +80,17 @@ ENV HEALTH_CHECK_INTERVAL_SECS ${HEALTH_CHECK_INTERVAL_SECS}
 # logging
 ENV LOG_LEVEL ${LOG_LEVEL}
 
+# create app user
+RUN adduser --group --system app
+
+RUN chown -R app:app /bin/validator
+
+RUN chmod +x /bin/validator
+
+RUN chown -R app:app /app
+
+# switch to app user
+USER app
+
 # run
-CMD ["/validator", "--config", "/app/defaults.yml"]
+CMD ["/bin/validator", "--config", "/app/defaults.yml"]

app/config.go

@@ -100,22 +100,22 @@ func validateConfig() {
 	}
 
 	// services
-	if Config.MintMonitor.Enabled == true && Config.MintMonitor.IntervalMillis == 0 {
+	if Config.MintMonitor.Enabled && Config.MintMonitor.IntervalMillis == 0 {
 		log.Fatal("[CONFIG] MintMonitor.Interval is required")
 	}
-	if Config.MintSigner.Enabled == true && Config.MintSigner.IntervalMillis == 0 {
+	if Config.MintSigner.Enabled && Config.MintSigner.IntervalMillis == 0 {
 		log.Fatal("[CONFIG] MintSigner.Interval is required")
 	}
-	if Config.MintExecutor.Enabled == true && Config.MintExecutor.IntervalMillis == 0 {
+	if Config.MintExecutor.Enabled && Config.MintExecutor.IntervalMillis == 0 {
 		log.Fatal("[CONFIG] MintExecutor.Interval is required")
 	}
-	if Config.BurnMonitor.Enabled == true && Config.BurnMonitor.IntervalMillis == 0 {
+	if Config.BurnMonitor.Enabled && Config.BurnMonitor.IntervalMillis == 0 {
 		log.Fatal("[CONFIG] BurnMonitor.Interval is required")
 	}
-	if Config.BurnSigner.Enabled == true && Config.BurnSigner.IntervalMillis == 0 {
+	if Config.BurnSigner.Enabled && Config.BurnSigner.IntervalMillis == 0 {
 		log.Fatal("[CONFIG] BurnSigner.Interval is required")
 	}
-	if Config.BurnExecutor.Enabled == true && Config.BurnExecutor.IntervalMillis == 0 {
+	if Config.BurnExecutor.Enabled && Config.BurnExecutor.IntervalMillis == 0 {
 		log.Fatal("[CONFIG] BurnExecutor.Interval is required")
 	}
 

app/database.go

@@ -70,30 +70,41 @@ func (d *MongoDatabase) SetupLocker() error {
 	defer cancel()
 
 	locker = lock.NewClient(d.db.Collection("locks"))
-	locker.CreateIndexes(ctx)
+	err := locker.CreateIndexes(ctx)
+	if err != nil {
+		return err
+	}
+
 	d.locker = locker
 
 	log.Info("[DB] Locker setup")
 	return nil
 }
 
-func randomString(n int) string {
+func randomString(n int) (string, error) {
 	const alphanum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
 	var bytes = make([]byte, n)
-	rand.Read(bytes)
+	_, err := rand.Read(bytes)
+	if err != nil {
+		return "", err
+	}
+
 	for i, b := range bytes {
 		bytes[i] = alphanum[b%byte(len(alphanum))]
 	}
-	return string(bytes)
+	return string(bytes), nil
 }
 
 // XLock locks a resource for exclusive access
 func (d *MongoDatabase) XLock(resourceId string) (string, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(Config.MongoDB.TimeoutMillis)*time.Millisecond)
 	defer cancel()
 
-	lockId := randomString(32)
-	err := d.locker.XLock(ctx, resourceId, lockId, lock.LockDetails{
+	lockId, err := randomString(32)
+	if err != nil {
+		return "", err
+	}
+	err = d.locker.XLock(ctx, resourceId, lockId, lock.LockDetails{
 		TTL: 60, // locks expire in 60 seconds
 	})
 	return lockId, err
@@ -104,8 +115,11 @@ func (d *MongoDatabase) SLock(resourceId string) (string, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(Config.MongoDB.TimeoutMillis)*time.Millisecond)
 	defer cancel()
 
-	lockId := randomString(32)
-	err := d.locker.SLock(ctx, resourceId, lockId, lock.LockDetails{
+	lockId, err := randomString(32)
+	if err != nil {
+		return "", err
+	}
+	err = d.locker.SLock(ctx, resourceId, lockId, lock.LockDetails{
 		TTL: 60, // locks expire in 60 seconds
 	}, -1)
 	return lockId, err
@@ -242,13 +256,16 @@ func InitDB() {
 
 	err := db.Connect()
 	if err != nil {
-		log.Fatal(err)
+		log.Fatal("[DB] Failed to connect to database: ", err)
 	}
 	err = db.SetupIndexes()
 	if err != nil {
-		log.Fatal(err)
+		log.Fatal("[DB] Failed to setup indexes: ", err)
 	}
 	err = db.SetupLocker()
+	if err != nil {
+		log.Fatal("[DB] Failed to setup locker: ", err)
+	}
 	log.Info("[DB] Database initialized")
 
 	DB = db

e2e/docker-compose.yml

@@ -3,26 +3,26 @@ services:
     image: dan13ram/wpokt-validator:latest
     restart: always
     volumes:
-      - ./config/validator/config.validator1.yml:/root/config.yml
-    command: sh -c "sleep 30 && /validator --config /root/config.yml"
+      - ./config/validator/config.validator1.yml:/home/app/config.yml
+    command: sh -c "sleep 30 && /bin/validator --config /home/app/config.yml"
     environment:
       LOG_LEVEL: debug
 
   wpokt.validator2:
     image: dan13ram/wpokt-validator:latest
     restart: always
     volumes:
-      - ./config/validator/config.validator2.yml:/root/config.yml
-    command: sh -c "sleep 30 && /validator --config /root/config.yml"
+      - ./config/validator/config.validator2.yml:/home/app/config.yml
+    command: sh -c "sleep 30 && /bin/validator --config /home/app/config.yml"
     environment:
       LOG_LEVEL: debug
 
   wpokt.validator3:
     image: dan13ram/wpokt-validator:latest
     restart: always
     volumes:
-      - ./config/validator/config.validator3.yml:/root/config.yml
-    command: sh -c "sleep 30 && /validator --config /root/config.yml"
+      - ./config/validator/config.validator3.yml:/home/app/config.yml
+    command: sh -c "sleep 30 && /bin/validator --config /home/app/config.yml"
     environment:
       LOG_LEVEL: debug
 

eth/client/mint_controller.go

@@ -0,0 +1,45 @@
+package client
+
+import (
+	"math/big"
+
+	"github.com/dan13ram/wpokt-validator/eth/autogen"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type DomainData struct {
+	Fields            [1]byte
+	Name              string
+	Version           string
+	ChainId           *big.Int
+	VerifyingContract common.Address
+	Salt              [32]byte
+	Extensions        []*big.Int
+}
+
+type MintControllerContract interface {
+	ValidatorCount(opts *bind.CallOpts) (*big.Int, error)
+	Eip712Domain(opts *bind.CallOpts) (DomainData, error)
+	MaxMintLimit(opts *bind.CallOpts) (*big.Int, error)
+}
+
+type MintControllerContractImpl struct {
+	contract *autogen.MintController
+}
+
+func (x *MintControllerContractImpl) ValidatorCount(opts *bind.CallOpts) (*big.Int, error) {
+	return x.contract.ValidatorCount(opts)
+}
+
+func (x *MintControllerContractImpl) Eip712Domain(opts *bind.CallOpts) (DomainData, error) {
+	return x.contract.Eip712Domain(opts)
+}
+
+func (x *MintControllerContractImpl) MaxMintLimit(opts *bind.CallOpts) (*big.Int, error) {
+	return x.contract.MaxMintLimit(opts)
+}
+
+func NewMintControllerContract(contract *autogen.MintController) MintControllerContract {
+	return &MintControllerContractImpl{contract: contract}
+}