draft(exporter): expose all messages

api/handlers/exporter.go

@@ -6,17 +6,26 @@
 	"net/http"
 
 	"github.com/attestantio/go-eth2-client/spec/phase0"
-	spectypes "github.com/ssvlabs/ssv-spec/types"
-	"github.com/ssvlabs/ssv/networkconfig"
-	qbftstorage "github.com/ssvlabs/ssv/protocol/v2/qbft/storage"
 
+	spectypes "github.com/ssvlabs/ssv-spec/types"
 	"github.com/ssvlabs/ssv/api"
+	model "github.com/ssvlabs/ssv/exporter/v2"
 	ibftstorage "github.com/ssvlabs/ssv/ibft/storage"
+	"github.com/ssvlabs/ssv/networkconfig"
+	qbftstorage "github.com/ssvlabs/ssv/protocol/v2/qbft/storage"
 )
 
 type Exporter struct {
 	NetworkConfig     networkconfig.NetworkConfig
 	ParticipantStores *ibftstorage.ParticipantStores
+	TraceStore        DutyTraceStore
+}
+
+type DutyTraceStore interface {
+	GetValidatorDuty(role spectypes.BeaconRole, slot phase0.Slot, pubkey spectypes.ValidatorPK) (*model.ValidatorDutyTrace, error)
+	GetCommitteeDutiesByOperator(indexes []spectypes.OperatorID, slot phase0.Slot) ([]*model.CommitteeDutyTrace, error)
+	GetCommitteeDuty(slot phase0.Slot, committeeID spectypes.CommitteeID) (*model.CommitteeDutyTrace, error)
+	GetAllValidatorDuties(role spectypes.BeaconRole, slot phase0.Slot) ([]*model.ValidatorDutyTrace, error)
 }
 
 type ParticipantResponse struct {
@@ -97,3 +106,142 @@
 
 	return response
 }
+
+func (e *Exporter) OperatorTraces(w http.ResponseWriter, r *http.Request) error {
+	var request struct {
+		From       uint64   `json:"from"`
+		To         uint64   `json:"to"`
+		OperatorID []uint64 `json:"operatorID"`
+	}
+
+	if err := api.Bind(r, &request); err != nil {
+		return api.BadRequestError(err)
+	}
+
+	var indexes []spectypes.OperatorID
+	indexes = append(indexes, request.OperatorID...)
+
+	var duties []*model.CommitteeDutyTrace
+	for s := request.From; s <= request.To; s++ {
+		slot := phase0.Slot(s)
+		dd, err := e.TraceStore.GetCommitteeDutiesByOperator(indexes, slot)
+		if err != nil {
+			return api.Error(fmt.Errorf("error getting duties: %w", err))
+		}
+		duties = append(duties, dd...)
+	}
+
+	return api.Render(w, r, toCommitteeTraceResponse(duties))
+}
+
+func (e *Exporter) CommitteeTraces(w http.ResponseWriter, r *http.Request) error {
+	var request struct {
+		From        uint64  `json:"from"`
+		To          uint64  `json:"to"`
+		CommitteeID api.Hex `json:"committeeID"`
+	}
+
+	if err := api.Bind(r, &request); err != nil {
+		return api.BadRequestError(err)
+	}
+
+	if request.From > request.To {
+		return api.BadRequestError(fmt.Errorf("'from' must be less than or equal to 'to'"))
+	}
+
+	var committeeID spectypes.CommitteeID
+
+	if len(request.CommitteeID) != len(committeeID) {
+		return api.BadRequestError(fmt.Errorf("invalid committee ID length"))
+	}
+
+	copy(committeeID[:], request.CommitteeID)
+
+	var duties []*model.CommitteeDutyTrace
+	for s := request.From; s <= request.To; s++ {
+		slot := phase0.Slot(s)
+		duty, err := e.TraceStore.GetCommitteeDuty(slot, committeeID)
+		if err != nil {
+			return api.Error(fmt.Errorf("error getting duties: %w", err))
+		}
+		duties = append(duties, duty)
+	}
+
+	return api.Render(w, r, toCommitteeTraceResponse(duties))
+}
+
+func toCommitteeTraceResponse(duties []*model.CommitteeDutyTrace) *committeeTraceResponse {
+	r := new(committeeTraceResponse)
+	for _, t := range duties {
+		r.Data = append(r.Data, toCommitteeTrace(t))
+	}
+	return r
+}
+
+func (e *Exporter) ValidatorTraces(w http.ResponseWriter, r *http.Request) error {
+	var request struct {
+		From   uint64        `json:"from"`
+		To     uint64        `json:"to"`
+		Roles  api.RoleSlice `json:"roles"`
+		PubKey api.Hex       `json:"pubkey"` // optional
+	}
+
+	if err := api.Bind(r, &request); err != nil {
+		return api.BadRequestError(err)
+	}
+
+	if request.From > request.To {
+		return api.BadRequestError(fmt.Errorf("'from' must be less than or equal to 'to'"))
+	}
+
+	if len(request.Roles) == 0 {
+		return api.BadRequestError(fmt.Errorf("at least one role is required"))
+	}
+
+	var results []*model.ValidatorDutyTrace
+
+	if len(request.PubKey) == 0 {
+		for s := request.From; s <= request.To; s++ {
+			slot := phase0.Slot(s)
+			for _, r := range request.Roles {
+				role := spectypes.BeaconRole(r)
+				duties, err := e.TraceStore.GetAllValidatorDuties(role, slot)
+				if err != nil {
+					return api.Error(fmt.Errorf("error getting duties: %w", err))
+				}
+				results = append(results, duties...)
+			}
+		}
+		return api.Render(w, r, toValidatorTraceResponse(results))
+	}
+
+	var pubkey spectypes.ValidatorPK
+
+	if len(request.PubKey) != len(pubkey) {
+		return api.BadRequestError(fmt.Errorf("invalid pubkey length"))
+	}
+
+	copy(pubkey[:], request.PubKey)
+
+	for s := request.From; s <= request.To; s++ {
+		slot := phase0.Slot(s)
+		for _, r := range request.Roles {
+			role := spectypes.BeaconRole(r)
+			duty, err := e.TraceStore.GetValidatorDuty(role, slot, pubkey)
+			if err != nil {
+				return api.Error(fmt.Errorf("error getting duties: %w", err))
+			}
+			results = append(results, duty)
+		}
+	}
+
+	return api.Render(w, r, toValidatorTraceResponse(results))
+}
+
+func toValidatorTraceResponse(duties []*model.ValidatorDutyTrace) *validatorTraceResponse {
+	r := new(validatorTraceResponse)
+	for _, t := range duties {
+		r.Data = append(r.Data, toValidatorTrace(t))
+	}
+	return r
+}

