Add helper ComputeDomainAndSign (#6773)

* Starting * Merge branch 'master' of github.com:prysmaticlabs/prysm into domain-and-sign * core blocks tests: updated * core state tests: updated * rpc validator tests updated * sync tests updated * testutil updated * Beacon-chain: update tests * Shared: update tests * Rest of the tests * Merge branch 'master' of github.com:prysmaticlabs/prysm into domain-and-sign * Merge refs/heads/master into domain-and-sign * Merge refs/heads/master into domain-and-sign * Merge refs/heads/master into domain-and-sign * Merge refs/heads/master into domain-and-sign * Sync with master * Merge branch 'domain-and-sign' of github.com:prysmaticlabs/prysm into domain-and-sign * Merge refs/heads/master into domain-and-sign
2026-01-09 21:38:05 -05:00 · 2020-07-30 12:11:22 -07:00
parent edc9fcd0d6
commit ec4de10001
22 changed files with 141 additions and 396 deletions
--- a/beacon-chain/core/blocks/attestation_test.go
+++ b/beacon-chain/core/blocks/attestation_test.go
@@ -269,17 +269,12 @@ func TestProcessAttestations_OK(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatal(err)
-	}
-	hashTreeRoot, err := helpers.ComputeSigningRoot(att.Data, domain)
-	if err != nil {
-		t.Error(err)
-	}
 	sigs := make([]bls.Signature, len(attestingIndices))
 	for i, indice := range attestingIndices {
-		sig := privKeys[indice].Sign(hashTreeRoot[:])
+		sb, err := helpers.ComputeDomainAndSign(beaconState, 0, att.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+		require.NoError(t, err)
+		sig, err := bls.SignatureFromBytes(sb)
+		require.NoError(t, err)
 		sigs[i] = sig
 	}
 	att.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
@@ -302,11 +297,6 @@ func TestProcessAttestations_OK(t *testing.T) {

 func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
-
-	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatal(err)
-	}
 	data := &ethpb.AttestationData{
 		Source: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
 		Target: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
@@ -337,13 +327,12 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	hashTreeRoot, err := helpers.ComputeSigningRoot(att1.Data, domain)
-	if err != nil {
-		t.Error(err)
-	}
 	sigs := make([]bls.Signature, len(attestingIndices1))
 	for i, indice := range attestingIndices1 {
-		sig := privKeys[indice].Sign(hashTreeRoot[:])
+		sb, err := helpers.ComputeDomainAndSign(beaconState, 0, att1.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+		require.NoError(t, err)
+		sig, err := bls.SignatureFromBytes(sb)
+		require.NoError(t, err)
 		sigs[i] = sig
 	}
 	att1.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
@@ -365,13 +354,12 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	hashTreeRoot, err = helpers.ComputeSigningRoot(data, domain)
-	if err != nil {
-		t.Error(err)
-	}
 	sigs = make([]bls.Signature, len(attestingIndices2))
 	for i, indice := range attestingIndices2 {
-		sig := privKeys[indice].Sign(hashTreeRoot[:])
+		sb, err := helpers.ComputeDomainAndSign(beaconState, 0, att2.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+		require.NoError(t, err)
+		sig, err := bls.SignatureFromBytes(sb)
+		require.NoError(t, err)
 		sigs[i] = sig
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
@@ -384,10 +372,6 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 300)

-	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatal(err)
-	}
 	var mockRoot [32]byte
 	copy(mockRoot[:], "hello-world")
 	data := &ethpb.AttestationData{
@@ -419,13 +403,12 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	hashTreeRoot, err := helpers.ComputeSigningRoot(data, domain)
-	if err != nil {
-		t.Error(err)
-	}
 	sigs := make([]bls.Signature, len(attestingIndices1))
 	for i, indice := range attestingIndices1 {
-		sig := privKeys[indice].Sign(hashTreeRoot[:])
+		sb, err := helpers.ComputeDomainAndSign(beaconState, 0, data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+		require.NoError(t, err)
+		sig, err := bls.SignatureFromBytes(sb)
+		require.NoError(t, err)
 		sigs[i] = sig
 	}
 	att1.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
@@ -446,13 +429,12 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	hashTreeRoot, err = helpers.ComputeSigningRoot(data, domain)
-	if err != nil {
-		t.Error(err)
-	}
 	sigs = make([]bls.Signature, len(attestingIndices2))
 	for i, indice := range attestingIndices2 {
-		sig := privKeys[indice].Sign(hashTreeRoot[:])
+		sb, err := helpers.ComputeDomainAndSign(beaconState, 0, att2.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+		require.NoError(t, err)
+		sig, err := bls.SignatureFromBytes(sb)
+		require.NoError(t, err)
 		sigs[i] = sig
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
@@ -684,17 +666,12 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
 	}

 	for _, tt := range tests {
-		domain, err := helpers.Domain(state.Fork(), tt.attestation.Data.Target.Epoch, params.BeaconConfig().DomainBeaconAttester, state.GenesisValidatorRoot())
-		if err != nil {
-			t.Fatal(err)
-		}
-		root, err := helpers.ComputeSigningRoot(tt.attestation.Data, domain)
-		if err != nil {
-			t.Error(err)
-		}
 		var sig []bls.Signature
 		for _, idx := range tt.attestation.AttestingIndices {
-			validatorSig := keys[idx].Sign(root[:])
+			sb, err := helpers.ComputeDomainAndSign(state, tt.attestation.Data.Target.Epoch, tt.attestation.Data, params.BeaconConfig().DomainBeaconAttester, keys[idx])
+			require.NoError(t, err)
+			validatorSig, err := bls.SignatureFromBytes(sb)
+			require.NoError(t, err)
 			sig = append(sig, validatorSig)
 		}
 		aggSig := bls.AggregateSignatures(sig)
--- a/beacon-chain/core/blocks/exit_test.go
+++ b/beacon-chain/core/blocks/exit_test.go
@@ -12,6 +12,7 @@ import (
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bls"
 	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

 func TestProcessVoluntaryExits_ValidatorNotActive(t *testing.T) {
@@ -155,16 +156,9 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) {
 	if err := state.UpdateValidatorAtIndex(0, val); err != nil {
 		t.Fatal(err)
 	}
-	domain, err := helpers.Domain(state.Fork(), helpers.CurrentEpoch(state), params.BeaconConfig().DomainVoluntaryExit, state.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatal(err)
-	}
-	signingRoot, err := helpers.ComputeSigningRoot(exits[0].Exit, domain)
-	if err != nil {
-		t.Error(err)
-	}
-	sig := priv.Sign(signingRoot[:])
-	exits[0].Signature = sig.Marshal()
+	exits[0].Signature, err = helpers.ComputeDomainAndSign(state, helpers.CurrentEpoch(state), exits[0].Exit, params.BeaconConfig().DomainVoluntaryExit, priv)
+	require.NoError(t, err)
+
 	block := &ethpb.BeaconBlock{
 		Body: &ethpb.BeaconBlockBody{
 			VoluntaryExits: exits,
--- a/beacon-chain/core/blocks/header_test.go
+++ b/beacon-chain/core/blocks/header_test.go
@@ -16,6 +16,7 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/bls"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	"github.com/sirupsen/logrus"
 )

@@ -52,10 +53,6 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 	}

 	currentEpoch := helpers.CurrentEpoch(state)
-	dt, err := helpers.Domain(state.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, state.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatalf("Failed to get domain form state: %v", err)
-	}
 	priv := bls.RandKey()
 	pID, err := helpers.BeaconProposerIndex(state)
 	if err != nil {
@@ -71,12 +68,8 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 			ParentRoot: latestBlockSignedRoot[:],
 		},
 	}
-	signingRoot, err := helpers.ComputeSigningRoot(block.Block, dt)
-	if err != nil {
-		t.Fatalf("Failed to get signing root of block: %v", err)
-	}
-	blockSig := priv.Sign(signingRoot[:])
-	block.Signature = blockSig.Marshal()[:]
+	block.Signature, err = helpers.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
+	require.NoError(t, err)

 	proposerIdx, err := helpers.BeaconProposerIndex(state)
 	if err != nil {
@@ -125,16 +118,8 @@ func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
 			ParentRoot: lbhdr[:],
 		},
 	}
-	dt, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatalf("Failed to get domain form state: %v", err)
-	}
-	signingRoot, err := helpers.ComputeSigningRoot(block.Block, dt)
-	if err != nil {
-		t.Fatalf("Failed to get signing root of block: %v", err)
-	}
-	blockSig := privKeys[proposerIdx+1].Sign(signingRoot[:])
-	block.Signature = blockSig.Marshal()[:]
+	block.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx+1])
+	require.NoError(t, err)

 	_, err = blocks.ProcessBlockHeader(beaconState, block)
 	want := "signature did not verify"
@@ -171,16 +156,10 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 		t.Error(err)
 	}
 	currentEpoch := helpers.CurrentEpoch(state)
-	dt, err := helpers.Domain(state.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, state.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatalf("Failed to get domain form state: %v", err)
-	}
+
 	priv := bls.RandKey()
-	root, err := helpers.ComputeSigningRoot([]byte("hello"), dt)
-	if err != nil {
-		t.Error(err)
-	}
-	blockSig := priv.Sign(root[:])
+	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, []byte("hello"), params.BeaconConfig().DomainBeaconProposer, priv)
+	require.NoError(t, err)
 	validators[5896].PublicKey = priv.PublicKey().Marshal()
 	block := &ethpb.SignedBeaconBlock{
 		Block: &ethpb.BeaconBlock{
@@ -190,7 +169,7 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 			},
 			ParentRoot: lbhsr[:],
 		},
-		Signature: blockSig.Marshal(),
+		Signature: blockSig,
 	}

 	_, err = blocks.ProcessBlockHeader(state, block)
@@ -224,16 +203,9 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
 	}

 	currentEpoch := helpers.CurrentEpoch(state)
-	dt, err := helpers.Domain(state.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, state.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatalf("Failed to get domain form state: %v", err)
-	}
 	priv := bls.RandKey()
-	root, err := helpers.ComputeSigningRoot([]byte("hello"), dt)
-	if err != nil {
-		t.Error(err)
-	}
-	blockSig := priv.Sign(root[:])
+	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, []byte("hello"), params.BeaconConfig().DomainBeaconProposer, priv)
+	require.NoError(t, err)
 	validators[5896].PublicKey = priv.PublicKey().Marshal()
 	pID, err := helpers.BeaconProposerIndex(state)
 	if err != nil {
@@ -248,7 +220,7 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
 			},
 			ParentRoot: []byte{'A'},
 		},
