Merge remote-tracking branch 'origin/master' into debug-block

Author: KolbyML

.github/workflows/_go-tests.yml

@@ -153,39 +153,71 @@ jobs:
           JIT_HASH=$(echo "$OUTPUT" | grep -oP 'hash \K[a-f0-9]+')
           echo "jit_hash=$JIT_HASH" >> $GITHUB_OUTPUT
 
-      - name: run the Rust validation server on block input json
+      - name: run Rust validation server (Native & Continuous)
         if: inputs.run-defaults-a
         run: |
-          # 1. Start server in background
+          # 0. Build once
           make build-validation-server
-          target/bin/validator --module-root-path ./target/machines/latest/module-root.txt &
-          SERVER_PID=$!
           
-          # 2. Wait for server to respond (up to 5 seconds)
-          echo "Waiting for validator to start..."
-          timeout 5s bash -c 'until curl -s localhost:4141 > /dev/null; do sleep 1; done'
-          
-          # 3. Send validation request
-          RESPONSE=$(curl -s -X POST http://localhost:4141/validation_validate \
-            -H "Content-Type: application/json" \
-            -d @target/TestProgramStorage/block_inputs.json)
-          
-          # 4. Stop the server
-          kill $SERVER_PID
-
-          # 5. Compare hashes          
-          SERVER_HASH=$(echo "$RESPONSE" | jq -r '.BlockHash')
+          # Capture the expected hash once
           JIT_HASH="${{ steps.jit.outputs.jit_hash }}"
+
+          validate_mode() {
+            local MODE_NAME=$1
+            local SERVER_ARGS=$2
+
+            echo "::group::Testing Mode: $MODE_NAME"
+            
+            # 1. Start server in background
+            echo "Starting server ($MODE_NAME)..."
+            target/bin/validator --module-root-path ./target/machines/latest/module-root.txt $SERVER_ARGS &
+            SERVER_PID=$!
+
+            # 2. Wait for server to respond (up to 5 seconds)
+            echo "Waiting for validator ($MODE_NAME) to start..."
+            if ! timeout 5s bash -c 'until curl -s localhost:4141 > /dev/null; do sleep 1; done'; then
+              echo "❌ Server ($MODE_NAME) failed to start within timeout"
+              kill $SERVER_PID
+              exit 1
+            fi
+
+            # 3. Send 2 validation requests
+            RESPONSE1=$(curl -s -X POST http://localhost:4141/validation_validate \
+              -H "Content-Type: application/json" \
+              -d @target/TestProgramStorage/block_inputs.json)
+
+            RESPONSE2=$(curl -s -X POST http://localhost:4141/validation_validate \
+              -H "Content-Type: application/json" \
+              -d @target/TestProgramStorage/block_inputs.json)
+
+            # 4. Stop the server
+            kill $SERVER_PID
+            wait $SERVER_PID 2>/dev/null || true
+
+            # 5. Compare hashes      
+            SERVER_HASH1=$(echo "$RESPONSE1" | jq -r '.BlockHash')
+            SERVER_HASH2=$(echo "$RESPONSE2" | jq -r '.BlockHash')
+            
+            echo "JIT Hash:    $JIT_HASH"
+            echo "Server response 1 Hash: $SERVER_HASH1"
+            echo "Server response 2 Hash: $SERVER_HASH2"
+
+            if [ "$JIT_HASH" == "$SERVER_HASH1" ] && [ "$JIT_HASH" == "$SERVER_HASH2" ]; then
+              echo "✅ $MODE_NAME Validation successful"
+            else
+              echo "❌ $MODE_NAME Validation failed: hashes do not match"
+              exit 1
+            fi
+            echo "::endgroup::"
+          }
+
+          # --- RUN TESTS ---
           
-          echo "JIT Hash:    $JIT_HASH"
-          echo "Server Hash: $SERVER_HASH"
-          
-          if [ "$JIT_HASH" == "$SERVER_HASH" ]; then
-            echo "✅ Validation successful"
-          else
-            echo "❌ Validation failed: hashes do not match"
-            exit 1
-          fi
+          # Run Validator in Native mode
+          validate_mode "Native" ""
+
+          # Run Validator in Continuous mode
+          validate_mode "Continuous" "--mode continuous"
 
       # --------------------- FLAKY MODE --------------------------
 

.github/workflows/automated-changelog.yml

@@ -25,13 +25,9 @@ jobs:
             
             const dir = 'changelog';
             
-            // Find the next available number
-            let x = 1;
-            while (fs.existsSync(path.join(dir, `dependabot-${x}.md`))) {
-              x++;
-            }
+            const prNumber = context.payload.pull_request.number;
+            const filename = path.join(dir, `dependabot-${prNumber}.md`);
 
-            const filename = path.join(dir, `dependabot-${x}.md`);
             const title = context.payload.pull_request.title;
             const content = `### Ignored\n- ${title}\n`;
 

