updates

Author: julienrbrt

apps/testapp/kv/kvexecutor.go

@@ -430,11 +430,11 @@ func (k *KVExecutor) GetExecutionInfo(ctx context.Context, height uint64) (execu
 	return execution.ExecutionInfo{MaxGas: 0}, nil
 }
 
-// FilterTxs validates force-included transactions and calculates gas for all transactions.
+// FilterTxs validates force-included transactions and applies gas filtering.
 // For KVExecutor, only force-included transactions are validated (key=value format).
 // Mempool transactions are passed through unchanged.
-// KVExecutor doesn't track gas, so GasPerTx is nil.
-func (k *KVExecutor) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool) (*execution.FilterTxsResult, error) {
+// KVExecutor doesn't track gas, so maxGas is ignored.
+func (k *KVExecutor) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool, maxGas uint64) (*execution.FilterTxsResult, error) {
 	validTxs := make([][]byte, 0, len(txs))
 	validMask := make([]bool, 0, len(txs))
 
@@ -460,6 +460,6 @@ func (k *KVExecutor) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedM
 	return &execution.FilterTxsResult{
 		ValidTxs:          validTxs,
 		ForceIncludedMask: validMask,
-		GasPerTx:          nil, // KVExecutor doesn't track gas
+		RemainingTxs:      nil, // KVExecutor doesn't track gas, so no gas-based filtering
 	}, nil
 }

core/execution/dummy.go

@@ -109,14 +109,13 @@ func (e *DummyExecutor) GetExecutionInfo(ctx context.Context, height uint64) (Ex
 	return ExecutionInfo{MaxGas: 0}, nil
 }
 
-// FilterTxs validates force-included transactions and calculates gas for all transactions.
+// FilterTxs validates force-included transactions and applies gas filtering.
 // For DummyExecutor, all transactions are considered valid (no parsing/gas checks).
-func (e *DummyExecutor) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool) (*FilterTxsResult, error) {
+func (e *DummyExecutor) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool, maxGas uint64) (*FilterTxsResult, error) {
 	// DummyExecutor doesn't do any filtering - return all txs as valid
-	// GasPerTx is nil since DummyExecutor doesn't track gas
 	return &FilterTxsResult{
 		ValidTxs:          txs,
 		ForceIncludedMask: forceIncludedMask,
-		GasPerTx:          nil,
+		RemainingTxs:      nil,
 	}, nil
 }

core/execution/execution.go

@@ -7,18 +7,19 @@ import (
 
 // FilterTxsResult contains the result of filtering transactions.
 type FilterTxsResult struct {
-	// ValidTxs contains transactions that passed validation.
+	// ValidTxs contains transactions that passed validation and fit within gas limit.
 	// Force-included txs that are invalid are removed.
-	// Mempool txs are passed through unchanged.
+	// Mempool txs are passed through unchanged (but may be trimmed for gas).
 	ValidTxs [][]byte
 
 	// ForceIncludedMask indicates which ValidTxs are force-included (true = force-included).
 	// Same length as ValidTxs.
 	ForceIncludedMask []bool
 
-	// GasPerTx contains the gas for each transaction in ValidTxs.
-	// For non-gas-based execution layers, this may be nil or all zeros.
-	GasPerTx []uint64
+	// RemainingTxs contains valid force-included transactions that didn't fit due to gas limit.
+	// These should be re-queued for the next block.
+	// Only force-included txs are returned here (mempool txs are handled by the sequencer).
+	RemainingTxs [][]byte
 }
 
 // ExecutionInfo contains execution layer parameters that may change per block.
@@ -121,27 +122,26 @@ type Executor interface {
 	// - error: Any errors during retrieval
 	GetExecutionInfo(ctx context.Context, height uint64) (ExecutionInfo, error)
 
-	// FilterTxs validates force-included transactions and calculates gas for all transactions.
+	// FilterTxs validates force-included transactions and applies gas filtering.
 	// Only transactions with forceIncludedMask[i]=true are validated for correctness.
 	// Mempool transactions (forceIncludedMask[i]=false) are passed through unchanged.
 	//
 	// The function filters out:
 	// - Invalid/unparseable force-included transactions (gibberish)
+	// - Transactions that would exceed the cumulative gas limit (for force-included txs)
 	//
-	// Gas limiting is NOT performed by this function. The caller (sequencer) is responsible
-	// for using the returned GasPerTx values to enforce gas limits.
-	//
-	// For non-gas-based execution layers, GasPerTx may be nil or all zeros.
+	// For non-gas-based execution layers (maxGas=0), return all valid transactions.
 	//
 	// Parameters:
 	// - ctx: Context for timeout/cancellation control
 	// - txs: All transactions (force-included + mempool)
 	// - forceIncludedMask: true for each tx that is force-included (needs validation)
+	// - maxGas: Maximum cumulative gas allowed (0 means no gas limit)
 	//
 	// Returns:
-	// - result: Contains valid txs, updated mask, and gas per tx
+	// - result: Contains valid txs, updated mask, remaining txs, and gas used
 	// - err: Any errors during filtering (not validation errors, which result in filtering)
-	FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool) (*FilterTxsResult, error)
+	FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool, maxGas uint64) (*FilterTxsResult, error)
 }
 
 // HeightProvider is an optional interface that execution clients can implement

