Merge branch 'v2-dev-1' into feat/incredible-dot-product-example

Author: maximopalopoli

examples/incredible-squaring/operator/operator_use_example.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/Layr-Labs/eigensdk-go/logging"
 	sdkoperator "github.com/Layr-Labs/eigensdk-go/operator"
-	sdktypes "github.com/Layr-Labs/eigensdk-go/types"
 
 	cstaskmanager "github.com/Layr-Labs/eigensdk-go/examples/incredible-squaring/bindings/taskManager"
 )
@@ -24,18 +23,6 @@ func main() {
 		logger.Fatalf(err.Error())
 	}
 
-	// This function calculates the task response from a Task, in this case with the number to square
-	responseCalcFunction := func(task sdktypes.GenericInputTask[*big.Int], taskIndex uint32) (sdktypes.GenericOutputTaskResponse[*big.Int], error) {
-		numberSquared := big.NewInt(0).Exp(task.InputValue, big.NewInt(2), nil)
-
-		taskResponse := sdktypes.GenericOutputTaskResponse[*big.Int]{
-			ReferenceTaskIndex: taskIndex,
-			OutputValue:        numberSquared,
-		}
-
-		return taskResponse, nil
-	}
-
 	// The values from this config are extracted from an incredible squaring config file:
 	// https://github.com/Layr-Labs/incredible-squaring-avs/blob/dev/config-files/operator.anvil.yaml
 	operatorConfig := sdkoperator.OperatorConfig{
@@ -51,7 +38,7 @@ func main() {
 		TaskManagerAbi:                taskManagerAbi,
 	}
 
-	operator, err := sdkoperator.NewOperatorFromConfig(operatorConfig, responseCalcFunction, nil)
+	operator, err := sdkoperator.NewOperatorFromConfig(operatorConfig, square, nil)
 	if err != nil {
 		logger.Errorf("Failed to create operator from config: %v", err)
 		return
@@ -63,3 +50,10 @@ func main() {
 		return
 	}
 }
+
+// This function computes the square of a number
+func square(taskIndex uint32, numberToSquare *big.Int) (*big.Int, error) {
+	numberSquared := big.NewInt(0).Exp(numberToSquare, big.NewInt(2), nil)
+
+	return numberSquared, nil
+}

operator/config.go

@@ -23,4 +23,15 @@ type OperatorConfig struct {
 
 	Logger         logging.Logger
 	TaskManagerAbi *abi.ABI
+
+	// Testing options for the operator.
+	// These shouldn't be used in production.
+	TestingOpts struct {
+		// Percentage chance of randomly failing a task
+		// This is used for testing purposes and defaults to not failing any tasks
+		FailingPercentage uint
+		// Seed used to generate operator failures
+		// Defaults to the current time
+		FailingSeed uint64
+	}
 }

operator/operator.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"fmt"
 	"math/big"
+	"math/rand/v2"
 	"os"
+	"time"
 
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
@@ -34,7 +36,7 @@ type Operator[Input any, Output any] struct {
 	taskResponseHashFn    TaskResponseHashFunction[Output]
 }
 
-type ResponseCalculationFunction[Input any, Output any] func(task sdktypes.GenericInputTask[Input], taskIndex uint32) (sdktypes.GenericOutputTaskResponse[Output], error)
+type ResponseCalculationFunction[Input any, Output any] func(taskIndex uint32, input Input) (Output, error)
 
 type TaskResponseHashFunction[Output any] func(taskResponse sdktypes.GenericOutputTaskResponse[Output]) ([32]byte, error)
 
@@ -79,8 +81,8 @@ func getDefaultHashFunction[Output any](taskResponseType abi.Type) TaskResponseH
 
 func NewOperatorFromConfig[Input any, Output any](
 	c OperatorConfig,
-	ResponseCalculationFn ResponseCalculationFunction[Input, Output],
-	TaskResponseHashFn TaskResponseHashFunction[Output],
+	responseCalculationFn ResponseCalculationFunction[Input, Output],
+	taskResponseHashFn TaskResponseHashFunction[Output],
 ) (*Operator[Input, Output], error) {
 	avs_config := avsregistry.Config{
 		RegistryCoordinatorAddress:    common.HexToAddress(c.AVSRegistryCoordinatorAddress),
@@ -153,14 +155,41 @@ func NewOperatorFromConfig[Input any, Output any](
 		c.Logger.Fatal("error subscribing to newTaskCreated events", "err", err)
 	}
 
-	if TaskResponseHashFn == nil {
+	if taskResponseHashFn == nil {
 		taskResponseType, err := extractTypeFromAbi(c.TaskManagerAbi)
 		if err != nil {
 			c.Logger.Error("Failed to get task response type in default abi.", "err", err)
 			return nil, err
 		}
 
-		TaskResponseHashFn = getDefaultHashFunction[Output](taskResponseType)
+		taskResponseHashFn = getDefaultHashFunction[Output](taskResponseType)
+	}
+
+	if c.TestingOpts.FailingPercentage != 0 {
+		failPercentage := c.TestingOpts.FailingPercentage
+		if failPercentage > 100 {
+			return nil, fmt.Errorf("failing percentage must be between 0 and 100")
+		}
+		computeOutput := responseCalculationFn
+
+		failSeed := c.TestingOpts.FailingSeed
+		if failSeed == 0 {
+			// If the seed is not set, we use the current time as the seed
+			failSeed = uint64(time.Now().UnixNano())
+		}
+		rng := rand.New(rand.NewPCG(42, failSeed))
+
+		c.Logger.Warn("FailingPercentage option was set. This operator will randomly fail tasks.")
+		c.Logger.Info("Using seed:", failSeed)
+
+		responseCalculationFn = func(taskIndex uint32, input Input) (Output, error) {
+			randomNumber := rng.UintN(100)
+			if randomNumber < failPercentage {
+				var emptyOutput Output
+				return emptyOutput, nil
+			}
+			return computeOutput(taskIndex, input)
+		}
 	}
 
 	operator := &Operator[Input, Output]{
@@ -170,8 +199,8 @@ func NewOperatorFromConfig[Input any, Output any](
 		operatorId:            operatorId,
 		newTaskCreatedLogs:    newTaskCreatedLogs,
 		taskManagerAbi:        c.TaskManagerAbi,
-		responseCalculationFn: ResponseCalculationFn,
-		taskResponseHashFn:    TaskResponseHashFn,
+		responseCalculationFn: responseCalculationFn,
+		taskResponseHashFn:    taskResponseHashFn,
 	}
 
 	c.Logger.Info("Operator info",
@@ -231,12 +260,15 @@ func (o *Operator[Input, Output]) processNewTaskCreatedLog(
 		"QuorumThresholdPercentage", newTaskCreatedLog.Task.QuorumThresholdPercentage,
 	)
 
-	taskResponse, err := o.responseCalculationFn(newTaskCreatedLog.Task, newTaskIndex)
+	output, err := o.responseCalculationFn(newTaskIndex, newTaskCreatedLog.Task.InputValue)
 	if err != nil {
 		return nil, fmt.Errorf("error calculating task response: %w", err)
 	}
-
-	return &taskResponse, nil
+	taskResponse := &sdktypes.GenericOutputTaskResponse[Output]{
+		ReferenceTaskIndex: newTaskIndex,
+		OutputValue:        output,
+	}
+	return taskResponse, nil
 }
 
 func (o *Operator[Input, Output]) signTaskResponse(