feat: embed preview network configs in binary (#1009)

Signed-off-by: Chris Gianelloni <wolf31o2@blinklabs.io>

Author: wolf31o2

config/cardano/embed.go

@@ -0,0 +1,24 @@
+// Copyright 2025 Blink Labs Software
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cardano
+
+import "embed"
+
+// EmbeddedConfigPreviewNetworkFS contains the embedded Cardano configuration files
+// for the preview network. This includes config.json and all genesis files required
+// for preview network operation when no external config files are available.
+//
+//go:embed preview
+var EmbeddedConfigPreviewNetworkFS embed.FS

config/cardano/embed_test.go

@@ -0,0 +1,94 @@
+// Copyright 2025 Blink Labs Software
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cardano
+
+import (
+	"testing"
+)
+
+func TestNewCardanoNodeConfigFromEmbedFS(t *testing.T) {
+	// Test loading config from embedded filesystem
+	cfg, err := NewCardanoNodeConfigFromEmbedFS(
+		EmbeddedConfigPreviewNetworkFS,
+		"preview/config.json",
+	)
+	if err != nil {
+		t.Fatalf("failed to load cardano config from embedded FS: %v", err)
+	}
+
+	if cfg == nil {
+		t.Fatal("expected non-nil config")
+	}
+
+	// Verify that the config has expected values
+	if cfg.ShelleyGenesisFile == "" {
+		t.Error("expected ShelleyGenesisFile to be set")
+	}
+
+	if cfg.ByronGenesisFile == "" {
+		t.Error("expected ByronGenesisFile to be set")
+	}
+
+	// Verify genesis configs were actually loaded
+	if cfg.ShelleyGenesis() == nil {
+		t.Error("expected ShelleyGenesis to be loaded")
+	}
+
+	if cfg.ByronGenesis() == nil {
+		t.Error("expected ByronGenesis to be loaded")
+	}
+}
+
+func TestNewCardanoNodeConfigFromEmbedFS_InvalidPath(t *testing.T) {
+	// Test loading config from embedded filesystem with invalid path
+	_, err := NewCardanoNodeConfigFromEmbedFS(
+		EmbeddedConfigPreviewNetworkFS,
+		"nonexistent/config.json",
+	)
+	if err == nil {
+		t.Fatal("expected error for invalid path")
+	}
+}
+
+func TestEmbedFS_ListFiles(t *testing.T) {
+	// Test that embedded FS contains expected files in preview directory
+	previewEntries, err := EmbeddedConfigPreviewNetworkFS.ReadDir("preview")
+	if err != nil {
+		t.Fatalf("failed to read preview directory: %v", err)
+	}
+
+	if len(previewEntries) == 0 {
+		t.Fatal("expected preview directory to contain files")
+	}
+
+	expectedFiles := []string{
+		"config.json",
+		"byron-genesis.json",
+		"shelley-genesis.json",
+		"alonzo-genesis.json",
+		"conway-genesis.json",
+	}
+	foundFiles := make(map[string]bool)
+
+	for _, entry := range previewEntries {
+		foundFiles[entry.Name()] = true
+	}
+
+	for _, expectedFile := range expectedFiles {
+		if !foundFiles[expectedFile] {
+			t.Errorf("expected to find %s in preview directory", expectedFile)
+		}
+	}
+}

config/cardano/loadhelper.go

@@ -0,0 +1,49 @@
+// Copyright 2025 Blink Labs Software
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cardano
+
+import (
+	"embed"
+	"fmt"
+	"os"
+)
+
+// LoadCardanoNodeConfigWithFallback tries to load config from file, then falls back to embed FS for preview network.
+func LoadCardanoNodeConfigWithFallback(
+	cfgPath, network string,
+	embedFS embed.FS,
+) (*CardanoNodeConfig, error) {
+	_, err := os.Stat(cfgPath)
+	if err == nil {
+		return NewCardanoNodeConfigFromFile(cfgPath)
+	}
+	if !os.IsNotExist(err) {
+		return nil, fmt.Errorf(
+			"failed to check config file %q: %w",
+			cfgPath,
+			err,
+		)
+	}
+
+	// File doesn't exist, try embedded config for preview network
+	if network == "preview" {
+		return NewCardanoNodeConfigFromEmbedFS(embedFS, cfgPath)
+	}
+	return nil, fmt.Errorf(
+		"config file %q not found and no embedded config available for network %q",
+		cfgPath,
+		network,
+	)
+}

config/cardano/node.go

@@ -15,6 +15,7 @@
 package cardano
 
 import (
+	"embed"
 	"io"
 	"os"
 	"path"
@@ -27,19 +28,21 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-// CardanoNodeConfig represents the config.json/yaml file used by cardano-node
+// CardanoNodeConfig represents the config.json/yaml file used by cardano-node.
 type CardanoNodeConfig struct {
-	path               string
+	// Embedded filesystem for loading genesis files
+	embedFS            embed.FS
 	alonzoGenesis      *alonzo.AlonzoGenesis
+	byronGenesis       *byron.ByronGenesis
+	conwayGenesis      *conway.ConwayGenesis
+	shelleyGenesis     *shelley.ShelleyGenesis
+	path               string
 	AlonzoGenesisFile  string `yaml:"AlonzoGenesisFile"`
 	AlonzoGenesisHash  string `yaml:"AlonzoGenesisHash"`
-	byronGenesis       *byron.ByronGenesis
 	ByronGenesisFile   string `yaml:"ByronGenesisFile"`
 	ByronGenesisHash   string `yaml:"ByronGenesisHash"`
-	conwayGenesis      *conway.ConwayGenesis
 	ConwayGenesisFile  string `yaml:"ConwayGenesisFile"`
 	ConwayGenesisHash  string `yaml:"ConwayGenesisHash"`
-	shelleyGenesis     *shelley.ShelleyGenesis
 	ShelleyGenesisFile string `yaml:"ShelleyGenesisFile"`
 	ShelleyGenesisHash string `yaml:"ShelleyGenesisHash"`
 }
@@ -69,6 +72,31 @@ func NewCardanoNodeConfigFromFile(file string) (*CardanoNodeConfig, error) {
 	return c, nil
 }
 
+// NewCardanoNodeConfigFromEmbedFS creates a CardanoNodeConfig from an embedded filesystem.
+// It loads the main config file and all referenced genesis files from the embedded FS.
+// The file parameter should be a path relative to the root of the embedded filesystem.
+func NewCardanoNodeConfigFromEmbedFS(
+	fs embed.FS,
+	file string,
+) (*CardanoNodeConfig, error) {
+	f, err := fs.Open(file)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	c, err := NewCardanoNodeConfigFromReader(f)
+	if err != nil {
+		return nil, err
+	}
+	c.path = path.Dir(file)
+	c.embedFS = fs // Store reference to embedded FS
+	if err := c.loadGenesisConfigsFromEmbed(); err != nil {
+		return nil, err
+	}
+	return c, nil
+}
+
 func (c *CardanoNodeConfig) loadGenesisConfigs() error {
 	// Load Byron genesis
 	if c.ByronGenesisFile != "" {
@@ -127,6 +155,79 @@ func (c *CardanoNodeConfig) loadGenesisConfigs() error {
 	return nil
 }
 
+// loadGenesisFromEmbedFS loads a single genesis file from the embedded filesystem.
+// It handles path resolution and file opening/closing automatically.
+func (c *CardanoNodeConfig) loadGenesisFromEmbedFS(
+	filename string,
+) (io.ReadCloser, error) {
+	if filename == "" {
+		return nil, nil
+	}
+
+	genesisPath := filename
+	genesisPath = path.Join(c.path, genesisPath)
+
+	f, err := c.embedFS.Open(genesisPath)
+	if err != nil {
+		return nil, err
+	}
+	return f, nil
+}
+
+// loadGenesisConfigsFromEmbed loads all genesis configuration files from the embedded filesystem.
+// This method mirrors loadGenesisConfigs but reads from embed.FS instead of the regular filesystem.
+func (c *CardanoNodeConfig) loadGenesisConfigsFromEmbed() error {
+	// Load Byron genesis
+	if f, err := c.loadGenesisFromEmbedFS(c.ByronGenesisFile); err != nil {
+		return err
+	} else if f != nil {
+		defer f.Close()
+		byronGenesis, err := byron.NewByronGenesisFromReader(f)
+		if err != nil {
+			return err
+		}
+		c.byronGenesis = &byronGenesis
+	}
+
+	// Load Shelley genesis
+	if f, err := c.loadGenesisFromEmbedFS(c.ShelleyGenesisFile); err != nil {
+		return err
+	} else if f != nil {
+		defer f.Close()
+		shelleyGenesis, err := shelley.NewShelleyGenesisFromReader(f)
+		if err != nil {
+			return err
+		}
+		c.shelleyGenesis = &shelleyGenesis
+	}
+
+	// Load Alonzo genesis
+	if f, err := c.loadGenesisFromEmbedFS(c.AlonzoGenesisFile); err != nil {
+		return err
+	} else if f != nil {
+		defer f.Close()
+		alonzoGenesis, err := alonzo.NewAlonzoGenesisFromReader(f)
+		if err != nil {
+			return err
+		}
+		c.alonzoGenesis = &alonzoGenesis
+	}
+
+	// Load Conway genesis
+	if f, err := c.loadGenesisFromEmbedFS(c.ConwayGenesisFile); err != nil {
+		return err
+	} else if f != nil {
+		defer f.Close()
+		conwayGenesis, err := conway.NewConwayGenesisFromReader(f)
+		if err != nil {
+			return err
+		}
+		c.conwayGenesis = &conwayGenesis
+	}
+
+	return nil
+}
+
 // ByronGenesis returns the Byron genesis config specified in the cardano-node config
 func (c *CardanoNodeConfig) ByronGenesis() *byron.ByronGenesis {
 	return c.byronGenesis

internal/config/config.go

@@ -67,7 +67,7 @@ var globalConfig = &Config{
 	BadgerCacheSize:    1073741824,
 	MempoolCapacity:    1048576,
 	BindAddr:           "0.0.0.0",
-	CardanoConfig:      "./config/cardano/preview/config.json",
+	CardanoConfig:      "", // Will be set dynamically based on network
 	DatabasePath:       ".dingo",
 	SocketPath:         "dingo.socket",
 	IntersectTip:       false,
@@ -103,6 +103,7 @@ func LoadConfig(configFile string) (*Config, error) {
 			}
 		}
 	}
+
 	if configFile != "" {
 		buf, err := os.ReadFile(configFile)
 		if err != nil {
@@ -113,11 +114,21 @@ func LoadConfig(configFile string) (*Config, error) {
 			return nil, fmt.Errorf("error parsing config file: %w", err)
 		}
 	}
+	// Process environment variables
 	err := envconfig.Process("cardano", globalConfig)
 	if err != nil {
 		return nil, fmt.Errorf("error processing environment: %+w", err)
 	}
 
+	// Set default CardanoConfig path based on network if not provided by user
+	if globalConfig.CardanoConfig == "" {
+		if globalConfig.Network == "preview" {
+			globalConfig.CardanoConfig = "preview/config.json"
+		} else {
+			globalConfig.CardanoConfig = "/opt/cardano/" + globalConfig.Network + "/config.json"
+		}
+	}
+
 	_, err = LoadTopologyConfig()
 	if err != nil {
 		return nil, fmt.Errorf("error loading topology: %+w", err)