-		Signature: blockSig.Marshal(),
+		Signature: blockSig,
 	}

 	_, err = blocks.ProcessBlockHeader(state, block)
@@ -286,16 +258,9 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
 		t.Error(err)
 	}
 	currentEpoch := helpers.CurrentEpoch(state)
-	dt, err := helpers.Domain(state.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, state.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatalf("Failed to get domain form state: %v", err)
-	}
 	priv := bls.RandKey()
-	root, err := helpers.ComputeSigningRoot([]byte("hello"), dt)
-	if err != nil {
-		t.Error(err)
-	}
-	blockSig := priv.Sign(root[:])
+	blockSig, err := helpers.ComputeDomainAndSign(state, currentEpoch, []byte("hello"), params.BeaconConfig().DomainBeaconProposer, priv)
+	require.NoError(t, err)

 	validators[12683].PublicKey = priv.PublicKey().Marshal()
 	pID, err := helpers.BeaconProposerIndex(state)
@@ -311,7 +276,7 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
 			},
 			ParentRoot: parentRoot[:],
 		},
-		Signature: blockSig.Marshal(),
+		Signature: blockSig,
 	}

 	_, err = blocks.ProcessBlockHeader(state, block)
@@ -350,10 +315,6 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	}

 	currentEpoch := helpers.CurrentEpoch(state)
-	dt, err := helpers.Domain(state.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, state.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatalf("Failed to get domain form state: %v", err)
-	}
 	priv := bls.RandKey()
 	pID, err := helpers.BeaconProposerIndex(state)
 	if err != nil {
@@ -369,12 +330,8 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 			ParentRoot: latestBlockSignedRoot[:],
 		},
 	}
