add generate_attestations task

Author: pk910

pkg/coordinator/clients/consensus/rpc/beaconapi.go

@@ -117,6 +117,10 @@ func (bc *BeaconClient) getJSON(ctx context.Context, requrl string, returnValue
 }
 
 func (bc *BeaconClient) postJSON(ctx context.Context, requrl string, postData, returnValue interface{}) error {
+	return bc.postJSONWithHeaders(ctx, requrl, postData, returnValue, nil)
+}
+
+func (bc *BeaconClient) postJSONWithHeaders(ctx context.Context, requrl string, postData, returnValue interface{}, extraHeaders map[string]string) error {
 	logurl := getRedactedURL(requrl)
 
 	postDataBytes, err := json.Marshal(postData)
@@ -137,6 +141,10 @@ func (bc *BeaconClient) postJSON(ctx context.Context, requrl string, postData, r
 		req.Header.Set(headerKey, headerVal)
 	}
 
+	for headerKey, headerVal := range extraHeaders {
+		req.Header.Set(headerKey, headerVal)
+	}
+
 	client := &nethttp.Client{Timeout: time.Second * 300}
 
 	resp, err := client.Do(req)
@@ -497,6 +505,42 @@ func (bc *BeaconClient) SubmitProposerSlashing(ctx context.Context, slashing *ph
 	return nil
 }
 
+type apiAttestationData struct {
+	Data *phase0.AttestationData `json:"data"`
+}
+
+func (bc *BeaconClient) GetAttestationData(ctx context.Context, slot uint64, committeeIndex uint64) (*phase0.AttestationData, error) {
+	var attestationData apiAttestationData
+
+	err := bc.getJSON(ctx, fmt.Sprintf("%s/eth/v1/validator/attestation_data?slot=%d&committee_index=%d", bc.endpoint, slot, committeeIndex), &attestationData)
+	if err != nil {
+		return nil, fmt.Errorf("error retrieving attestation data: %v", err)
+	}
+
+	return attestationData.Data, nil
+}
+
+// SingleAttestation represents the Electra single attestation format for the v2 API.
+type SingleAttestation struct {
+	CommitteeIndex uint64                  `json:"committee_index,string"`
+	AttesterIndex  uint64                  `json:"attester_index,string"`
+	Data           *phase0.AttestationData `json:"data"`
+	Signature      string                  `json:"signature"`
+}
+
+func (bc *BeaconClient) SubmitAttestations(ctx context.Context, attestations []*SingleAttestation) error {
+	headers := map[string]string{
+		"Eth-Consensus-Version": "electra",
+	}
+
+	err := bc.postJSONWithHeaders(ctx, fmt.Sprintf("%s/eth/v2/beacon/pool/attestations", bc.endpoint), attestations, nil, headers)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 type NodeIdentity struct {
 	PeerID             string   `json:"peer_id"`
 	ENR                string   `json:"enr"`

pkg/coordinator/tasks/generate_attestations/README.md

@@ -0,0 +1,108 @@
+## `generate_attestations` Task
+
+### Description
+The `generate_attestations` task is designed to generate valid attestations for a specified range of validator keys and submit them to the network. This task fetches attester duties for the configured validators, retrieves attestation data from the beacon node, signs the attestations with the validator private keys, and submits them via the beacon API.
+
+The task supports advanced configuration options for testing various attestation scenarios, including attesting for previous epochs, using delayed head blocks, and randomizing late head offsets per attestation.
+
+### Configuration Parameters
+
+- **`mnemonic`**:\
+  A mnemonic phrase used for generating the validators' private keys. The keys are derived using the standard BIP39/BIP44 path (`m/12381/3600/{index}/0/0`).
+
+- **`startIndex`**:\
+  The starting index within the mnemonic from which to begin generating validator keys. This sets the initial point for key derivation.
+
+- **`indexCount`**:\
+  The number of validator keys to generate from the mnemonic, determining how many validators will be used for attestation generation.
+
+- **`limitTotal`**:\
+  The total limit on the number of attestations that the task will generate. The task will stop after reaching this limit.
+
+- **`limitEpochs`**:\
+  The total number of epochs to generate attestations for. The task will stop after processing this many epochs.
+
+- **`clientPattern`**:\
+  A regex pattern for selecting specific client endpoints for fetching attestation data and submitting attestations. If left empty, any available endpoint will be used.
+
+- **`excludeClientPattern`**:\
+  A regex pattern to exclude certain client endpoints from being used. This parameter adds a layer of control by allowing the exclusion of specific clients.
+
+### Advanced Settings
+
+- **`lastEpochAttestations`**:\
+  When set to `true`, the task will generate attestations for the previous epoch's duties instead of the current epoch. This is useful for testing late attestation scenarios. Attestations are sent one slot at a time (each wallclock slot sends attestations for the corresponding slot in the previous epoch).
+
+- **`sendAllLastEpoch`**:\
+  When set to `true`, instead of sending attestations slot-by-slot, all attestations for the previous epoch are sent at once at each epoch boundary. This is useful for bulk testing of late attestations. Requires `lastEpochAttestations` to be implicitly treated as true.
+
+- **`lateHead`**:\
+  Offsets the beacon block root in the attestation by the specified number of blocks. For example, setting `lateHead: 5` will use the block root from 5 blocks before the current head. This simulates validators with a delayed view of the chain. Positive values go back (older blocks), negative values go forward.
+
+- **`randomLateHead`**:\
+  Specifies a range for randomizing the late head offset per attestation in `"min:max"` or `"min-max"` format. For example, `randomLateHead: "1-5"` will apply a random late head offset between 1 and 5 blocks (inclusive). By default, each attestation gets its own random offset. Use `lateHeadClusterSize` to group attestations with the same offset.
+
+- **`lateHeadClusterSize`**:\
+  Controls how many attestations share the same random late head offset. Default is `1` (each attestation gets its own random offset). Setting this to a higher value groups attestations together with the same late head value. For example, `lateHeadClusterSize: 10` means every 10 attestations will share the same random offset.
+
+
+### Defaults
+
+Default settings for the `generate_attestations` task:
+
+```yaml
+- name: generate_attestations
+  config:
+    mnemonic: ""
+    startIndex: 0
+    indexCount: 0
+    limitTotal: 0
+    limitEpochs: 0
+    clientPattern: ""
+    excludeClientPattern: ""
+    lastEpochAttestations: false
+    sendAllLastEpoch: false
+    lateHead: 0
+    randomLateHead: ""
+    lateHeadClusterSize: 1
+```
+
+### Example Usage
+
+Basic usage to generate attestations for 100 validators over 5 epochs:
+
+```yaml
+- name: generate_attestations
+  config:
+    mnemonic: "your mnemonic phrase here"
+    startIndex: 0
+    indexCount: 100
+    limitEpochs: 5
+```
+
+Advanced usage with late head for testing delayed attestations:
+
+```yaml
+- name: generate_attestations
+  config:
+    mnemonic: "your mnemonic phrase here"
+    startIndex: 0
+    indexCount: 50
+    limitTotal: 1000
+    clientPattern: "lighthouse.*"
+    lastEpochAttestations: true
+    lateHead: 3
+```
+
+Bulk send all previous epoch attestations at once with random late head:
+
+```yaml
+- name: generate_attestations
+  config:
+    mnemonic: "your mnemonic phrase here"
+    startIndex: 0
+    indexCount: 100
+    limitEpochs: 3
+    sendAllLastEpoch: true
+    randomLateHead: "1:10"
+```

pkg/coordinator/tasks/generate_attestations/config.go

@@ -0,0 +1,92 @@
+package generateattestations
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type Config struct {
+	// Key configuration
+	Mnemonic   string `yaml:"mnemonic" json:"mnemonic"`
+	StartIndex int    `yaml:"startIndex" json:"startIndex"`
+	IndexCount int    `yaml:"indexCount" json:"indexCount"`
+
+	// Limit configuration
+	LimitTotal  int `yaml:"limitTotal" json:"limitTotal"`
+	LimitEpochs int `yaml:"limitEpochs" json:"limitEpochs"`
+
+	// Client selection
+	ClientPattern        string `yaml:"clientPattern" json:"clientPattern"`
+	ExcludeClientPattern string `yaml:"excludeClientPattern" json:"excludeClientPattern"`
+
+	// Advanced settings
+	LastEpochAttestations bool   `yaml:"lastEpochAttestations" json:"lastEpochAttestations"`
+	SendAllLastEpoch      bool   `yaml:"sendAllLastEpoch" json:"sendAllLastEpoch"`
+	LateHead              int    `yaml:"lateHead" json:"lateHead"`
+	RandomLateHead        string `yaml:"randomLateHead" json:"randomLateHead"`
+	LateHeadClusterSize   int    `yaml:"lateHeadClusterSize" json:"lateHeadClusterSize"`
+}
+
+// ParseRandomLateHead parses the RandomLateHead string in "min:max" or "min-max" format.
+// Returns min, max values and whether random late head is enabled.
+func (c *Config) ParseRandomLateHead() (min, max int, enabled bool, err error) {
+	if c.RandomLateHead == "" {
+		return 0, 0, false, nil
+	}
+
+	// Try colon separator first, then dash
+	var parts []string
+	if strings.Contains(c.RandomLateHead, ":") {
+		parts = strings.Split(c.RandomLateHead, ":")
+	} else if strings.Contains(c.RandomLateHead, "-") {
+		parts = strings.Split(c.RandomLateHead, "-")
+	}
+
+	if len(parts) != 2 {
+		return 0, 0, false, fmt.Errorf("randomLateHead must be in 'min:max' or 'min-max' format, got: %s", c.RandomLateHead)
+	}
+
+	min, err = strconv.Atoi(strings.TrimSpace(parts[0]))
+	if err != nil {
+		return 0, 0, false, fmt.Errorf("invalid min value in randomLateHead: %w", err)
+	}
+
+	max, err = strconv.Atoi(strings.TrimSpace(parts[1]))
+	if err != nil {
+		return 0, 0, false, fmt.Errorf("invalid max value in randomLateHead: %w", err)
+	}
+
+	if min > max {
+		return 0, 0, false, fmt.Errorf("min (%d) cannot be greater than max (%d) in randomLateHead", min, max)
+	}
+
+	return min, max, true, nil
+}
+
+func DefaultConfig() Config {
+	return Config{}
+}
+
+func (c *Config) Validate() error {
+	if c.LimitTotal == 0 && c.LimitEpochs == 0 {
+		return errors.New("either limitTotal or limitEpochs must be set")
+	}
+
+	if c.Mnemonic == "" {
+		return errors.New("mnemonic must be set")
+	}
+
+	if c.IndexCount == 0 {
+		return errors.New("indexCount must be set")
+	}
+
+	if c.RandomLateHead != "" {
+		if _, _, _, err := c.ParseRandomLateHead(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}