api/handlers/model.go

@@ -0,0 +1,222 @@
+package handlers
+
+import (
+	"encoding/hex"
+	"time"
+
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	spectypes "github.com/ssvlabs/ssv-spec/types"
+	model "github.com/ssvlabs/ssv/exporter/v2"
+	qbftmsg "github.com/ssvlabs/ssv/protocol/v2/message"
+)
+
+type validatorTraceResponse struct {
+	Data []validatorTrace `json:"data"`
+}
+
+type validatorTrace struct {
+	Slot      phase0.Slot `json:"slot"`
+	Rounds    []round
+	Decideds  []decided
+	Pre       []message             `json:"pre"`
+	Post      []message             `json:"post"`
+	Role      spectypes.BeaconRole  `json:"role"`
+	Validator phase0.ValidatorIndex `json:"validator"`
+}
+
+type decided struct {
+	Round        uint64                 `json:"round"`
+	BeaconRoot   phase0.Root            `json:"beaconRoot"`
+	Signers      []spectypes.OperatorID `json:"signers"`
+	ReceivedTime time.Time              `json:"time"`
+}
+
+type round struct {
+	ProposalTrace *proposalTrace       `json:"proposal"`
+	Proposer      spectypes.OperatorID `json:"proposer"`
+	Prepares      []message            `json:"prepares"`
+	Commits       []message            `json:"commits"`
+	RoundChanges  []roundChange        `json:"roundChanges"`
+}
+
+type proposalTrace struct {
+	Round           uint64               `json:"round"`
+	BeaconRoot      phase0.Root          `json:"beaconRoot"`
+	Signer          spectypes.OperatorID `json:"signer"`
+	RoundChanges    []roundChange        `json:"roundChanges"`
+	PrepareMessages []message            `json:"prepareMessages"`
+	ReceivedTime    time.Time            `json:"time"`
+}
+
+type roundChange struct {
+	message
+	PreparedRound   uint64    `json:"preparedRound"`
+	PrepareMessages []message `json:"prepareMessages"`
+}
+
+type message struct {
+	Round        uint64               `json:"round"`
+	BeaconRoot   phase0.Root          `json:"beaconRoot"`
+	Signer       spectypes.OperatorID `json:"signer"`
+	ReceivedTime time.Time            `json:"time"`
+}
+
+type partialSigMessage struct {
+	BeaconRoot phase0.Root           `json:"beaconRoot"`
+	Signer     spectypes.OperatorID  `json:"signer"`
+	Validator  phase0.ValidatorIndex `json:"validator"`
+}
+
+func toValidatorTrace(t *model.ValidatorDutyTrace) validatorTrace {
+	return validatorTrace{
+		Slot:      t.Slot,
+		Role:      t.Role,
+		Validator: t.Validator,
+		Pre:       toMessageTrace(t.Pre),
+		Post:      toMessageTrace(t.Post),
+		Rounds:    toRounds(t.Rounds),
+	}
+}
+
+func toMessageTrace(m []*model.PartialSigTrace) (out []message) {
+	for _, mt := range m {
+		out = append(out, message{
+			BeaconRoot:   mt.BeaconRoot,
+			Signer:       mt.Signer,
+			ReceivedTime: mt.ReceivedTime,
+		})
+	}
+
+	return
+}
+
+func toRounds(r []*model.RoundTrace) (out []round) {
+	for _, rt := range r {
+		out = append(out, round{
+			Proposer:      rt.Proposer,
+			ProposalTrace: toProposalTrace(rt.ProposalTrace),
+			Prepares:      toUIMessageTrace(rt.Prepares),
+			Commits:       toUIMessageTrace(rt.Commits),
+			RoundChanges:  toUIRoundChangeTrace(rt.RoundChanges),
+		})
+	}
+
+	return
+}
+
+func toProposalTrace(rt *model.ProposalTrace) *proposalTrace {
+	if rt == nil {
+		return nil
+	}
+	return &proposalTrace{
+		Round:           rt.Round,
+		BeaconRoot:      rt.BeaconRoot,
+		Signer:          rt.Signer,
+		ReceivedTime:    rt.ReceivedTime,
+		RoundChanges:    toUIRoundChangeTrace(rt.RoundChanges),
+		PrepareMessages: toUIMessageTrace(rt.PrepareMessages),
+	}
+}
+
+func toUIMessageTrace(m []*model.QBFTTrace) (out []message) {
+	for _, mt := range m {
+		out = append(out, message{
+			Round:        mt.Round,
+			BeaconRoot:   mt.BeaconRoot,
+			Signer:       mt.Signer,
+			ReceivedTime: mt.ReceivedTime,
+		})
+	}
+
+	return
+}
+
+func toUIRoundChangeTrace(m []*model.RoundChangeTrace) (out []roundChange) {
+	for _, mt := range m {
+		out = append(out, roundChange{
+			message: message{
+				Round:        mt.Round,
+				BeaconRoot:   mt.BeaconRoot,
+				Signer:       mt.Signer,
+				ReceivedTime: mt.ReceivedTime,
+			},
+			PreparedRound:   mt.PreparedRound,
+			PrepareMessages: toUIMessageTrace(mt.PrepareMessages),
+		})
+	}
+
+	return
+}
+
+// committee
+
+type committeeTraceResponse struct {
+	Data []committeeTrace `json:"data"`
+}
+
+type committeeTrace struct {
+	Slot     phase0.Slot        `json:"slot"`
+	Rounds   []round            `json:"rounds"`
+	Decideds []decided          `json:"decideds"`
+	Post     []committeeMessage `json:"post"`
+
+	CommitteeID string                 `json:"committeeID"`
+	OperatorIDs []spectypes.OperatorID `json:"operatorIDs"`
+}
+
+type committeeMessage struct {
+	Type         string               `json:"type"`
+	Signer       spectypes.OperatorID `json:"signer"`
+	Messages     []partialSigMessage  `json:"messages"`
+	ReceivedTime time.Time            `json:"time"`
+}
+
+func toCommitteeTrace(t *model.CommitteeDutyTrace) committeeTrace {
+	return committeeTrace{
+		// consensus trace
+		Rounds:      toRounds(t.Rounds),
+		Decideds:    toDecidedTrace(t.Decideds),
+		Slot:        t.Slot,
+		Post:        toCommitteePost(t.Post),
+		CommitteeID: hex.EncodeToString(t.CommitteeID[:]),
+		OperatorIDs: t.OperatorIDs,
+	}
+}
+
+func toDecidedTrace(d []*model.DecidedTrace) (out []decided) {
+	for _, dt := range d {
+		out = append(out, decided{
+			Round:        dt.Round,
+			BeaconRoot:   dt.BeaconRoot,
+			Signers:      dt.Signers,
+			ReceivedTime: dt.ReceivedTime,
+		})
+	}
+
+	return
+}
+
+func toCommitteePost(m []*model.CommitteePartialSigMessageTrace) (out []committeeMessage) {
+	for _, mt := range m {
+		out = append(out, committeeMessage{
+			Type:         qbftmsg.PartialMsgTypeToString(mt.Type),
+			Signer:       mt.Signer,
+			Messages:     toCommitteePartSigMessage(mt.Messages),
+			ReceivedTime: mt.ReceivedTime,
+		})
+	}
+
+	return
+}
+
+func toCommitteePartSigMessage(m []*model.PartialSigMessage) (out []partialSigMessage) {
+	for _, mt := range m {
+		out = append(out, partialSigMessage{
+			BeaconRoot: mt.BeaconRoot,
+			Signer:     mt.Signer,
+			Validator:  mt.ValidatorIndex,
+		})
+	}
+
+	return
+}