-	signingRoot, err := helpers.ComputeSigningRoot(block.Block, dt)
-	if err != nil {
-		t.Fatalf("Failed to get signing root of block: %v", err)
-	}
-	blockSig := priv.Sign(signingRoot[:])
-	block.Signature = blockSig.Marshal()[:]
+	block.Signature, err = helpers.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
+	require.NoError(t, err)
 	bodyRoot, err := stateutil.BlockBodyRoot(block.Block.Body)
 	if err != nil {
 		t.Fatalf("Failed to hash block bytes got: %v", err)
@@ -438,10 +395,6 @@ func TestBlockSignatureSet_OK(t *testing.T) {
 	}

 	currentEpoch := helpers.CurrentEpoch(state)
-	dt, err := helpers.Domain(state.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, state.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatalf("Failed to get domain form state: %v", err)
-	}
 	priv := bls.RandKey()
 	pID, err := helpers.BeaconProposerIndex(state)
 	if err != nil {
@@ -457,13 +410,8 @@ func TestBlockSignatureSet_OK(t *testing.T) {
 			ParentRoot: latestBlockSignedRoot[:],
 		},
 	}
-	signingRoot, err := helpers.ComputeSigningRoot(block.Block, dt)
-	if err != nil {
-		t.Fatalf("Failed to get signing root of block: %v", err)
-	}
-	blockSig := priv.Sign(signingRoot[:])
-	block.Signature = blockSig.Marshal()[:]
-
+	block.Signature, err = helpers.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
+	require.NoError(t, err)
 	proposerIdx, err := helpers.BeaconProposerIndex(state)
 	if err != nil {
 		t.Fatal(err)
--- a/beacon-chain/core/blocks/proposer_slashing_test.go
+++ b/beacon-chain/core/blocks/proposer_slashing_test.go
@@ -14,6 +14,7 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

 func TestProcessProposerSlashings_UnmatchedHeaderSlots(t *testing.T) {
@@ -146,10 +147,6 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
 	proposerIdx := uint64(1)

-	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatal(err)
-	}
 	header1 := &ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
 			ProposerIndex: proposerIdx,
@@ -157,11 +154,9 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 			StateRoot:     []byte("A"),
 		},
 	}
-	signingRoot, err := helpers.ComputeSigningRoot(header1.Header, domain)
-	if err != nil {
-		t.Errorf("Could not get signing root of beacon block header: %v", err)
-	}
-	header1.Signature = privKeys[proposerIdx].Sign(signingRoot[:]).Marshal()[:]
+	var err error
+	header1.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, header1.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
+	require.NoError(t, err)

 	header2 := &ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
@@ -170,11 +165,8 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 			StateRoot:     []byte("B"),
 		},
 	}
-	signingRoot, err = helpers.ComputeSigningRoot(header2.Header, domain)
-	if err != nil {
-		t.Errorf("Could not get signing root of beacon block header: %v", err)
-	}
-	header2.Signature = privKeys[proposerIdx].Sign(signingRoot[:]).Marshal()[:]
+	header2.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, header2.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
+	require.NoError(t, err)

 	slashings := []*ethpb.ProposerSlashing{
 		{
--- a/beacon-chain/core/helpers/signing_root.go
+++ b/beacon-chain/core/helpers/signing_root.go
@@ -23,6 +23,19 @@ const DomainByteLength = 4
 // failed to verify.
 var ErrSigFailedToVerify = errors.New("signature did not verify")

+// ComputeDomainAndSign computes the domain and signing root and sign it using the passed in private key.
+func ComputeDomainAndSign(state *state.BeaconState, epoch uint64, obj interface{}, domain [4]byte, key bls.SecretKey) ([]byte, error) {
+	d, err := Domain(state.Fork(), epoch, domain, state.GenesisValidatorRoot())
+	if err != nil {
+		return nil, err
+	}
+	sr, err := ComputeSigningRoot(obj, d)
+	if err != nil {
+		return nil, err
+	}
+	return key.Sign(sr[:]).Marshal(), nil
+}
+
 // ComputeSigningRoot computes the root of the object by calculating the hash tree root of the signing data with the given domain.
 //
 // Spec pseudocode definition:
--- a/beacon-chain/core/state/BUILD.bazel
+++ b/beacon-chain/core/state/BUILD.bazel
@@ -73,6 +73,7 @@ go_test(
        "//shared/hashutil:go_default_library",
        "//shared/params:go_default_library",
        "//shared/testutil:go_default_library",
+        "//shared/testutil/require:go_default_library",
        "//shared/trieutil:go_default_library",
        "@com_github_gogo_protobuf//proto:go_default_library",
        "@com_github_google_gofuzz//:go_default_library",
--- a/beacon-chain/core/state/transition_test.go
+++ b/beacon-chain/core/state/transition_test.go
@@ -22,6 +22,7 @@ import (
 	"github.com/prysmaticlabs/prysm/shared/hashutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	"github.com/prysmaticlabs/prysm/shared/trieutil"
 	"github.com/sirupsen/logrus"
 )
@@ -252,16 +253,8 @@ func TestProcessBlock_IncorrectProposerSlashing(t *testing.T) {
 	if err := beaconState.SetSlot(beaconState.Slot() - 1); err != nil {
 		t.Fatal(err)
 	}
-	domain, err := helpers.Domain(beaconState.Fork(), helpers.CurrentEpoch(beaconState), params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatal(err)
-	}
-	root, err := helpers.ComputeSigningRoot(block.Block, domain)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sig := privKeys[proposerIdx].Sign(root[:])
-	block.Signature = sig.Marshal()
+	block.Signature, err = helpers.ComputeDomainAndSign(beaconState, helpers.CurrentEpoch(beaconState), block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
+	require.NoError(t, err)

 	beaconState, err = state.ProcessSlots(context.Background(), beaconState, 1)
 	if err != nil {
@@ -300,16 +293,8 @@ func TestProcessBlock_IncorrectProcessBlockAttestations(t *testing.T) {
 	if err := beaconState.SetSlot(beaconState.Slot() - 1); err != nil {
 		t.Fatal(err)
 	}
-	domain, err := helpers.Domain(beaconState.Fork(), helpers.CurrentEpoch(beaconState), params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatal(err)
-	}
-	root, err := helpers.ComputeSigningRoot(block.Block, domain)
-	if err != nil {
-		t.Fatal(err)
-	}
-	sig := privKeys[proposerIdx].Sign(root[:])
-	block.Signature = sig.Marshal()
+	block.Signature, err = helpers.ComputeDomainAndSign(beaconState, helpers.CurrentEpoch(beaconState), block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
+	require.NoError(t, err)

 	beaconState, err = state.ProcessSlots(context.Background(), beaconState, 1)
 	if err != nil {
@@ -472,16 +457,6 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
 	}

 	currentEpoch := helpers.CurrentEpoch(beaconState)
-	domain, err := helpers.Domain(
-		beaconState.Fork(),
-		currentEpoch,
-		params.BeaconConfig().DomainBeaconProposer,
-		beaconState.GenesisValidatorRoot(),
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-
 	header1 := &ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
 			ProposerIndex: proposerSlashIdx,
@@ -489,11 +464,8 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
 			StateRoot:     []byte("A"),
 		},
 	}
-	root, err := helpers.ComputeSigningRoot(header1.Header, domain)
-	if err != nil {
-		t.Fatal(err)
-	}
-	header1.Signature = privKeys[proposerSlashIdx].Sign(root[:]).Marshal()[:]
+	header1.Signature, err = helpers.ComputeDomainAndSign(beaconState, currentEpoch, header1.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerSlashIdx])
+	require.NoError(t, err)

 	header2 := &ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
@@ -502,11 +474,8 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
 			StateRoot:     []byte("B"),
 		},
 	}
-	root, err = helpers.ComputeSigningRoot(header2.Header, domain)
-	if err != nil {
-		t.Fatal(err)
-	}
-	header2.Signature = privKeys[proposerSlashIdx].Sign(root[:]).Marshal()[:]
+	header2.Signature, err = helpers.ComputeDomainAndSign(beaconState, helpers.CurrentEpoch(beaconState), header2.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerSlashIdx])
+	require.NoError(t, err)

 	proposerSlashings := []*ethpb.ProposerSlashing{
 		{
@@ -527,7 +496,7 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
 			Target: &ethpb.Checkpoint{Epoch: 0}},
 		AttestingIndices: []uint64{0, 1},
 	}
-	domain, err = helpers.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
+	domain, err := helpers.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -610,15 +579,8 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
 			Epoch:          0,
 		},
 	}
-	domain, err = helpers.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainVoluntaryExit, beaconState.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatal(err)
-	}
-	signingRoot, err := helpers.ComputeSigningRoot(exit.Exit, domain)
-	if err != nil {
-		t.Errorf("Could not get signing root of beacon block header: %v", err)
-	}
-	exit.Signature = privKeys[exit.Exit.ValidatorIndex].Sign(signingRoot[:]).Marshal()[:]
+	exit.Signature, err = helpers.ComputeDomainAndSign(beaconState, currentEpoch, exit.Exit, params.BeaconConfig().DomainVoluntaryExit, privKeys[exit.Exit.ValidatorIndex])
+	require.NoError(t, err)

 	header := beaconState.LatestBlockHeader()
 	prevStateRoot, err := beaconState.HashTreeRoot(context.Background())