Cargo.lock

@@ -104,6 +104,12 @@ stylus_files = $(wildcard $(stylus_dir)/*.toml $(stylus_dir)/src/*.rs) $(wasm_li
 jit_dir = crates/jit
 jit_files = $(wildcard $(jit_dir)/*.toml $(jit_dir)/*.rs $(jit_dir)/src/*.rs $(jit_dir)/src/*/*.rs) $(stylus_files)
 
+validation_crate_dir = crates/validation
+validation_files = $(wildcard $(validation_crate_dir)/*.toml $(validation_crate_dir)/src/*.rs $(validation_crate_dir)/src/*/*.rs) $(rust_arbutil_files)
+
+validator_dir = crates/validator
+validator_files = $(wildcard $(validator_dir)/*.toml $(validator_dir)/src/*.rs $(validator_dir)/src/*/*.rs) $(jit_files) $(validation_files)
+
 wasm32_wasi = target/wasm32-wasip1/release
 wasm32_unknown = target/wasm32-unknown-unknown/release
 
@@ -385,7 +391,7 @@ $(arbitrator_jit): $(DEP_PREDICATE) $(jit_files)
 	cargo build --release -p jit ${CARGOFLAGS}
 	install target/release/jit $@
 
-$(validation_server): $(DEP_PREDICATE)
+$(validation_server): $(DEP_PREDICATE) $(validator_files)
 	mkdir -p `dirname $(validation_server)`
 	cargo build --release -p validator ${CARGOFLAGS}
 	install target/release/validator $@

Makefile

@@ -0,0 +1,3 @@
+### Internal
+- Add support for multiple module roots for Validator
+- Fix Validator continuous mode to run jit binary from inside tokio runtime

changelog/bragaigor-nit-4390.md

@@ -0,0 +1,2 @@
+### Added
+- Multi-gas constraints to L2-pricing simulator

changelog/gligneul-nit-4111.md

@@ -0,0 +1,2 @@
+### Ignored
+- ensure dependabot changelog files are unique

changelog/jcolvin-bot-changelog-fix.md

@@ -4,8 +4,12 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
+	"os"
+	"strings"
+	"unicode"
 
 	"github.com/spf13/pflag"
 
@@ -99,26 +103,26 @@ func (c *LegacyConfig) Print(w io.Writer) {
 	fmt.Fprintln(w, "Backlog tolerance:\t", c.BacklogTolerance)
 }
 
