feat: upgrade eigen contracts and middleware version up to rewardsv2

aggregator/aggregator.go

@@ -99,6 +99,8 @@ func NewAggregator(c *config.Config) (*Aggregator, error) {
 		OperatorStateRetrieverAddr: c.OperatorStateRetrieverAddr.String(),
 		AvsName:                    avsName,
 		PromMetricsIpPortAddress:   ":9090",
+
+		DontUseAllocationManager: true,
 	}
 	clients, err := clients.BuildAll(chainioConfig, c.EcdsaPrivateKey, c.Logger)
 	if err != nil {
@@ -255,6 +257,7 @@ func (agg *Aggregator) sendNewTask(numToSquare *big.Int) error {
 	for _, quorumNum := range newTask.QuorumNumbers {
 		quorumNums = append(quorumNums, sdktypes.QuorumNum(quorumNum))
 	}
-	agg.blsAggregationService.InitializeNewTask(taskIndex, newTask.TaskCreatedBlock, quorumNums, quorumThresholdPercentages, taskTimeToExpiry)
+	metadata := blsagg.NewTaskMetadata(taskIndex, newTask.TaskCreatedBlock, quorumNums, quorumThresholdPercentages, taskTimeToExpiry)
+	agg.blsAggregationService.InitializeNewTask(metadata)
 	return nil
 }

aggregator/aggregator_test.go

@@ -67,31 +67,31 @@ func (mr *MockBlsAggregationServiceMockRecorder) GetResponseChannel() *gomock.Ca
 }
 
 // InitializeNewTask mocks base method.
-func (m *MockBlsAggregationService) InitializeNewTask(arg0, arg1 uint32, arg2 sdktypes.QuorumNums, arg3 sdktypes.QuorumThresholdPercentages, arg4 time.Duration) error {
+func (m *MockBlsAggregationService) InitializeNewTask(arg0 blsagg.TaskMetadata) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "InitializeNewTask", arg0, arg1, arg2, arg3, arg4)
+	ret := m.ctrl.Call(m, "InitializeNewTask", arg0)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // InitializeNewTask indicates an expected call of InitializeNewTask.
-func (mr *MockBlsAggregationServiceMockRecorder) InitializeNewTask(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
+func (mr *MockBlsAggregationServiceMockRecorder) InitializeNewTask(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitializeNewTask", reflect.TypeOf((*MockBlsAggregationService)(nil).InitializeNewTask), arg0, arg1, arg2, arg3, arg4)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitializeNewTask", reflect.TypeOf((*MockBlsAggregationService)(nil).InitializeNewTask), arg0)
 }
 
 // ProcessNewSignature mocks base method.