--- a/beacon-chain/rpc/validator/aggregator_test.go
+++ b/beacon-chain/rpc/validator/aggregator_test.go
@@ -229,21 +229,20 @@ func generateAtt(state *beaconstate.BeaconState, index uint64, privKeys []bls.Se
 		return nil, err
 	}
 	attestingIndices := attestationutil.AttestingIndices(att.AggregationBits, committee)
-	domain, err := helpers.Domain(state.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, params.BeaconConfig().ZeroHash[:])
-	if err != nil {
-		return nil, err
-	}

 	sigs := make([]bls.Signature, len(attestingIndices))
 	zeroSig := [96]byte{}
 	att.Signature = zeroSig[:]

 	for i, indice := range attestingIndices {
-		hashTreeRoot, err := helpers.ComputeSigningRoot(att.Data, domain)
+		sb, err := helpers.ComputeDomainAndSign(state, 0, att.Data, params.BeaconConfig().DomainBeaconAttester, privKeys[indice])
+		if err != nil {
+			return nil, err
+		}
+		sig, err := bls.SignatureFromBytes(sb)
 		if err != nil {
 			return nil, err
 		}
-		sig := privKeys[indice].Sign(hashTreeRoot[:])
 		sigs[i] = sig
 	}

--- a/beacon-chain/rpc/validator/exit_test.go
+++ b/beacon-chain/rpc/validator/exit_test.go
@@ -64,11 +64,8 @@ func TestSub(t *testing.T) {
 			ValidatorIndex: validatorIndex,
 		},
 	}
-	domain, err := helpers.Domain(beaconState.Fork(), epoch, params.BeaconConfig().DomainVoluntaryExit, beaconState.GenesisValidatorRoot())
+	req.Signature, err = helpers.ComputeDomainAndSign(beaconState, epoch, req.Exit, params.BeaconConfig().DomainVoluntaryExit, keys[0])
 	require.NoError(t, err)
-	sigRoot, err := helpers.ComputeSigningRoot(req.Exit, domain)
-	require.NoError(t, err, "Could not compute signing root")
-	req.Signature = keys[0].Sign(sigRoot[:]).Marshal()

 	_, err = server.ProposeExit(context.Background(), req)
 	require.NoError(t, err)
@@ -144,13 +141,8 @@ func TestProposeExit_NoPanic(t *testing.T) {

 	_, err = server.ProposeExit(context.Background(), req)
 	require.ErrorContains(t, "invalid signature provided", err, "Expected error for invalid signature length")
-
-	domain, err := helpers.Domain(beaconState.Fork(), epoch, params.BeaconConfig().DomainVoluntaryExit, beaconState.GenesisValidatorRoot())
+	req.Signature, err = helpers.ComputeDomainAndSign(beaconState, epoch, req.Exit, params.BeaconConfig().DomainVoluntaryExit, keys[0])
 	require.NoError(t, err)
-	sigRoot, err := helpers.ComputeSigningRoot(req.Exit, domain)
-	require.NoError(t, err, "Could not compute signing root")
-	req.Signature = keys[0].Sign(sigRoot[:]).Marshal()
-
 	_, err = server.ProposeExit(context.Background(), req)
 	require.NoError(t, err)
 }
--- a/beacon-chain/rpc/validator/proposer_test.go
+++ b/beacon-chain/rpc/validator/proposer_test.go
@@ -297,12 +297,8 @@ func TestComputeStateRoot_OK(t *testing.T) {
 	require.NoError(t, beaconState.SetSlot(beaconState.Slot()-1))
 	req.Block.Body.RandaoReveal = randaoReveal[:]
 	currentEpoch := helpers.CurrentEpoch(beaconState)
-	domain, err := helpers.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	req.Signature, err = helpers.ComputeDomainAndSign(beaconState, currentEpoch, req.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
 	require.NoError(t, err)
-	signingRoot, err := helpers.ComputeSigningRoot(req.Block, domain)
-	require.NoError(t, err)
-	blockSig := privKeys[proposerIdx].Sign(signingRoot[:]).Marshal()
-	req.Signature = blockSig[:]

 	_, err = proposerServer.computeStateRoot(context.Background(), req)
 	require.NoError(t, err)
--- a/beacon-chain/sync/pending_attestations_queue_test.go
+++ b/beacon-chain/sync/pending_attestations_queue_test.go
@@ -134,23 +134,17 @@ func TestProcessPendingAtts_HasBlockSaveAggregatedAtt(t *testing.T) {
 	}
 	att.Signature = bls.AggregateSignatures(sigs).Marshal()[:]

-	selectionDomain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainSelectionProof, beaconState.GenesisValidatorRoot())
-	require.NoError(t, err)
-	slotRoot, err := helpers.ComputeSigningRoot(att.Data.Slot, selectionDomain)
-	require.NoError(t, err)
 	// Arbitrary aggregator index for testing purposes.
 	aggregatorIndex := committee[0]
-	sig := privKeys[aggregatorIndex].Sign(slotRoot[:])
+	sig, err := helpers.ComputeDomainAndSign(beaconState, 0, att.Data.Slot, params.BeaconConfig().DomainSelectionProof, privKeys[aggregatorIndex])
+	require.NoError(t, err)
 	aggregateAndProof := &ethpb.AggregateAttestationAndProof{
-		SelectionProof:  sig.Marshal(),
+		SelectionProof:  sig,
 		Aggregate:       att,
 		AggregatorIndex: aggregatorIndex,
 	}
-	attesterDomain, err = helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainAggregateAndProof, beaconState.GenesisValidatorRoot())
+	aggreSig, err := helpers.ComputeDomainAndSign(beaconState, 0, aggregateAndProof, params.BeaconConfig().DomainAggregateAndProof, privKeys[aggregatorIndex])
 	require.NoError(t, err)
