feat: reflect changes in Spectre Prover and contracts

chains/evm/contracts/spectre.go

@@ -46,7 +46,6 @@ func (c *Spectre) Step(
 
 func (c *Spectre) Rotate(
 	domainID uint8,
-	rotateInput message.RotateInput,
 	rotateProof []byte,
 	stepInput message.SyncStepInput,
 	stepProof []byte,
@@ -55,6 +54,6 @@ func (c *Spectre) Rotate(
 	return c.ExecuteTransaction(
 		"rotate",
 		opts,
-		domainID, rotateInput, rotateProof, stepInput, stepProof,
+		domainID, rotateProof, stepInput, stepProof,
 	)
 }

chains/evm/executor/executor.go

@@ -24,7 +24,6 @@ type ProofSubmitter interface {
 	) (*common.Hash, error)
 	Rotate(
 		domainID uint8,
-		rotateInput message.RotateInput,
 		rotateProof []byte,
 		stepInput message.SyncStepInput,
 		stepProof []byte,
@@ -77,7 +76,6 @@ func (e *EVMExecutor) step(domainID uint8, stepData message.StepData) error {
 func (e *EVMExecutor) rotate(domainID uint8, rotateData message.RotateData) error {
 	hash, err := e.proofSubmitter.Rotate(
 		domainID,
-		rotateData.RotateInput,
 		rotateData.RotateProof,
 		rotateData.StepInput,
 		rotateData.StepProof,

chains/evm/executor/executor_test.go

@@ -66,7 +66,7 @@ func (s *ExecutorTestSuite) Test_Execute_Step_Successful() {
 }
 
 func (s *ExecutorTestSuite) Test_Execute_Rotate_SubmissionFails() {
-	s.mockProofSubmitter.EXPECT().Rotate(uint8(1), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, fmt.Errorf("error"))
+	s.mockProofSubmitter.EXPECT().Rotate(uint8(1), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, fmt.Errorf("error"))
 
 	err := s.executor.Execute([]*proposal.Proposal{{
 		Data:   message.RotateData{},
@@ -78,7 +78,7 @@ func (s *ExecutorTestSuite) Test_Execute_Rotate_SubmissionFails() {
 }
 
 func (s *ExecutorTestSuite) Test_Execute_Rotate_Successful() {
-	s.mockProofSubmitter.EXPECT().Rotate(uint8(1), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(&common.Hash{}, nil)
+	s.mockProofSubmitter.EXPECT().Rotate(uint8(1), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(&common.Hash{}, nil)
 
 	err := s.executor.Execute([]*proposal.Proposal{{
 		Data:   message.RotateData{},

chains/evm/listener/handlers/rotate.go

@@ -102,7 +102,6 @@ func (h *RotateHandler) HandleEvents(checkpoint *apiv1.Finality) error {
 		log.Debug().Uint8("domainID", h.domainID).Msgf("Sending rotate message to domain %d", domain)
 		h.msgChan <- []*message.Message{
 			evmMessage.NewEvmRotateMessage(h.domainID, domain, evmMessage.RotateData{
-				RotateInput: rotateProof.Input,
 				RotateProof: rotateProof.Proof,
 				StepProof:   stepProof.Proof,
 				StepInput:   stepProof.Input,

chains/evm/listener/handlers/rotate_test.go

@@ -79,9 +79,9 @@ func (s *RotateHandlerTestSuite) Test_HandleEvents_ValidPeriod() {
 		Spec:    "mainnet",
 		Pubkeys: [512][48]byte{},
 	}, nil)
-	s.mockProver.EXPECT().RotateProof(gomock.Any()).Return(&prover.EvmProof[evmMessage.RotateInput]{
+	s.mockProver.EXPECT().RotateProof(gomock.Any()).Return(&prover.EvmProof[struct{}]{
 		Proof: []byte{},
-		Input: evmMessage.RotateInput{},
+		Input: struct{}{},
 	}, nil)
 	s.mockProver.EXPECT().StepProof(gomock.Any()).Return(&prover.EvmProof[evmMessage.SyncStepInput]{
 		Proof: []byte{},

chains/evm/listener/handlers/step.go

@@ -32,7 +32,7 @@ type EventFetcher interface {
 
 type Prover interface {
 	StepProof(args *prover.StepArgs) (*prover.EvmProof[evmMessage.SyncStepInput], error)
-	RotateProof(args *prover.RotateArgs) (*prover.EvmProof[evmMessage.RotateInput], error)
+	RotateProof(args *prover.RotateArgs) (*prover.EvmProof[struct{}], error)
 	StepArgs() (*prover.StepArgs, error)
 	RotateArgs(epoch uint64) (*prover.RotateArgs, error)
 }

chains/evm/message/rotate.go

@@ -4,8 +4,6 @@
 package message
 
 import (
-	"math/big"
-
 	"github.com/rs/zerolog/log"
 	"github.com/sygmaprotocol/sygma-core/relayer/message"
 	"github.com/sygmaprotocol/sygma-core/relayer/proposal"
@@ -16,15 +14,8 @@ const (
 	EVMRotateProposal proposal.ProposalType = "EVMRotateProposal"
 )
 
-type RotateInput struct {
-	SyncCommitteeSSZ      [32]byte
-	SyncCommitteePoseidon *big.Int
-	Accumulator           [12]*big.Int
-}
-
 type RotateData struct {
 	RotateProof []byte
-	RotateInput RotateInput
 	StepProof   []byte
 	StepInput   SyncStepInput
 }

chains/evm/message/step.go

@@ -4,8 +4,6 @@
 package message
 
 import (
-	"math/big"
-
 	"github.com/rs/zerolog/log"
 	"github.com/sygmaprotocol/sygma-core/relayer/message"
 	"github.com/sygmaprotocol/sygma-core/relayer/proposal"
@@ -22,7 +20,6 @@ type SyncStepInput struct {
 	Participation        uint64
 	FinalizedHeaderRoot  [32]byte
 	ExecutionPayloadRoot [32]byte
-	Accumulator          [12]*big.Int
 }
 
 type StepData struct {

chains/evm/prover/prover.go

@@ -6,11 +6,9 @@ package prover
 import (
 	"context"
 	"fmt"
-	"math/big"
 
 	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
-	ssz "github.com/ferranbt/fastssz"
 	"github.com/rs/zerolog/log"
 	"github.com/sygmaprotocol/spectre-node/chains/evm/message"
 	consensus "github.com/umbracle/go-eth-consensus"
@@ -31,9 +29,8 @@ type RotateArgs struct {
 }
 
 type ProverResponse struct {
-	Accumulator [12]string `json:"accumulator"`
-	Proof       []uint16   `json:"proof"`
-	Commitment  string     `json:"committee_poseidon"`
+	Proof      []uint16 `json:"proof"`
+	Commitment string   `json:"committee_poseidon"`
 }
 
 type EvmProof[T any] struct {
@@ -101,11 +98,6 @@ func (p *Prover) StepProof(args *StepArgs) (*EvmProof[message.SyncStepInput], er
 		return nil, err
 	}
 
-	accumulator := [12]*big.Int{}
-	for i, value := range resp.Accumulator {
-		accumulator[i], _ = new(big.Int).SetString(value[2:], 16)
-	}
-
 	log.Info().Msgf("Generated step proof")
 
 	finalizedHeaderRoot, err := args.Update.FinalizedHeader.Header.HashTreeRoot()
@@ -124,19 +116,14 @@ func (p *Prover) StepProof(args *StepArgs) (*EvmProof[message.SyncStepInput], er
 			Participation:        uint64(CountSetBits(args.Update.SyncAggregate.SyncCommiteeBits)),
 			FinalizedHeaderRoot:  finalizedHeaderRoot,
 			ExecutionPayloadRoot: executionRoot,
-			Accumulator:          accumulator,
 		},
 	}
 	return proof, nil
 }
 
 // RotateProof generates the proof for the sync committee rotation for the period
-func (p *Prover) RotateProof(args *RotateArgs) (*EvmProof[message.RotateInput], error) {
+func (p *Prover) RotateProof(args *RotateArgs) (*EvmProof[struct{}], error) {
 	args.Update.AttestedHeader = args.Update.FinalizedHeader
-	syncCommiteeRoot, err := p.pubkeysRoot(args.Update.NextSyncCommittee.PubKeys)
-	if err != nil {
-		return nil, err
-	}
 	updateSzz, err := args.Update.MarshalSSZ()
 	if err != nil {
 		return nil, err
@@ -147,26 +134,17 @@ func (p *Prover) RotateProof(args *RotateArgs) (*EvmProof[message.RotateInput],
 		Spec   Spec     `json:"spec"`
 	}
 	var resp ProverResponse
+
 	err = p.proverClient.CallFor(context.Background(), &resp, "genEvmProof_CommitteeUpdateCompressed", rotateArgs{Update: ByteArrayToU16Array(updateSzz), Spec: args.Spec})
 	if err != nil {
 		return nil, err
 	}
 
 	log.Info().Msgf("Generated rotate proof")
 
-	comm, _ := new(big.Int).SetString(resp.Commitment[2:], 16)
-	accumulator := [12]*big.Int{}
-	for i, value := range resp.Accumulator {
-		accumulator[i], _ = new(big.Int).SetString(value[2:], 16)
-	}
-
-	proof := &EvmProof[message.RotateInput]{
+	proof := &EvmProof[struct{}]{
 		Proof: U16ArrayToByteArray(resp.Proof),
-		Input: message.RotateInput{
-			SyncCommitteeSSZ:      syncCommiteeRoot,
-			SyncCommitteePoseidon: comm,
-			Accumulator:           accumulator,
-		},
+		Input: struct{}{},
 	}
 	return proof, nil
 }
@@ -247,13 +225,3 @@ func (p *Prover) pubkeysSSZ(pubkeys [512][48]byte) []byte {
 	}
 	return pubkeysSSZ
 }
-
-func (p *Prover) pubkeysRoot(pubkeys [512][48]byte) ([32]byte, error) {
-	h := ssz.NewHasher()
-	subIndx := h.Index()
-	for _, key := range pubkeys {
-		h.PutBytes(key[:])
-	}
-	h.Merkleize(subIndx)
-	return h.HashRoot()
-}