core/sigagg: add dutyproposer to sigagg

core/encode.go

@@ -230,3 +230,48 @@ func DecodeBlockParSignedData(data ParSignedData) (*spec.VersionedSignedBeaconBl
 
 	return block, nil
 }
+
+// EncodeBlockAggSignedData returns the partially signed block data as an encoded AggSignedData.
+func EncodeBlockAggSignedData(block *spec.VersionedSignedBeaconBlock) (AggSignedData, error) {
+	data, err := json.Marshal(block)
+	if err != nil {
+		return AggSignedData{}, errors.Wrap(err, "marshal signed block")
+	}
+
+	var sig Signature
+	switch block.Version {
+	case spec.DataVersionPhase0:
+		if block.Phase0 == nil {
+			return AggSignedData{}, errors.New("no phase0 block")
+		}
+		sig = SigFromETH2(block.Phase0.Signature)
+	case spec.DataVersionAltair:
+		if block.Altair == nil {
+			return AggSignedData{}, errors.New("no altair block")
+		}
+		sig = SigFromETH2(block.Altair.Signature)
+	case spec.DataVersionBellatrix:
+		if block.Bellatrix == nil {
+			return AggSignedData{}, errors.New("no bellatrix block")
+		}
+		sig = SigFromETH2(block.Bellatrix.Signature)
+	default:
+		return AggSignedData{}, errors.New("invalid block")
+	}
+
+	return AggSignedData{
+		Data:      data,
+		Signature: sig,
+	}, nil
+}
+
+// DecodeBlockAggSignedData returns the partially signed block data from the encoded AggSignedData.
+func DecodeBlockAggSignedData(data AggSignedData) (*spec.VersionedSignedBeaconBlock, error) {
+	block := new(spec.VersionedSignedBeaconBlock)
+	err := json.Unmarshal(data.Data, block)
+	if err != nil {
+		return nil, errors.Wrap(err, "unmarshal signed block")
+	}
+
+	return block, nil
+}

core/encode_test.go

@@ -171,3 +171,25 @@ func TestEncodeBlockParSignedData(t *testing.T) {
 	require.Equal(t, block1, block2)
 	require.Equal(t, data1, data2)
 }
+
+func TestEncodeBlockAggSignedData(t *testing.T) {
+	block1 := &spec.VersionedSignedBeaconBlock{
+		Version: spec.DataVersionPhase0,
+		Phase0: &eth2p0.SignedBeaconBlock{
+			Message:   testutil.RandomPhase0BeaconBlock(),
+			Signature: testutil.RandomEth2Signature(),
+		},
+	}
+
+	data1, err := core.EncodeBlockAggSignedData(block1)
+	require.NoError(t, err)
+
+	block2, err := core.DecodeBlockAggSignedData(data1)
+	require.NoError(t, err)
+
+	data2, err := core.EncodeBlockAggSignedData(block2)
+	require.NoError(t, err)
+
+	require.Equal(t, block1, block2)
+	require.Equal(t, data1, data2)
+}

core/sigagg/sigagg.go