-	signingRoot, err := helpers.ComputeSigningRoot(aggregateAndProof, attesterDomain)
-	assert.NoError(t, err)
-	aggreSig := privKeys[aggregatorIndex].Sign(signingRoot[:]).Marshal()

 	require.NoError(t, beaconState.SetGenesisTime(uint64(time.Now().Unix())))

--- a/beacon-chain/sync/subscriber_beacon_attestation_test.go
+++ b/beacon-chain/sync/subscriber_beacon_attestation_test.go
@@ -83,14 +83,10 @@ func TestService_committeeIndexBeaconAttestationSubscriber_ValidMessage(t *testi
 		},
 		AggregationBits: bitfield.Bitlist{0b0101},
 	}
-	domain, err := helpers.Domain(s.Fork(), att.Data.Target.Epoch, params.BeaconConfig().DomainBeaconAttester, s.GenesisValidatorRoot())
-	require.NoError(t, err)
-	attRoot, err := helpers.ComputeSigningRoot(att.Data, domain)
-	require.NoError(t, err)
 	committee, err := helpers.BeaconCommitteeFromState(s, att.Data.Slot, att.Data.CommitteeIndex)
 	require.NoError(t, err)
-	att.Signature = sKeys[committee[0]].Sign(attRoot[:]).Marshal()
-
+	att.Signature, err = helpers.ComputeDomainAndSign(s, att.Data.Target.Epoch, att.Data, params.BeaconConfig().DomainBeaconAttester, sKeys[committee[0]])
+	require.NoError(t, err)
 	p.ReceivePubSub("/eth2/%x/beacon_attestation_0", att)

 	time.Sleep(time.Second * 1)
--- a/beacon-chain/sync/validate_aggregate_proof_test.go
+++ b/beacon-chain/sync/validate_aggregate_proof_test.go
@@ -110,12 +110,9 @@ func TestVerifySelection_CanVerify(t *testing.T) {
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, validators)

 	data := &ethpb.AttestationData{}
-	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainSelectionProof, beaconState.GenesisValidatorRoot())
+	sig, err := helpers.ComputeDomainAndSign(beaconState, 0, data.Slot, params.BeaconConfig().DomainSelectionProof, privKeys[0])
 	require.NoError(t, err)
-	slotRoot, err := helpers.ComputeSigningRoot(data.Slot, domain)
-	require.NoError(t, err)
-	sig := privKeys[0].Sign(slotRoot[:])
-	require.NoError(t, validateSelection(ctx, beaconState, data, 0, sig.Marshal()))
+	require.NoError(t, validateSelection(ctx, beaconState, data, 0, sig))
 }

 func TestValidateAggregateAndProof_NoBlock(t *testing.T) {
@@ -359,27 +356,17 @@ func TestValidateAggregateAndProofWithNewStateMgmt_CanValidate(t *testing.T) {
 		sigs[i] = sig
 	}
 	att.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
-
-	selectionDomain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainSelectionProof, beaconState.GenesisValidatorRoot())
-	require.NoError(t, err)
-	slotRoot, err := helpers.ComputeSigningRoot(att.Data.Slot, selectionDomain)
-	require.NoError(t, err)
-
 	ai := committee[0]
-	sig := privKeys[ai].Sign(slotRoot[:])
+	sig, err := helpers.ComputeDomainAndSign(beaconState, 0, att.Data.Slot, params.BeaconConfig().DomainSelectionProof, privKeys[ai])
+	require.NoError(t, err)
 	aggregateAndProof := &ethpb.AggregateAttestationAndProof{
-		SelectionProof:  sig.Marshal(),
+		SelectionProof:  sig,
 		Aggregate:       att,
 		AggregatorIndex: ai,
 	}
 	signedAggregateAndProof := &ethpb.SignedAggregateAttestationAndProof{Message: aggregateAndProof}
-
-	attesterDomain, err = helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainAggregateAndProof, beaconState.GenesisValidatorRoot())
+	signedAggregateAndProof.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, signedAggregateAndProof.Message, params.BeaconConfig().DomainAggregateAndProof, privKeys[ai])
 	require.NoError(t, err)
-	signingRoot, err := helpers.ComputeSigningRoot(signedAggregateAndProof.Message, attesterDomain)
-	require.NoError(t, err)
-	aggreSig := privKeys[ai].Sign(signingRoot[:]).Marshal()
-	signedAggregateAndProof.Signature = aggreSig[:]

 	require.NoError(t, beaconState.SetGenesisTime(uint64(time.Now().Unix())))
 	c, err := lru.New(10)
@@ -456,28 +443,17 @@ func TestVerifyIndexInCommittee_SeenAggregatorEpoch(t *testing.T) {
 		sigs[i] = sig
 	}
 	att.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
-
-	selectionDomain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainSelectionProof, beaconState.GenesisValidatorRoot())
-	require.NoError(t, err)
-	slotRoot, err := helpers.ComputeSigningRoot(att.Data.Slot, selectionDomain)
-	require.NoError(t, err)
-
 	ai := committee[0]
-	sig := privKeys[ai].Sign(slotRoot[:])
+	sig, err := helpers.ComputeDomainAndSign(beaconState, 0, att.Data.Slot, params.BeaconConfig().DomainSelectionProof, privKeys[ai])
+	require.NoError(t, err)
 	aggregateAndProof := &ethpb.AggregateAttestationAndProof{
-		SelectionProof:  sig.Marshal(),
+		SelectionProof:  sig,
 		Aggregate:       att,
 		AggregatorIndex: ai,
 	}
 	signedAggregateAndProof := &ethpb.SignedAggregateAttestationAndProof{Message: aggregateAndProof}