execution/evm/execution.go

@@ -788,14 +788,15 @@ func (c *EngineClient) GetExecutionInfo(ctx context.Context, height uint64) (exe
 	return execution.ExecutionInfo{MaxGas: gasLimit}, nil
 }
 
-// FilterTxs validates force-included transactions and calculates gas for all transactions.
+// FilterTxs validates force-included transactions and applies gas filtering.
 // Only transactions with forceIncludedMask[i]=true are validated for correctness.
 // Mempool transactions (forceIncludedMask[i]=false) are passed through unchanged.
-// Gas limiting is NOT performed by this function - the caller handles that using GasPerTx.
-func (c *EngineClient) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool) (*execution.FilterTxsResult, error) {
+// Gas limiting is applied to force-included transactions; remaining valid ones are returned in RemainingTxs.
+func (c *EngineClient) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool, maxGas uint64) (*execution.FilterTxsResult, error) {
 	validTxs := make([][]byte, 0, len(txs))
 	validMask := make([]bool, 0, len(txs))
-	gasPerTx := make([]uint64, 0, len(txs))
+	var remainingTxs [][]byte
+	var cumulativeGas uint64
 
 	for i, tx := range txs {
 		isForceIncluded := i < len(forceIncludedMask) && forceIncludedMask[i]
@@ -817,32 +818,62 @@ func (c *EngineClient) FilterTxs(ctx context.Context, txs [][]byte, forceInclude
 				continue
 			}
 
+			txGas := ethTx.Gas()
+
+			// Check gas limit for force-included transactions
+			if maxGas > 0 && cumulativeGas+txGas > maxGas {
+				// This tx and remaining force-included txs don't fit - add to remaining
+				remainingTxs = append(remainingTxs, tx)
+				// Continue to collect remaining valid force-included txs
+				for j := i + 1; j < len(txs); j++ {
+					if j < len(forceIncludedMask) && forceIncludedMask[j] {
+						if len(txs[j]) == 0 {
+							continue
+						}
+						var remainingEthTx types.Transaction
+						if err := remainingEthTx.UnmarshalBinary(txs[j]); err != nil {
+							c.logger.Debug().
+								Int("tx_index", j).
+								Err(err).
+								Msg("filtering out invalid force-included transaction in remaining (gibberish)")
+							continue
+						}
+						remainingTxs = append(remainingTxs, txs[j])
+					} else {
+						// Add remaining mempool txs to validTxs
+						validTxs = append(validTxs, txs[j])
+						validMask = append(validMask, false)
+					}
+				}
+
+				c.logger.Debug().
+					Int("valid_txs", len(validTxs)).
+					Int("remaining_txs", len(remainingTxs)).
+					Uint64("cumulative_gas", cumulativeGas).
+					Uint64("max_gas", maxGas).
+					Msg("force-included transactions exceeded gas limit, splitting batch")
+
+				return &execution.FilterTxsResult{
+					ValidTxs:          validTxs,
+					ForceIncludedMask: validMask,
+					RemainingTxs:      remainingTxs,
+				}, nil
+			}
+
+			cumulativeGas += txGas
 			validTxs = append(validTxs, tx)
 			validMask = append(validMask, true)
-			gasPerTx = append(gasPerTx, ethTx.Gas())
 		} else {
 			// Mempool transactions pass through unchanged
-			// Still calculate gas for them
-			var txGas uint64
-			if len(tx) > 0 {
-				var ethTx types.Transaction
-				if err := ethTx.UnmarshalBinary(tx); err == nil {
-					txGas = ethTx.Gas()
-				}
-				// If parsing fails for mempool tx, we still include it with gas=0
-				// The execution layer will handle it during actual execution
-			}
-
 			validTxs = append(validTxs, tx)
 			validMask = append(validMask, false)
-			gasPerTx = append(gasPerTx, txGas)
 		}
 	}
 
 	return &execution.FilterTxsResult{
 		ValidTxs:          validTxs,
 		ForceIncludedMask: validMask,
-		GasPerTx:          gasPerTx,
+		RemainingTxs:      nil,
 	}, nil
 }
 

