Custom Method For Block Signing Root

beacon-chain/core/blocks/block_operations.go

@@ -223,7 +223,7 @@ func VerifyBlockHeaderSignature(beaconState *stateTrie.BeaconState, block *ethpb
 	if err != nil {
 		return err
 	}
-	return helpers.VerifySigningRoot(block.Block, proposer.PublicKey, block.Signature, domain)
+	return helpers.VerifyBlockSigningRoot(block.Block, proposer.PublicKey, block.Signature, domain)
 }
 
 // ProcessBlockHeaderNoVerify validates a block by its header but skips proposer

beacon-chain/core/helpers/BUILD.bazel

@@ -29,6 +29,7 @@ go_library(
     deps = [
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/stateutil:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/bls:go_default_library",
         "//shared/bytesutil:go_default_library",
@@ -61,10 +62,12 @@ go_test(
     shard_count = 2,
     deps = [
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/stateutil:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/attestationutil:go_default_library",
         "//shared/bls:go_default_library",
         "//shared/bytesutil:go_default_library",
+        "//shared/featureconfig:go_default_library",
         "//shared/hashutil:go_default_library",
         "//shared/params:go_default_library",
         "//shared/sliceutil:go_default_library",

beacon-chain/core/helpers/signing_root.go

@@ -2,7 +2,9 @@ package helpers
 
 import (
 	"github.com/pkg/errors"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/go-ssz"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	p2ppb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bls"
@@ -33,7 +35,16 @@ var ErrSigFailedToVerify = errors.New("signature did not verify")
 //    )
 //    return hash_tree_root(domain_wrapped_object)
 func ComputeSigningRoot(object interface{}, domain []byte) ([32]byte, error) {
-	objRoot, err := ssz.HashTreeRoot(object)
+	// utilise generic ssz library
+	return signingRoot(func() ([32]byte, error) {
+		return ssz.HashTreeRoot(object)
+	}, domain)
+}
+
+// Computes the signing root by utilising the provided root function and then
+// returning the signing root of the container object.
+func signingRoot(rootFunc func() ([32]byte, error), domain []byte) ([32]byte, error) {
+	objRoot, err := rootFunc()
 	if err != nil {
 		return [32]byte{}, err
 	}
@@ -64,6 +75,29 @@ func VerifySigningRoot(obj interface{}, pub []byte, signature []byte, domain []b
 	return nil
 }
 
+// VerifyBlockSigningRoot verifies the signing root of a block given it's public key, signature and domain.
+func VerifyBlockSigningRoot(blk *ethpb.BeaconBlock, pub []byte, signature []byte, domain []byte) error {
+	publicKey, err := bls.PublicKeyFromBytes(pub)
+	if err != nil {
+		return errors.Wrap(err, "could not convert bytes to public key")
+	}
+	sig, err := bls.SignatureFromBytes(signature)
+	if err != nil {
+		return errors.Wrap(err, "could not convert bytes to signature")
+	}
+	root, err := signingRoot(func() ([32]byte, error) {
+		// utilize custom block hashing function
+		return stateutil.BlockRoot(blk)
+	}, domain)
+	if err != nil {
+		return errors.Wrap(err, "could not compute signing root")
+	}
+	if !sig.Verify(root[:], publicKey) {
+		return ErrSigFailedToVerify
+	}
+	return nil
+}
+
 // ComputeDomain returns the domain version for BLS private key to sign and verify with a zeroed 4-byte
 // array as the fork version.
 //

beacon-chain/core/helpers/signing_root_test.go

@@ -6,7 +6,9 @@ import (
 
 	fuzz "github.com/google/gofuzz"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
 	ethereum_beacon_p2p_v1 "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
@@ -37,6 +39,36 @@ func TestComputeDomain_OK(t *testing.T) {
 	}
 }
 
+func TestSigningRoot_Compatibility(t *testing.T) {
+	featureFlags := new(featureconfig.Flags)
+	featureFlags.EnableBlockHTR = true
+	reset := featureconfig.InitWithReset(featureFlags)
+	defer reset()
+
+	parRoot := [32]byte{'A'}
+	stateRoot := [32]byte{'B'}
+	blk := &ethpb.BeaconBlock{
+		Slot:          20,
+		ProposerIndex: 20,
+		ParentRoot:    parRoot[:],
+		StateRoot:     stateRoot[:],
+		Body:          &ethpb.BeaconBlockBody{},
+	}
+	root, err := ComputeSigningRoot(blk, params.BeaconConfig().DomainBeaconProposer[:])
+	if err != nil {
+		t.Fatal(err)
+	}
+	newRoot, err := signingRoot(func() ([32]byte, error) {
+		return stateutil.BlockRoot(blk)
+	}, params.BeaconConfig().DomainBeaconProposer[:])
+	if err != nil {
+		t.Fatal(err)
+	}
+	if root != newRoot {
+		t.Errorf("Wanted root of %#x but got %#x", root, newRoot)
+	}
+}
+
 func TestComputeForkDigest_OK(t *testing.T) {
 	tests := []struct {
 		version []byte

beacon-chain/state/stateutil/blocks.go

@@ -72,55 +72,56 @@ func BlockBodyRoot(body *ethpb.BeaconBlockBody) ([32]byte, error) {
 	}
 	hasher := hashutil.CustomSHA256Hasher()
 	fieldRoots := make([][32]byte, 8)
-	if body != nil {
-		rawRandao := bytesutil.ToBytes96(body.RandaoReveal)
-		packedRandao, err := pack([][]byte{rawRandao[:]})
-		if err != nil {
-			return [32]byte{}, err
-		}
-		randaoRoot, err := bitwiseMerkleize(hasher, packedRandao, uint64(len(packedRandao)), uint64(len(packedRandao)))
-		if err != nil {
-			return [32]byte{}, err
-		}
-		fieldRoots[0] = randaoRoot
+	if body == nil {
+		return [32]byte{}, errors.New("nil block body provided")
+	}
+	rawRandao := bytesutil.ToBytes96(body.RandaoReveal)
+	packedRandao, err := pack([][]byte{rawRandao[:]})
+	if err != nil {
+		return [32]byte{}, err
+	}
+	randaoRoot, err := bitwiseMerkleize(hasher, packedRandao, uint64(len(packedRandao)), uint64(len(packedRandao)))
+	if err != nil {
+		return [32]byte{}, err
+	}
+	fieldRoots[0] = randaoRoot
 
-		eth1Root, err := Eth1Root(hasher, body.Eth1Data)
-		if err != nil {
-			return [32]byte{}, err
-		}
-		fieldRoots[1] = eth1Root
+	eth1Root, err := Eth1Root(hasher, body.Eth1Data)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	fieldRoots[1] = eth1Root
 
-		graffitiRoot := bytesutil.ToBytes32(body.Graffiti)
-		fieldRoots[2] = graffitiRoot
+	graffitiRoot := bytesutil.ToBytes32(body.Graffiti)
+	fieldRoots[2] = graffitiRoot
 
-		proposerSlashingsRoot, err := ssz.HashTreeRootWithCapacity(body.ProposerSlashings, 16)
-		if err != nil {
-			return [32]byte{}, err
-		}
-		fieldRoots[3] = proposerSlashingsRoot
-		attesterSlashingsRoot, err := ssz.HashTreeRootWithCapacity(body.AttesterSlashings, 1)
-		if err != nil {
-			return [32]byte{}, err
-		}
-		fieldRoots[4] = attesterSlashingsRoot
-		attsRoot, err := blockAttestationRoot(body.Attestations)
-		if err != nil {
-			return [32]byte{}, err
-		}
-		fieldRoots[5] = attsRoot
+	proposerSlashingsRoot, err := ssz.HashTreeRootWithCapacity(body.ProposerSlashings, 16)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	fieldRoots[3] = proposerSlashingsRoot
+	attesterSlashingsRoot, err := ssz.HashTreeRootWithCapacity(body.AttesterSlashings, 1)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	fieldRoots[4] = attesterSlashingsRoot
+	attsRoot, err := blockAttestationRoot(body.Attestations)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	fieldRoots[5] = attsRoot
 
-		depositRoot, err := ssz.HashTreeRootWithCapacity(body.Deposits, 16)
-		if err != nil {
-			return [32]byte{}, err
-		}
-		fieldRoots[6] = depositRoot
+	depositRoot, err := ssz.HashTreeRootWithCapacity(body.Deposits, 16)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	fieldRoots[6] = depositRoot
 
-		exitRoot, err := ssz.HashTreeRootWithCapacity(body.VoluntaryExits, 16)
-		if err != nil {
-			return [32]byte{}, err
-		}
-		fieldRoots[7] = exitRoot
+	exitRoot, err := ssz.HashTreeRootWithCapacity(body.VoluntaryExits, 16)
+	if err != nil {
+		return [32]byte{}, err
 	}
+	fieldRoots[7] = exitRoot
 	return bitwiseMerkleizeArrays(hasher, fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots)))
 }