-
-	attesterDomain, err = helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainAggregateAndProof, beaconState.GenesisValidatorRoot())
+	signedAggregateAndProof.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, signedAggregateAndProof.Message, params.BeaconConfig().DomainAggregateAndProof, privKeys[ai])
 	require.NoError(t, err)
-	signingRoot, err := helpers.ComputeSigningRoot(signedAggregateAndProof.Message, attesterDomain)
-	assert.NoError(t, err)
-	aggreSig := privKeys[ai].Sign(signingRoot[:]).Marshal()
-	signedAggregateAndProof.Signature = aggreSig[:]
-
 	require.NoError(t, beaconState.SetGenesisTime(uint64(time.Now().Unix())))

 	c, err := lru.New(10)
@@ -577,27 +553,18 @@ func TestValidateAggregateAndProof_BadBlock(t *testing.T) {
 		sigs[i] = sig
 	}
 	att.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
-
-	selectionDomain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainSelectionProof, beaconState.GenesisValidatorRoot())
-	require.NoError(t, err)
-	slotRoot, err := helpers.ComputeSigningRoot(att.Data.Slot, selectionDomain)
-	require.NoError(t, err)
-
 	ai := committee[0]
-	sig := privKeys[ai].Sign(slotRoot[:])
+	sig, err := helpers.ComputeDomainAndSign(beaconState, 0, att.Data.Slot, params.BeaconConfig().DomainSelectionProof, privKeys[ai])
+	require.NoError(t, err)
+
 	aggregateAndProof := &ethpb.AggregateAttestationAndProof{
-		SelectionProof:  sig.Marshal(),
+		SelectionProof:  sig,
 		Aggregate:       att,
 		AggregatorIndex: ai,
 	}
 	signedAggregateAndProof := &ethpb.SignedAggregateAttestationAndProof{Message: aggregateAndProof}
-
-	attesterDomain, err = helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainAggregateAndProof, beaconState.GenesisValidatorRoot())
+	signedAggregateAndProof.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, signedAggregateAndProof.Message, params.BeaconConfig().DomainAggregateAndProof, privKeys[ai])
 	require.NoError(t, err)
-	signingRoot, err := helpers.ComputeSigningRoot(signedAggregateAndProof.Message, attesterDomain)
-	require.NoError(t, err)
-	aggreSig := privKeys[ai].Sign(signingRoot[:]).Marshal()
-	signedAggregateAndProof.Signature = aggreSig[:]

 	require.NoError(t, beaconState.SetGenesisTime(uint64(time.Now().Unix())))
 	c, err := lru.New(10)
--- a/beacon-chain/sync/validate_beacon_blocks_test.go
+++ b/beacon-chain/sync/validate_beacon_blocks_test.go
@@ -155,13 +155,8 @@ func TestValidateBeaconBlockPubSub_ValidProposerSignature(t *testing.T) {
 			ParentRoot:    bRoot[:],
 		},
 	}
-
-	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	msg.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, msg.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
 	require.NoError(t, err)
-	signingRoot, err := helpers.ComputeSigningRoot(msg.Block, domain)
-	require.NoError(t, err)
-	blockSig := privKeys[proposerIdx].Sign(signingRoot[:]).Marshal()
-	msg.Signature = blockSig[:]

 	c, err := lru.New(10)
 	require.NoError(t, err)
@@ -232,13 +227,8 @@ func TestValidateBeaconBlockPubSub_AdvanceEpochsForState(t *testing.T) {
 			ParentRoot:    bRoot[:],
 		},
 	}
-
-	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	msg.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, msg.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
 	require.NoError(t, err)
-	signingRoot, err := helpers.ComputeSigningRoot(msg.Block, domain)
-	require.NoError(t, err)
-	blockSig := privKeys[proposerIdx].Sign(signingRoot[:]).Marshal()
-	msg.Signature = blockSig[:]

 	c, err := lru.New(10)
 	require.NoError(t, err)
@@ -445,13 +435,8 @@ func TestValidateBeaconBlockPubSub_SeenProposerSlot(t *testing.T) {
 			ParentRoot:    bRoot[:],
 		},
 	}
-
-	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	msg.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, msg.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
 	require.NoError(t, err)
-	signingRoot, err := helpers.ComputeSigningRoot(msg.Block, domain)
-	require.NoError(t, err)
-	blockSig := privKeys[proposerIdx].Sign(signingRoot[:]).Marshal()
-	msg.Signature = blockSig[:]

 	c, err := lru.New(10)
 	require.NoError(t, err)
@@ -584,13 +569,8 @@ func TestValidateBeaconBlockPubSub_ParentNotFinalizedDescendant(t *testing.T) {
 			ParentRoot:    bRoot[:],
 		},
 	}
-
-	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
+	msg.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, msg.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
 	require.NoError(t, err)
-	signingRoot, err := helpers.ComputeSigningRoot(msg.Block, domain)
-	require.NoError(t, err)
-	blockSig := privKeys[proposerIdx].Sign(signingRoot[:]).Marshal()
-	msg.Signature = blockSig[:]

 	c, err := lru.New(10)
 	require.NoError(t, err)
@@ -659,16 +639,11 @@ func TestValidateBeaconBlockPubSub_InvalidParentBlock(t *testing.T) {
 			ParentRoot:    bRoot[:],
 		},
 	}
+	msg.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, msg.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
+	require.NoError(t, err)

-	domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
-	require.NoError(t, err)
-	signingRoot, err := helpers.ComputeSigningRoot(msg.Block, domain)
-	require.NoError(t, err)
-	blockSig := privKeys[proposerIdx].Sign(signingRoot[:]).Marshal()
 	// Mutate Signature
-	copy(blockSig[:4], []byte{1, 2, 3, 4})
-	msg.Signature = blockSig
-
+	copy(msg.Signature[:4], []byte{1, 2, 3, 4})
 	currBlockRoot, err := stateutil.BlockRoot(msg.Block)
 	require.NoError(t, err)

--- a/beacon-chain/sync/validate_proposer_slashing_test.go
+++ b/beacon-chain/sync/validate_proposer_slashing_test.go
@@ -61,15 +61,7 @@ func setupValidProposerSlashing(t *testing.T) (*ethpb.ProposerSlashing, *stateTr
 	})
 	require.NoError(t, err)

-	domain, err := helpers.Domain(
-		state.Fork(),
-		helpers.CurrentEpoch(state),
-		params.BeaconConfig().DomainBeaconProposer,
-		state.GenesisValidatorRoot(),
-	)
-	require.NoError(t, err)
 	privKey := bls.RandKey()
