Add deployment-specific prefix to message hashing

aggregator/aggregator.go

@@ -113,6 +113,7 @@ type Aggregator struct {
  rollupBroadcaster RollupBroadcasterer
  httpClient safeclient.SafeClient
  wsClient safeclient.SafeClient
+ messageHasher *messages.Hasher
  clock core.Clock
 
  // TODO(edwin): once rpc & rest decouple from aggregator fome it with them
@@ -215,6 +216,14 @@ func NewAggregator(
  return nil, err
  }
 
+ messagingPrefix, err := avsReader.GetMessagingPrefix(ctx)
+ if err != nil {
+ logger.Error("Cannot get messaging prefix", "err", err)
+ return nil, err
+ }
+
+ messageHasher := messages.NewHasher(messagingPrefix)
+
  operatorPubkeysService := opinfoserv.NewOperatorsInfoServiceInMemory(ctx, avsRegistryChainSubscriber, avsReader, logger)
  avsRegistryService := avsregistry.NewAvsRegistryServiceChainCaller(avsReader, operatorPubkeysService, logger)
  taskBlsAggregationService := blsagg.NewBlsAggregatorService(avsRegistryService, logger)
@@ -232,6 +241,7 @@ func NewAggregator(
  rollupBroadcaster: rollupBroadcaster,
  httpClient: ethHttpClient,
  wsClient: ethWsClient,
+ messageHasher: messageHasher,
  clock: core.SystemClock,
  taskBlsAggregationService: taskBlsAggregationService,
  stateRootUpdateBlsAggregationService: stateRootUpdateBlsAggregationService,
@@ -523,7 +533,7 @@ func (agg *Aggregator) handleOperatorSetUpdateReachedQuorum(ctx context.Context,
 
 func (agg *Aggregator) ProcessSignedCheckpointTaskResponse(signedCheckpointTaskResponse *messages.SignedCheckpointTaskResponse) error {
  taskIndex := signedCheckpointTaskResponse.TaskResponse.ReferenceTaskIndex
- taskResponseDigest, err := signedCheckpointTaskResponse.TaskResponse.Digest()
+ taskResponseDigest, err := agg.messageHasher.Hash(signedCheckpointTaskResponse.TaskResponse)
  if err != nil {
  agg.logger.Error("Failed to get task response digest", "err", err)
  return TaskResponseDigestError
@@ -551,7 +561,7 @@ func (agg *Aggregator) ProcessSignedCheckpointTaskResponse(signedCheckpointTaskR
 
 // Rpc request handlers
 func (agg *Aggregator) ProcessSignedStateRootUpdateMessage(signedStateRootUpdateMessage *messages.SignedStateRootUpdateMessage) error {
- messageDigest, err := signedStateRootUpdateMessage.Message.Digest()
+ messageDigest, err := agg.messageHasher.Hash(signedStateRootUpdateMessage.Message)
  if err != nil {
  agg.logger.Error("Failed to get message digest", "err", err)
  return DigestError
@@ -588,7 +598,7 @@ func (agg *Aggregator) ProcessSignedStateRootUpdateMessage(signedStateRootUpdate
 }
 
 func (agg *Aggregator) ProcessSignedOperatorSetUpdateMessage(signedOperatorSetUpdateMessage *messages.SignedOperatorSetUpdateMessage) error {
- messageDigest, err := signedOperatorSetUpdateMessage.Message.Digest()
+ messageDigest, err := agg.messageHasher.Hash(signedOperatorSetUpdateMessage.Message)
  if err != nil {
  agg.logger.Error("Failed to get message digest", "err", err)
  return DigestError

aggregator/aggregator_test.go

@@ -55,7 +55,7 @@ func TestSendNewTask(t *testing.T) {
  mockCtrl := gomock.NewController(t)
  defer mockCtrl.Finish()
 
- aggregator, mockAvsReaderer, mockAvsWriterer, mockTaskBlsAggService, _, _, _, _, mockClient, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
+ aggregator, mockAvsReaderer, mockAvsWriterer, mockTaskBlsAggService, _, _, _, _, mockClient, _, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
  assert.Nil(t, err)
 
  var TASK_INDEX = uint32(0)
@@ -92,11 +92,11 @@ func TestHandleStateRootUpdateAggregationReachedQuorum(t *testing.T) {
  mockCtrl := gomock.NewController(t)
  defer mockCtrl.Finish()
 
- aggregator, _, _, _, _, _, mockMsgDb, _, _, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
+ aggregator, _, _, _, _, _, mockMsgDb, _, _, hasher, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
  assert.Nil(t, err)
 
  msg := messages.StateRootUpdateMessage{}
- msgDigest, err := msg.Digest()
+ msgDigest, err := hasher.Hash(msg)
  assert.Nil(t, err)
 
  blsAggServiceResp := types.MessageBlsAggregationServiceResponse{
@@ -122,11 +122,11 @@ func TestHandleOperatorSetUpdateAggregationReachedQuorum(t *testing.T) {
  mockCtrl := gomock.NewController(t)
  defer mockCtrl.Finish()
 
- aggregator, _, _, _, _, _, mockMsgDb, mockRollupBroadcaster, _, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
+ aggregator, _, _, _, _, _, mockMsgDb, mockRollupBroadcaster, _, hasher, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
  assert.Nil(t, err)
 
  msg := messages.OperatorSetUpdateMessage{}
- msgDigest, err := msg.Digest()
+ msgDigest, err := hasher.Hash(msg)
  assert.Nil(t, err)
 
  blsAggServiceResp := types.MessageBlsAggregationServiceResponse{
@@ -158,7 +158,7 @@ func TestExpiredStateRootUpdateMessage(t *testing.T) {
  mockCtrl := gomock.NewController(t)
  defer mockCtrl.Finish()
 
- aggregator, _, _, _, _, _, _, _, _, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
+ aggregator, _, _, _, _, _, _, _, _, _, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
  assert.NoError(t, err)
 
  nowTimestamp := uint64(6000)
@@ -178,7 +178,7 @@ func TestExpiredOperatorSetUpdate(t *testing.T) {
  mockCtrl := gomock.NewController(t)
  defer mockCtrl.Finish()
 
- aggregator, _, _, _, _, _, _, _, _, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
+ aggregator, _, _, _, _, _, _, _, _, _, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
  assert.NoError(t, err)
 
  nowTimestamp := uint64(8000)
@@ -196,7 +196,7 @@ func TestExpiredOperatorSetUpdate(t *testing.T) {
 
 func createMockAggregator(
  mockCtrl *gomock.Controller, operatorPubkeyDict map[eigentypes.OperatorId]types.OperatorInfo,
-) (*Aggregator, *chainiomocks.MockAvsReaderer, *chainiomocks.MockAvsWriterer, *blsaggservmock.MockBlsAggregationService, *aggmocks.MockMessageBlsAggregationService, *aggmocks.MockMessageBlsAggregationService, *dbmocks.MockDatabaser, *aggmocks.MockRollupBroadcasterer, *safeclientmocks.MockSafeClient, error) {
+) (*Aggregator, *chainiomocks.MockAvsReaderer, *chainiomocks.MockAvsWriterer, *blsaggservmock.MockBlsAggregationService, *aggmocks.MockMessageBlsAggregationService, *aggmocks.MockMessageBlsAggregationService, *dbmocks.MockDatabaser, *aggmocks.MockRollupBroadcasterer, *safeclientmocks.MockSafeClient, *messages.Hasher, error) {
  logger := sdklogging.NewNoopLogger()
  mockAvsWriter := chainiomocks.NewMockAvsWriterer(mockCtrl)
  mockAvsReader := chainiomocks.NewMockAvsReaderer(mockCtrl)
@@ -206,6 +206,7 @@ func createMockAggregator(
  mockMsgDb := dbmocks.NewMockDatabaser(mockCtrl)
  mockRollupBroadcaster := aggmocks.NewMockRollupBroadcasterer(mockCtrl)
  mockClient := safeclientmocks.NewMockSafeClient(mockCtrl)
+ messageHasher := messages.NewHasher([32]byte{})
 
  aggregator := &Aggregator{
  logger: logger,
@@ -223,7 +224,8 @@ func createMockAggregator(
  httpClient: mockClient,
  wsClient: mockClient,
  aggregatorListener: &SelectiveAggregatorListener{},
+ messageHasher: messageHasher,
  clock: core.SystemClock,
  }
- return aggregator, mockAvsReader, mockAvsWriter, mockTaskBlsAggregationService, mockStateRootUpdateBlsAggregationService, mockOperatorSetUpdateBlsAggregationService, mockMsgDb, mockRollupBroadcaster, mockClient, nil
+ return aggregator, mockAvsReader, mockAvsWriter, mockTaskBlsAggregationService, mockStateRootUpdateBlsAggregationService, mockOperatorSetUpdateBlsAggregationService, mockMsgDb, mockRollupBroadcaster, mockClient, messageHasher, nil
 }

aggregator/rest_server/server_test.go

@@ -3,13 +3,14 @@ package rest_server
 import (
  "encoding/json"
  "fmt"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
  sdklogging "github.com/Layr-Labs/eigensdk-go/logging"
  "github.com/NethermindEth/near-sffl/aggregator/mocks"
  "github.com/NethermindEth/near-sffl/core/types/messages"
  "github.com/NethermindEth/near-sffl/tests"
- "net/http"
- "net/http/httptest"
- "testing"
 
  "github.com/stretchr/testify/assert"
  "go.uber.org/mock/gomock"
@@ -25,6 +26,8 @@ func TestGetStateRootUpdateAggregation(t *testing.T) {
  aggregator := mocks.NewMockRestAggregatorer(mockCtrl)
  restServer := NewRestServer("", aggregator, logger)
 
+ hasher := messages.NewHasher([32]byte{})
+
  msg := messages.StateRootUpdateMessage{
  RollupId: 1,
  BlockHeight: 2,
@@ -33,7 +36,7 @@ func TestGetStateRootUpdateAggregation(t *testing.T) {
  NearDaTransactionId: tests.Keccak256(5),
  StateRoot: tests.Keccak256(6),
  }
- msgDigest, err := msg.Digest()
+ msgDigest, err := hasher.Hash(msg)
  assert.Nil(t, err)
 
  response := aggtypes.GetStateRootUpdateAggregationResponse{
@@ -69,11 +72,13 @@ func TestGetOperatorSetUpdateAggregation(t *testing.T) {
  aggregator := mocks.NewMockRestAggregatorer(mockCtrl)
  restServer := NewRestServer("", aggregator, logger)
 
+ hasher := messages.NewHasher([32]byte{})
+
  msg := messages.OperatorSetUpdateMessage{
  Id: 1,
  Timestamp: 2,
  }
- digest, err := msg.Digest()
+ digest, err := hasher.Hash(msg)
  assert.Nil(t, err)
 
  response := aggtypes.GetOperatorSetUpdateAggregationResponse{
@@ -110,12 +115,14 @@ func TestGetCheckpointMessages(t *testing.T) {
  aggregator := mocks.NewMockRestAggregatorer(mockCtrl)
  restServer := NewRestServer("", aggregator, logger)
 
+ hasher := messages.NewHasher([32]byte{})
+
  stateRootMessage := messages.StateRootUpdateMessage{
  RollupId: 1,
  BlockHeight: 2,
  Timestamp: 3,
  }
- stateRootDigest, err := stateRootMessage.Digest()
+ stateRootDigest, err := hasher.Hash(stateRootMessage)
  assert.Nil(t, err)
  stateRootAggregation := messages.MessageBlsAggregation{
  MessageDigest: stateRootDigest,
@@ -125,7 +132,7 @@ func TestGetCheckpointMessages(t *testing.T) {
  Id: 1,
  Timestamp: 2,
  }
- operatorSetDigest, err := operatorSetMesssage.Digest()
+ operatorSetDigest, err := hasher.Hash(operatorSetMesssage)
  assert.Nil(t, err)
  operatorSetAggregation := messages.MessageBlsAggregation{
  MessageDigest: operatorSetDigest,

aggregator/rpc_server_test.go

@@ -29,17 +29,17 @@ func TestProcessSignedCheckpointTaskResponse(t *testing.T) {
  var FROM_NEAR_BLOCK = uint64(3)
  var TO_NEAR_BLOCK = uint64(4)
 
- aggregator, _, _, mockBlsAggServ, _, _, _, _, _, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
+ aggregator, _, _, mockBlsAggServ, _, _, _, _, _, hasher, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
  assert.Nil(t, err)
 
  signedCheckpointTaskResponse, err := createMockSignedCheckpointTaskResponse(MockTask{
  TaskNum: TASK_INDEX,
  BlockNumber: BLOCK_NUMBER,
  FromTimestamp: FROM_NEAR_BLOCK,
  ToTimestamp: TO_NEAR_BLOCK,
- }, *MOCK_OPERATOR_KEYPAIR)
+ }, *MOCK_OPERATOR_KEYPAIR, hasher)
  assert.Nil(t, err)
- signedCheckpointTaskResponseDigest, err := signedCheckpointTaskResponse.TaskResponse.Digest()
+ signedCheckpointTaskResponseDigest, err := hasher.Hash(signedCheckpointTaskResponse.TaskResponse)
  assert.Nil(t, err)
 
  // TODO(samlaf): is this the right way to test writing to external service?
@@ -55,7 +55,7 @@ func TestProcessSignedStateRootUpdateMessage(t *testing.T) {
  mockCtrl := gomock.NewController(t)
  defer mockCtrl.Finish()
 
- aggregator, _, _, _, mockMessageBlsAggServ, _, _, _, _, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
+ aggregator, _, _, _, mockMessageBlsAggServ, _, _, _, _, hasher, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
  assert.Nil(t, err)
 
  aggregator.clock = core.Clock{Now: func() time.Time { return time.Unix(10_000, 0) }}
@@ -68,9 +68,9 @@ func TestProcessSignedStateRootUpdateMessage(t *testing.T) {
  StateRoot: keccak256(6),
  }
 
- signedMessage, err := createMockSignedStateRootUpdateMessage(message, *MOCK_OPERATOR_KEYPAIR)
+ signedMessage, err := createMockSignedStateRootUpdateMessage(message, *MOCK_OPERATOR_KEYPAIR, hasher)
  assert.Nil(t, err)
- messageDigest, err := signedMessage.Message.Digest()
+ messageDigest, err := hasher.Hash(signedMessage.Message)
  assert.Nil(t, err)
 
  mockMessageBlsAggServ.EXPECT().ProcessNewSignature(context.Background(), messageDigest, &signedMessage.BlsSignature, signedMessage.OperatorId)
@@ -83,7 +83,7 @@ func TestProcessOperatorSetUpdateMessage(t *testing.T) {
  mockCtrl := gomock.NewController(t)
  defer mockCtrl.Finish()
 
- aggregator, mockAvsReader, _, _, _, mockMessageBlsAggServ, _, _, _, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
+ aggregator, mockAvsReader, _, _, _, mockMessageBlsAggServ, _, _, _, hasher, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
  assert.Nil(t, err)
 
  aggregator.clock = core.Clock{Now: func() time.Time { return time.Unix(10_000, 0) }}
@@ -95,9 +95,9 @@ func TestProcessOperatorSetUpdateMessage(t *testing.T) {
  },
  }
 
- signedMessage, err := createMockSignedOperatorSetUpdateMessage(message, *MOCK_OPERATOR_KEYPAIR)
+ signedMessage, err := createMockSignedOperatorSetUpdateMessage(message, *MOCK_OPERATOR_KEYPAIR, hasher)
  assert.Nil(t, err)
- messageDigest, err := signedMessage.Message.Digest()
+ messageDigest, err := hasher.Hash(signedMessage.Message)
  assert.Nil(t, err)
 
  mockAvsReader.EXPECT().GetOperatorSetUpdateBlock(context.Background(), uint64(1)).Return(uint32(10), nil)
@@ -113,7 +113,7 @@ func TestGetAggregatedCheckpointMessages(t *testing.T) {
  mockCtrl := gomock.NewController(t)
  defer mockCtrl.Finish()
 
- aggregator, _, _, _, _, _, mockDb, _, _, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
+ aggregator, _, _, _, _, _, mockDb, _, _, _, err := createMockAggregator(mockCtrl, MOCK_OPERATOR_PUBKEY_DICT)
  assert.Nil(t, err)
 
  var checkpointMessages messages.CheckpointMessages
@@ -131,13 +131,13 @@ func keccak256(num uint64) [32]byte {
  return hash
 }
 
-func createMockSignedCheckpointTaskResponse(mockTask MockTask, keypair bls.KeyPair) (*messages.SignedCheckpointTaskResponse, error) {
+func createMockSignedCheckpointTaskResponse(mockTask MockTask, keypair bls.KeyPair, messageHasher *messages.Hasher) (*messages.SignedCheckpointTaskResponse, error) {
  taskResponse := &messages.CheckpointTaskResponse{
  ReferenceTaskIndex: mockTask.TaskNum,
  StateRootUpdatesRoot: keccak256(mockTask.FromTimestamp),
  OperatorSetUpdatesRoot: keccak256(mockTask.ToTimestamp),
  }
- taskResponseHash, err := taskResponse.Digest()
+ taskResponseHash, err := messageHasher.Hash(taskResponse)
  if err != nil {
  return nil, err
  }
@@ -150,8 +150,8 @@ func createMockSignedCheckpointTaskResponse(mockTask MockTask, keypair bls.KeyPa
  return signedCheckpointTaskResponse, nil
 }
 
-func createMockSignedStateRootUpdateMessage(mockMessage messages.StateRootUpdateMessage, keypair bls.KeyPair) (*messages.SignedStateRootUpdateMessage, error) {
- messageDigest, err := mockMessage.Digest()
+func createMockSignedStateRootUpdateMessage(mockMessage messages.StateRootUpdateMessage, keypair bls.KeyPair, messageHasher *messages.Hasher) (*messages.SignedStateRootUpdateMessage, error) {
+ messageDigest, err := messageHasher.Hash(mockMessage)
  if err != nil {
  return nil, err
  }
@@ -164,8 +164,8 @@ func createMockSignedStateRootUpdateMessage(mockMessage messages.StateRootUpdate
  return signedStateRootUpdateMessage, nil
 }
 
-func createMockSignedOperatorSetUpdateMessage(mockMessage messages.OperatorSetUpdateMessage, keypair bls.KeyPair) (*messages.SignedOperatorSetUpdateMessage, error) {
- messageDigest, err := mockMessage.Digest()
+func createMockSignedOperatorSetUpdateMessage(mockMessage messages.OperatorSetUpdateMessage, keypair bls.KeyPair, messageHasher *messages.Hasher) (*messages.SignedOperatorSetUpdateMessage, error) {
+ messageDigest, err := messageHasher.Hash(mockMessage)
  if err != nil {
  return nil, err
  }