-func (m *MockBlsAggregationService) ProcessNewSignature(arg0 context.Context, arg1 uint32, arg2 interface{}, arg3 *bls.Signature, arg4 sdktypes.Bytes32) error {
+func (m *MockBlsAggregationService) ProcessNewSignature(arg0 context.Context, arg1 blsagg.TaskSignature) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ProcessNewSignature", arg0, arg1, arg2, arg3, arg4)
+	ret := m.ctrl.Call(m, "ProcessNewSignature", arg0, arg1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // ProcessNewSignature indicates an expected call of ProcessNewSignature.
-func (mr *MockBlsAggregationServiceMockRecorder) ProcessNewSignature(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
+func (mr *MockBlsAggregationServiceMockRecorder) ProcessNewSignature(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessNewSignature", reflect.TypeOf((*MockBlsAggregationService)(nil).ProcessNewSignature), arg0, arg1, arg2, arg3, arg4)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessNewSignature", reflect.TypeOf((*MockBlsAggregationService)(nil).ProcessNewSignature), arg0, arg1)
 }
 
 type MockTask struct {
@@ -137,7 +137,14 @@ func TestSendNewTask(t *testing.T) {
 	// make sure that initializeNewTask was called on the blsAggService
 	// maybe there's a better way to do this? There's a saying "don't mock 3rd party code"
 	// see https://hynek.me/articles/what-to-mock-in-5-mins/
-	mockBlsAggService.EXPECT().InitializeNewTask(TASK_INDEX, BLOCK_NUMBER, types.QUORUM_NUMBERS, sdktypes.QuorumThresholdPercentages{types.QUORUM_THRESHOLD_NUMERATOR}, taskTimeToExpiry)
+	taskMetadata := blsagg.NewTaskMetadata(
+		TASK_INDEX,
+		BLOCK_NUMBER,
+		types.QUORUM_NUMBERS,
+		sdktypes.QuorumThresholdPercentages{types.QUORUM_THRESHOLD_NUMERATOR},
+		taskTimeToExpiry,
+	)
+	mockBlsAggService.EXPECT().InitializeNewTask(taskMetadata)
 
 	err = aggregator.sendNewTask(NUMBER_TO_SQUARE_BIG_INT)
 	assert.Nil(t, err)

aggregator/rpc_server.go

@@ -9,7 +9,8 @@ import (
 	cstaskmanager "github.com/Layr-Labs/incredible-squaring-avs/contracts/bindings/IncredibleSquaringTaskManager"
 
 	"github.com/Layr-Labs/eigensdk-go/crypto/bls"
-	"github.com/Layr-Labs/eigensdk-go/types"
+	blsagg "github.com/Layr-Labs/eigensdk-go/services/bls_aggregation"
+	sdktypes "github.com/Layr-Labs/eigensdk-go/types"
 )
 
 var (
@@ -39,7 +40,7 @@ func (agg *Aggregator) startServer(ctx context.Context) error {
 type SignedTaskResponse struct {
 	TaskResponse cstaskmanager.IIncredibleSquaringTaskManagerTaskResponse
 	BlsSignature bls.Signature
-	OperatorId   types.OperatorId
+	OperatorId   sdktypes.OperatorId
 }
 
 // rpc endpoint which is called by operator
@@ -49,9 +50,9 @@ func (agg *Aggregator) ProcessSignedTaskResponse(signedTaskResponse *SignedTaskR
 	agg.logger.Infof("Received signed task response: %#v", signedTaskResponse)
 	taskIndex := signedTaskResponse.TaskResponse.ReferenceTaskIndex
 
-	err := agg.blsAggregationService.ProcessNewSignature(
-		context.Background(), taskIndex, signedTaskResponse.TaskResponse,
-		&signedTaskResponse.BlsSignature, signedTaskResponse.OperatorId,
-	)
+	taskSignature := blsagg.NewTaskSignature(taskIndex, signedTaskResponse.TaskResponse, &signedTaskResponse.BlsSignature, signedTaskResponse.OperatorId)
+
+	err := agg.blsAggregationService.ProcessNewSignature(context.Background(), taskSignature)
+
 	return err
 }

aggregator/rpc_server_test.go

@@ -10,6 +10,7 @@ import (
 	"go.uber.org/mock/gomock"
 
 	"github.com/Layr-Labs/eigensdk-go/crypto/bls"
+	blsagg "github.com/Layr-Labs/eigensdk-go/services/bls_aggregation"
 	sdktypes "github.com/Layr-Labs/eigensdk-go/types"
 	"github.com/Layr-Labs/incredible-squaring-avs/aggregator/types"
 	cstaskmanager "github.com/Layr-Labs/incredible-squaring-avs/contracts/bindings/IncredibleSquaringTaskManager"
@@ -52,8 +53,9 @@ func TestProcessSignedTaskResponse(t *testing.T) {
 	// TODO(samlaf): is this the right way to test writing to external service?
 	// or is there some wisdom to "don't mock 3rd party code"?
 	// see https://hynek.me/articles/what-to-mock-in-5-mins/
-	mockBlsAggServ.EXPECT().ProcessNewSignature(context.Background(), TASK_INDEX, signedTaskResponse.TaskResponse,
+	taskSignature := blsagg.NewTaskSignature(TASK_INDEX, signedTaskResponse.TaskResponse,
 		&signedTaskResponse.BlsSignature, signedTaskResponse.OperatorId)
+	mockBlsAggServ.EXPECT().ProcessNewSignature(context.Background(), taskSignature)
 	err = aggregator.ProcessSignedTaskResponse(signedTaskResponse, nil)
 	assert.Nil(t, err)
 }