-
 	someRoot := [32]byte{1, 2, 3}
 	someRoot2 := [32]byte{4, 5, 6}
 	header1 := &ethpb.SignedBeaconBlockHeader{
@@ -81,9 +73,8 @@ func setupValidProposerSlashing(t *testing.T) (*ethpb.ProposerSlashing, *stateTr
 			BodyRoot:      someRoot[:],
 		},
 	}
-	signingRoot, err := helpers.ComputeSigningRoot(header1.Header, domain)
-	assert.NoError(t, err, "Could not get signing root of beacon block header")
-	header1.Signature = privKey.Sign(signingRoot[:]).Marshal()[:]
+	header1.Signature, err = helpers.ComputeDomainAndSign(state, helpers.CurrentEpoch(state), header1.Header, params.BeaconConfig().DomainBeaconProposer, privKey)
+	require.NoError(t, err)

 	header2 := &ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
@@ -94,9 +85,8 @@ func setupValidProposerSlashing(t *testing.T) (*ethpb.ProposerSlashing, *stateTr
 			BodyRoot:      someRoot2[:],
 		},
 	}
-	signingRoot, err = helpers.ComputeSigningRoot(header2.Header, domain)
-	assert.NoError(t, err, "Could not get signing root of beacon block header")
-	header2.Signature = privKey.Sign(signingRoot[:]).Marshal()[:]
+	header2.Signature, err = helpers.ComputeDomainAndSign(state, helpers.CurrentEpoch(state), header2.Header, params.BeaconConfig().DomainBeaconProposer, privKey)
+	require.NoError(t, err)

 	slashing := &ethpb.ProposerSlashing{
 		Header_1: header1,
--- a/beacon-chain/sync/validate_voluntary_exit_test.go
+++ b/beacon-chain/sync/validate_voluntary_exit_test.go
@@ -48,14 +48,10 @@ func setupValidExit(t *testing.T) (*ethpb.SignedVoluntaryExit, *stateTrie.Beacon
 	require.NoError(t, err)
 	err = state.SetSlot(state.Slot() + (params.BeaconConfig().ShardCommitteePeriod * params.BeaconConfig().SlotsPerEpoch))
 	require.NoError(t, err)
-	domain, err := helpers.Domain(state.Fork(), helpers.CurrentEpoch(state), params.BeaconConfig().DomainVoluntaryExit, state.GenesisValidatorRoot())
-	require.NoError(t, err)
-	signingRoot, err := helpers.ComputeSigningRoot(exit.Exit, domain)
-	require.NoError(t, err)
-	priv := bls.RandKey()

-	sig := priv.Sign(signingRoot[:])
-	exit.Signature = sig.Marshal()
+	priv := bls.RandKey()
+	exit.Signature, err = helpers.ComputeDomainAndSign(state, helpers.CurrentEpoch(state), exit.Exit, params.BeaconConfig().DomainVoluntaryExit, priv)
+	require.NoError(t, err)

 	val, err := state.ValidatorAtIndex(0)
 	require.NoError(t, err)
--- a/shared/testutil/BUILD.bazel
+++ b/shared/testutil/BUILD.bazel
@@ -58,5 +58,6 @@ go_test(
        "//proto/beacon/p2p/v1:go_default_library",
        "//shared/bytesutil:go_default_library",
        "//shared/params:go_default_library",
+        "//shared/testutil/require:go_default_library",
    ],
 )
--- a/shared/testutil/block.go
+++ b/shared/testutil/block.go
@@ -197,15 +197,11 @@ func GenerateProposerSlashingForValidator(
 		},
 	}
 	currentEpoch := helpers.CurrentEpoch(bState)
-	domain, err := helpers.Domain(bState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, bState.GenesisValidatorRoot())
+	var err error
+	header1.Signature, err = helpers.ComputeDomainAndSign(bState, currentEpoch, header1.Header, params.BeaconConfig().DomainBeaconProposer, priv)
 	if err != nil {
 		return nil, err
 	}
-	root, err := helpers.ComputeSigningRoot(header1.Header, domain)
-	if err != nil {
-		return nil, err
-	}
-	header1.Signature = priv.Sign(root[:]).Marshal()

 	header2 := &ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
@@ -216,11 +212,10 @@ func GenerateProposerSlashingForValidator(
 			ParentRoot:    make([]byte, 32),
 		},
 	}
-	root, err = helpers.ComputeSigningRoot(header2.Header, domain)
+	header2.Signature, err = helpers.ComputeDomainAndSign(bState, currentEpoch, header2.Header, params.BeaconConfig().DomainBeaconProposer, priv)
 	if err != nil {
 		return nil, err
 	}
-	header2.Signature = priv.Sign(root[:]).Marshal()

 	return &ethpb.ProposerSlashing{
 		Header_1: header1,
@@ -271,16 +266,11 @@ func GenerateAttesterSlashingForValidator(
 		},
 		AttestingIndices: []uint64{idx},
 	}
-	domain, err := helpers.Domain(bState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconAttester, bState.GenesisValidatorRoot())
+	var err error
+	att1.Signature, err = helpers.ComputeDomainAndSign(bState, currentEpoch, att1.Data, params.BeaconConfig().DomainBeaconAttester, priv)
 	if err != nil {
 		return nil, err
 	}
-	dataRoot, err := helpers.ComputeSigningRoot(att1.Data, domain)
-	if err != nil {
-		return nil, err
-	}
-	sig := priv.Sign(dataRoot[:])
-	att1.Signature = bls.AggregateSignatures([]bls.Signature{sig}).Marshal()

 	att2 := &ethpb.IndexedAttestation{
 		Data: &ethpb.AttestationData{
@@ -297,12 +287,10 @@ func GenerateAttesterSlashingForValidator(
 		},
 		AttestingIndices: []uint64{idx},
 	}
-	dataRoot, err = helpers.ComputeSigningRoot(att2.Data, domain)
+	att2.Signature, err = helpers.ComputeDomainAndSign(bState, currentEpoch, att2.Data, params.BeaconConfig().DomainBeaconAttester, priv)
 	if err != nil {
 		return nil, err
 	}
-	sig = priv.Sign(dataRoot[:])
-	att2.Signature = bls.AggregateSignatures([]bls.Signature{sig}).Marshal()

 	return &ethpb.AttesterSlashing{
 		Attestation_1: att1,
@@ -510,15 +498,10 @@ func generateVoluntaryExits(
 				ValidatorIndex: valIndex,
 			},
 		}
-		domain, err := helpers.Domain(bState.Fork(), currentEpoch, params.BeaconConfig().DomainVoluntaryExit, bState.GenesisValidatorRoot())
+		exit.Signature, err = helpers.ComputeDomainAndSign(bState, currentEpoch, exit.Exit, params.BeaconConfig().DomainVoluntaryExit, privs[valIndex])
 		if err != nil {
 			return nil, err
 		}
-		root, err := helpers.ComputeSigningRoot(exit.Exit, domain)
-		if err != nil {
-			return nil, err
-		}
-		exit.Signature = privs[valIndex].Sign(root[:]).Marshal()
 		voluntaryExits[i] = exit
 	}
 	return voluntaryExits, nil