execution/grpc/client.go

@@ -132,14 +132,16 @@ func (c *Client) GetExecutionInfo(ctx context.Context, height uint64) (execution
 	}, nil
 }
 
-// FilterTxs validates force-included transactions and calculates gas for all transactions.
+// FilterTxs validates force-included transactions and applies gas filtering.
 //
 // This method sends transactions to the remote execution service for validation.
 // Only force-included transactions are validated; mempool transactions pass through unchanged.
-func (c *Client) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool) (*execution.FilterTxsResult, error) {
+// Gas limiting is applied to force-included transactions.
+func (c *Client) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool, maxGas uint64) (*execution.FilterTxsResult, error) {
 	req := connect.NewRequest(&pb.FilterTxsRequest{
 		Txs:               txs,
 		ForceIncludedMask: forceIncludedMask,
+		MaxGas:            maxGas,
 	})
 
 	resp, err := c.client.FilterTxs(ctx, req)
@@ -150,6 +152,6 @@ func (c *Client) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask
 	return &execution.FilterTxsResult{
 		ValidTxs:          resp.Msg.ValidTxs,
 		ForceIncludedMask: resp.Msg.ForceIncludedMask,
-		GasPerTx:          resp.Msg.GasPerTx,
+		RemainingTxs:      resp.Msg.RemainingTxs,
 	}, nil
 }

execution/grpc/client_test.go

@@ -16,7 +16,7 @@ type mockExecutor struct {
 	executeTxsFunc       func(ctx context.Context, txs [][]byte, blockHeight uint64, timestamp time.Time, prevStateRoot []byte) ([]byte, error)
 	setFinalFunc         func(ctx context.Context, blockHeight uint64) error
 	getExecutionInfoFunc func(ctx context.Context, height uint64) (execution.ExecutionInfo, error)
-	filterTxsFunc        func(ctx context.Context, txs [][]byte, forceIncludedMask []bool) (*execution.FilterTxsResult, error)
+	filterTxsFunc        func(ctx context.Context, txs [][]byte, forceIncludedMask []bool, maxGas uint64) (*execution.FilterTxsResult, error)
 }
 
 func (m *mockExecutor) InitChain(ctx context.Context, genesisTime time.Time, initialHeight uint64, chainID string) ([]byte, error) {
@@ -54,15 +54,15 @@ func (m *mockExecutor) GetExecutionInfo(ctx context.Context, height uint64) (exe
 	return execution.ExecutionInfo{MaxGas: 0}, nil
 }
 
-func (m *mockExecutor) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool) (*execution.FilterTxsResult, error) {
+func (m *mockExecutor) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool, maxGas uint64) (*execution.FilterTxsResult, error) {
 	if m.filterTxsFunc != nil {
-		return m.filterTxsFunc(ctx, txs, forceIncludedMask)
+		return m.filterTxsFunc(ctx, txs, forceIncludedMask, maxGas)
 	}
-	// Default: return all txs as valid, no gas info
+	// Default: return all txs as valid, no remaining
 	return &execution.FilterTxsResult{
 		ValidTxs:          txs,
 		ForceIncludedMask: forceIncludedMask,
-		GasPerTx:          nil,
+		RemainingTxs:      nil,
 	}, nil
 }
 

execution/grpc/server.go

@@ -156,20 +156,20 @@ func (s *Server) GetExecutionInfo(
 
 // FilterTxs handles the FilterTxs RPC request.
 //
-// It validates force-included transactions and calculates gas for all transactions.
+// It validates force-included transactions and applies gas filtering.
 // Only transactions with forceIncludedMask[i]=true are validated.
 func (s *Server) FilterTxs(
 	ctx context.Context,
 	req *connect.Request[pb.FilterTxsRequest],
 ) (*connect.Response[pb.FilterTxsResponse], error) {
-	result, err := s.executor.FilterTxs(ctx, req.Msg.Txs, req.Msg.ForceIncludedMask)
+	result, err := s.executor.FilterTxs(ctx, req.Msg.Txs, req.Msg.ForceIncludedMask, req.Msg.MaxGas)
 	if err != nil {
 		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("failed to filter transactions: %w", err))
 	}
 
 	return connect.NewResponse(&pb.FilterTxsResponse{
 		ValidTxs:          result.ValidTxs,
 		ForceIncludedMask: result.ForceIncludedMask,
-		GasPerTx:          result.GasPerTx,
+		RemainingTxs:      result.RemainingTxs,
 	}), nil
 }

