Goldenage

.dockerignore

@@ -0,0 +1,3 @@
+nodelogs
+.git
+.gitignore

.gitignore

@@ -2,9 +2,11 @@ build/bin/
 nodelogs/
 traces/
 /data/
-*/config.toml
+*config.toml
 */private.key
 .vscode/
 .idea*
 *.env
 *.sh
+**/testdata/
+*.cov

Dockerfile

@@ -0,0 +1,48 @@
+# First stage: build the Go binary
+FROM golang:1.23-alpine AS builder
+
+# Install make and other build dependencies
+RUN apk --no-cache add make gcc musl-dev
+# Set the Current Working Directory inside the container
+WORKDIR /app
+
+# Copy go mod and sum files
+COPY go.mod go.sum ./
+
+# Download all dependencies
+RUN go mod download
+
+# Copy the source code
+COPY . .
+
+# Build the Go app using the Makefile
+RUN make go-quai
+
+# Second stage: create a smaller runtime image
+FROM alpine:latest
+
+# Install any dependencies required to run the application
+RUN apk update && apk add --no-cache \
+    coreutils \
+    findutils \
+    procps \
+    util-linux \
+    curl \
+    ca-certificates
+
+# Set the Current Working Directory inside the container
+WORKDIR /root/
+
+# Copy the binary from the builder stage
+COPY --from=builder /app/build/bin/go-quai ./build/bin/go-quai
+COPY --from=builder /app/VERSION ./VERSION
+
+
+# Ensure the binary has execute permissions
+RUN chmod +x ./build/bin/go-quai
+
+# Expose the necessary ports
+EXPOSE 8001 8002 8003 8004 8200 8201 8202 8220 8221 8222 8240 8241 8242 9001 9002 9003 9004 9200 9201 9202 9220 9221 9222 9240 9241 9242
+
+# Command to run the executable
+CMD ["./build/bin/go-quai", "start"]

Makefile

@@ -30,7 +30,7 @@ mocks:
 ## generate protobuf files
 protogen:
 	@echo "Generating protobuf files"
-	@find . -name '*.proto' -exec protoc --go_out=. --go_opt=paths=source_relative {} \;
+	@find . -name '*.proto' -exec protoc --go_out=. --go_opt=paths=source_relative --experimental_allow_proto3_optional {} \;
 
 debug:
 	go build -gcflags=all="-N -l" -v -o build/bin/go-quai ./cmd/go-quai
@@ -40,3 +40,9 @@ go-quai:
 	$(GORUN) build/ci.go build ./cmd/go-quai
 	@echo "Done building."
 	@echo "Run \"$(GOBIN)/go-quai\" to launch go-quai."
+
+## build the go-quai binary
+go-quai-race:
+	$(GORUN) build/ci.go build -race ./cmd/go-quai
+	@echo "Done building."
+	@echo "Run \"$(GOBIN)/go-quai\" to launch go-quai."

README.md

@@ -17,18 +17,22 @@ cd go-quai
 make go-quai
 ```
 
+After a successful build, the binary will be located at `build/bin/go-quai`.
+
 ### Running a node
-To run a node with default options, simply execute:
+To run a go-quai node, simply execute the `go-quai start` command. Be sure to specify the parameters you wish to use, such as your coinbase address (if you plan on mining), and which slices you wish to participate in.
+
+For example, here is the run command for miner (0x00a3e45aa16163F2663015b6695894D918866d19) in cyprus-1 (zone-0-0) on the "garden" test network:
 ```shell
