Allow messages to preinsert public access data and disable signatures #…

…397

proto/consensus/consensus_queue.proto

@@ -24,6 +24,7 @@ message QueuedSignedMessage {
   repeated Evidence evidence = 7;
 
   PublicAccessData publicAccessData = 8;
+  bool requireSignatures = 9;
 }
 
 message BatchOfConsensusMessages {

x/consensus/keeper/concensus_keeper.go

@@ -54,13 +54,13 @@ func (k Keeper) RemoveConsensusQueue(ctx sdk.Context, queueTypeName string) erro
 	return nil
 }
 
-func (k Keeper) PutMessageForSigning(ctx sdk.Context, queueTypeName string, msg consensus.ConsensusMsg) error {
+func (k Keeper) PutMessageInQueue(ctx sdk.Context, queueTypeName string, msg consensus.ConsensusMsg, opts *consensus.PutOptions) error {
 	cq, err := k.getConsensusQueue(ctx, queueTypeName)
 	if err != nil {
 		k.Logger(ctx).Error("error while getting consensus queue", "error", err)
 		return err
 	}
-	err = cq.Put(ctx, msg)
+	err = cq.Put(ctx, msg, opts)
 	if err != nil {
 		k.Logger(ctx).Error("error while putting message into queue", "error", err)
 		return err

x/consensus/keeper/concensus_keeper_test.go

@@ -25,11 +25,11 @@ func TestEndToEndTestingOfPuttingAndGettingMessagesOfTheConsensusQueue(t *testin
 	keeper, _, ctx := newConsensusKeeper(t)
 
 	t.Run("it returns a message if type is not registered with the queue", func(t *testing.T) {
-		err := keeper.PutMessageForSigning(ctx, "i don't exist", &types.SimpleMessage{
+		err := keeper.PutMessageInQueue(ctx, "i don't exist", &types.SimpleMessage{
 			Sender: "bob",
 			Hello:  "hello",
 			World:  "mars",
-		})
+		}, nil)
 
 		require.ErrorIs(t, err, ErrConsensusQueueNotImplemented)
 	})
@@ -60,11 +60,11 @@ func TestEndToEndTestingOfPuttingAndGettingMessagesOfTheConsensusQueue(t *testin
 	})
 
 	t.Run("it sucessfully puts message into the queue", func(t *testing.T) {
-		err := keeper.PutMessageForSigning(ctx, queue, &types.SimpleMessage{
+		err := keeper.PutMessageInQueue(ctx, queue, &types.SimpleMessage{
 			Sender: "bob",
 			Hello:  "hello",
 			World:  "mars",
-		})
+		}, nil)
 
 		require.NoError(t, err)
 	})
@@ -144,15 +144,15 @@ func TestGettingMessagesThatHaveReachedConsensus(t *testing.T) {
 			preRun: func(t *testing.T, sd setupData) {
 				msg := &types.SimpleMessage{}
 				// sd.cq.On("GetAll", mock.Anything).Return([]types.QueuedSignedMessageI{msg}, nil).Once()
-				sd.keeper.PutMessageForSigning(sd.ctx, defaultQueueName, msg)
+				sd.keeper.PutMessageInQueue(sd.ctx, defaultQueueName, msg, nil)
 				sd.ms.ValsetKeeper.On("GetCurrentSnapshot", mock.Anything).Return(&valsettypes.Snapshot{}, nil)
 			},
 		},
 		{
 			name: "with messages returned but no signature data it returns nothing",
 			preRun: func(t *testing.T, sd setupData) {
 				msg := &types.SimpleMessage{}
-				sd.keeper.PutMessageForSigning(sd.ctx, defaultQueueName, msg)
+				sd.keeper.PutMessageInQueue(sd.ctx, defaultQueueName, msg, nil)
 				// msg := consensustypesmock.NewQueuedSignedMessageI(t)
 				// msg.On("GetSignData").Return(nil).Once()
 				// sd.cq.On("GetAll", mock.Anything).Return([]types.QueuedSignedMessageI{msg}, nil).Once()
@@ -169,7 +169,7 @@ func TestGettingMessagesThatHaveReachedConsensus(t *testing.T) {
 			name: "with a single signature only which is not enough it returns nothing",
 			preRun: func(t *testing.T, sd setupData) {
 				msg := &types.SimpleMessage{}
-				err := sd.keeper.PutMessageForSigning(sd.ctx, defaultQueueName, msg)
+				err := sd.keeper.PutMessageInQueue(sd.ctx, defaultQueueName, msg, nil)
 				require.NoError(t, err)
 				sd.ms.ValsetKeeper.On("GetSigningKey", mock.Anything, sdk.ValAddress("val1"), "EVM", "test", "bob").Return(
 					[]byte("signing-key"),
@@ -198,7 +198,7 @@ func TestGettingMessagesThatHaveReachedConsensus(t *testing.T) {
 			expMsgsLen: 1,
 			preRun: func(t *testing.T, sd setupData) {
 				msg := &types.SimpleMessage{}
-				err := sd.keeper.PutMessageForSigning(sd.ctx, defaultQueueName, msg)
+				err := sd.keeper.PutMessageInQueue(sd.ctx, defaultQueueName, msg, nil)
 				require.NoError(t, err)
 
 				sd.ms.ValsetKeeper.On("GetSigningKey", mock.Anything, sdk.ValAddress("val3"), "EVM", "test", "bob3").Return(
@@ -242,8 +242,8 @@ func TestGettingMessagesThatHaveReachedConsensus(t *testing.T) {
 			expMsgsLen: 1,
 			preRun: func(t *testing.T, sd setupData) {
 				msg := &types.SimpleMessage{}
-				err := sd.keeper.PutMessageForSigning(sd.ctx, defaultQueueName, msg)
-				err = sd.keeper.PutMessageForSigning(sd.ctx, defaultQueueName, msg)
+				err := sd.keeper.PutMessageInQueue(sd.ctx, defaultQueueName, msg, nil)
+				err = sd.keeper.PutMessageInQueue(sd.ctx, defaultQueueName, msg, nil)
 				require.NoError(t, err)
 
 				sd.ms.ValsetKeeper.On("GetSigningKey", mock.Anything, sdk.ValAddress("val3"), "EVM", "test", "bob3").Return(
@@ -300,9 +300,9 @@ func TestGettingMessagesThatHaveReachedConsensus(t *testing.T) {
 			expMsgsLen: 2,
 			preRun: func(t *testing.T, sd setupData) {
 				msg := &types.SimpleMessage{}
-				err := sd.keeper.PutMessageForSigning(sd.ctx, defaultQueueName, msg)
+				err := sd.keeper.PutMessageInQueue(sd.ctx, defaultQueueName, msg, nil)
 				require.NoError(t, err)
-				err = sd.keeper.PutMessageForSigning(sd.ctx, defaultQueueName, msg)
+				err = sd.keeper.PutMessageInQueue(sd.ctx, defaultQueueName, msg, nil)
 				require.NoError(t, err)
 
 				sd.ms.ValsetKeeper.On("GetSigningKey", mock.Anything, sdk.ValAddress("val2"), "EVM", "test", "bob2").Return(
@@ -381,7 +381,7 @@ func TestGettingMessagesThatHaveReachedConsensus(t *testing.T) {
 			name: "if it's signed by a validator which is not in the snapshot it skips it",
 			preRun: func(t *testing.T, sd setupData) {
 				msg := &types.SimpleMessage{}
-				err := sd.keeper.PutMessageForSigning(sd.ctx, defaultQueueName, msg)
+				err := sd.keeper.PutMessageInQueue(sd.ctx, defaultQueueName, msg, nil)
 				require.NoError(t, err)
 
 				sd.ms.ValsetKeeper.On("GetSigningKey", mock.Anything, sdk.ValAddress("404"), "EVM", "test", "404").Return(
@@ -472,11 +472,11 @@ func TestAddingSignatures(t *testing.T) {
 		},
 	)
 
-	err := keeper.PutMessageForSigning(ctx, queue, &types.SimpleMessage{
+	err := keeper.PutMessageInQueue(ctx, queue, &types.SimpleMessage{
 		Sender: "bob",
 		Hello:  "hello",
 		World:  "mars",
-	})
+	}, nil)
 	require.NoError(t, err)
 	val1 := sdk.ValAddress("val1")
 

x/consensus/keeper/consensus/batch.go

@@ -27,29 +27,27 @@ func NewBatchQueue(qo QueueOptions) BatchQueue {
 	}
 }
 
-func (c BatchQueue) Put(ctx sdk.Context, msgs ...ConsensusMsg) error {
-	for _, msg := range msgs {
-		if !c.batchedTypeChecker(msg) {
-			return ErrIncorrectMessageType.Format(msg)
-		}
+func (c BatchQueue) Put(ctx sdk.Context, msg ConsensusMsg, opts *PutOptions) error {
+	if !c.batchedTypeChecker(msg) {
+		return ErrIncorrectMessageType.Format(msg)
+	}
 
-		newID := c.base.qo.Ider.IncrementNextID(ctx, consensusBatchQueueIDCounterKey)
+	newID := c.base.qo.Ider.IncrementNextID(ctx, consensusBatchQueueIDCounterKey)
 
-		anyMsg, err := codectypes.NewAnyWithValue(msg)
-		if err != nil {
-			return err
-		}
+	anyMsg, err := codectypes.NewAnyWithValue(msg)
+	if err != nil {
+		return err
+	}
 
-		var batchedMsg types.MessageQueuedForBatchingI = &batchOfConsensusMessages{
-			Msg: anyMsg,
-		}
+	var batchedMsg types.MessageQueuedForBatchingI = &batchOfConsensusMessages{
+		Msg: anyMsg,
+	}
 
-		data, err := c.base.qo.Cdc.MarshalInterface(batchedMsg)
-		if err != nil {
-			return err
-		}
-		c.batchQueue(ctx).Set(sdk.Uint64ToBigEndian(newID), data)
+	data, err := c.base.qo.Cdc.MarshalInterface(batchedMsg)
+	if err != nil {
+		return err
 	}
+	c.batchQueue(ctx).Set(sdk.Uint64ToBigEndian(newID), data)
 	return nil
 }
 
@@ -92,7 +90,7 @@ func (c BatchQueue) ProcessBatches(ctx sdk.Context) error {
 	}
 
 	for _, batch := range batches {
-		err := c.base.Put(ctx, batch)
+		err := c.base.Put(ctx, batch, nil)
 		if err != nil {
 			return err
 		}

x/consensus/keeper/consensus/batch_test.go

@@ -56,17 +56,15 @@ func TestBatching(t *testing.T) {
 		})
 	ctx := sdk.NewContext(stateStore, tmproto.Header{}, false, nil)
 
-	var consensusMsgs []ConsensusMsg
-
-	for i := 0; i < 666; i++ {
-		consensusMsgs = append(consensusMsgs, &types.SimpleMessage{
-			Sender: fmt.Sprintf("sender_%d", i),
-		})
-	}
-
 	t.Run("putting messages in", func(t *testing.T) {
-		err := cq.Put(ctx, consensusMsgs...)
-		assert.NoError(t, err)
+		for i := 0; i < 666; i++ {
+			consensusMsg := &types.SimpleMessage{
+				Sender: fmt.Sprintf("sender_%d", i),
+			}
+
+			err := cq.Put(ctx, consensusMsg, nil)
+			assert.NoError(t, err)
+		}
 	})
 
 	t.Run("without calling ProcessBatch", func(t *testing.T) {

x/consensus/keeper/consensus/consensus.go

@@ -126,32 +126,43 @@ func NewQueue(qo QueueOptions) Queue {
 }
 
 // Put puts raw message into a signing queue.
-func (c Queue) Put(ctx sdk.Context, msgs ...ConsensusMsg) error {
-	for _, msg := range msgs {
-		if !c.qo.TypeCheck(msg) {
-			return ErrIncorrectMessageType.Format(msg)
-		}
-		newID := c.qo.Ider.IncrementNextID(ctx, consensusQueueIDCounterKey)
-		// just so it's clear that nonce is an actual ID
-		nonce := newID
-		anyMsg, err := codectypes.NewAnyWithValue(msg)
-		if err != nil {
-			return err
-		}
-		queuedMsg := &types.QueuedSignedMessage{
-			Id:                 newID,
-			Msg:                anyMsg,
-			SignData:           []*types.SignData{},
-			AddedAtBlockHeight: ctx.BlockHeight(),
-			AddedAt:            ctx.BlockTime(),
-			BytesToSign: c.qo.BytesToSignCalculator(msg, types.Salt{
-				Nonce: nonce,
-			}),
-		}
-		if err := c.save(ctx, queuedMsg); err != nil {
-			return err
+func (c Queue) Put(ctx sdk.Context, msg ConsensusMsg, opts *PutOptions) error {
+	requireSignatures := true
+	var publicAccessData *types.PublicAccessData
+
+	if opts != nil {
+		requireSignatures = opts.RequireSignatures
+		publicAccessData = &types.PublicAccessData{
+			ValAddress: nil,
+			Data:       opts.PublicAccessData,
 		}
 	}
+
+	if !c.qo.TypeCheck(msg) {
+		return ErrIncorrectMessageType.Format(msg)
+	}
+	newID := c.qo.Ider.IncrementNextID(ctx, consensusQueueIDCounterKey)
+	// just so it's clear that nonce is an actual ID
+	nonce := newID
+	anyMsg, err := codectypes.NewAnyWithValue(msg)
+	if err != nil {
+		return err
+	}
+	queuedMsg := &types.QueuedSignedMessage{
+		Id:                 newID,
+		Msg:                anyMsg,
+		SignData:           []*types.SignData{},
+		AddedAtBlockHeight: ctx.BlockHeight(),
+		AddedAt:            ctx.BlockTime(),
+		RequireSignatures:  requireSignatures,
+		PublicAccessData:   publicAccessData,
+		BytesToSign: c.qo.BytesToSignCalculator(msg, types.Salt{
+			Nonce: nonce,
+		}),
+	}
+	if err := c.save(ctx, queuedMsg); err != nil {
+		return err
+	}
 	return nil
 }
 

x/consensus/keeper/consensus/consensus_test.go

@@ -64,7 +64,7 @@ func TestConsensusQueueAllMethods(t *testing.T) {
 	var msgs []types.QueuedSignedMessageI
 
 	t.Run("putting message", func(t *testing.T) {
-		err := cq.Put(ctx, msg)
+		err := cq.Put(ctx, msg, nil)
 		assert.NoError(t, err)
 	})
 
@@ -119,7 +119,12 @@ func TestConsensusQueueAllMethods(t *testing.T) {
 			cq.Put(
 				ctx,
 				&types.SimpleMessage{},
+				nil,
+			)
+			cq.Put(
+				ctx,
 				&types.SimpleMessage{},
+				nil,
 			)
 			msgs, err = cq.GetAll(ctx)
 			assert.NoError(t, err)
@@ -131,7 +136,7 @@ func TestConsensusQueueAllMethods(t *testing.T) {
 		msgOfWrongType := &types.EvenSimplerMessage{
 			Boo: "boo",
 		}
-		err := cq.Put(ctx, msgOfWrongType)
+		err := cq.Put(ctx, msgOfWrongType, nil)
 		assert.ErrorIs(t, err, ErrIncorrectMessageType)
 	})
 

x/consensus/keeper/consensus/types.go

@@ -16,9 +16,14 @@ const (
 	consensusQueueMaxBatchSize = 100
 )
 
+type PutOptions struct {
+	RequireSignatures bool
+	PublicAccessData  []byte
+}
+
 //go:generate mockery --name=Queuer
 type Queuer interface {
-	Put(sdk.Context, ...ConsensusMsg) error
+	Put(sdk.Context, ConsensusMsg, *PutOptions) error
 	AddSignature(ctx sdk.Context, id uint64, signData *types.SignData) error
 	AddEvidence(ctx sdk.Context, id uint64, evidence *types.Evidence) error
 	SetPublicAccessData(ctx sdk.Context, id uint64, data *types.PublicAccessData) error

x/consensus/keeper/grpc_query_messages_in_queue.go

@@ -23,12 +23,12 @@ func (k Keeper) MessagesInQueue(goCtx context.Context, req *types.QueryMessagesI
 	}
 
 	res := &types.QueryMessagesInQueueResponse{}
-	skipIfValidatorSigned := req.GetSkipEvidenceProvidedByValAddress()
+	skipIfValidatorProvidedEvidence := req.GetSkipEvidenceProvidedByValAddress()
 	for _, msg := range msgs {
-		if skipIfValidatorSigned != nil {
+		if skipIfValidatorProvidedEvidence != nil {
 			shouldSkipThisMsg := false
 			for _, evidence := range msg.GetEvidence() {
-				if evidence.ValAddress.Equals(skipIfValidatorSigned) {
+				if evidence.ValAddress.Equals(skipIfValidatorProvidedEvidence) {
 					shouldSkipThisMsg = true
 					break
 				}

x/consensus/keeper/query_queued_messages_for_signing.go

@@ -22,7 +22,9 @@ func (k Keeper) QueuedMessagesForSigning(goCtx context.Context, req *types.Query
 
 	var res []*types.MessageToSign
 	for _, msg := range msgs {
-		res = append(res, k.queuedMessageToMessageToSign(msg))
+		if msg.GetRequireSignatures() {
+			res = append(res, k.queuedMessageToMessageToSign(msg))
+		}
 	}
 
 	return &types.QueryQueuedMessagesForSigningResponse{