pkg/sequencers/based/sequencer.go

@@ -156,44 +156,25 @@ func (s *BasedSequencer) GetNextBatch(ctx context.Context, req coresequencer.Get
 		maxGas = info.MaxGas
 	}
 
-	// Filter transactions - validates force-included txs and returns gas per tx
-	filterResult, err := s.executor.FilterTxs(ctx, batchTxs, forceIncludedMask)
+	// Filter transactions - validates force-included txs and applies gas filtering
+	filterResult, err := s.executor.FilterTxs(ctx, batchTxs, forceIncludedMask, maxGas)
 	if err != nil {
 		s.logger.Warn().Err(err).Msg("failed to filter transactions, proceeding with unfiltered")
 		filterResult = &execution.FilterTxsResult{
 			ValidTxs:          batchTxs,
 			ForceIncludedMask: forceIncludedMask,
-			GasPerTx:          nil,
+			RemainingTxs:      nil,
 		}
 	}
 
-	// Apply gas limits using the returned GasPerTx
-	var filteredTxs [][]byte
-	var remainingGasFilteredTxs [][]byte
-	var cumulativeGas uint64
-
-	for i, tx := range filterResult.ValidTxs {
-		txGas := uint64(0)
-		if filterResult.GasPerTx != nil && i < len(filterResult.GasPerTx) {
-			txGas = filterResult.GasPerTx[i]
-		}
-
-		// Check if this tx fits within gas limit
-		if maxGas > 0 && cumulativeGas+txGas > maxGas {
-			// This tx and remaining txs don't fit - save for next block
-			remainingGasFilteredTxs = append(remainingGasFilteredTxs, filterResult.ValidTxs[i:]...)
-			break
-		}
-
-		cumulativeGas += txGas
-		filteredTxs = append(filteredTxs, tx)
-	}
+	// FilterTxs returns valid txs that fit within gas, and remaining txs that didn't fit
+	filteredTxs := filterResult.ValidTxs
+	remainingGasFilteredTxs := filterResult.RemainingTxs
 
 	s.logger.Debug().
 		Int("input_txs", len(batchTxs)).
 		Int("filtered_txs", len(filteredTxs)).
 		Int("remaining_for_next_block", len(remainingGasFilteredTxs)).
-		Uint64("gas_used", cumulativeGas).
 		Uint64("max_gas", maxGas).
 		Msg("filtered DA transactions")
 

pkg/sequencers/based/sequencer_test.go

@@ -26,7 +26,7 @@ import (
 type mockExecutor struct {
 	maxGas     uint64
 	getInfoErr error
-	filterFunc func(ctx context.Context, txs [][]byte, forceIncludedMask []bool) (*execution.FilterTxsResult, error)
+	filterFunc func(ctx context.Context, txs [][]byte, forceIncludedMask []bool, maxGas uint64) (*execution.FilterTxsResult, error)
 }
 
 func (m *mockExecutor) InitChain(ctx context.Context, genesisTime time.Time, initialHeight uint64, chainID string) ([]byte, error) {
@@ -49,15 +49,15 @@ func (m *mockExecutor) GetExecutionInfo(ctx context.Context, height uint64) (exe
 	return execution.ExecutionInfo{MaxGas: m.maxGas}, m.getInfoErr
 }
 
-func (m *mockExecutor) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool) (*execution.FilterTxsResult, error) {
+func (m *mockExecutor) FilterTxs(ctx context.Context, txs [][]byte, forceIncludedMask []bool, maxGas uint64) (*execution.FilterTxsResult, error) {
 	if m.filterFunc != nil {
-		return m.filterFunc(ctx, txs, forceIncludedMask)
+		return m.filterFunc(ctx, txs, forceIncludedMask, maxGas)
 	}
-	// Default: return all txs as valid, no gas info
+	// Default: return all txs as valid, no remaining
 	return &execution.FilterTxsResult{
 		ValidTxs:          txs,
 		ForceIncludedMask: forceIncludedMask,
-		GasPerTx:          nil,
+		RemainingTxs:      nil,
 	}, nil
 }