--- a/shared/testutil/helpers.go
+++ b/shared/testutil/helpers.go
@@ -24,17 +24,9 @@ func RandaoReveal(beaconState *stateTrie.BeaconState, epoch uint64, privKeys []b
 	}
 	buf := make([]byte, 32)
 	binary.LittleEndian.PutUint64(buf, epoch)
-	domain, err := helpers.Domain(beaconState.Fork(), epoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorRoot())
-	if err != nil {
-		return nil, err
-	}
-	root, err := helpers.ComputeSigningRoot(epoch, domain)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not compute signing root of epoch")
-	}
+
 	// We make the previous validator's index sign the message instead of the proposer.
-	epochSignature := privKeys[proposerIdx].Sign(root[:])
-	return epochSignature.Marshal(), nil
+	return helpers.ComputeDomainAndSign(beaconState, epoch, epoch, params.BeaconConfig().DomainRandao, privKeys[proposerIdx])
 }

 // BlockSignature calculates the post-state root of the block and returns the signature.
--- a/shared/testutil/helpers_test.go
+++ b/shared/testutil/helpers_test.go
@@ -7,6 +7,7 @@ import (

 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/shared/params"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )

 func TestBlockSignature(t *testing.T) {
@@ -28,16 +29,8 @@ func TestBlockSignature(t *testing.T) {
 		t.Error(err)
 	}
 	epoch := helpers.SlotToEpoch(block.Block.Slot)
-	domain, err := helpers.Domain(beaconState.Fork(), epoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatal(err)
-	}
-	signingRoot, err := helpers.ComputeSigningRoot(block.Block, domain)
-	if err != nil {
-		t.Error(err)
-	}
-
-	blockSig := privKeys[proposerIdx].Sign(signingRoot[:]).Marshal()
+	blockSig, err := helpers.ComputeDomainAndSign(beaconState, epoch, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
+	require.NoError(t, err)

 	signature, err := BlockSignature(beaconState, block.Block, privKeys)
 	if err != nil {
@@ -64,16 +57,10 @@ func TestRandaoReveal(t *testing.T) {
 	}
 	buf := make([]byte, 32)
 	binary.LittleEndian.PutUint64(buf, epoch)
-	domain, err := helpers.Domain(beaconState.Fork(), epoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorRoot())
-	if err != nil {
-		t.Fatal(err)
-	}
-	root, err := helpers.ComputeSigningRoot(epoch, domain)
-	if err != nil {
-		t.Fatal(err)
-	}
+
 	// We make the previous validator's index sign the message instead of the proposer.
-	epochSignature := privKeys[proposerIdx].Sign(root[:]).Marshal()
+	epochSignature, err := helpers.ComputeDomainAndSign(beaconState, epoch, epoch, params.BeaconConfig().DomainRandao, privKeys[proposerIdx])
+	require.NoError(t, err)

 	if !bytes.Equal(randaoReveal[:], epochSignature[:]) {
 		t.Errorf("Expected randao reveals to be equal, received %#x != %#x", randaoReveal[:], epochSignature[:])
--- a/slasher/rpc/server_test.go
+++ b/slasher/rpc/server_test.go
@@ -287,9 +287,7 @@ func TestServer_IsSlashableBlock(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-	blockSig := keys[incomingBlock.Header.ProposerIndex].Sign(root[:])
-	marshalledSig := blockSig.Marshal()
-	incomingBlock.Signature = marshalledSig
+	incomingBlock.Signature = keys[incomingBlock.Header.ProposerIndex].Sign(root[:]).Marshal()

 	savedBlockEpoch := helpers.SlotToEpoch(savedBlock.Header.Slot)
 	domain, err = helpers.Domain(fork, savedBlockEpoch, params.BeaconConfig().DomainBeaconProposer, wantedGenesis.GenesisValidatorsRoot)
@@ -304,9 +302,7 @@ func TestServer_IsSlashableBlock(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-	blockSig = keys[savedBlock.Header.ProposerIndex].Sign(root[:])
-	marshalledSig = blockSig.Marshal()
-	savedBlock.Signature = marshalledSig
+	savedBlock.Signature = keys[savedBlock.Header.ProposerIndex].Sign(root[:]).Marshal()
 	bcCfg := &beaconclient.Config{BeaconClient: bClient, NodeClient: nClient, SlasherDB: db}
 	bs, err := beaconclient.NewBeaconClientService(ctx, bcCfg)
 	ds := detection.NewDetectionService(ctx, cfg)
--- a/tools/benchmark-files-gen/main.go
+++ b/tools/benchmark-files-gen/main.go
@@ -134,7 +134,6 @@ func generateMarshalledFullStateAndBlock() error {
 	block.Block.StateRoot = s[:]
 	// Temporarily incrementing the beacon state slot here since BeaconProposerIndex is a
 	// function deterministic on beacon state slot.
-	root := beaconState.GenesisValidatorRoot()
 	if err := beaconState.SetSlot(beaconState.Slot() + 1); err != nil {
 		return err
 	}
@@ -142,15 +141,10 @@ func generateMarshalledFullStateAndBlock() error {
 	if err != nil {
 		return err
 	}
-	domain, err := helpers.Domain(beaconState.Fork(), helpers.CurrentEpoch(beaconState), params.BeaconConfig().DomainBeaconProposer, root)
+	block.Signature, err = helpers.ComputeDomainAndSign(beaconState, helpers.CurrentEpoch(beaconState), block.Block, params.BeaconConfig().DomainBeaconProposer, privs[proposerIdx])
 	if err != nil {
 		return err
 	}
-	blockRoot, err := helpers.ComputeSigningRoot(block.Block, domain)
-	if err != nil {
-		return errors.Wrap(err, "could not get signing root of block")
-	}
-	block.Signature = privs[proposerIdx].Sign(blockRoot[:]).Marshal()
 	if err := beaconState.SetSlot(beaconState.Slot() - 1); err != nil {
 		return err
 	}