core: voluntary exit

core/bcast/bcast.go

@@ -19,6 +19,7 @@ package bcast
 
 import (
 	"context"
+	"encoding/json"
 
 	eth2client "github.com/attestantio/go-eth2-client"
 	eth2p0 "github.com/attestantio/go-eth2-client/spec/phase0"
@@ -32,6 +33,7 @@ import (
 type eth2Provider interface {
 	eth2client.AttestationsSubmitter
 	eth2client.BeaconBlockSubmitter
+	eth2client.VoluntaryExitSubmitter
 }
 
 // New returns a new broadcaster instance.
@@ -49,8 +51,11 @@ type Broadcaster struct {
 }
 
 // Broadcast broadcasts the aggregated signed duty data object to the beacon-node.
-func (b Broadcaster) Broadcast(ctx context.Context, duty core.Duty,
-	pubkey core.PubKey, aggData core.AggSignedData,
+func (b Broadcaster) Broadcast(
+	ctx context.Context,
+	duty core.Duty,
+	pubkey core.PubKey,
+	aggData core.AggSignedData,
 ) (err error) {
 	ctx = log.WithTopic(ctx, "bcast")
 	defer func() {
@@ -72,6 +77,7 @@ func (b Broadcaster) Broadcast(ctx context.Context, duty core.Duty,
 				z.U64("slot", uint64(att.Data.Slot)),
 				z.U64("target_epoch", uint64(att.Data.Target.Epoch)),
 				z.Hex("agg_bits", att.AggregationBits.Bytes()),
+				z.Any("pubkey", pubkey.String()),
 			)
 		}
 
@@ -86,13 +92,33 @@ func (b Broadcaster) Broadcast(ctx context.Context, duty core.Duty,
 		if err == nil {
 			log.Info(ctx, "Block proposal successfully submitted to beacon node",
 				z.U64("slot", uint64(duty.Slot)),
+				z.Any("pubkey", pubkey.String()),
 			)
 		}
 
 		return err
 	case core.DutyRandao:
 		// Randao is an internal duty, not broadcasted to beacon chain
 		return nil
+	case core.DutyVoluntaryExit:
+		// JSON decoding from the previous component
+		ve := new(eth2p0.SignedVoluntaryExit)
+		err := json.Unmarshal(aggData.Data, ve)
+		if err != nil {
+			return errors.Wrap(err, "json decoding voluntary exit")
+		}
+
+		err = b.eth2Cl.SubmitVoluntaryExit(ctx, ve)
+
+		if err == nil {
+			log.Info(ctx, "Voluntary exit successfully submitted to beacon node",
+				z.U64("epoch", uint64(ve.Message.Epoch)),
+				z.U64("validator_index", uint64(ve.Message.ValidatorIndex)),
+				z.Any("pubkey", pubkey.String()),
+			)
+		}
+
+		return err
 	default:
 		return errors.New("unsupported duty type")
 	}

core/bcast/bcast_test.go

@@ -17,6 +17,7 @@ package bcast_test
 
 import (
 	"context"
+	"encoding/json"
 	"testing"
 
 	"github.com/attestantio/go-eth2-client/spec"
@@ -86,3 +87,34 @@ func TestBroadcastBeaconBlock(t *testing.T) {
 
 	<-ctx.Done()
 }
+
+func TestBroadcastVoluntaryExit(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	mock, err := beaconmock.New()
+	require.NoError(t, err)
+
+	ve := testutil.RandomSignedVoluntaryExit(t)
+
+	aggDataData, err := json.Marshal(ve)
+	require.NoError(t, err)
+
+	aggData := core.AggSignedData{
+		Data:      aggDataData,
+		Signature: core.SigFromETH2(ve.Signature),
+	}
+
+	mock.SubmitVoluntaryExitFunc = func(ctx context.Context, ve2 *eth2p0.SignedVoluntaryExit) error {
+		require.Equal(t, ve, ve2)
+		cancel()
+
+		return ctx.Err()
+	}
+
+	bcaster, err := bcast.New(mock)
+	require.NoError(t, err)
+
+	err = bcaster.Broadcast(ctx, core.Duty{Type: core.DutyVoluntaryExit}, "", aggData)
+	require.ErrorIs(t, err, context.Canceled)
+
+	<-ctx.Done()
+}

core/encode.go

@@ -102,6 +102,22 @@ func EncodeAttestationParSignedData(att *eth2p0.Attestation, shareIdx int) (ParS
 	}, nil
 }
 
+// EncodeVoluntaryExitParSignedData encodes to json to pass between Go components losing typing,
+// returns a ParSignedData that contains json.
+// WARNING: using this method makes you lose Golang type safety features.
+func EncodeVoluntaryExitParSignedData(ve *eth2p0.SignedVoluntaryExit, shareIdx int) (ParSignedData, error) {
+	data, err := json.Marshal(ve)
+	if err != nil {
+		return ParSignedData{}, errors.Wrap(err, "json marshal signed voluntary exit")
+	}
+
+	return ParSignedData{
+		Data:      data,
+		Signature: SigFromETH2(ve.Signature),
+		ShareIdx:  shareIdx,
+	}, nil
+}
+
 // DecodeAttestationParSignedData returns the attestation from the encoded ParSignedData.
 func DecodeAttestationParSignedData(data ParSignedData) (*eth2p0.Attestation, error) {
 	att := new(eth2p0.Attestation)
@@ -113,6 +129,18 @@ func DecodeAttestationParSignedData(data ParSignedData) (*eth2p0.Attestation, er
 	return att, nil
 }
 
+// DecodeSignedVoluntaryExitParSignedData json decode signed voluntary exit from the previous
+// Golang component.
+func DecodeSignedVoluntaryExitParSignedData(data ParSignedData) (*eth2p0.SignedVoluntaryExit, error) {
+	ve := new(eth2p0.SignedVoluntaryExit)
+	err := json.Unmarshal(data.Data, ve)
+	if err != nil {
+		return nil, errors.Wrap(err, "json decoding signed voluntary exit")
+	}
+
+	return ve, nil
+}
+
 // EncodeAttestationAggSignedData returns the attestation as an encoded AggSignedData.
 func EncodeAttestationAggSignedData(att *eth2p0.Attestation) (AggSignedData, error) {
 	data, err := json.Marshal(att)
@@ -275,3 +303,18 @@ func DecodeBlockAggSignedData(data AggSignedData) (*spec.VersionedSignedBeaconBl
 
 	return block, nil
 }
+
+// EncodeSignedVoluntaryExitAggSignedData encodes to json to pass between Go components losing typing,
+// returns a AggSignedData that contains json.
+// WARNING: using this method makes you lose Golang type safety features.
+func EncodeSignedVoluntaryExitAggSignedData(ve *eth2p0.SignedVoluntaryExit) (AggSignedData, error) {
+	data, err := json.Marshal(ve)
+	if err != nil {
+		return AggSignedData{}, errors.Wrap(err, "json encoding voluntary exit")
+	}
+
+	return AggSignedData{
+		Data:      data,
+		Signature: SigFromETH2(ve.Signature),
+	}, nil
+}

core/sigagg/sigagg.go

@@ -148,6 +148,18 @@ func getAggSignedData(typ core.DutyType, data core.ParSignedData, aggSig *bls_si
 		}
 
 		return core.EncodeBlockAggSignedData(block)
+	case core.DutyVoluntaryExit:
+		// JSON decode from previous component
+		ve, err := core.DecodeSignedVoluntaryExitParSignedData(data)
+		if err != nil {
+			return core.AggSignedData{}, errors.Wrap(err, "json decoding voluntary exit")
+		}
+
+		// change signature to TSS aggregated one
+		ve.Signature = eth2Sig
+
+		// JSON encode for next component
+		return core.EncodeSignedVoluntaryExitAggSignedData(ve)
 	default:
 		return core.AggSignedData{}, errors.New("unsupported duty type")
 	}
@@ -178,6 +190,14 @@ func getSignedRoot(typ core.DutyType, data core.ParSignedData) (eth2p0.Root, err
 		}
 
 		return block.Root()
+	case core.DutyVoluntaryExit:
+		// JSON decode from previous component
+		ve, err := core.DecodeSignedVoluntaryExitParSignedData(data)
+		if err != nil {
+			return eth2p0.Root{}, errors.Wrap(err, "json decoding voluntary exit")
+		}
+
+		return ve.Message.HashTreeRoot()
 	default:
 		return eth2p0.Root{}, errors.New("unsupported duty type")
 	}

core/sigagg/sigagg_test.go

@@ -18,6 +18,7 @@ package sigagg_test
 import (
 	"context"
 	"crypto/rand"
+	"encoding/json"
 	"testing"
 
 	"github.com/attestantio/go-eth2-client/spec"
@@ -151,6 +152,75 @@ func TestSigAgg_DutyRandao(t *testing.T) {
 	require.NoError(t, err)
 }
 
+func TestSigAgg_DutyVoluntaryExit(t *testing.T) {
+	ctx := context.Background()
+
+	const (
+		threshold = 3
+		peers     = 4
+	)
+
+	// Generate private shares
+	tss, secrets, err := tbls.GenerateTSS(threshold, peers, rand.Reader)
+	require.NoError(t, err)
+
+	uve := testutil.RandomVoluntaryExit(t)
+
+	msg, err := uve.MarshalSSZ()
+	require.NoError(t, err)
+
+	// Create partial signatures (in two formats)
+	var (
+		parsigs []core.ParSignedData
+		psigs   []*bls_sig.PartialSignature
+	)
+	for _, secret := range secrets {
+		psig, err := tbls.PartialSign(secret, msg)
+		require.NoError(t, err)
+
+		sig := tblsconv.SigToETH2(tblsconv.SigFromPartial(psig))
+		ve := &eth2p0.SignedVoluntaryExit{
+			Message:   uve,
+			Signature: sig,
+		}
+
+		data, err := json.Marshal(ve)
+		require.NoError(t, err)
+
+		parsig := core.ParSignedData{
+			Data:      data,
+			Signature: core.SigFromETH2(ve.Signature),
+			ShareIdx:  int(psig.Identifier),
+		}
+
+		psigs = append(psigs, psig)
+		parsigs = append(parsigs, parsig)
+	}
+
+	aggSig, err := tbls.Aggregate(psigs)
+	require.NoError(t, err)
+	expect := tblsconv.SigToCore(aggSig)
+
+	agg := sigagg.New(threshold)
+
+	// Assert output
+	agg.Subscribe(func(_ context.Context, _ core.Duty, _ core.PubKey, aggData core.AggSignedData) error {
+		require.Equal(t, expect, aggData.Signature)
+		sig, err := tblsconv.SigFromCore(aggData.Signature)
+		require.NoError(t, err)
+
+		ok, err := tbls.Verify(tss.PublicKey(), msg, sig)
+		require.NoError(t, err)
+		require.True(t, ok)
+
+		return nil
+	})
+
+	// Run aggregation
+	err = agg.Aggregate(ctx, core.Duty{Type: core.DutyVoluntaryExit}, "", parsigs)
+	require.NoError(t, err)
+}
+
 func TestSigAgg_DutyProposer(t *testing.T) {
 	ctx := context.Background()
 

core/types.go

@@ -32,13 +32,14 @@ type DutyType int
 const (
 	// DutyType enums MUST not change, it will break backwards compatibility.
 
-	DutyUnknown  DutyType = 0
-	DutyProposer DutyType = 1
-	DutyAttester DutyType = 2
-	DutyRandao   DutyType = 3
+	DutyUnknown       DutyType = 0
+	DutyProposer      DutyType = 1
+	DutyAttester      DutyType = 2
+	DutyRandao        DutyType = 3
+	DutyVoluntaryExit DutyType = 4
 	// Only ever append new types here...
 
-	dutySentinel DutyType = 4 // Must always be last
+	dutySentinel DutyType = 5 // Must always be last
 )
 
 func (d DutyType) Valid() bool {

core/types_test.go

@@ -32,9 +32,10 @@ func TestBackwardsCompatability(t *testing.T) {
 	require.EqualValues(t, 1, core.DutyProposer)
 	require.EqualValues(t, 2, core.DutyAttester)
 	require.EqualValues(t, 3, core.DutyRandao)
+	require.EqualValues(t, 4, core.DutyVoluntaryExit)
 	// Add more types here.
 
-	const sentinel = core.DutyType(4)
+	const sentinel = core.DutyType(5)
 	for i := core.DutyUnknown; i <= sentinel; i++ {
 		if i == core.DutyUnknown || i == sentinel {
 			require.False(t, i.Valid())

core/validatorapi/router.go

@@ -59,6 +59,7 @@ type Handler interface {
 	eth2client.BeaconBlockSubmitter
 	eth2client.ProposerDutiesProvider
 	eth2client.ValidatorsProvider
+	eth2client.VoluntaryExitSubmitter
 	// Above sorted alphabetically.
 }
 
@@ -71,6 +72,7 @@ func NewRouter(h Handler, beaconNodeAddr string) (*mux.Router, error) {
 		Name    string
 		Path    string
 		Handler handlerFunc
+		Methods []string
 	}{
 		{
 			Name:    "attester_duties",
@@ -112,12 +114,21 @@ func NewRouter(h Handler, beaconNodeAddr string) (*mux.Router, error) {
 			Path:    "/eth/v1/beacon/blocks",
 			Handler: submitBlock(h),
 		},
+		{
+			Name:    "submit_voluntary_exit",
+			Path:    "/eth/v1/beacon/pool/voluntary_exits",
+			Handler: submitVoluntaryExit(h),
+			Methods: []string{"POST"},
+		},
 		// TODO(corver): Add more endpoints
 	}
 
 	r := mux.NewRouter()
 	for _, e := range endpoints {
-		r.Handle(e.Path, wrap(e.Name, e.Handler))
+		route := r.Handle(e.Path, wrap(e.Name, e.Handler))
+		if e.Methods != nil && len(e.Methods) > 0 {
+			route.Methods(e.Methods...)
+		}
 	}
 
 	// Everything else is proxied
@@ -439,6 +450,19 @@ func submitBlock(p eth2client.BeaconBlockSubmitter) handlerFunc {
 	}
 }
 
+// submitVoluntaryExit receives the partially signed voluntary exit.
+func submitVoluntaryExit(p eth2client.VoluntaryExitSubmitter) handlerFunc {
+	return func(ctx context.Context, params map[string]string, query url.Values, body []byte) (interface{}, error) {
+		ve := new(eth2p0.SignedVoluntaryExit)
+		err := ve.UnmarshalJSON(body)
+		if err != nil {
+			return nil, errors.New("invalid voluntary exit data")
+		}
+
+		return nil, p.SubmitVoluntaryExit(ctx, ve)
+	}
+}
+
 // proxyHandler returns a reverse proxy handler.
 func proxyHandler(target string) (http.HandlerFunc, error) {
 	targetURL, err := url.Parse(target)