op-devstack: Support Rule Update (ethereum-optimism#19562)

Author: pcw109550

op-devstack/dsl/l2_op_rbuilder.go

@@ -54,3 +54,8 @@ func (el *OPRBuilderNode) Start() {
 	el.require.Truef(ok, "op-rbuilder node %s is not lifecycle-controllable", el.inner.Name())
 	lifecycle.Start()
 }
+
+func (el *OPRBuilderNode) UpdateRuleSet(rulesYaml string) {
+	el.log.Info("Updating rule", "content", rulesYaml)
+	el.require.NoError(el.inner.UpdateRuleSet(rulesYaml), "failed to update rule: %s", rulesYaml)
+}

op-devstack/presets/flashblocks.go

@@ -88,6 +88,7 @@ func singleChainWithFlashblocksFromRuntime(t devtest.T, runtime *sysgo.SingleCha
 		l2ChainID,
 		runtime.Flashblocks.Builder.UserRPC(),
 		runtime.Flashblocks.Builder.FlashblocksWSURL(),
+		runtime.Flashblocks.Builder.UpdateRuleSet,
 		runtime.L2Network.RollupConfig(),
 		runtime.Flashblocks.Builder,
 	)

op-devstack/presets/rpc_frontends.go

@@ -346,17 +346,19 @@ type oprBuilderFrontend struct {
 	engineClient      *sources.EngineClient
 	flashblocksClient *opclient.WSClient
 	lifecycle         stack.Lifecycle
+	updateRuleSet     func(rulesYaml string) error
 }
 
 var _ stack.OPRBuilderNode = (*oprBuilderFrontend)(nil)
 
-func newPresetOPRBuilderNode(t devtest.T, name string, chainID eth.ChainID, rpcCl opclient.RPC, rollupCfg *rollup.Config, flashblocksCl *opclient.WSClient) *oprBuilderFrontend {
+func newPresetOPRBuilderNode(t devtest.T, name string, chainID eth.ChainID, rpcCl opclient.RPC, rollupCfg *rollup.Config, flashblocksCl *opclient.WSClient, updateRuleSet func(string) error) *oprBuilderFrontend {
 	engineClient, err := sources.NewEngineClient(rpcCl, t.Logger(), nil, sources.EngineClientDefaultConfig(rollupCfg))
 	t.Require().NoError(err)
 	return &oprBuilderFrontend{
 		rpcELNode:         newRPCELNode(t, name, chainID, rpcCl, 0),
 		engineClient:      engineClient,
 		flashblocksClient: flashblocksCl,
+		updateRuleSet:     updateRuleSet,
 	}
 }
 
@@ -372,6 +374,10 @@ func (r *oprBuilderFrontend) FlashblocksClient() *opclient.WSClient {
 	return r.flashblocksClient
 }
 
+func (r *oprBuilderFrontend) UpdateRuleSet(rulesYaml string) error {
+	return r.updateRuleSet(rulesYaml)
+}
+
 func (r *oprBuilderFrontend) Start() {
 	r.require().NotNil(r.lifecycle, "OPR builder node %s is not lifecycle-controllable", r.Name())
 	r.lifecycle.Start()

op-devstack/presets/sysgo_runtime.go

@@ -84,7 +84,7 @@ func newL2BatcherFrontend(t devtest.T, name string, chainID eth.ChainID, rpcEndp
 	return newPresetL2Batcher(t, name, chainID, rpcCl)
 }
 
-func newOPRBuilderFrontend(t devtest.T, name string, chainID eth.ChainID, userRPC string, flashblocksWSURL string, rollupCfg *rollup.Config, lifecycle ...stack.Lifecycle) *oprBuilderFrontend {
+func newOPRBuilderFrontend(t devtest.T, name string, chainID eth.ChainID, userRPC string, flashblocksWSURL string, updateRuleSet func(string) error, rollupCfg *rollup.Config, lifecycle ...stack.Lifecycle) *oprBuilderFrontend {
 	rpcCl, err := client.NewRPC(t.Ctx(), t.Logger(), userRPC, client.WithLazyDial())
 	t.Require().NoError(err)
 	t.Cleanup(rpcCl.Close)
@@ -96,7 +96,7 @@ func newOPRBuilderFrontend(t devtest.T, name string, chainID eth.ChainID, userRP
 	})
 	t.Require().NoError(err)
 
-	oprb := newPresetOPRBuilderNode(t, name, chainID, rpcCl, rollupCfg, wsCl)
+	oprb := newPresetOPRBuilderNode(t, name, chainID, rpcCl, rollupCfg, wsCl, updateRuleSet)
 	if len(lifecycle) > 0 {
 		oprb.lifecycle = lifecycle[0]
 	}

op-devstack/stack/op_rbuilder.go

@@ -10,6 +10,7 @@ type OPRBuilderNode interface {
 	L2EthClient() apis.L2EthClient
 	L2EngineClient() apis.EngineClient
 	FlashblocksClient() *client.WSClient
+	UpdateRuleSet(rulesYaml string) error
 
 	ELNode
 }

op-devstack/sysgo/op_rbuilder.go

@@ -3,13 +3,15 @@ package sysgo
 
 import (
 	"encoding/hex"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
 	"sync"
 
 	"github.com/ethereum/go-ethereum/log"
+	yaml "gopkg.in/yaml.v3"
 
 	"github.com/ethereum-optimism/optimism/op-devstack/devtest"
 	"github.com/ethereum-optimism/optimism/op-devstack/stack"
@@ -461,3 +463,33 @@ func (b *OPRBuilderNode) UserRPC() string {
 func (b *OPRBuilderNode) FlashblocksWSURL() string {
 	return b.wsProxyURL
 }
+
+type RulesConfig struct {
+	File []struct {
+		Path string `yaml:"path"`
+	} `yaml:"file"`
+	RefreshInterval int `yaml:"refresh_interval"`
+}
+
+func (b *OPRBuilderNode) UpdateRuleSet(rulesYaml string) error {
+	if b.cfg.RulesConfigPath == "" {
+		return fmt.Errorf("rules config path is not configured (rules not enabled?)")
+	}
+	rulesConfigContent, err := os.ReadFile(b.cfg.RulesConfigPath)
+	if err != nil {
+		return fmt.Errorf("failed to open rules config yaml: %w", err)
+	}
+	var rulesConfig RulesConfig
+	if err := yaml.Unmarshal(rulesConfigContent, &rulesConfig); err != nil {
+		return fmt.Errorf("failed to parse rules config yaml: %w", err)
+	}
+	if len(rulesConfig.File) == 0 {
+		return fmt.Errorf("no file entries found")
+	}
+	// Use only the first file entry for simplicity
+	rulesPath := rulesConfig.File[0].Path
+	if err := os.WriteFile(rulesPath, []byte(rulesYaml), 0644); err != nil {
+		return fmt.Errorf("failed to update rules file: %w", err)
+	}
+	return nil
+}