@@ -22,6 +22,7 @@ package sigagg
 import (
 	"context"
 
+	"github.com/attestantio/go-eth2-client/spec"
 	eth2p0 "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/coinbase/kryptology/pkg/signatures/bls/bls_sig"
 
@@ -94,7 +95,7 @@ func (a *Aggregator) Aggregate(ctx context.Context, duty core.Duty, pubkey core.
 		return err
 	}
 
-	// Inject signature into resulting aggregate singed data.
+	// Inject signature into resulting aggregate signed data.
 	aggSig, err := getAggSignedData(duty.Type, firstParSig, sig)
 	if err != nil {
 		return err
@@ -126,6 +127,23 @@ func getAggSignedData(typ core.DutyType, data core.ParSignedData, aggSig *bls_si
 		return core.EncodeAttestationAggSignedData(att)
 	case core.DutyRandao:
 		return core.EncodeRandaoAggSignedData(eth2Sig), nil
+	case core.DutyProposer:
+		block, err := core.DecodeBlockParSignedData(data)
+		if err != nil {
+			return core.AggSignedData{}, err
+		}
+		switch block.Version {
+		case spec.DataVersionPhase0:
+			block.Phase0.Signature = eth2Sig
+		case spec.DataVersionAltair:
+			block.Altair.Signature = eth2Sig
+		case spec.DataVersionBellatrix:
+			block.Bellatrix.Signature = eth2Sig
+		default:
+			return core.AggSignedData{}, errors.New("invalid block version")
+		}
+
+		return core.EncodeBlockAggSignedData(block)
 	default:
 		return core.AggSignedData{}, errors.New("unsupported duty type")
 	}
@@ -149,6 +167,13 @@ func getSignedRoot(typ core.DutyType, data core.ParSignedData) (eth2p0.Root, err
 	case core.DutyRandao:
 		// randao is just a signature, it doesn't have other data to check
 		return eth2p0.Root{}, nil
+	case core.DutyProposer:
+		block, err := core.DecodeBlockParSignedData(data)
+		if err != nil {
+			return eth2p0.Root{}, err
+		}
+
+		return block.Root()
 	default:
 		return eth2p0.Root{}, errors.New("unsupported duty type")
 	}

core/sigagg/sigagg_test.go

@@ -20,6 +20,10 @@ import (
 	"crypto/rand"
 	"testing"
 
+	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/altair"
+	"github.com/attestantio/go-eth2-client/spec/bellatrix"
+	eth2p0 "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/coinbase/kryptology/pkg/signatures/bls/bls_sig"
 	"github.com/stretchr/testify/require"
 
@@ -146,3 +150,113 @@ func TestSigAgg_DutyRandao(t *testing.T) {
 	err = agg.Aggregate(ctx, core.Duty{Type: core.DutyRandao}, "", parsigs)
 	require.NoError(t, err)
 }
+
+func TestSigAgg_DutyProposer(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)
+
+	tests := []struct {
+		name  string
+		block *spec.VersionedSignedBeaconBlock
+	}{
+		{
+			name: "phase0 block",
+			block: &spec.VersionedSignedBeaconBlock{
+				Version: spec.DataVersionPhase0,
+				Phase0: &eth2p0.SignedBeaconBlock{
+					Message:   testutil.RandomPhase0BeaconBlock(),
+					Signature: testutil.RandomEth2Signature(),
+				},
+			},
+		},
+		{
+			name: "altair block",
+			block: &spec.VersionedSignedBeaconBlock{
+				Version: spec.DataVersionAltair,
+				Altair: &altair.SignedBeaconBlock{
+					Message:   testutil.RandomAltairBeaconBlock(t),
+					Signature: testutil.RandomEth2Signature(),
+				},
+			},
+		},
+		{
+			name: "bellatrix block",
+			block: &spec.VersionedSignedBeaconBlock{
+				Version: spec.DataVersionBellatrix,
+				Bellatrix: &bellatrix.SignedBeaconBlock{
+					Message:   testutil.RandomBellatrixBeaconBlock(t),
+					Signature: testutil.RandomEth2Signature(),
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			// Ignoring Domain for this test
+			msg, err := test.block.Root()
+			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)
+
+				setSigToSignedBlock(test.block, tblsconv.SigToETH2(tblsconv.SigFromPartial(psig)))
+
+				parsig, err := core.EncodeBlockParSignedData(test.block, int(psig.Identifier))
+				require.NoError(t, err)
+
+				psigs = append(psigs, psig)
+				parsigs = append(parsigs, parsig)
+			}
+
+			// Create expected aggregated signature
+			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.DutyProposer}, "", parsigs)
+			require.NoError(t, err)
+		})
+	}
+}
+
+func setSigToSignedBlock(block *spec.VersionedSignedBeaconBlock, sig eth2p0.BLSSignature) {
+	switch block.Version {
+	case spec.DataVersionPhase0:
+		block.Phase0.Signature = sig
+	case spec.DataVersionAltair:
+		block.Altair.Signature = sig
+	case spec.DataVersionBellatrix:
+		block.Bellatrix.Signature = sig
+	}
+}