-type ConstraintsConfig struct {
+type SingleGasConfig struct {
 	CommonConfig
 	Targets  []int64
 	Windows  []int64
 	Backlogs []int64
 }
 
-var DefaultConstraintConfig = ConstraintsConfig{
+var DefaultConstraintConfig = SingleGasConfig{
 	Targets: []int64{60_000_000, 41_000_000, 29_000_000, 20_000_000, 14_000_000, 10_000_000},
 	Windows: []int64{9, 52, 329, 2_105, 13_485, 86_400},
 }
 
-func (c *ConstraintsConfig) AddFlags(flags *pflag.FlagSet) {
+func (c *SingleGasConfig) AddFlags(flags *pflag.FlagSet) {
 	c.CommonConfig.AddFlags(flags)
 	flags.Int64SliceVar(&c.Targets, "targets", DefaultConstraintConfig.Targets, "List of constraints' targets; previously speed-limit")
 	flags.Int64SliceVar(&c.Windows, "windows", DefaultConstraintConfig.Windows, "List of constraints' adjustment windows; previously inertia")
 	flags.Int64SliceVar(&c.Backlogs, "backlogs", DefaultConstraintConfig.Backlogs, "List of constraints' initial backlogs")
 }
 
-func (c *ConstraintsConfig) Print(w io.Writer) {
+func (c *SingleGasConfig) Print(w io.Writer) {
 	c.CommonConfig.Print(w)
 	fmt.Fprintln(w, "Number of constraints:\t", len(c.Targets))
 	for i := range len(c.Targets) {
@@ -132,7 +136,7 @@ func (c *ConstraintsConfig) Print(w io.Writer) {
 	}
 }
 
-func (c *ConstraintsConfig) Validate() error {
+func (c *SingleGasConfig) Validate() error {
 	for _, target := range c.Targets {
 		if target < 0 {
 			return fmt.Errorf("invalid negative target")
@@ -159,3 +163,66 @@ func (c *ConstraintsConfig) Validate() error {
 	}
 	return nil
 }
+
+type MultiGasConfig struct {
+	CommonConfig
+	Constraints         []MultiGasConstraint
+	constraintsJson     string
+	constraintsJsonPath string
+	printConstraints    bool
+}
+
+var DefaultMultiGasConfig = MultiGasConfig{
+	constraintsJson:  DefaultMultiGasConstraints,
+	printConstraints: false,
+}
+
+func (c *MultiGasConfig) AddFlags(flags *pflag.FlagSet) {
+	c.CommonConfig.AddFlags(flags)
+	defaultConstraints := strings.Map(func(r rune) rune {
+		if unicode.IsSpace(r) {
+			return -1
+		}
+		return r
+	}, DefaultMultiGasConstraints)
+	flags.StringVar(&c.constraintsJson, "constraints", defaultConstraints, "Multi-gas constraints specified as JSON")
+	flags.StringVar(&c.constraintsJsonPath, "constraints-path", "", "If set, load the constraints from the file")
+	flags.BoolVar(&c.printConstraints, "print-constraints", DefaultMultiGasConfig.printConstraints, "print the constraints")
+}
+
+func (c *MultiGasConfig) Print(w io.Writer) {
+	c.CommonConfig.Print(w)
+	if c.printConstraints {
+		result, err := json.MarshalIndent(c.Constraints, "             ", "  ")
+		if err != nil {
+			fmt.Fprintf(w, "Failed to print constraints: %v\n", err.Error())
+		} else {
+			fmt.Fprintf(w, "Constraints: %v\n", string(result))
+		}
+	} else {
+		fmt.Fprintf(w, "Number of constraints: %v\n", len(c.Constraints))
+	}
+}
+
+func (c *MultiGasConfig) Validate() error {
+	var constraintsJson []byte
+	if c.constraintsJsonPath != "" {
+		var err error
+		constraintsJson, err = os.ReadFile(c.constraintsJsonPath)
+		if err != nil {
+			return fmt.Errorf("failed to read constraints file: %w", err)
+		}
+	} else {
+		constraintsJson = []byte(c.constraintsJson)
+	}
+	err := json.Unmarshal(constraintsJson, &c.Constraints)
+	if err != nil {
+		return fmt.Errorf("failed to parse constraints: %w", err)
+	}
+	for _, constraint := range c.Constraints {
+		if err := constraint.Validate(); err != nil {
+			return err
+		}
+	}
+	return nil
+}

cmd/l2pricing-simulator/config.go

@@ -67,8 +67,8 @@ func runLegacyModel(args []string) error {
 	return nil
 }
 
-func runConstraintsModel(args []string) error {
-	var config ConstraintsConfig
+func runSingleGasModel(args []string) error {
+	var config SingleGasConfig
 	if err := ParseConfig(&config, args); err != nil {
 		return err
 	}
@@ -116,20 +116,62 @@ func runConstraintsModel(args []string) error {
 	return nil
 }
 
+func runMultiGasModel(args []string) error {
+	var config MultiGasConfig
+	if err := ParseConfig(&config, args); err != nil {
+		return err
+	}
+
+	pricing, err := newPricingState(params.ArbosVersion_MultiGasConstraintsVersion)
+	if err != nil {
+		return err
+	}
+
+	longTermWindow := uint32(0)
+	longTermTarget := uint64(0)
+	for _, constraint := range config.Constraints {
+		_ = pricing.AddMultiGasConstraint(constraint.Target, constraint.Window, constraint.Backlog, constraint.Weights)
+		if constraint.Window > longTermWindow {
+			longTermWindow = constraint.Window
+			longTermTarget = constraint.Target
+		}
+	}
+
+	gasSimulator := NewGasSimulator(config.CommonConfig, longTermTarget)
+
+	results := []Result{}
+	for i := range config.Iterations() {
+		baseFee, _ := pricing.BaseFeeWei()
+		gas := gasSimulator.compute(i, baseFee)
+		_ = pricing.GrowBacklog(gas, multigas.ComputationGas(gas))
+		pricing.UpdatePricingModel(1)
+		baseFee, _ = pricing.BaseFeeWei()
+		results = append(results, Result{
+			baseFee:  baseFee,
+			gasRatio: float64(gas) / float64(longTermTarget),
+		})
+	}
+
+	printOutput(&config, results)
+	return nil
+}
+
 func main() {
 	args := os.Args
 	if len(args) < 2 {
-		fmt.Println("Usage: l2pricing-simulator [legacy|constraints] ...")
+		fmt.Println("Usage: l2pricing-simulator [legacy|singlegas|multigas] ...")
 		os.Exit(1)
 	}
 	var err error
 	switch strings.ToLower(args[1]) {
 	case "legacy":
 		err = runLegacyModel(args[2:])
-	case "constraints":
-		err = runConstraintsModel(args[2:])
+	case "singlegas":
+		err = runSingleGasModel(args[2:])
+	case "multigas":
+		err = runMultiGasModel(args[2:])
 	default:
-		err = fmt.Errorf("unknown command '%s', valid commands are: legacy and constraints", args[1])
+		err = fmt.Errorf("unknown command '%s', valid commands are: legacy, singlegas, multigas", args[1])
 	}
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)