make da request timeout configurable

Author: tac0turtle

block/public.go

@@ -1,8 +1,6 @@
 package block
 
 import (
-	"time"
-
 	"github.com/evstack/ev-node/block/internal/common"
 	"github.com/evstack/ev-node/block/internal/da"
 	coreda "github.com/evstack/ev-node/core/da"
@@ -44,7 +42,7 @@ func NewDAClient(
 		DA:                daLayer,
 		Logger:            logger,
 		Namespace:         config.DA.GetNamespace(),
-		DefaultTimeout:    15 * time.Second,
+		DefaultTimeout:    config.DA.RequestTimeout.Duration,
 		DataNamespace:     config.DA.GetDataNamespace(),
 		RetrieveBatchSize: config.DA.RetrieveBatchSize,
 	})

docs/learn/config.md

@@ -490,6 +490,42 @@ _Example:_ `--rollkit.da.mempool_ttl 30`
 _Default:_ `20`
 _Constant:_ `FlagDAMempoolTTL`
 
+### DA Retrieve Batch Size
+
+**Description:**
+Number of blob IDs requested per DA `Get` call when the node retrieves blocks from the DA layer. Smaller batches help unreliable DA RPC endpoints return data before the per-request timeout, while larger batches reduce the total number of round trips for fast DA nodes.
+
+**YAML:**
+
+```yaml
+da:
+  retrieve_batch_size: 100
+```
+
+**Command-line Flag:**
+`--rollkit.da.retrieve_batch_size <int>`
+_Example:_ `--rollkit.da.retrieve_batch_size 50`
+_Default:_ `100`
+_Constant:_ `FlagDARetrieveBatchSize`
+
+### DA Request Timeout
+
+**Description:**
+Per-request timeout applied to DA `GetIDs` and `Get` RPC calls while retrieving blobs. Increase this value if your DA endpoint has high latency to avoid premature failures; decrease it to make the syncer fail fast and free resources sooner when the DA node becomes unresponsive.
+
+**YAML:**
+
+```yaml
+da:
+  request_timeout: "30s"
+```
+
+**Command-line Flag:**
+`--rollkit.da.request_timeout <duration>`
+_Example:_ `--rollkit.da.request_timeout 45s`
+_Default:_ `"30s"`
+_Constant:_ `FlagDARequestTimeout`
+
 ## P2P Configuration (`p2p`)
 
 Settings for peer-to-peer networking, enabling nodes to discover each other, exchange blocks, and share transactions.

docs/learn/specs/block-manager.md

@@ -167,6 +167,8 @@ The block components share a common configuration:
 | Namespace                | da.Namespace  | DA namespace ID for block submissions (deprecated, use HeaderNamespace and DataNamespace instead)                                                    |
 | HeaderNamespace          | string        | namespace ID for submitting headers to DA layer (automatically encoded by the node)                                                                  |
 | DataNamespace            | string        | namespace ID for submitting data to DA layer (automatically encoded by the node)                                                                     |
+| RetrieveBatchSize        | int           | number of blob IDs fetched per DA `Get` call, trading off payload size vs. number of RPC round trips (default: 100)                                  |
+| RequestTimeout           | duration      | per-request timeout for DA `GetIDs`/`Get` calls; higher values tolerate slow DA nodes, lower values fail faster (default: 30s)                     |
 
 ### Block Production (Executor Component)
 

pkg/config/config.go

