merge 105 and 107 PRs

Author: MoeMahhouk

internal/artifacts.go

@@ -276,6 +276,21 @@ func (b *ArtifactsBuilder) Build() (*Artifacts, error) {
 			}
 		}
 
+		// Update the allocs to include the same prefunded accounts as the L1 genesis.
+		allocs := make(map[string]interface{})
+		input["alloc"] = allocs
+		for _, privStr := range prefundedAccounts {
+			priv, err := getPrivKey(privStr)
+			if err != nil {
+				return nil, err
+			}
+			addr := ecrypto.PubkeyToAddress(priv.PublicKey)
+			allocs[addr.String()] = map[string]interface{}{
+				"balance": "0x10000000000000000000000",
+				"nonce":   "0x1",
+			}
+		}
+
 		newOpGenesis, err := overrideJSON(opGenesis, input)
 		if err != nil {
 			return nil, err

internal/components.go

@@ -87,7 +87,7 @@ func (o *OpNode) Run(service *service, ctx *ExContext) {
 			"--rpc.port", `{{Port "http" 8549}}`,
 			"--p2p.listen.ip", "0.0.0.0",
 			"--p2p.listen.tcp", `{{Port "p2p" 9003}}`,
-			"--p2p.listen.udp", `{{Port "p2p" 9003}}`,
+			"--p2p.listen.udp", `{{PortUDP "p2p" 9003}}`,
 			"--p2p.scoring.peers", "light",
 			"--p2p.ban.peers", "true",
 			"--metrics.enabled",
@@ -303,11 +303,11 @@ func (l *LighthouseBeaconNode) Run(svc *service, ctx *ExContext) {
 			"--disable-peer-scoring",
 			"--staking",
 			"--enr-address", "10.0.2.2",
-			"--enr-udp-port", `{{Port "p2p" 9000}}`,
+			"--enr-udp-port", `{{PortUDP "p2p" 9000}}`,
 			"--enr-tcp-port", `{{Port "p2p" 9000}}`,
-			"--enr-quic-port", `{{Port "quic-p2p" 9100}}`,
-			"--port", `{{Port "p2p" 9000}}`,
-			"--quic-port", `{{Port "quic-p2p" 9100}}`,
+			"--enr-quic-port", `{{PortUDP "quic-p2p" 9100}}`,
+			"--port", `{{PortUDP "p2p" 9000}}`,
+			"--quic-port", `{{PortUDP "quic-p2p" 9100}}`,
 			"--http",
 			"--http-port", `{{Port "http" 3500}}`,
 			"--http-address", "0.0.0.0",
@@ -440,7 +440,7 @@ func (b *BuilderHubPostgres) Run(service *service, ctx *ExContext) {
 	service.
 		WithImage("docker.io/flashbots/builder-hub-db").
 		WithTag("0.2.1").
-		WithLocalPort("postgres", 5432).
+		WithPort("postgres", 5432).
 		WithEnv("POSTGRES_USER", "postgres").
 		WithEnv("POSTGRES_PASSWORD", "postgres").
 		WithEnv("POSTGRES_DB", "postgres").
@@ -487,7 +487,7 @@ func (b *BuilderHubMockProxy) Run(service *service, ctx *ExContext) {
 	service.
 		WithImage("nginx").
 		WithTag("1.27").
-		WithLocalPort("http", 8888).
+		WithPort("http", 8888).
 		DependsOnRunning(b.TargetService).
 		WithEntrypoint("/bin/sh").
 		WithArgs("-c", fmt.Sprintf(`cat > /etc/nginx/conf.d/default.conf << 'EOF'

internal/local_runner.go

@@ -59,6 +59,9 @@ type LocalRunner struct {
 	tasksMtx     sync.Mutex
 	tasks        map[string]*task
 	taskUpdateCh chan struct{}
+
+	// wether to bind the ports to the local interface
+	bindHostPortsLocally bool
 }
 
 type task struct {
@@ -88,12 +91,14 @@ func newDockerClient() (*client.Client, error) {
 	return client, nil
 }
 
-func NewLocalRunner(out *output, manifest *Manifest, overrides map[string]string, interactive bool) (*LocalRunner, error) {
+func NewLocalRunner(out *output, manifest *Manifest, overrides map[string]string, interactive bool, bindHostPortsLocally bool) (*LocalRunner, error) {
 	client, err := newDockerClient()
 	if err != nil {
 		return nil, fmt.Errorf("failed to create docker client: %w", err)
 	}
 
+	fmt.Println(bindHostPortsLocally)
+
 	// merge the overrides with the manifest overrides
 	if overrides == nil {
 		overrides = make(map[string]string)
@@ -134,15 +139,16 @@ func NewLocalRunner(out *output, manifest *Manifest, overrides map[string]string
 	}
 
 	d := &LocalRunner{
-		out:           out,
-		manifest:      manifest,
-		client:        client,
-		reservedPorts: map[int]bool{},
-		overrides:     overrides,
-		handles:       []*exec.Cmd{},
-		tasks:         tasks,
-		taskUpdateCh:  make(chan struct{}),
-		exitErr:       make(chan error, 2),
+		out:                  out,
+		manifest:             manifest,
+		client:               client,
+		reservedPorts:        map[int]bool{},
+		overrides:            overrides,
+		handles:              []*exec.Cmd{},
+		tasks:                tasks,
+		taskUpdateCh:         make(chan struct{}),
+		exitErr:              make(chan error, 2),
+		bindHostPortsLocally: bindHostPortsLocally,
 	}
 
 	if interactive {
@@ -380,6 +386,16 @@ func (d *LocalRunner) applyTemplate(s *service) ([]string, map[string]string, er
 		}
 	}
 
+	resolvePort := func(name string, defaultPort int, protocol string) int {
+		// For {{Port "name" "defaultPort"}}:
+		// - Service runs on host: return the host port
+		// - Service runs inside docker: return the docker port
+		if d.isHostService(s.Name) {
+			return s.MustGetPort(name).HostPort
+		}
+		return defaultPort
+	}
+
 	funcs := template.FuncMap{
 		"Service": func(name string, portLabel, protocol string) string {
 			protocolPrefix := ""
@@ -412,13 +428,10 @@ func (d *LocalRunner) applyTemplate(s *service) ([]string, map[string]string, er
 			}
 		},
 		"Port": func(name string, defaultPort int) int {
-			// For {{Port "name" "defaultPort"}}:
-			// - Service runs on host: return the host port
-			// - Service runs inside docker: return the docker port
-			if d.isHostService(s.Name) {
-				return s.MustGetPort(name).HostPort
-			}
-			return defaultPort
+			return resolvePort(name, defaultPort, ProtocolTCP)
+		},
+		"PortUDP": func(name string, defaultPort int) int {
+			return resolvePort(name, defaultPort, ProtocolUDP)
 		},
 	}
 
@@ -583,14 +596,15 @@ func (d *LocalRunner) toDockerComposeService(s *service) (map[string]interface{}
 	if len(s.ports) > 0 {
 		ports := []string{}
 		for _, p := range s.ports {
-			if p.Local {
-				// Bind only to localhost (127.0.0.1)
-				ports = append(ports, fmt.Sprintf("127.0.0.1:%d:%d/tcp", p.HostPort, p.Port))
-				ports = append(ports, fmt.Sprintf("127.0.0.1:%d:%d/udp", p.HostPort, p.Port))
+			protocol := ""
+			if p.Protocol == ProtocolUDP {
+				protocol = "/udp"
+			}
+
+			if d.bindHostPortsLocally {
+				ports = append(ports, fmt.Sprintf("127.0.0.1:%d:%d%s", p.HostPort, p.Port, protocol))
 			} else {
-				// Bind to all interfaces (default)
-				ports = append(ports, fmt.Sprintf("%d:%d/tcp", p.HostPort, p.Port))
-				ports = append(ports, fmt.Sprintf("%d:%d/udp", p.HostPort, p.Port))
+				ports = append(ports, fmt.Sprintf("%d:%d%s", p.HostPort, p.Port, protocol))
 			}
 		}
 		service["ports"] = ports

internal/manifest.go

@@ -210,6 +210,11 @@ func (s *Manifest) Validate() error {
 	return nil
 }
 
+const (
+	ProtocolUDP = "udp"
+	ProtocolTCP = "tcp"
+)
+
 // Port describes a port that a service exposes
 type Port struct {
 	// Name is the name of the port
@@ -218,6 +223,9 @@ type Port struct {
 	// Port is the port number
 	Port int
 
+	// Protocol (tcp or udp)
+	Protocol string
+
 	// HostPort is the port number assigned on the host machine for this
 	// container port. It is populated by the local runner
 	// TODO: We might want to move this to the runner itself.
@@ -359,37 +367,39 @@ func (s *service) WithTag(tag string) *service {
 	return s
 }
 
-func (s *service) WithPort(name string, portNumber int, local bool) *service {
+func (s *service) WithPort(name string, portNumber int, protocolVar ...string) *service {
+	protocol := ProtocolTCP
+	if len(protocolVar) > 0 {
+		if protocolVar[0] != ProtocolTCP && protocolVar[0] != ProtocolUDP {
+			panic(fmt.Sprintf("protocol %s not supported", protocolVar[0]))
+		}
+		protocol = protocolVar[0]
+	}
+
 	// add the port if not already present with the same name.
 	// if preset with the same name, they must have same port number
 	for _, p := range s.ports {
 		if p.Name == name {
 			if p.Port != portNumber {
 				panic(fmt.Sprintf("port %s already defined with different port number", name))
 			}
+			if p.Protocol != protocol {
+				// If they have different protocols they are different ports
+				continue
+			}
 			return s
 		}
 	}
-	s.ports = append(s.ports, &Port{Name: name, Port: portNumber, Local: local})
+	s.ports = append(s.ports, &Port{Name: name, Port: portNumber, Protocol: protocol})
 	return s
 }
 
-// WithLocalPort is a convenience method to add a port that should only be bound to localhost
-func (s *service) WithLocalPort(name string, portNumber int) *service {
-	return s.WithPort(name, portNumber, true)
-}
-
-// WithPublicPort is a convenience method to add a port that should be bound to all interfaces (default behavior)
-func (s *service) WithPublicPort(name string, portNumber int) *service {
-	return s.WithPort(name, portNumber, false)
-}
-
 func (s *service) applyTemplate(arg string) {
 	var port []Port
 	var nodeRef []NodeRef
 	_, port, nodeRef = applyTemplate(arg)
 	for _, p := range port {
-		s.WithPort(p.Name, p.Port, false) // Default to non-local ports for backward compatibility
+		s.WithPort(p.Name, p.Port, p.Protocol)
 	}
 	for _, n := range nodeRef {
 		s.nodeRefs = append(s.nodeRefs, &n)
@@ -458,9 +468,13 @@ func applyTemplate(templateStr string) (string, []Port, []NodeRef) {
 			return fmt.Sprintf(`{{Service "%s" "%s"}}`, name, portLabel)
 		},
 		"Port": func(name string, defaultPort int) string {
-			portRef = append(portRef, Port{Name: name, Port: defaultPort, Local: false})
+			portRef = append(portRef, Port{Name: name, Port: defaultPort, Protocol: ProtocolTCP})
 			return fmt.Sprintf(`{{Port "%s" %d}}`, name, defaultPort)
 		},
+		"PortUDP": func(name string, defaultPort int) string {
+			portRef = append(portRef, Port{Name: name, Port: defaultPort, Protocol: ProtocolUDP})
+			return fmt.Sprintf(`{{PortUDP "%s" %d}}`, name, defaultPort)
+		},
 	}
 
 	tpl, err := template.New("").Funcs(funcs).Parse(templateStr)

main.go

@@ -24,7 +24,7 @@ var dryRun bool
 var interactive bool
 var timeout time.Duration
 var logLevelFlag string
-var localPortsFlag bool
+var bindExternal bool
 
 var rootCmd = &cobra.Command{
 	Use:   "playground",
@@ -168,7 +168,7 @@ func main() {
 		recipeCmd.Flags().BoolVar(&interactive, "interactive", false, "interactive mode")
 		recipeCmd.Flags().DurationVar(&timeout, "timeout", 0, "") // Used for CI
 		recipeCmd.Flags().StringVar(&logLevelFlag, "log-level", "info", "log level")
-		recipeCmd.Flags().BoolVar(&localPortsFlag, "local-ports", false, "bind all ports to localhost only (127.0.0.1) for enhanced security")
+		recipeCmd.Flags().BoolVar(&bindExternal, "bind-external", false, "bind host ports to external interface")
 
 		cookCmd.AddCommand(recipeCmd)
 	}
@@ -219,15 +219,6 @@ func runIt(recipe internal.Recipe) error {
 		return fmt.Errorf("failed to validate manifest: %w", err)
 	}
 
-	// set the local ports flag
-	if localPortsFlag {
-		for _, svc := range svcManager.Services() {
-			for _, port := range svc.Ports() {
-				port.Local = true
-			}
-		}
-	}
-
 	// generate the dot graph
 	dotGraph := svcManager.GenerateDotGraph()
 	if err := artifacts.Out.WriteFile("graph.dot", dotGraph); err != nil {
@@ -245,7 +236,7 @@ func runIt(recipe internal.Recipe) error {
 		}
 	}
 
-	dockerRunner, err := internal.NewLocalRunner(artifacts.Out, svcManager, overrides, interactive)
+	dockerRunner, err := internal.NewLocalRunner(artifacts.Out, svcManager, overrides, interactive, !bindExternal)
 	if err != nil {
 		return fmt.Errorf("failed to create docker runner: %w", err)
 	}
@@ -275,7 +266,11 @@ func runIt(recipe internal.Recipe) error {
 
 			portsStr := []string{}
 			for _, p := range ports {
-				portsStr = append(portsStr, fmt.Sprintf("%s: %d/%d", p.Name, p.Port, p.HostPort))
+				protocol := ""
+				if p.Protocol == internal.ProtocolUDP {
+					protocol = "/udp"
+				}
+				portsStr = append(portsStr, fmt.Sprintf("%s: %d/%d%s", p.Name, p.Port, p.HostPort, protocol))
 			}
 			fmt.Printf("- %s (%s)\n", ss.Name, strings.Join(portsStr, ", "))
 		}