-make run
+./build/bin/go-quai start --node.slices "[0 0]" --node.coinbases "0x00a3e45aa16163F2663015b6695894D918866d19" --node.environment "garden"
 ```
 
-There are several options and subcommands available when running the go-quai client. See the help menu for a complete list:
+For the full list of available options and their default values, consult the help menu:
 ```shell
 ./build/go-quai --help
 ```
 
-Any options may be provided as command-line arguments or specified in the config file at `config.yaml`.
+All configuration options may be supplied in a config file too, located in the directory specified by `--global.config-dir`. Note specified on the command-line will override options specified in the config file.
 
 ### Running tests
 To run the included unit tests, run the following command:

VERSION

@@ -1 +1 @@
-v0.19.0-pre
+v0.34.0-pre

build/ci.go

@@ -24,7 +24,7 @@ Usage: go run build/ci.go <command> <command flags/arguments>
 
 Available commands are:
 
--  build    [ -arch architecture ] [ -cc compiler ] [ packages... ]                          -- builds packages and executables
+-  build    [ -arch architecture ] [ -cc compiler ] [ -race ] [ packages... ]                          -- builds packages and executables
 -  test       [ -coverage ] [ packages... ]                                                    -- runs the tests
 -  lint                                                                                        -- runs certain pre-selected linters
 
@@ -119,6 +119,7 @@ func doBuild(cmdline []string) {
 		dlgo = flag.Bool("dlgo", false, "Download Go and build with it")
 		arch = flag.String("arch", "", "Architecture to cross build for")
 		cc   = flag.String("cc", "", "C compiler to cross build with")
+		race = flag.Bool("race", false, "Enable race detector")
 	)
 	flag.CommandLine.Parse(cmdline)
 
@@ -146,6 +147,11 @@ func doBuild(cmdline []string) {
 	// Show packages during build.
 	gobuild.Args = append(gobuild.Args, "-v")
 
+	// Add race flag if specified.
+	if *race {
+		gobuild.Args = append(gobuild.Args, "-race")
+	}
+
 	// Now we choose what we're even building.
 	// Default: collect all 'main' packages in cmd/ and build those.
 	packages := flag.Args()
@@ -254,3 +260,4 @@ func downloadLinter(cachedir string) string {
 	}
 	return filepath.Join(cachedir, base, "golangci-lint")
 }
+

cmd/go-quai/config.go

@@ -0,0 +1,78 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"github.com/dominant-strategies/go-quai/cmd/utils"
+	"github.com/dominant-strategies/go-quai/common/constants"
+	"github.com/dominant-strategies/go-quai/log"
+	"github.com/dominant-strategies/go-quai/params"
+)
+
+var configCmd = &cobra.Command{
+	Use:   "config",
+	Short: "creates the default config file",
+	Long: `creates the default config file in the location specified by the --config-dir flag. 
+			The default config file will contain all the default values for the flags.
+			Any flags passed in the command line here will also overwrite the default values in the config file.`,
+	RunE:                       runConfig,
+	SilenceUsage:               true,
+	SuggestionsMinimumDistance: 2,
+	Example:                    `go-quai start -log-level=debug`,
+	PreRunE:                    startCmdPreRun,
+}
+
+func init() {
+	rootCmd.AddCommand(configCmd)
+
+	for _, flagGroup := range utils.Flags {
+		for _, flag := range flagGroup {
+			utils.CreateAndBindFlag(flag, configCmd)
+		}
+	}
+}
+
+func configCmdPreRun(cmd *cobra.Command, args []string) error {
+	// set keyfile path
+	if viper.GetString(utils.KeyFileFlag.Name) == "" {
+		configDir := cmd.Flag(utils.ConfigDirFlag.Name).Value.String()
+		viper.Set(utils.KeyFileFlag.Name, filepath.Join(configDir, "private.key"))
+	}
+	// Initialize the version info
+	params.InitVersion()
+	return nil
+}
+
+func runConfig(cmd *cobra.Command, args []string) error {
+	// set config path to read config file
+	configDir := cmd.Flag(utils.ConfigDirFlag.Name).Value.String()
+
+	// Make sure configDir is a valid directory using path/filepath
+	// filepath.Clean returns the shortest path name equivalent to path by purely lexical processing
+	configDir = filepath.Clean(configDir)
+
+	_, err := os.Stat(configDir)
+	if err != nil && os.IsNotExist(err) {
+		// If the directory does not exist, create it
+		if err := os.MkdirAll(configDir, 0755); err != nil {
+			log.Global.Fatalf("Failed to create config directory: %s, Error: %v", configDir, err)
+		}
+		log.Global.Debugf("Config directory created: %s", configDir)
+	} else if err != nil {
+		log.Global.Fatalf("Error accessing config directory: %s, Error: %v", configDir, err)
+	}
+	if _, err := os.Stat(filepath.Join(configDir, constants.CONFIG_FILE_NAME)); os.IsNotExist(err) {
+		err := utils.WriteDefaultConfigFile(configDir, constants.CONFIG_FILE_NAME, constants.CONFIG_FILE_TYPE)
+		if err != nil {
+			return err
+		}
+		log.Global.WithField("path", filepath.Join(configDir, constants.CONFIG_FILE_NAME)).Info("Initialized new config file.")
+	} else {
+		log.Global.WithField("path", filepath.Join(configDir, constants.CONFIG_FILE_NAME)).Fatal("Cannot init config file. File already exists. Either remove this option to run with the existing config file, or delete the existing config file to re-initialize a new one.")
+	}
+	return nil
+}

cmd/go-quai/root.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"runtime/debug"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -18,6 +19,14 @@ var rootCmd = &cobra.Command{
 }
 
 func Execute() error {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Global.WithFields(log.Fields{
+				"error":      r,
+				"stacktrace": string(debug.Stack()),
+			}).Fatal("Go-Quai Panicked")
+		}
+	}()
 	err := rootCmd.Execute()
 	if err != nil {
 		return err
@@ -26,8 +35,10 @@ func Execute() error {
 }
 
 func init() {
-	for _, flag := range utils.GlobalFlags {
-		utils.CreateAndBindFlag(flag, rootCmd)
+	for _, flagGroup := range utils.Flags {
+		for _, flag := range flagGroup {
+			utils.CreateAndBindFlag(flag, rootCmd)
+		}
 	}
 }
 
@@ -45,7 +56,7 @@ func rootCmdPreRun(cmd *cobra.Command, args []string) error {
 		if err := os.MkdirAll(configDir, 0755); err != nil {
 			log.Global.Fatalf("Failed to create config directory: %s, Error: %v", configDir, err)
 		}
-		log.Global.Debug("Config directory created: %s", configDir)
+		log.Global.Debugf("Config directory created: %s", configDir)
 	} else if err != nil {
 		log.Global.Fatalf("Error accessing config directory: %s, Error: %v", configDir, err)
 	}
@@ -54,12 +65,16 @@ func rootCmdPreRun(cmd *cobra.Command, args []string) error {
 	viper.SetConfigType(constants.CONFIG_FILE_TYPE)
 
 	// Write default config file if it does not exist
-	if _, err := os.Stat(filepath.Join(configDir, constants.CONFIG_FILE_NAME)); os.IsNotExist(err) {
-		err := utils.WriteDefaultConfigFile(configDir, constants.CONFIG_FILE_NAME, constants.CONFIG_FILE_TYPE)
-		if err != nil {
-			return err
+	if viper.GetBool(utils.InitConfigFlag.Name) {
+		if _, err := os.Stat(filepath.Join(configDir, constants.CONFIG_FILE_NAME)); os.IsNotExist(err) {
+			err := utils.WriteDefaultConfigFile(configDir, constants.CONFIG_FILE_NAME, constants.CONFIG_FILE_TYPE)
+			if err != nil {
+				return err
+			}
+			log.Global.WithField("path", filepath.Join(configDir, constants.CONFIG_FILE_NAME)).Info("Initialized new config file.")
+		} else {
+			log.Global.WithField("path", filepath.Join(configDir, constants.CONFIG_FILE_NAME)).Fatal("Cannot init config file. File already exists. Either remove this option to run with the existing config file, or delete the existing config file to re-initialize a new one.")
 		}
-		log.Global.WithField("path", filepath.Join(configDir, constants.CONFIG_FILE_NAME)).Info("Default config file created")
 	}
 
 	// load config from file and environment variables