@@ -72,6 +72,8 @@ const (
 	FlagDAMaxSubmitAttempts = FlagPrefixEvnode + "da.max_submit_attempts"
 	// FlagDARetrieveBatchSize configures how many IDs are fetched per DA Get request
 	FlagDARetrieveBatchSize = FlagPrefixEvnode + "da.retrieve_batch_size"
+	// FlagDARequestTimeout controls the per-request timeout when talking to the DA layer
+	FlagDARequestTimeout = FlagPrefixEvnode + "da.request_timeout"
 
 	// P2P configuration flags
 
@@ -165,6 +167,7 @@ type DAConfig struct {
 	MempoolTTL        uint64          `mapstructure:"mempool_ttl" yaml:"mempool_ttl" comment:"Number of DA blocks after which a transaction is considered expired and dropped from the mempool. Controls retry backoff timing."`
 	MaxSubmitAttempts int             `mapstructure:"max_submit_attempts" yaml:"max_submit_attempts" comment:"Maximum number of attempts to submit data to the DA layer before giving up. Higher values provide more resilience but can delay error reporting."`
 	RetrieveBatchSize int             `mapstructure:"retrieve_batch_size" yaml:"retrieve_batch_size" comment:"Number of IDs to request per DA Get call when retrieving blobs. Smaller batches lower per-request latency; larger batches reduce the number of RPC round trips. Default: 100."`
+	RequestTimeout    DurationWrapper `mapstructure:"request_timeout" yaml:"request_timeout" comment:"Per-request timeout applied to DA GetIDs/Get calls when retrieving blobs. Larger values tolerate slower DA nodes at the cost of waiting longer before failing. Default: 30s."`
 }
 
 // GetNamespace returns the namespace for header submissions.
@@ -324,6 +327,7 @@ func AddFlags(cmd *cobra.Command) {
 	cmd.Flags().Uint64(FlagDAMempoolTTL, def.DA.MempoolTTL, "number of DA blocks until transaction is dropped from the mempool")
 	cmd.Flags().Int(FlagDAMaxSubmitAttempts, def.DA.MaxSubmitAttempts, "maximum number of attempts to submit data to the DA layer before giving up")
 	cmd.Flags().Int(FlagDARetrieveBatchSize, def.DA.RetrieveBatchSize, "number of IDs to request per DA Get call when retrieving blobs")
+	cmd.Flags().Duration(FlagDARequestTimeout, def.DA.RequestTimeout.Duration, "per-request timeout when retrieving blobs from the DA layer")
 
 	// P2P configuration flags
 	cmd.Flags().String(FlagP2PListenAddress, def.P2P.ListenAddress, "P2P listen address (host:port)")

pkg/config/config_test.go

@@ -26,7 +26,8 @@ func TestDefaultConfig(t *testing.T) {
 	assert.Equal(t, "", def.DA.AuthToken)
 	assert.Equal(t, "", def.DA.SubmitOptions)
 	assert.NotEmpty(t, def.DA.Namespace)
-	assert.Equal(t, 150, def.DA.RetrieveBatchSize)
+	assert.Equal(t, 100, def.DA.RetrieveBatchSize)
+	assert.Equal(t, 30*time.Second, def.DA.RequestTimeout.Duration)
 	assert.Equal(t, 1*time.Second, def.Node.BlockTime.Duration)
 	assert.Equal(t, 6*time.Second, def.DA.BlockTime.Duration)
 	assert.Equal(t, uint64(0), def.DA.MempoolTTL)
@@ -72,6 +73,7 @@ func TestAddFlags(t *testing.T) {
 	assertFlagValue(t, flags, FlagDAMempoolTTL, DefaultConfig().DA.MempoolTTL)
 	assertFlagValue(t, flags, FlagDAMaxSubmitAttempts, DefaultConfig().DA.MaxSubmitAttempts)
 	assertFlagValue(t, flags, FlagDARetrieveBatchSize, DefaultConfig().DA.RetrieveBatchSize)
+	assertFlagValue(t, flags, FlagDARequestTimeout, DefaultConfig().DA.RequestTimeout.Duration)
 
 	// P2P flags
 	assertFlagValue(t, flags, FlagP2PListenAddress, DefaultConfig().P2P.ListenAddress)
@@ -101,7 +103,7 @@ func TestAddFlags(t *testing.T) {
 	assertFlagValue(t, flags, FlagRPCAddress, DefaultConfig().RPC.Address)
 
 	// Count the number of flags we're explicitly checking
-	expectedFlagCount := 38 // Update this number if you add more flag checks above
+	expectedFlagCount := 39 // Update this number if you add more flag checks above
 
 	// Get the actual number of flags (both regular and persistent)
 	actualFlagCount := 0

pkg/config/defaults.go

@@ -75,7 +75,8 @@ func DefaultConfig() Config {
 			MaxSubmitAttempts: 30,
 			Namespace:         randString(10),
 			DataNamespace:     "",
-			RetrieveBatchSize: 150,
+			RetrieveBatchSize: 100,
+			RequestTimeout:    DurationWrapper{30 * time.Second},
 		},
 		Instrumentation: DefaultInstrumentationConfig(),
 		Log: LogConfig{