Refactor enviroment usage (#58)

* Remove unused Node Types and default certain configs to avoid repetition

* Move to SDK usage

* move direct usage of local env to client + public networks + tests

* start network on tests

* update readme

* update thor

* move env to internal

* lint

* pr comments

* Initial refactor

* refactor actions

* moving envs to overseer

* working overseer

* overseer is now launch

* update readme

* Enabling custom genesis configs for hayabusa

* update docker

* pr comments

Author: otherview

.github/README.md

@@ -8,34 +8,44 @@ networkHub is a Go SDK framework designed to streamline the process of launching
 
 ## Quick Start
 
-### **Launch Local Custom Network**:
+### **Launch Local Custom Network** (Simplest Way):
 ```go
 package main
 
 import (
     "log"
     "github.com/vechain/networkhub/client"
     "github.com/vechain/networkhub/preset"
+    "github.com/vechain/networkhub/thorbuilder"
 )
 
 func main() {
-    // Create a local three-node network
-    network := preset.LocalThreeMasterNodesNetwork()
+    // Step 1: Use a preset network configuration (3 nodes local network)
+    network := preset.LocalThreeNodesNetwork()
+    
+    // Step 2: Configure thor builder for automatic binary management
+    cfg := thorbuilder.DefaultConfig()
+    network.ThorBuilder = cfg
 
-    // Set the thor binary path for all nodes
-    for _, node := range network.Nodes {
-        node.SetExecArtifact("/path/to/thor/binary")
+    // Step 3: Create client and start network
+    client, err := client.New(network)
+    if err != nil {
+        log.Fatal(err)
     }
+    defer client.Stop()
 
-    // Create client and start network
-    c, err := client.NewWithNetwork(network)
+    // Step 4: Start the network
+    err = client.Start()
     if err != nil {
         log.Fatal(err)
     }
-    defer c.Stop()
 
-    log.Println("Network started successfully!")
-    // Your network is ready for use
+    log.Println("✅ 3-node VeChain network started successfully!")
+    log.Printf("🌐 First node API: %s", network.Nodes[0].GetHTTPAddr())
+    
+    // Your network is ready for use!
+    // The thor binary is automatically downloaded and built
+    // All nodes are configured with genesis, keys, and networking
 }
 ```
 
@@ -51,31 +61,88 @@ import (
 
 func main() {
     // Connect to VeChain testnet (auto-starts)
-    testnet, _ := preset.NewTestnetNetwork("dev")
-    testnetClient, err := client.NewWithNetwork(testnet)
+    testnet, err := preset.NewTestnetNetwork()
+    if err != nil {
+        log.Fatal(err)
+    }
+    
+    testnetClient, err := client.New(testnet)
     if err != nil {
         log.Fatal(err)
     }
     defer testnetClient.Stop()
 
-    // Connect to VeChain mainnet (auto-starts)
-    mainnet, _ := preset.NewMainnetNetwork("main")
-    mainnetClient, err := client.NewWithNetwork(mainnet)
+    // Connect to VeChain mainnet (auto-starts)  
+    mainnet, err := preset.NewMainnetNetwork()
+    if err != nil {
+        log.Fatal(err)
+    }
+    
+    mainnetClient, err := client.New(mainnet)
     if err != nil {
         log.Fatal(err)
     }
     defer mainnetClient.Stop()
 
-    log.Println("Connected to public networks!")
+    log.Println("✅ Connected to VeChain public networks!")
+    // Networks auto-start when connecting to public networks
 }
 ```
 
+## Key Features
+
+- **🚀 Simple API**: Get a VeChain network running in just 4 lines of code
+- **🔧 Automatic Thor Management**: Thor binary is automatically downloaded, built, and configured
+- **🌐 Multiple Environments**: Support for both Local and Docker environments  
+- **📦 Built-in Presets**: Pre-configured networks for common use cases
+- **🏗️ Custom Networks**: Full control over genesis, nodes, and network parameters
+- **🔗 Public Network Support**: Easy connection to VeChain mainnet and testnet
+- **⚙️ Node Management**: Dynamically add and remove nodes from running networks
+- **🏥 Health Monitoring**: Built-in network health checks and validation
+- **🐳 Docker Support**: Run networks in Docker containers with proper networking
+- **🔑 Key Management**: Automatic private key and genesis configuration
+
 ## Purpose and Scope
 networkHub enables teams to quickly deploy custom networks and connect to public VeChain networks, facilitating development and testing in both isolated and live environments. The SDK approach provides full programmatic control over network lifecycle management.
 
+## Architecture
+
+The framework is built around a **Launcher** architecture that orchestrates node management across different environments:
+
+- **Client**: High-level API for network management
+- **Launcher**: Central orchestrator for network operations (previously called "Overseer")
+- **Environments**: Support for Local process execution and Docker containers
+- **Presets**: Pre-configured network templates for common scenarios
+- **ThorBuilder**: Automatic Thor binary management and building
+
+## Available Presets
+
+### Local Networks
+- `preset.LocalThreeNodesNetwork()` - 3-node local network with authority nodes
+- `preset.LocalSixNodesNetwork()` - 6-node local network for larger testing scenarios
+
+### Public Networks  
+- `preset.NewTestnetNetwork()` - Connect to VeChain testnet
+- `preset.NewMainnetNetwork()` - Connect to VeChain mainnet
+
+## Environments
+
+### Local Environment
+Runs Thor nodes as local processes on your machine:
+```go
+network.Environment = environments.Local
+```
+
+### Docker Environment  
+Runs Thor nodes in Docker containers with proper networking:
+```go
+network.Environment = environments.Docker
+```
+
 ## Technical Requirements
-- **Git**: For cloning the repository.
-- **Golang**: Version 1.19 or higher.
+- **Git**: For cloning the repository
+- **Golang**: Version 1.19 or higher
+- **Docker**: Required for Docker environment (optional for Local environment)
 
 ## Thorbuilder Package
 The `thorbuilder` package is a key component of the networkHub framework that provides flexible configuration options for building Thor binaries from source. It supports both local builds and Docker image creation, with options for reusable builds and debug configurations.

client/client.go

@@ -5,56 +5,49 @@ import (
 	"strings"
 
 	"github.com/vechain/networkhub/internal/environments"
-	"github.com/vechain/networkhub/internal/environments/docker"
-	"github.com/vechain/networkhub/internal/environments/local"
+	"github.com/vechain/networkhub/internal/environments/launcher"
 	"github.com/vechain/networkhub/network"
 	"github.com/vechain/networkhub/network/node"
-	"github.com/vechain/networkhub/thorbuilder"
 )
 
 type Client struct {
-	network     *network.Network
-	environment environments.Actions
-	factories   map[string]environments.Factory
+	network *network.Network
+	actions environments.Actions
 }
 
-func New() *Client {
-	factories := map[string]environments.Factory{
-		"local":  local.NewFactory(),
-		"docker": docker.NewFactory(),
-	}
-
-	return &Client{
-		factories: factories,
+func New(net *network.Network) (*Client, error) {
+	env, err := launcher.New(net)
+	if err != nil {
+		return nil, err
 	}
-}
 
-func NewWithNetwork(net *network.Network) (*Client, error) {
-	c := New()
-	if err := c.LoadNetwork(net); err != nil {
-		return nil, err
+	c := &Client{
+		network: net,
+		actions: env,
 	}
 
-	if strings.Contains(net.ID(), "mainnet") || strings.Contains(net.ID(), "testnet") {
+	// Auto-start for public networks (testnet/mainnet)
+	if strings.Contains(net.ID(), network.Mainnet) || strings.Contains(net.ID(), network.Testnet) {
 		if err := c.Start(); err != nil {
 			return nil, err
 		}
 	}
+
 	return c, nil
 }
 
 func (c *Client) Stop() error {
-	if c.environment == nil {
+	if c.actions == nil {
 		return fmt.Errorf("no network loaded")
 	}
-	return c.environment.StopNetwork()
+	return c.actions.StopNetwork()
 }
 
 func (c *Client) Start() error {
-	if c.environment == nil {
+	if c.actions == nil {
 		return fmt.Errorf("no network loaded")
 	}
-	return c.environment.StartNetwork()
+	return c.actions.StartNetwork()
 }
 
 func (c *Client) GetNetwork() (*network.Network, error) {
@@ -64,71 +57,29 @@ func (c *Client) GetNetwork() (*network.Network, error) {
 	return c.network, nil
 }
 
-func (c *Client) LoadNetwork(net *network.Network) error {
-	factory, ok := c.factories[net.Environment]
-	if !ok {
-		return fmt.Errorf("unsupported environment: %s", net.Environment)
-	}
-
-	// Handle thor binary management at client level
-	if net.ThorBuilder != nil {
-		execPath, err := thorbuilder.NewAndBuild(net.ThorBuilder)
-		if err != nil {
-			return fmt.Errorf("failed to build thor binary: %w", err)
-		}
-
-		// Set exec artifact for all nodes that don't have one
-		for _, nodeConfig := range net.Nodes {
-			if nodeConfig.GetExecArtifact() == "" {
-				nodeConfig.SetExecArtifact(execPath)
-			}
-		}
-	}
-
-	env := factory.New()
-	_, err := env.LoadConfig(net)
-	if err != nil {
-		return fmt.Errorf("failed to load network config: %w", err)
-	}
-
-	c.network = net
-	c.environment = env
-	return nil
-}
-
 func (c *Client) Nodes() (map[string]node.Lifecycle, error) {
-	if c.environment == nil {
+	if c.actions == nil {
 		return nil, fmt.Errorf("no network loaded")
 	}
-	return c.environment.Nodes(), nil
+	return c.actions.Nodes(), nil
 }
 
 func (c *Client) AddNode(nodeConfig node.Config) error {
 	if c.network == nil {
 		return fmt.Errorf("no network loaded")
 	}
 
-	if c.environment == nil {
+	if c.actions == nil {
 		return fmt.Errorf("environment not initialized")
 	}
 
-	// Set exec artifact for the new node if it doesn't have one and we have a thor builder
-	if nodeConfig.GetExecArtifact() == "" && c.network.ThorBuilder != nil {
-		execPath, err := thorbuilder.NewAndBuild(c.network.ThorBuilder)
-		if err != nil {
-			return fmt.Errorf("failed to build thor binary for new node: %w", err)
-		}
-
-		nodeConfig.SetExecArtifact(execPath)
-	}
-
 	// Use environment's AddNode method
-	if err := c.environment.AddNode(nodeConfig); err != nil {
+	if err := c.actions.AddNode(nodeConfig); err != nil {
 		return fmt.Errorf("failed to add node to environment: %w", err)
 	}
 
 	// Update client's network reference
-	c.network = c.environment.Config()
+	c.network = c.actions.Config()
 
 	return nil
 }
@@ -138,17 +89,17 @@ func (c *Client) RemoveNode(nodeID string) error {
 		return fmt.Errorf("no network loaded")
 	}
 
-	if c.environment == nil {
+	if c.actions == nil {
 		return fmt.Errorf("environment not initialized")
 	}
 
 	// Use environment's RemoveNode method
-	if err := c.environment.RemoveNode(nodeID); err != nil {
+	if err := c.actions.RemoveNode(nodeID); err != nil {
 		return fmt.Errorf("failed to remove node from environment: %w", err)
 	}
 
 	// Update client's network reference
-	c.network = c.environment.Config()
+	c.network = c.actions.Config()
 
 	return nil
 }