From 45bfd82c8832f2da4803e73a319dfa0b3236f388 Mon Sep 17 00:00:00 2001 From: Raul Jordan Date: Tue, 21 Sep 2021 10:02:48 -0500 Subject: [PATCH] Add Encoding SSZ Package (#9630) * ssz package * compile * htrutils * rem pkg doc * fix cloners_test.go * fix circular dep/build issues Co-authored-by: prestonvanloon Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com> --- beacon-chain/state/stateutil/BUILD.bazel | 6 +- .../state/stateutil/benchmark_test.go | 4 +- .../state/stateutil/block_header_root.go | 4 +- beacon-chain/state/stateutil/eth1_root.go | 12 +- .../stateutil/pending_attestation_root.go | 16 +- beacon-chain/state/stateutil/trie_helpers.go | 10 +- .../state/stateutil/validator_root.go | 16 +- beacon-chain/state/v1/BUILD.bazel | 2 +- beacon-chain/state/v1/field_roots.go | 18 +- beacon-chain/state/v1/getters_attestation.go | 8 +- beacon-chain/state/v1/getters_eth1.go | 4 +- beacon-chain/state/v1/getters_misc.go | 6 +- beacon-chain/state/v1/getters_validator.go | 8 +- beacon-chain/state/v1/state_trie.go | 20 +- beacon-chain/state/v2/BUILD.bazel | 2 +- beacon-chain/state/v2/field_root_eth1.go | 4 +- .../state/v2/field_root_participation_bit.go | 6 +- .../state/v2/field_root_sync_committee.go | 12 +- beacon-chain/state/v2/field_root_validator.go | 8 +- beacon-chain/state/v2/field_root_vector.go | 6 +- beacon-chain/state/v2/field_roots.go | 18 +- beacon-chain/state/v2/state_trie.go | 20 +- beacon-chain/sync/BUILD.bazel | 4 +- beacon-chain/sync/pending_blocks_queue.go | 4 +- beacon-chain/sync/rpc_metadata_test.go | 6 +- container/trie/BUILD.bazel | 2 +- container/trie/sparse_merkle_test.go | 55 +++--- {shared/htrutils => encoding/ssz}/BUILD.bazel | 6 +- .../sszutil => encoding/ssz}/deep_equal.go | 4 +- .../ssz}/deep_equal_test.go | 52 ++--- {shared/htrutils => encoding/ssz}/hashers.go | 3 +- .../htrutils => encoding/ssz}/hashers_test.go | 10 +- {shared/htrutils => encoding/ssz}/helpers.go | 4 +- .../htrutils => encoding/ssz}/helpers_test.go | 18 +- {shared/htrutils => encoding/ssz}/htrutils.go | 27 ++- .../ssz}/htrutils_test.go | 16 +- .../htrutils => encoding/ssz}/merkleize.go | 3 +- .../ssz}/merkleize_test.go | 30 +-- .../aggregation/attestations/BUILD.bazel | 2 +- .../attestations/attestations_test.go | 4 +- proto/prysm/v1alpha1/cloners_test.go | 181 +++++++++--------- shared/params/BUILD.bazel | 2 +- shared/params/checktags_test.go | 2 +- shared/params/loader.go | 5 +- shared/params/loader_test.go | 33 ++-- shared/params/testnet_config_test.go | 2 +- shared/params/testnet_prater_config_test.go | 8 +- shared/sszutil/BUILD.bazel | 23 --- shared/testutil/assert/assertions.go | 4 +- shared/testutil/assertions/BUILD.bazel | 2 +- shared/testutil/assertions/assertions.go | 10 +- tools/pcli/BUILD.bazel | 2 +- tools/pcli/main.go | 4 +- 53 files changed, 361 insertions(+), 377 deletions(-) rename {shared/htrutils => encoding/ssz}/BUILD.bazel (82%) rename {shared/sszutil => encoding/ssz}/deep_equal.go (99%) rename {shared/sszutil => encoding/ssz}/deep_equal_test.go (55%) rename {shared/htrutils => encoding/ssz}/hashers.go (94%) rename {shared/htrutils => encoding/ssz}/hashers_test.go (85%) rename {shared/htrutils => encoding/ssz}/helpers.go (98%) rename {shared/htrutils => encoding/ssz}/helpers_test.go (86%) rename {shared/htrutils => encoding/ssz}/htrutils.go (74%) rename {shared/htrutils => encoding/ssz}/htrutils_test.go (82%) rename {shared/htrutils => encoding/ssz}/merkleize.go (98%) rename {shared/htrutils => encoding/ssz}/merkleize_test.go (73%) delete mode 100644 shared/sszutil/BUILD.bazel diff --git a/beacon-chain/state/stateutil/BUILD.bazel b/beacon-chain/state/stateutil/BUILD.bazel index 4eaabf95f7..59ddf91278 100644 --- a/beacon-chain/state/stateutil/BUILD.bazel +++ b/beacon-chain/state/stateutil/BUILD.bazel @@ -29,9 +29,9 @@ go_library( "//beacon-chain/core/transition/stateutils:go_default_library", "//container/trie:go_default_library", "//crypto/hash:go_default_library", + "//encoding/ssz:go_default_library", "//proto/prysm/v1alpha1:go_default_library", "//shared/bytesutil:go_default_library", - "//shared/htrutils:go_default_library", "//shared/params:go_default_library", "@com_github_pkg_errors//:go_default_library", "@com_github_prysmaticlabs_eth2_types//:go_default_library", @@ -53,9 +53,9 @@ go_test( "//beacon-chain/state/v1:go_default_library", "//config/features:go_default_library", "//crypto/hash:go_default_library", + "//encoding/ssz:go_default_library", "//proto/prysm/v1alpha1:go_default_library", "//shared/bytesutil:go_default_library", - "//shared/htrutils:go_default_library", "//shared/interop:go_default_library", "//shared/params:go_default_library", "//shared/testutil:go_default_library", @@ -82,8 +82,8 @@ go_test( deps = [ "//beacon-chain/state/stateutil:go_default_library", "//crypto/hash:go_default_library", + "//encoding/ssz:go_default_library", "//proto/prysm/v1alpha1:go_default_library", - "//shared/htrutils:go_default_library", "//shared/testutil:go_default_library", "//shared/testutil/require:go_default_library", ], diff --git a/beacon-chain/state/stateutil/benchmark_test.go b/beacon-chain/state/stateutil/benchmark_test.go index 98b54a8246..9b716b0d50 100644 --- a/beacon-chain/state/stateutil/benchmark_test.go +++ b/beacon-chain/state/stateutil/benchmark_test.go @@ -4,7 +4,7 @@ import ( "testing" "github.com/prysmaticlabs/prysm/crypto/hash" - "github.com/prysmaticlabs/prysm/shared/htrutils" + "github.com/prysmaticlabs/prysm/encoding/ssz" "github.com/prysmaticlabs/prysm/shared/testutil/require" ) @@ -18,7 +18,7 @@ func BenchmarkMerkleize_Buffered(b *testing.B) { leafIndexer := func(i uint64) []byte { return chunks[i][:] } - return htrutils.Merkleize(htrutils.NewHasherFunc(hash.CustomSHA256Hasher()), count, limit, leafIndexer), nil + return ssz.Merkleize(ssz.NewHasherFunc(hash.CustomSHA256Hasher()), count, limit, leafIndexer), nil } b.ResetTimer() diff --git a/beacon-chain/state/stateutil/block_header_root.go b/beacon-chain/state/stateutil/block_header_root.go index 53f0baabf7..daf56cca0d 100644 --- a/beacon-chain/state/stateutil/block_header_root.go +++ b/beacon-chain/state/stateutil/block_header_root.go @@ -4,9 +4,9 @@ import ( "encoding/binary" "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/shared/bytesutil" - "github.com/prysmaticlabs/prysm/shared/htrutils" ) // BlockHeaderRoot computes the HashTreeRoot Merkleization of @@ -30,5 +30,5 @@ func BlockHeaderRoot(header *ethpb.BeaconBlockHeader) ([32]byte, error) { bodyRoot := bytesutil.ToBytes32(header.BodyRoot) fieldRoots[4] = bodyRoot[:] } - return htrutils.BitwiseMerkleize(hash.CustomSHA256Hasher(), fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) + return ssz.BitwiseMerkleize(hash.CustomSHA256Hasher(), fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) } diff --git a/beacon-chain/state/stateutil/eth1_root.go b/beacon-chain/state/stateutil/eth1_root.go index 269b70ecd5..f60655e4af 100644 --- a/beacon-chain/state/stateutil/eth1_root.go +++ b/beacon-chain/state/stateutil/eth1_root.go @@ -6,9 +6,9 @@ import ( "github.com/pkg/errors" "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/shared/bytesutil" - "github.com/prysmaticlabs/prysm/shared/htrutils" "github.com/prysmaticlabs/prysm/shared/params" ) @@ -34,7 +34,7 @@ func Eth1DataEncKey(eth1Data *ethpb.Eth1Data) []byte { } // Eth1DataRootWithHasher returns the hash tree root of input `eth1Data`. -func Eth1DataRootWithHasher(hasher htrutils.HashFn, eth1Data *ethpb.Eth1Data) ([32]byte, error) { +func Eth1DataRootWithHasher(hasher ssz.HashFn, eth1Data *ethpb.Eth1Data) ([32]byte, error) { if eth1Data == nil { return [32]byte{}, errors.New("nil eth1 data") } @@ -55,7 +55,7 @@ func Eth1DataRootWithHasher(hasher htrutils.HashFn, eth1Data *ethpb.Eth1Data) ([ blockHash := bytesutil.ToBytes32(eth1Data.BlockHash) fieldRoots[2] = blockHash[:] } - root, err := htrutils.BitwiseMerkleize(hasher, fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) + root, err := ssz.BitwiseMerkleize(hasher, fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) if err != nil { return [32]byte{}, err } @@ -89,12 +89,12 @@ func Eth1DatasRoot(eth1Datas []*ethpb.Eth1Data) ([32]byte, error) { } eth1VotesRoots = append(eth1VotesRoots, eth1[:]) } - eth1Chunks, err := htrutils.Pack(eth1VotesRoots) + eth1Chunks, err := ssz.Pack(eth1VotesRoots) if err != nil { return [32]byte{}, errors.Wrap(err, "could not chunk eth1 votes roots") } - eth1VotesRootsRoot, err := htrutils.BitwiseMerkleize( + eth1VotesRootsRoot, err := ssz.BitwiseMerkleize( hasher, eth1Chunks, uint64(len(eth1Chunks)), @@ -110,7 +110,7 @@ func Eth1DatasRoot(eth1Datas []*ethpb.Eth1Data) ([32]byte, error) { // We need to mix in the length of the slice. eth1VotesRootBufRoot := make([]byte, 32) copy(eth1VotesRootBufRoot, eth1VotesRootBuf.Bytes()) - root := htrutils.MixInLength(eth1VotesRootsRoot, eth1VotesRootBufRoot) + root := ssz.MixInLength(eth1VotesRootsRoot, eth1VotesRootBufRoot) return root, nil } diff --git a/beacon-chain/state/stateutil/pending_attestation_root.go b/beacon-chain/state/stateutil/pending_attestation_root.go index 83818db9a8..b33372b0cb 100644 --- a/beacon-chain/state/stateutil/pending_attestation_root.go +++ b/beacon-chain/state/stateutil/pending_attestation_root.go @@ -4,19 +4,19 @@ import ( "encoding/binary" "github.com/pkg/errors" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/shared/bytesutil" - "github.com/prysmaticlabs/prysm/shared/htrutils" "github.com/prysmaticlabs/prysm/shared/params" ) // PendingAttRootWithHasher describes a method from which the hash tree root // of a pending attestation is returned. -func PendingAttRootWithHasher(hasher htrutils.HashFn, att *ethpb.PendingAttestation) ([32]byte, error) { +func PendingAttRootWithHasher(hasher ssz.HashFn, att *ethpb.PendingAttestation) ([32]byte, error) { var fieldRoots [][32]byte // Bitfield. - aggregationRoot, err := htrutils.BitlistRoot(hasher, att.AggregationBits, params.BeaconConfig().MaxValidatorsPerCommittee) + aggregationRoot, err := ssz.BitlistRoot(hasher, att.AggregationBits, params.BeaconConfig().MaxValidatorsPerCommittee) if err != nil { return [32]byte{}, err } @@ -37,7 +37,7 @@ func PendingAttRootWithHasher(hasher htrutils.HashFn, att *ethpb.PendingAttestat fieldRoots = [][32]byte{aggregationRoot, attDataRoot, inclusionRoot, proposerRoot} - return htrutils.BitwiseMerkleizeArrays(hasher, fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) + return ssz.BitwiseMerkleizeArrays(hasher, fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) } // PendingAttEncKey returns the encoded key in bytes of input `pendingAttestation`, @@ -63,7 +63,7 @@ func PendingAttEncKey(att *ethpb.PendingAttestation) []byte { return enc } -func attDataRootWithHasher(hasher htrutils.HashFn, data *ethpb.AttestationData) ([32]byte, error) { +func attDataRootWithHasher(hasher ssz.HashFn, data *ethpb.AttestationData) ([32]byte, error) { fieldRoots := make([][]byte, 5) if data != nil { @@ -84,21 +84,21 @@ func attDataRootWithHasher(hasher htrutils.HashFn, data *ethpb.AttestationData) fieldRoots[2] = blockRoot[:] // Source - sourceRoot, err := htrutils.CheckpointRoot(hasher, data.Source) + sourceRoot, err := ssz.CheckpointRoot(hasher, data.Source) if err != nil { return [32]byte{}, errors.Wrap(err, "could not compute source checkpoint merkleization") } fieldRoots[3] = sourceRoot[:] // Target - targetRoot, err := htrutils.CheckpointRoot(hasher, data.Target) + targetRoot, err := ssz.CheckpointRoot(hasher, data.Target) if err != nil { return [32]byte{}, errors.Wrap(err, "could not compute target checkpoint merkleization") } fieldRoots[4] = targetRoot[:] } - return htrutils.BitwiseMerkleize(hasher, fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) + return ssz.BitwiseMerkleize(hasher, fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) } func marshalAttData(data *ethpb.AttestationData) []byte { diff --git a/beacon-chain/state/stateutil/trie_helpers.go b/beacon-chain/state/stateutil/trie_helpers.go index 0e4dfc62e3..0e61c0b3c2 100644 --- a/beacon-chain/state/stateutil/trie_helpers.go +++ b/beacon-chain/state/stateutil/trie_helpers.go @@ -7,7 +7,7 @@ import ( "github.com/pkg/errors" "github.com/prysmaticlabs/prysm/container/trie" "github.com/prysmaticlabs/prysm/crypto/hash" - "github.com/prysmaticlabs/prysm/shared/htrutils" + "github.com/prysmaticlabs/prysm/encoding/ssz" ) // ReturnTrieLayer returns the representation of a merkle trie when @@ -21,7 +21,7 @@ func ReturnTrieLayer(elements [][32]byte, length uint64) [][]*[32]byte { return [][]*[32]byte{{&leaves[0]}} } hashLayer := leaves - layers := make([][][32]byte, htrutils.Depth(length)+1) + layers := make([][][32]byte, ssz.Depth(length)+1) layers[0] = hashLayer layers, _ = merkleizeTrieLeaves(layers, hashLayer, hasher) refLayers := make([][]*[32]byte, len(layers)) @@ -66,7 +66,7 @@ func merkleizeTrieLeaves(layers [][][32]byte, hashLayer [][32]byte, // it. func ReturnTrieLayerVariable(elements [][32]byte, length uint64) [][]*[32]byte { hasher := hash.CustomSHA256Hasher() - depth := htrutils.Depth(length) + depth := ssz.Depth(length) layers := make([][]*[32]byte, depth+1) // Return zerohash at depth if len(elements) == 0 { @@ -252,7 +252,7 @@ func AddInMixin(root [32]byte, length uint64) ([32]byte, error) { // We need to mix in the length of the slice. rootBufRoot := make([]byte, 32) copy(rootBufRoot, rootBuf.Bytes()) - return htrutils.MixInLength(root, rootBufRoot), nil + return ssz.MixInLength(root, rootBufRoot), nil } // Merkleize 32-byte leaves into a Merkle trie for its adequate depth, returning @@ -260,7 +260,7 @@ func AddInMixin(root [32]byte, length uint64) ([32]byte, error) { // pads the leaves to a length of 32. func Merkleize(leaves [][]byte) [][][]byte { hashFunc := hash.CustomSHA256Hasher() - layers := make([][][]byte, htrutils.Depth(uint64(len(leaves)))+1) + layers := make([][][]byte, ssz.Depth(uint64(len(leaves)))+1) for len(leaves) != 32 { leaves = append(leaves, make([]byte, 32)) } diff --git a/beacon-chain/state/stateutil/validator_root.go b/beacon-chain/state/stateutil/validator_root.go index 704f49f283..a6410de140 100644 --- a/beacon-chain/state/stateutil/validator_root.go +++ b/beacon-chain/state/stateutil/validator_root.go @@ -6,15 +6,15 @@ import ( "github.com/pkg/errors" "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/shared/bytesutil" - "github.com/prysmaticlabs/prysm/shared/htrutils" "github.com/prysmaticlabs/prysm/shared/params" ) // ValidatorRootWithHasher describes a method from which the hash tree root // of a validator is returned. -func ValidatorRootWithHasher(hasher htrutils.HashFn, validator *ethpb.Validator) ([32]byte, error) { +func ValidatorRootWithHasher(hasher ssz.HashFn, validator *ethpb.Validator) ([32]byte, error) { var fieldRoots [][32]byte if validator != nil { pubkey := bytesutil.ToBytes48(validator.PublicKey) @@ -41,18 +41,18 @@ func ValidatorRootWithHasher(hasher htrutils.HashFn, validator *ethpb.Validator) binary.LittleEndian.PutUint64(withdrawalBuf[:8], uint64(validator.WithdrawableEpoch)) // Public key. - pubKeyChunks, err := htrutils.Pack([][]byte{pubkey[:]}) + pubKeyChunks, err := ssz.Pack([][]byte{pubkey[:]}) if err != nil { return [32]byte{}, err } - pubKeyRoot, err := htrutils.BitwiseMerkleize(hasher, pubKeyChunks, uint64(len(pubKeyChunks)), uint64(len(pubKeyChunks))) + pubKeyRoot, err := ssz.BitwiseMerkleize(hasher, pubKeyChunks, uint64(len(pubKeyChunks)), uint64(len(pubKeyChunks))) if err != nil { return [32]byte{}, err } fieldRoots = [][32]byte{pubKeyRoot, withdrawCreds, effectiveBalanceBuf, slashBuf, activationEligibilityBuf, activationBuf, exitBuf, withdrawalBuf} } - return htrutils.BitwiseMerkleizeArrays(hasher, fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) + return ssz.BitwiseMerkleizeArrays(hasher, fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) } // Uint64ListRootWithRegistryLimit computes the HashTreeRoot Merkleization of @@ -65,7 +65,7 @@ func Uint64ListRootWithRegistryLimit(balances []uint64) ([32]byte, error) { binary.LittleEndian.PutUint64(balanceBuf, balances[i]) balancesMarshaling = append(balancesMarshaling, balanceBuf) } - balancesChunks, err := htrutils.Pack(balancesMarshaling) + balancesChunks, err := ssz.Pack(balancesMarshaling) if err != nil { return [32]byte{}, errors.Wrap(err, "could not pack balances into chunks") } @@ -79,14 +79,14 @@ func Uint64ListRootWithRegistryLimit(balances []uint64) ([32]byte, error) { balLimit = uint64(len(balances)) } } - balancesRootsRoot, err := htrutils.BitwiseMerkleize(hasher, balancesChunks, uint64(len(balancesChunks)), balLimit) + balancesRootsRoot, err := ssz.BitwiseMerkleize(hasher, balancesChunks, uint64(len(balancesChunks)), balLimit) if err != nil { return [32]byte{}, errors.Wrap(err, "could not compute balances merkleization") } balancesLengthRoot := make([]byte, 32) binary.LittleEndian.PutUint64(balancesLengthRoot, uint64(len(balances))) - return htrutils.MixInLength(balancesRootsRoot, balancesLengthRoot), nil + return ssz.MixInLength(balancesRootsRoot, balancesLengthRoot), nil } // ValidatorEncKey returns the encoded key in bytes of input `validator`, diff --git a/beacon-chain/state/v1/BUILD.bazel b/beacon-chain/state/v1/BUILD.bazel index eba3eb8d80..ef978f281b 100644 --- a/beacon-chain/state/v1/BUILD.bazel +++ b/beacon-chain/state/v1/BUILD.bazel @@ -50,11 +50,11 @@ go_library( "//config/features:go_default_library", "//container/slice:go_default_library", "//crypto/hash:go_default_library", + "//encoding/ssz:go_default_library", "//proto/eth/v1:go_default_library", "//proto/prysm/v1alpha1:go_default_library", "//runtime/version:go_default_library", "//shared/bytesutil:go_default_library", - "//shared/htrutils:go_default_library", "//shared/params:go_default_library", "@com_github_dgraph_io_ristretto//:go_default_library", "@com_github_pkg_errors//:go_default_library", diff --git a/beacon-chain/state/v1/field_roots.go b/beacon-chain/state/v1/field_roots.go index 7cedd69601..c9282a9556 100644 --- a/beacon-chain/state/v1/field_roots.go +++ b/beacon-chain/state/v1/field_roots.go @@ -10,9 +10,9 @@ import ( "github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil" "github.com/prysmaticlabs/prysm/config/features" "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/shared/bytesutil" - "github.com/prysmaticlabs/prysm/shared/htrutils" "github.com/prysmaticlabs/prysm/shared/params" "go.opencensus.io/trace" ) @@ -67,7 +67,7 @@ func (h *stateRootHasher) computeFieldRootsWithHasher(ctx context.Context, state fieldRoots := make([][]byte, params.BeaconConfig().BeaconStateFieldCount) // Genesis time root. - genesisRoot := htrutils.Uint64Root(state.GenesisTime) + genesisRoot := ssz.Uint64Root(state.GenesisTime) fieldRoots[0] = genesisRoot[:] // Genesis validator root. @@ -76,11 +76,11 @@ func (h *stateRootHasher) computeFieldRootsWithHasher(ctx context.Context, state fieldRoots[1] = r[:] // Slot root. - slotRoot := htrutils.Uint64Root(uint64(state.Slot)) + slotRoot := ssz.Uint64Root(uint64(state.Slot)) fieldRoots[2] = slotRoot[:] // Fork data structure root. - forkHashTreeRoot, err := htrutils.ForkRoot(state.Fork) + forkHashTreeRoot, err := ssz.ForkRoot(state.Fork) if err != nil { return nil, errors.Wrap(err, "could not compute fork merkleization") } @@ -108,7 +108,7 @@ func (h *stateRootHasher) computeFieldRootsWithHasher(ctx context.Context, state fieldRoots[6] = stateRootsRoot[:] // HistoricalRoots slice root. - historicalRootsRt, err := htrutils.HistoricalRootsRoot(state.HistoricalRoots) + historicalRootsRt, err := ssz.ByteArrayRootWithLimit(state.HistoricalRoots, params.BeaconConfig().HistoricalRootsLimit) if err != nil { return nil, errors.Wrap(err, "could not compute historical roots merkleization") } @@ -156,7 +156,7 @@ func (h *stateRootHasher) computeFieldRootsWithHasher(ctx context.Context, state fieldRoots[13] = randaoRootsRoot[:] // Slashings array root. - slashingsRootsRoot, err := htrutils.SlashingsRoot(state.Slashings) + slashingsRootsRoot, err := ssz.SlashingsRoot(state.Slashings) if err != nil { return nil, errors.Wrap(err, "could not compute slashings merkleization") } @@ -181,21 +181,21 @@ func (h *stateRootHasher) computeFieldRootsWithHasher(ctx context.Context, state fieldRoots[17] = justifiedBitsRoot[:] // PreviousJustifiedCheckpoint data structure root. - prevCheckRoot, err := htrutils.CheckpointRoot(hasher, state.PreviousJustifiedCheckpoint) + prevCheckRoot, err := ssz.CheckpointRoot(hasher, state.PreviousJustifiedCheckpoint) if err != nil { return nil, errors.Wrap(err, "could not compute previous justified checkpoint merkleization") } fieldRoots[18] = prevCheckRoot[:] // CurrentJustifiedCheckpoint data structure root. - currJustRoot, err := htrutils.CheckpointRoot(hasher, state.CurrentJustifiedCheckpoint) + currJustRoot, err := ssz.CheckpointRoot(hasher, state.CurrentJustifiedCheckpoint) if err != nil { return nil, errors.Wrap(err, "could not compute current justified checkpoint merkleization") } fieldRoots[19] = currJustRoot[:] // FinalizedCheckpoint data structure root. - finalRoot, err := htrutils.CheckpointRoot(hasher, state.FinalizedCheckpoint) + finalRoot, err := ssz.CheckpointRoot(hasher, state.FinalizedCheckpoint) if err != nil { return nil, errors.Wrap(err, "could not compute finalized checkpoint merkleization") } diff --git a/beacon-chain/state/v1/getters_attestation.go b/beacon-chain/state/v1/getters_attestation.go index f915573598..6605ae00bf 100644 --- a/beacon-chain/state/v1/getters_attestation.go +++ b/beacon-chain/state/v1/getters_attestation.go @@ -8,8 +8,8 @@ import ( "github.com/pkg/errors" "github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil" "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" - "github.com/prysmaticlabs/prysm/shared/htrutils" "github.com/prysmaticlabs/prysm/shared/params" ) @@ -79,7 +79,7 @@ func (h *stateRootHasher) epochAttestationsRoot(atts []*ethpb.PendingAttestation roots[i] = pendingRoot[:] } - attsRootsRoot, err := htrutils.BitwiseMerkleize( + attsRootsRoot, err := ssz.BitwiseMerkleize( hasher, roots, uint64(len(roots)), @@ -95,11 +95,11 @@ func (h *stateRootHasher) epochAttestationsRoot(atts []*ethpb.PendingAttestation // We need to mix in the length of the slice. attsLenRoot := make([]byte, 32) copy(attsLenRoot, attsLenBuf.Bytes()) - res := htrutils.MixInLength(attsRootsRoot, attsLenRoot) + res := ssz.MixInLength(attsRootsRoot, attsLenRoot) return res, nil } -func (h *stateRootHasher) pendingAttestationRoot(hasher htrutils.HashFn, att *ethpb.PendingAttestation) ([32]byte, error) { +func (h *stateRootHasher) pendingAttestationRoot(hasher ssz.HashFn, att *ethpb.PendingAttestation) ([32]byte, error) { if att == nil { return [32]byte{}, errors.New("nil pending attestation") } diff --git a/beacon-chain/state/v1/getters_eth1.go b/beacon-chain/state/v1/getters_eth1.go index d3fb1f6fa9..13376c4007 100644 --- a/beacon-chain/state/v1/getters_eth1.go +++ b/beacon-chain/state/v1/getters_eth1.go @@ -4,8 +4,8 @@ import ( "github.com/pkg/errors" "github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil" "github.com/prysmaticlabs/prysm/config/features" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" - "github.com/prysmaticlabs/prysm/shared/htrutils" ) // Eth1Data corresponding to the proof-of-work chain information stored in the beacon state. @@ -97,7 +97,7 @@ func (b *BeaconState) eth1DepositIndex() uint64 { // eth1Root computes the HashTreeRoot Merkleization of // a BeaconBlockHeader struct according to the Ethereum // Simple Serialize specification. -func eth1Root(hasher htrutils.HashFn, eth1Data *ethpb.Eth1Data) ([32]byte, error) { +func eth1Root(hasher ssz.HashFn, eth1Data *ethpb.Eth1Data) ([32]byte, error) { if eth1Data == nil { return [32]byte{}, errors.New("nil eth1 data") } diff --git a/beacon-chain/state/v1/getters_misc.go b/beacon-chain/state/v1/getters_misc.go index 85b2c7e3f6..85bfa0eafa 100644 --- a/beacon-chain/state/v1/getters_misc.go +++ b/beacon-chain/state/v1/getters_misc.go @@ -6,10 +6,10 @@ import ( "github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil" "github.com/prysmaticlabs/prysm/config/features" "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/runtime/version" "github.com/prysmaticlabs/prysm/shared/bytesutil" - "github.com/prysmaticlabs/prysm/shared/htrutils" "github.com/prysmaticlabs/prysm/shared/params" ) @@ -181,7 +181,7 @@ func (h *stateRootHasher) arraysRoot(input [][]byte, length uint64, fieldName st defer lock.Unlock() hashFunc := hash.CustomSHA256Hasher() if _, ok := layersCache[fieldName]; !ok && h.rootsCache != nil { - depth := htrutils.Depth(length) + depth := ssz.Depth(length) layersCache[fieldName] = make([][][32]byte, depth+1) } @@ -289,7 +289,7 @@ func (h *stateRootHasher) merkleizeWithCache(leaves [][32]byte, length uint64, return leaves[0] } hashLayer := leaves - layers := make([][][32]byte, htrutils.Depth(length)+1) + layers := make([][][32]byte, ssz.Depth(length)+1) if items, ok := layersCache[fieldName]; ok && h.rootsCache != nil { if len(items[0]) == len(leaves) { layers = items diff --git a/beacon-chain/state/v1/getters_validator.go b/beacon-chain/state/v1/getters_validator.go index 939438824e..2ec03f5d7a 100644 --- a/beacon-chain/state/v1/getters_validator.go +++ b/beacon-chain/state/v1/getters_validator.go @@ -11,9 +11,9 @@ import ( "github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil" "github.com/prysmaticlabs/prysm/config/features" "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/shared/bytesutil" - "github.com/prysmaticlabs/prysm/shared/htrutils" "github.com/prysmaticlabs/prysm/shared/params" ) @@ -326,7 +326,7 @@ func (h *stateRootHasher) validatorRegistryRoot(validators []*ethpb.Validator) ( } } - validatorsRootsRoot, err := htrutils.BitwiseMerkleizeArrays(hasher, roots, uint64(len(roots)), params.BeaconConfig().ValidatorRegistryLimit) + validatorsRootsRoot, err := ssz.BitwiseMerkleizeArrays(hasher, roots, uint64(len(roots)), params.BeaconConfig().ValidatorRegistryLimit) if err != nil { return [32]byte{}, errors.Wrap(err, "could not compute validator registry merkleization") } @@ -337,14 +337,14 @@ func (h *stateRootHasher) validatorRegistryRoot(validators []*ethpb.Validator) ( // We need to mix in the length of the slice. var validatorsRootsBufRoot [32]byte copy(validatorsRootsBufRoot[:], validatorsRootsBuf.Bytes()) - res := htrutils.MixInLength(validatorsRootsRoot, validatorsRootsBufRoot[:]) + res := ssz.MixInLength(validatorsRootsRoot, validatorsRootsBufRoot[:]) if hashKey != emptyKey && h.rootsCache != nil { h.rootsCache.Set(string(hashKey[:]), res, 32) } return res, nil } -func (h *stateRootHasher) validatorRoot(hasher htrutils.HashFn, validator *ethpb.Validator) ([32]byte, error) { +func (h *stateRootHasher) validatorRoot(hasher ssz.HashFn, validator *ethpb.Validator) ([32]byte, error) { if validator == nil { return [32]byte{}, errors.New("nil validator") } diff --git a/beacon-chain/state/v1/state_trie.go b/beacon-chain/state/v1/state_trie.go index 364e7c1b45..30a267fa57 100644 --- a/beacon-chain/state/v1/state_trie.go +++ b/beacon-chain/state/v1/state_trie.go @@ -14,10 +14,10 @@ import ( "github.com/prysmaticlabs/prysm/beacon-chain/state/types" "github.com/prysmaticlabs/prysm/container/slice" "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" v1 "github.com/prysmaticlabs/prysm/proto/eth/v1" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/shared/bytesutil" - "github.com/prysmaticlabs/prysm/shared/htrutils" "github.com/prysmaticlabs/prysm/shared/params" "go.opencensus.io/trace" "google.golang.org/protobuf/proto" @@ -394,15 +394,15 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex) hasher := hash.CustomSHA256Hasher() switch field { case genesisTime: - return htrutils.Uint64Root(b.state.GenesisTime), nil + return ssz.Uint64Root(b.state.GenesisTime), nil case genesisValidatorRoot: return bytesutil.ToBytes32(b.state.GenesisValidatorsRoot), nil case slot: - return htrutils.Uint64Root(uint64(b.state.Slot)), nil + return ssz.Uint64Root(uint64(b.state.Slot)), nil case eth1DepositIndex: - return htrutils.Uint64Root(b.state.Eth1DepositIndex), nil + return ssz.Uint64Root(b.state.Eth1DepositIndex), nil case fork: - return htrutils.ForkRoot(b.state.Fork) + return ssz.ForkRoot(b.state.Fork) case latestBlockHeader: return stateutil.BlockHeaderRoot(b.state.LatestBlockHeader) case blockRoots: @@ -426,7 +426,7 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex) } return b.recomputeFieldTrie(stateRoots, b.state.StateRoots) case historicalRoots: - return htrutils.HistoricalRootsRoot(b.state.HistoricalRoots) + return ssz.ByteArrayRootWithLimit(b.state.HistoricalRoots, params.BeaconConfig().HistoricalRootsLimit) case eth1Data: return eth1Root(hasher, b.state.Eth1Data) case eth1DataVotes: @@ -466,7 +466,7 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex) } return b.recomputeFieldTrie(randaoMixes, b.state.RandaoMixes) case slashings: - return htrutils.SlashingsRoot(b.state.Slashings) + return ssz.SlashingsRoot(b.state.Slashings) case previousEpochAttestations: if b.rebuildTrie[field] { err := b.resetFieldTrie( @@ -498,11 +498,11 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex) case justificationBits: return bytesutil.ToBytes32(b.state.JustificationBits), nil case previousJustifiedCheckpoint: - return htrutils.CheckpointRoot(hasher, b.state.PreviousJustifiedCheckpoint) + return ssz.CheckpointRoot(hasher, b.state.PreviousJustifiedCheckpoint) case currentJustifiedCheckpoint: - return htrutils.CheckpointRoot(hasher, b.state.CurrentJustifiedCheckpoint) + return ssz.CheckpointRoot(hasher, b.state.CurrentJustifiedCheckpoint) case finalizedCheckpoint: - return htrutils.CheckpointRoot(hasher, b.state.FinalizedCheckpoint) + return ssz.CheckpointRoot(hasher, b.state.FinalizedCheckpoint) } return [32]byte{}, errors.New("invalid field index provided") } diff --git a/beacon-chain/state/v2/BUILD.bazel b/beacon-chain/state/v2/BUILD.bazel index ca02859a65..4156bc964a 100644 --- a/beacon-chain/state/v2/BUILD.bazel +++ b/beacon-chain/state/v2/BUILD.bazel @@ -32,11 +32,11 @@ go_library( "//config/features:go_default_library", "//container/slice:go_default_library", "//crypto/hash:go_default_library", + "//encoding/ssz:go_default_library", "//proto/eth/v1:go_default_library", "//proto/prysm/v1alpha1:go_default_library", "//runtime/version:go_default_library", "//shared/bytesutil:go_default_library", - "//shared/htrutils:go_default_library", "//shared/params:go_default_library", "@com_github_dgraph_io_ristretto//:go_default_library", "@com_github_pkg_errors//:go_default_library", diff --git a/beacon-chain/state/v2/field_root_eth1.go b/beacon-chain/state/v2/field_root_eth1.go index 4d298ddc0f..1f805966ab 100644 --- a/beacon-chain/state/v2/field_root_eth1.go +++ b/beacon-chain/state/v2/field_root_eth1.go @@ -4,14 +4,14 @@ import ( "github.com/pkg/errors" "github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil" "github.com/prysmaticlabs/prysm/config/features" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" - "github.com/prysmaticlabs/prysm/shared/htrutils" ) // eth1Root computes the HashTreeRoot Merkleization of // a BeaconBlockHeader struct according to the eth2 // Simple Serialize specification. -func eth1Root(hasher htrutils.HashFn, eth1Data *ethpb.Eth1Data) ([32]byte, error) { +func eth1Root(hasher ssz.HashFn, eth1Data *ethpb.Eth1Data) ([32]byte, error) { if eth1Data == nil { return [32]byte{}, errors.New("nil eth1 data") } diff --git a/beacon-chain/state/v2/field_root_participation_bit.go b/beacon-chain/state/v2/field_root_participation_bit.go index 2a44fd29de..a9e56e060d 100644 --- a/beacon-chain/state/v2/field_root_participation_bit.go +++ b/beacon-chain/state/v2/field_root_participation_bit.go @@ -5,7 +5,7 @@ import ( "github.com/pkg/errors" "github.com/prysmaticlabs/prysm/crypto/hash" - "github.com/prysmaticlabs/prysm/shared/htrutils" + "github.com/prysmaticlabs/prysm/encoding/ssz" "github.com/prysmaticlabs/prysm/shared/params" ) @@ -27,14 +27,14 @@ func participationBitsRoot(bits []byte) ([32]byte, error) { } } - bytesRoot, err := htrutils.BitwiseMerkleize(hasher, chunkedRoots, uint64(len(chunkedRoots)), limit) + bytesRoot, err := ssz.BitwiseMerkleize(hasher, chunkedRoots, uint64(len(chunkedRoots)), limit) if err != nil { return [32]byte{}, errors.Wrap(err, "could not compute merkleization") } bytesRootBufRoot := make([]byte, 32) binary.LittleEndian.PutUint64(bytesRootBufRoot[:8], uint64(len(bits))) - return htrutils.MixInLength(bytesRoot, bytesRootBufRoot), nil + return ssz.MixInLength(bytesRoot, bytesRootBufRoot), nil } // packParticipationBits into chunks. It'll pad the last chunk with zero bytes if diff --git a/beacon-chain/state/v2/field_root_sync_committee.go b/beacon-chain/state/v2/field_root_sync_committee.go index aaddd6f9b9..c62d1884b3 100644 --- a/beacon-chain/state/v2/field_root_sync_committee.go +++ b/beacon-chain/state/v2/field_root_sync_committee.go @@ -2,8 +2,8 @@ package v2 import ( "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" - "github.com/prysmaticlabs/prysm/shared/htrutils" ) // syncCommitteeRoot computes the HashTreeRoot Merkleization of a commitee root. @@ -25,7 +25,7 @@ func syncCommitteeRoot(committee *ethpb.SyncCommittee) ([32]byte, error) { } pubKeyRoots = append(pubKeyRoots, r) } - pubkeyRoot, err := htrutils.BitwiseMerkleizeArrays(hasher, pubKeyRoots, uint64(len(pubKeyRoots)), uint64(len(pubKeyRoots))) + pubkeyRoot, err := ssz.BitwiseMerkleizeArrays(hasher, pubKeyRoots, uint64(len(pubKeyRoots)), uint64(len(pubKeyRoots))) if err != nil { return [32]byte{}, err } @@ -37,13 +37,13 @@ func syncCommitteeRoot(committee *ethpb.SyncCommittee) ([32]byte, error) { } fieldRoots = [][32]byte{pubkeyRoot, aggregateKeyRoot} - return htrutils.BitwiseMerkleizeArrays(hasher, fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) + return ssz.BitwiseMerkleizeArrays(hasher, fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) } -func merkleizePubkey(hasher htrutils.HashFn, pubkey []byte) ([32]byte, error) { - chunks, err := htrutils.Pack([][]byte{pubkey}) +func merkleizePubkey(hasher ssz.HashFn, pubkey []byte) ([32]byte, error) { + chunks, err := ssz.Pack([][]byte{pubkey}) if err != nil { return [32]byte{}, err } - return htrutils.BitwiseMerkleize(hasher, chunks, uint64(len(chunks)), uint64(len(chunks))) + return ssz.BitwiseMerkleize(hasher, chunks, uint64(len(chunks)), uint64(len(chunks))) } diff --git a/beacon-chain/state/v2/field_root_validator.go b/beacon-chain/state/v2/field_root_validator.go index 606d436e15..da5a82b4b3 100644 --- a/beacon-chain/state/v2/field_root_validator.go +++ b/beacon-chain/state/v2/field_root_validator.go @@ -8,8 +8,8 @@ import ( "github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil" "github.com/prysmaticlabs/prysm/config/features" "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" - "github.com/prysmaticlabs/prysm/shared/htrutils" "github.com/prysmaticlabs/prysm/shared/params" ) @@ -36,7 +36,7 @@ func (h *stateRootHasher) validatorRegistryRoot(validators []*ethpb.Validator) ( } } - validatorsRootsRoot, err := htrutils.BitwiseMerkleizeArrays(hasher, roots, uint64(len(roots)), params.BeaconConfig().ValidatorRegistryLimit) + validatorsRootsRoot, err := ssz.BitwiseMerkleizeArrays(hasher, roots, uint64(len(roots)), params.BeaconConfig().ValidatorRegistryLimit) if err != nil { return [32]byte{}, errors.Wrap(err, "could not compute validator registry merkleization") } @@ -47,14 +47,14 @@ func (h *stateRootHasher) validatorRegistryRoot(validators []*ethpb.Validator) ( // We need to mix in the length of the slice. var validatorsRootsBufRoot [32]byte copy(validatorsRootsBufRoot[:], validatorsRootsBuf.Bytes()) - res := htrutils.MixInLength(validatorsRootsRoot, validatorsRootsBufRoot[:]) + res := ssz.MixInLength(validatorsRootsRoot, validatorsRootsBufRoot[:]) if hashKey != emptyKey && h.rootsCache != nil { h.rootsCache.Set(string(hashKey[:]), res, 32) } return res, nil } -func (h *stateRootHasher) validatorRoot(hasher htrutils.HashFn, validator *ethpb.Validator) ([32]byte, error) { +func (h *stateRootHasher) validatorRoot(hasher ssz.HashFn, validator *ethpb.Validator) ([32]byte, error) { if validator == nil { return [32]byte{}, errors.New("nil validator") } diff --git a/beacon-chain/state/v2/field_root_vector.go b/beacon-chain/state/v2/field_root_vector.go index c581f96b52..f4341f4955 100644 --- a/beacon-chain/state/v2/field_root_vector.go +++ b/beacon-chain/state/v2/field_root_vector.go @@ -4,7 +4,7 @@ import ( "github.com/pkg/errors" "github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil" "github.com/prysmaticlabs/prysm/crypto/hash" - "github.com/prysmaticlabs/prysm/shared/htrutils" + "github.com/prysmaticlabs/prysm/encoding/ssz" ) func (h *stateRootHasher) arraysRoot(input [][]byte, length uint64, fieldName string) ([32]byte, error) { @@ -12,7 +12,7 @@ func (h *stateRootHasher) arraysRoot(input [][]byte, length uint64, fieldName st defer lock.Unlock() hashFunc := hash.CustomSHA256Hasher() if _, ok := layersCache[fieldName]; !ok && h.rootsCache != nil { - depth := htrutils.Depth(length) + depth := ssz.Depth(length) layersCache[fieldName] = make([][][32]byte, depth+1) } @@ -120,7 +120,7 @@ func (h *stateRootHasher) merkleizeWithCache(leaves [][32]byte, length uint64, return leaves[0] } hashLayer := leaves - layers := make([][][32]byte, htrutils.Depth(length)+1) + layers := make([][][32]byte, ssz.Depth(length)+1) if items, ok := layersCache[fieldName]; ok && h.rootsCache != nil { if len(items[0]) == len(leaves) { layers = items diff --git a/beacon-chain/state/v2/field_roots.go b/beacon-chain/state/v2/field_roots.go index 637ebd9670..7cd2bb742d 100644 --- a/beacon-chain/state/v2/field_roots.go +++ b/beacon-chain/state/v2/field_roots.go @@ -9,9 +9,9 @@ import ( "github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil" "github.com/prysmaticlabs/prysm/config/features" "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/shared/bytesutil" - "github.com/prysmaticlabs/prysm/shared/htrutils" "github.com/prysmaticlabs/prysm/shared/params" ) @@ -62,7 +62,7 @@ func (h *stateRootHasher) computeFieldRootsWithHasher(state *ethpb.BeaconStateAl fieldRoots := make([][]byte, params.BeaconConfig().BeaconStateAltairFieldCount) // Genesis time root. - genesisRoot := htrutils.Uint64Root(state.GenesisTime) + genesisRoot := ssz.Uint64Root(state.GenesisTime) fieldRoots[0] = genesisRoot[:] // Genesis validator root. @@ -71,11 +71,11 @@ func (h *stateRootHasher) computeFieldRootsWithHasher(state *ethpb.BeaconStateAl fieldRoots[1] = r[:] // Slot root. - slotRoot := htrutils.Uint64Root(uint64(state.Slot)) + slotRoot := ssz.Uint64Root(uint64(state.Slot)) fieldRoots[2] = slotRoot[:] // Fork data structure root. - forkHashTreeRoot, err := htrutils.ForkRoot(state.Fork) + forkHashTreeRoot, err := ssz.ForkRoot(state.Fork) if err != nil { return nil, errors.Wrap(err, "could not compute fork merkleization") } @@ -103,7 +103,7 @@ func (h *stateRootHasher) computeFieldRootsWithHasher(state *ethpb.BeaconStateAl fieldRoots[6] = stateRootsRoot[:] // HistoricalRoots slice root. - historicalRootsRt, err := htrutils.HistoricalRootsRoot(state.HistoricalRoots) + historicalRootsRt, err := ssz.ByteArrayRootWithLimit(state.HistoricalRoots, params.BeaconConfig().HistoricalRootsLimit) if err != nil { return nil, errors.Wrap(err, "could not compute historical roots merkleization") } @@ -151,7 +151,7 @@ func (h *stateRootHasher) computeFieldRootsWithHasher(state *ethpb.BeaconStateAl fieldRoots[13] = randaoRootsRoot[:] // Slashings array root. - slashingsRootsRoot, err := htrutils.SlashingsRoot(state.Slashings) + slashingsRootsRoot, err := ssz.SlashingsRoot(state.Slashings) if err != nil { return nil, errors.Wrap(err, "could not compute slashings merkleization") } @@ -176,21 +176,21 @@ func (h *stateRootHasher) computeFieldRootsWithHasher(state *ethpb.BeaconStateAl fieldRoots[17] = justifiedBitsRoot[:] // PreviousJustifiedCheckpoint data structure root. - prevCheckRoot, err := htrutils.CheckpointRoot(hasher, state.PreviousJustifiedCheckpoint) + prevCheckRoot, err := ssz.CheckpointRoot(hasher, state.PreviousJustifiedCheckpoint) if err != nil { return nil, errors.Wrap(err, "could not compute previous justified checkpoint merkleization") } fieldRoots[18] = prevCheckRoot[:] // CurrentJustifiedCheckpoint data structure root. - currJustRoot, err := htrutils.CheckpointRoot(hasher, state.CurrentJustifiedCheckpoint) + currJustRoot, err := ssz.CheckpointRoot(hasher, state.CurrentJustifiedCheckpoint) if err != nil { return nil, errors.Wrap(err, "could not compute current justified checkpoint merkleization") } fieldRoots[19] = currJustRoot[:] // FinalizedCheckpoint data structure root. - finalRoot, err := htrutils.CheckpointRoot(hasher, state.FinalizedCheckpoint) + finalRoot, err := ssz.CheckpointRoot(hasher, state.FinalizedCheckpoint) if err != nil { return nil, errors.Wrap(err, "could not compute finalized checkpoint merkleization") } diff --git a/beacon-chain/state/v2/state_trie.go b/beacon-chain/state/v2/state_trie.go index 312b379a58..0698b74afc 100644 --- a/beacon-chain/state/v2/state_trie.go +++ b/beacon-chain/state/v2/state_trie.go @@ -12,9 +12,9 @@ import ( "github.com/prysmaticlabs/prysm/beacon-chain/state/types" "github.com/prysmaticlabs/prysm/container/slice" "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/shared/bytesutil" - "github.com/prysmaticlabs/prysm/shared/htrutils" "github.com/prysmaticlabs/prysm/shared/params" "go.opencensus.io/trace" "google.golang.org/protobuf/proto" @@ -240,15 +240,15 @@ func (b *BeaconState) rootSelector(field types.FieldIndex) ([32]byte, error) { hasher := hash.CustomSHA256Hasher() switch field { case genesisTime: - return htrutils.Uint64Root(b.state.GenesisTime), nil + return ssz.Uint64Root(b.state.GenesisTime), nil case genesisValidatorRoot: return bytesutil.ToBytes32(b.state.GenesisValidatorsRoot), nil case slot: - return htrutils.Uint64Root(uint64(b.state.Slot)), nil + return ssz.Uint64Root(uint64(b.state.Slot)), nil case eth1DepositIndex: - return htrutils.Uint64Root(b.state.Eth1DepositIndex), nil + return ssz.Uint64Root(b.state.Eth1DepositIndex), nil case fork: - return htrutils.ForkRoot(b.state.Fork) + return ssz.ForkRoot(b.state.Fork) case latestBlockHeader: return stateutil.BlockHeaderRoot(b.state.LatestBlockHeader) case blockRoots: @@ -274,7 +274,7 @@ func (b *BeaconState) rootSelector(field types.FieldIndex) ([32]byte, error) { } return b.recomputeFieldTrie(stateRoots, b.state.StateRoots) case historicalRoots: - return htrutils.HistoricalRootsRoot(b.state.HistoricalRoots) + return ssz.ByteArrayRootWithLimit(b.state.HistoricalRoots, params.BeaconConfig().HistoricalRootsLimit) case eth1Data: return eth1Root(hasher, b.state.Eth1Data) case eth1DataVotes: @@ -313,7 +313,7 @@ func (b *BeaconState) rootSelector(field types.FieldIndex) ([32]byte, error) { } return b.recomputeFieldTrie(randaoMixes, b.state.RandaoMixes) case slashings: - return htrutils.SlashingsRoot(b.state.Slashings) + return ssz.SlashingsRoot(b.state.Slashings) case previousEpochParticipationBits: return participationBitsRoot(b.state.PreviousEpochParticipation) case currentEpochParticipationBits: @@ -321,11 +321,11 @@ func (b *BeaconState) rootSelector(field types.FieldIndex) ([32]byte, error) { case justificationBits: return bytesutil.ToBytes32(b.state.JustificationBits), nil case previousJustifiedCheckpoint: - return htrutils.CheckpointRoot(hasher, b.state.PreviousJustifiedCheckpoint) + return ssz.CheckpointRoot(hasher, b.state.PreviousJustifiedCheckpoint) case currentJustifiedCheckpoint: - return htrutils.CheckpointRoot(hasher, b.state.CurrentJustifiedCheckpoint) + return ssz.CheckpointRoot(hasher, b.state.CurrentJustifiedCheckpoint) case finalizedCheckpoint: - return htrutils.CheckpointRoot(hasher, b.state.FinalizedCheckpoint) + return ssz.CheckpointRoot(hasher, b.state.FinalizedCheckpoint) case inactivityScores: return stateutil.Uint64ListRootWithRegistryLimit(b.state.InactivityScores) case currentSyncCommittee: diff --git a/beacon-chain/sync/BUILD.bazel b/beacon-chain/sync/BUILD.bazel index e30d633118..9cf7279f23 100644 --- a/beacon-chain/sync/BUILD.bazel +++ b/beacon-chain/sync/BUILD.bazel @@ -82,6 +82,7 @@ go_library( "//container/slice:go_default_library", "//crypto/bls:go_default_library", "//crypto/rand:go_default_library", + "//encoding/ssz:go_default_library", "//monitoring/tracing:go_default_library", "//network/forks:go_default_library", "//proto/prysm/v1alpha1:go_default_library", @@ -93,7 +94,6 @@ go_library( "//runtime/version:go_default_library", "//shared/bytesutil:go_default_library", "//shared/params:go_default_library", - "//shared/sszutil:go_default_library", "//time:go_default_library", "//time/slots:go_default_library", "@com_github_ferranbt_fastssz//:go_default_library", @@ -186,6 +186,7 @@ go_test( "//cmd/beacon-chain/flags:go_default_library", "//crypto/bls:go_default_library", "//crypto/rand:go_default_library", + "//encoding/ssz:go_default_library", "//network/forks:go_default_library", "//proto/prysm/v1alpha1:go_default_library", "//proto/prysm/v1alpha1/attestation:go_default_library", @@ -194,7 +195,6 @@ go_test( "//proto/prysm/v1alpha1/wrapper:go_default_library", "//shared/bytesutil:go_default_library", "//shared/params:go_default_library", - "//shared/sszutil:go_default_library", "//shared/testutil:go_default_library", "//shared/testutil/assert:go_default_library", "//shared/testutil/require:go_default_library", diff --git a/beacon-chain/sync/pending_blocks_queue.go b/beacon-chain/sync/pending_blocks_queue.go index 8a721c9276..60d82456d9 100644 --- a/beacon-chain/sync/pending_blocks_queue.go +++ b/beacon-chain/sync/pending_blocks_queue.go @@ -14,11 +14,11 @@ import ( "github.com/prysmaticlabs/prysm/beacon-chain/core/helpers" p2ptypes "github.com/prysmaticlabs/prysm/beacon-chain/p2p/types" "github.com/prysmaticlabs/prysm/crypto/rand" + "github.com/prysmaticlabs/prysm/encoding/ssz" "github.com/prysmaticlabs/prysm/monitoring/tracing" "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block" "github.com/prysmaticlabs/prysm/shared/bytesutil" "github.com/prysmaticlabs/prysm/shared/params" - "github.com/prysmaticlabs/prysm/shared/sszutil" "github.com/prysmaticlabs/prysm/time/slots" "github.com/sirupsen/logrus" "github.com/trailofbits/go-mutexasserts" @@ -315,7 +315,7 @@ func (s *Service) deleteBlockFromPendingQueue(slot types.Slot, b block.SignedBea newBlks := make([]block.SignedBeaconBlock, 0, len(blks)) for _, blk := range blks { - if sszutil.DeepEqual(blk.Proto(), b.Proto()) { + if ssz.DeepEqual(blk.Proto(), b.Proto()) { continue } newBlks = append(newBlks, blk) diff --git a/beacon-chain/sync/rpc_metadata_test.go b/beacon-chain/sync/rpc_metadata_test.go index 2d1cda95b4..ddb24f7583 100644 --- a/beacon-chain/sync/rpc_metadata_test.go +++ b/beacon-chain/sync/rpc_metadata_test.go @@ -16,11 +16,11 @@ import ( db "github.com/prysmaticlabs/prysm/beacon-chain/db/testing" "github.com/prysmaticlabs/prysm/beacon-chain/p2p" p2ptest "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing" + "github.com/prysmaticlabs/prysm/encoding/ssz" pb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/metadata" "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper" "github.com/prysmaticlabs/prysm/shared/params" - "github.com/prysmaticlabs/prysm/shared/sszutil" "github.com/prysmaticlabs/prysm/shared/testutil" "github.com/prysmaticlabs/prysm/shared/testutil/assert" "github.com/prysmaticlabs/prysm/shared/testutil/require" @@ -125,7 +125,7 @@ func TestMetadataRPCHandler_SendsMetadata(t *testing.T) { metadata, err := r.sendMetaDataRequest(context.Background(), p2.BHost.ID()) assert.NoError(t, err) - if !sszutil.DeepEqual(metadata.InnerObject(), p2.LocalMetadata.InnerObject()) { + if !ssz.DeepEqual(metadata.InnerObject(), p2.LocalMetadata.InnerObject()) { t.Fatalf("MetadataV0 unequal, received %v but wanted %v", metadata, p2.LocalMetadata) } @@ -213,7 +213,7 @@ func TestMetadataRPCHandler_SendsMetadataAltair(t *testing.T) { metadata, err := r.sendMetaDataRequest(context.Background(), p2.BHost.ID()) assert.NoError(t, err) - if !sszutil.DeepEqual(metadata.InnerObject(), p2.LocalMetadata.InnerObject()) { + if !ssz.DeepEqual(metadata.InnerObject(), p2.LocalMetadata.InnerObject()) { t.Fatalf("MetadataV1 unequal, received %v but wanted %v", metadata, p2.LocalMetadata) } diff --git a/container/trie/BUILD.bazel b/container/trie/BUILD.bazel index 16034261ab..20a431c9cc 100644 --- a/container/trie/BUILD.bazel +++ b/container/trie/BUILD.bazel @@ -20,8 +20,8 @@ go_test( name = "go_default_test", size = "small", srcs = ["sparse_merkle_test.go"], - embed = [":go_default_library"], deps = [ + ":go_default_library", "//contracts/deposit-contract:go_default_library", "//crypto/hash:go_default_library", "//proto/prysm/v1alpha1:go_default_library", diff --git a/container/trie/sparse_merkle_test.go b/container/trie/sparse_merkle_test.go index ebd3d6e497..247aa51cf0 100644 --- a/container/trie/sparse_merkle_test.go +++ b/container/trie/sparse_merkle_test.go @@ -1,10 +1,11 @@ -package trie +package trie_test import ( "strconv" "testing" "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/prysmaticlabs/prysm/container/trie" contracts "github.com/prysmaticlabs/prysm/contracts/deposit-contract" "github.com/prysmaticlabs/prysm/crypto/hash" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" @@ -23,7 +24,7 @@ func TestMarshalDepositWithProof(t *testing.T) { []byte("FFFFFF"), []byte("GGGGGGG"), } - m, err := GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth) + m, err := trie.GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth) require.NoError(t, err) proof, err := m.MerkleProof(2) require.NoError(t, err) @@ -49,27 +50,27 @@ func TestMarshalDepositWithProof(t *testing.T) { func TestMerkleTrie_MerkleProofOutOfRange(t *testing.T) { h := hash.Hash([]byte("hi")) - m := &SparseMerkleTrie{ - branches: [][][]byte{ + m := trie.CreateTrieFromProto(ðpb.SparseMerkleTrie{ + Layers: []*ethpb.TrieLayer{ { - h[:], + Layer: [][]byte{h[:]}, }, { - h[:], + Layer: [][]byte{h[:]}, }, { - []byte{}, + Layer: [][]byte{}, }, }, - depth: 4, - } + Depth: 4, + }) if _, err := m.MerkleProof(6); err == nil { t.Error("Expected out of range failure, received nil", err) } } func TestMerkleTrieRoot_EmptyTrie(t *testing.T) { - trie, err := NewTrie(params.BeaconConfig().DepositContractTreeDepth) + trie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth) require.NoError(t, err) testAccount, err := contracts.Setup() require.NoError(t, err) @@ -80,7 +81,7 @@ func TestMerkleTrieRoot_EmptyTrie(t *testing.T) { } func TestGenerateTrieFromItems_NoItemsProvided(t *testing.T) { - if _, err := GenerateTrieFromItems(nil, params.BeaconConfig().DepositContractTreeDepth); err == nil { + if _, err := trie.GenerateTrieFromItems(nil, params.BeaconConfig().DepositContractTreeDepth); err == nil { t.Error("Expected error when providing nil items received nil") } } @@ -96,19 +97,19 @@ func TestMerkleTrie_VerifyMerkleProof(t *testing.T) { []byte("G"), []byte("H"), } - m, err := GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth) + m, err := trie.GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth) require.NoError(t, err) proof, err := m.MerkleProof(0) require.NoError(t, err) require.Equal(t, int(params.BeaconConfig().DepositContractTreeDepth)+1, len(proof)) root := m.HashTreeRoot() - if ok := VerifyMerkleBranch(root[:], items[0], 0, proof, params.BeaconConfig().DepositContractTreeDepth); !ok { + if ok := trie.VerifyMerkleBranch(root[:], items[0], 0, proof, params.BeaconConfig().DepositContractTreeDepth); !ok { t.Error("First Merkle proof did not verify") } proof, err = m.MerkleProof(3) require.NoError(t, err) - require.Equal(t, true, VerifyMerkleBranch(root[:], items[3], 3, proof, params.BeaconConfig().DepositContractTreeDepth)) - require.Equal(t, false, VerifyMerkleBranch(root[:], []byte("buzz"), 3, proof, params.BeaconConfig().DepositContractTreeDepth)) + require.Equal(t, true, trie.VerifyMerkleBranch(root[:], items[3], 3, proof, params.BeaconConfig().DepositContractTreeDepth)) + require.Equal(t, false, trie.VerifyMerkleBranch(root[:], []byte("buzz"), 3, proof, params.BeaconConfig().DepositContractTreeDepth)) } func TestMerkleTrie_VerifyMerkleProof_TrieUpdated(t *testing.T) { @@ -119,22 +120,22 @@ func TestMerkleTrie_VerifyMerkleProof_TrieUpdated(t *testing.T) { {4}, } depth := params.BeaconConfig().DepositContractTreeDepth + 1 - m, err := GenerateTrieFromItems(items, depth) + m, err := trie.GenerateTrieFromItems(items, depth) require.NoError(t, err) proof, err := m.MerkleProof(0) require.NoError(t, err) root := m.HashTreeRoot() - require.Equal(t, true, VerifyMerkleBranch(root[:], items[0], 0, proof, depth)) + require.Equal(t, true, trie.VerifyMerkleBranch(root[:], items[0], 0, proof, depth)) // Now we update the trie. m.Insert([]byte{5}, 3) proof, err = m.MerkleProof(3) require.NoError(t, err) root = m.HashTreeRoot() - if ok := VerifyMerkleBranch(root[:], []byte{5}, 3, proof, depth); !ok { + if ok := trie.VerifyMerkleBranch(root[:], []byte{5}, 3, proof, depth); !ok { t.Error("Second Merkle proof did not verify") } - if ok := VerifyMerkleBranch(root[:], []byte{4}, 3, proof, depth); ok { + if ok := trie.VerifyMerkleBranch(root[:], []byte{4}, 3, proof, depth); ok { t.Error("Old item should not verify") } @@ -149,13 +150,13 @@ func TestRoundtripProto_OK(t *testing.T) { {3}, {4}, } - m, err := GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth+1) + m, err := trie.GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth+1) require.NoError(t, err) protoTrie := m.ToProto() depositRoot := m.HashTreeRoot() - newTrie := CreateTrieFromProto(protoTrie) + newTrie := trie.CreateTrieFromProto(protoTrie) require.DeepEqual(t, depositRoot, newTrie.HashTreeRoot()) } @@ -167,7 +168,7 @@ func TestCopy_OK(t *testing.T) { {3}, {4}, } - source, err := GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth+1) + source, err := trie.GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth+1) require.NoError(t, err) copiedTrie := source.Copy() @@ -189,7 +190,7 @@ func BenchmarkGenerateTrieFromItems(b *testing.B) { []byte("GGGGGGG"), } for i := 0; i < b.N; i++ { - _, err := GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth) + _, err := trie.GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth) require.NoError(b, err, "Could not generate Merkle trie from items") } } @@ -202,7 +203,7 @@ func BenchmarkInsertTrie_Optimized(b *testing.B) { someRoot := bytesutil.ToBytes32([]byte(strconv.Itoa(i))) items[i] = someRoot[:] } - tr, err := GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth) + tr, err := trie.GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth) require.NoError(b, err) someItem := bytesutil.ToBytes32([]byte("hello-world")) @@ -223,7 +224,7 @@ func BenchmarkGenerateProof(b *testing.B) { []byte("FFFFFF"), []byte("GGGGGGG"), } - normalTrie, err := GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth) + normalTrie, err := trie.GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth) require.NoError(b, err) b.StartTimer() @@ -244,7 +245,7 @@ func BenchmarkVerifyMerkleBranch(b *testing.B) { []byte("FFFFFF"), []byte("GGGGGGG"), } - m, err := GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth) + m, err := trie.GenerateTrieFromItems(items, params.BeaconConfig().DepositContractTreeDepth) require.NoError(b, err) proof, err := m.MerkleProof(2) require.NoError(b, err) @@ -252,7 +253,7 @@ func BenchmarkVerifyMerkleBranch(b *testing.B) { root := m.HashTreeRoot() b.StartTimer() for i := 0; i < b.N; i++ { - if ok := VerifyMerkleBranch(root[:], items[2], 2, proof, params.BeaconConfig().DepositContractTreeDepth); !ok { + if ok := trie.VerifyMerkleBranch(root[:], items[2], 2, proof, params.BeaconConfig().DepositContractTreeDepth); !ok { b.Error("Merkle proof did not verify") } } diff --git a/shared/htrutils/BUILD.bazel b/encoding/ssz/BUILD.bazel similarity index 82% rename from shared/htrutils/BUILD.bazel rename to encoding/ssz/BUILD.bazel index e67cd832b6..f55ef705ca 100644 --- a/shared/htrutils/BUILD.bazel +++ b/encoding/ssz/BUILD.bazel @@ -3,12 +3,13 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test") go_library( name = "go_default_library", srcs = [ + "deep_equal.go", "hashers.go", "helpers.go", "htrutils.go", "merkleize.go", ], - importpath = "github.com/prysmaticlabs/prysm/shared/htrutils", + importpath = "github.com/prysmaticlabs/prysm/encoding/ssz", visibility = ["//visibility:public"], deps = [ "//container/trie:go_default_library", @@ -18,7 +19,9 @@ go_library( "//shared/params:go_default_library", "@com_github_minio_sha256_simd//:go_default_library", "@com_github_pkg_errors//:go_default_library", + "@com_github_prysmaticlabs_eth2_types//:go_default_library", "@com_github_prysmaticlabs_go_bitfield//:go_default_library", + "@org_golang_google_protobuf//proto:go_default_library", ], ) @@ -26,6 +29,7 @@ go_test( name = "go_default_test", size = "small", srcs = [ + "deep_equal_test.go", "hashers_test.go", "helpers_test.go", "htrutils_test.go", diff --git a/shared/sszutil/deep_equal.go b/encoding/ssz/deep_equal.go similarity index 99% rename from shared/sszutil/deep_equal.go rename to encoding/ssz/deep_equal.go index 8c701dc059..a2dd0b2158 100644 --- a/shared/sszutil/deep_equal.go +++ b/encoding/ssz/deep_equal.go @@ -1,4 +1,4 @@ -package sszutil +package ssz import ( "reflect" @@ -22,7 +22,7 @@ type visit struct { // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // -// This file extends Go's reflect.DeepEqual function into a sszutil.DeepEqual +// This file extends Go's reflect.DeepEqual function into a ssz.DeepEqual // function that is compliant with the supported types of ssz and its // intricacies when determining equality of empty values. // diff --git a/shared/sszutil/deep_equal_test.go b/encoding/ssz/deep_equal_test.go similarity index 55% rename from shared/sszutil/deep_equal_test.go rename to encoding/ssz/deep_equal_test.go index e016eb9658..74fb0006ec 100644 --- a/shared/sszutil/deep_equal_test.go +++ b/encoding/ssz/deep_equal_test.go @@ -1,34 +1,34 @@ -package sszutil_test +package ssz_test import ( "testing" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" - "github.com/prysmaticlabs/prysm/shared/sszutil" "github.com/prysmaticlabs/prysm/shared/testutil/assert" ) func TestDeepEqualBasicTypes(t *testing.T) { - assert.Equal(t, true, sszutil.DeepEqual(true, true)) - assert.Equal(t, false, sszutil.DeepEqual(true, false)) + assert.Equal(t, true, ssz.DeepEqual(true, true)) + assert.Equal(t, false, ssz.DeepEqual(true, false)) - assert.Equal(t, true, sszutil.DeepEqual(byte(222), byte(222))) - assert.Equal(t, false, sszutil.DeepEqual(byte(222), byte(111))) + assert.Equal(t, true, ssz.DeepEqual(byte(222), byte(222))) + assert.Equal(t, false, ssz.DeepEqual(byte(222), byte(111))) - assert.Equal(t, true, sszutil.DeepEqual(uint64(1234567890), uint64(1234567890))) - assert.Equal(t, false, sszutil.DeepEqual(uint64(1234567890), uint64(987653210))) + assert.Equal(t, true, ssz.DeepEqual(uint64(1234567890), uint64(1234567890))) + assert.Equal(t, false, ssz.DeepEqual(uint64(1234567890), uint64(987653210))) - assert.Equal(t, true, sszutil.DeepEqual("hello", "hello")) - assert.Equal(t, false, sszutil.DeepEqual("hello", "world")) + assert.Equal(t, true, ssz.DeepEqual("hello", "hello")) + assert.Equal(t, false, ssz.DeepEqual("hello", "world")) - assert.Equal(t, true, sszutil.DeepEqual([3]byte{1, 2, 3}, [3]byte{1, 2, 3})) - assert.Equal(t, false, sszutil.DeepEqual([3]byte{1, 2, 3}, [3]byte{1, 2, 4})) + assert.Equal(t, true, ssz.DeepEqual([3]byte{1, 2, 3}, [3]byte{1, 2, 3})) + assert.Equal(t, false, ssz.DeepEqual([3]byte{1, 2, 3}, [3]byte{1, 2, 4})) var nilSlice1, nilSlice2 []byte - assert.Equal(t, true, sszutil.DeepEqual(nilSlice1, nilSlice2)) - assert.Equal(t, true, sszutil.DeepEqual(nilSlice1, []byte{})) - assert.Equal(t, true, sszutil.DeepEqual([]byte{1, 2, 3}, []byte{1, 2, 3})) - assert.Equal(t, false, sszutil.DeepEqual([]byte{1, 2, 3}, []byte{1, 2, 4})) + assert.Equal(t, true, ssz.DeepEqual(nilSlice1, nilSlice2)) + assert.Equal(t, true, ssz.DeepEqual(nilSlice1, []byte{})) + assert.Equal(t, true, ssz.DeepEqual([]byte{1, 2, 3}, []byte{1, 2, 3})) + assert.Equal(t, false, ssz.DeepEqual([]byte{1, 2, 3}, []byte{1, 2, 4})) } func TestDeepEqualStructs(t *testing.T) { @@ -39,8 +39,8 @@ func TestDeepEqualStructs(t *testing.T) { store1 := Store{uint64(1234), nil} store2 := Store{uint64(1234), []byte{}} store3 := Store{uint64(4321), []byte{}} - assert.Equal(t, true, sszutil.DeepEqual(store1, store2)) - assert.Equal(t, false, sszutil.DeepEqual(store1, store3)) + assert.Equal(t, true, ssz.DeepEqual(store1, store2)) + assert.Equal(t, false, ssz.DeepEqual(store1, store3)) } func TestDeepEqualStructs_Unexported(t *testing.T) { @@ -53,14 +53,14 @@ func TestDeepEqualStructs_Unexported(t *testing.T) { store2 := Store{uint64(1234), []byte{}, "hi there"} store3 := Store{uint64(4321), []byte{}, "wow"} store4 := Store{uint64(4321), []byte{}, "bow wow"} - assert.Equal(t, true, sszutil.DeepEqual(store1, store2)) - assert.Equal(t, false, sszutil.DeepEqual(store1, store3)) - assert.Equal(t, false, sszutil.DeepEqual(store3, store4)) + assert.Equal(t, true, ssz.DeepEqual(store1, store2)) + assert.Equal(t, false, ssz.DeepEqual(store1, store3)) + assert.Equal(t, false, ssz.DeepEqual(store3, store4)) } func TestDeepEqualProto(t *testing.T) { var fork1, fork2 *ethpb.Fork - assert.Equal(t, true, sszutil.DeepEqual(fork1, fork2)) + assert.Equal(t, true, ssz.DeepEqual(fork1, fork2)) fork1 = ðpb.Fork{ PreviousVersion: []byte{123}, @@ -72,8 +72,8 @@ func TestDeepEqualProto(t *testing.T) { CurrentVersion: []byte{125}, Epoch: 1234567890, } - assert.Equal(t, true, sszutil.DeepEqual(fork1, fork1)) - assert.Equal(t, false, sszutil.DeepEqual(fork1, fork2)) + assert.Equal(t, true, ssz.DeepEqual(fork1, fork1)) + assert.Equal(t, false, ssz.DeepEqual(fork1, fork2)) checkpoint1 := ðpb.Checkpoint{ Epoch: 1234567890, @@ -83,7 +83,7 @@ func TestDeepEqualProto(t *testing.T) { Epoch: 1234567890, Root: nil, } - assert.Equal(t, true, sszutil.DeepEqual(checkpoint1, checkpoint2)) + assert.Equal(t, true, ssz.DeepEqual(checkpoint1, checkpoint2)) } func Test_IsProto(t *testing.T) { @@ -125,7 +125,7 @@ func Test_IsProto(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - if got := sszutil.IsProto(tt.item); got != tt.want { + if got := ssz.IsProto(tt.item); got != tt.want { t.Errorf("isProtoSlice() = %v, want %v", got, tt.want) } }) diff --git a/shared/htrutils/hashers.go b/encoding/ssz/hashers.go similarity index 94% rename from shared/htrutils/hashers.go rename to encoding/ssz/hashers.go index da9df143d0..1e13532e14 100644 --- a/shared/htrutils/hashers.go +++ b/encoding/ssz/hashers.go @@ -1,5 +1,4 @@ -// Package htrutils defines HashTreeRoot utility functions. -package htrutils +package ssz import "encoding/binary" diff --git a/shared/htrutils/hashers_test.go b/encoding/ssz/hashers_test.go similarity index 85% rename from shared/htrutils/hashers_test.go rename to encoding/ssz/hashers_test.go index dab6f22844..0f9ff62117 100644 --- a/shared/htrutils/hashers_test.go +++ b/encoding/ssz/hashers_test.go @@ -1,16 +1,16 @@ -package htrutils_test +package ssz_test import ( "testing" "github.com/prysmaticlabs/prysm/crypto/hash" - "github.com/prysmaticlabs/prysm/shared/htrutils" + "github.com/prysmaticlabs/prysm/encoding/ssz" "github.com/prysmaticlabs/prysm/shared/testutil/assert" ) func TestHash(t *testing.T) { byteSlice := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9} - hasher := htrutils.NewHasherFunc(hash.CustomSHA256Hasher()) + hasher := ssz.NewHasherFunc(hash.CustomSHA256Hasher()) expected := [32]byte{71, 228, 238, 127, 33, 31, 115, 38, 93, 209, 118, 88, 246, 226, 28, 19, 24, 189, 108, 129, 243, 117, 152, 226, 10, 39, 86, 41, 149, 66, 239, 207} result := hasher.Hash(byteSlice) assert.Equal(t, expected, result) @@ -19,7 +19,7 @@ func TestHash(t *testing.T) { func TestCombi(t *testing.T) { byteSlice1 := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32} byteSlice2 := [32]byte{32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1} - hasher := htrutils.NewHasherFunc(hash.CustomSHA256Hasher()) + hasher := ssz.NewHasherFunc(hash.CustomSHA256Hasher()) expected := [32]byte{203, 73, 0, 148, 142, 9, 145, 147, 186, 232, 143, 117, 95, 44, 38, 46, 102, 69, 101, 74, 50, 37, 87, 189, 40, 196, 203, 140, 19, 233, 161, 225} result := hasher.Combi(byteSlice1, byteSlice2) assert.Equal(t, expected, result) @@ -28,7 +28,7 @@ func TestCombi(t *testing.T) { func TestMixIn(t *testing.T) { byteSlice := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32} intToAdd := uint64(33) - hasher := htrutils.NewHasherFunc(hash.CustomSHA256Hasher()) + hasher := ssz.NewHasherFunc(hash.CustomSHA256Hasher()) expected := [32]byte{170, 90, 0, 249, 34, 60, 140, 68, 77, 51, 218, 139, 54, 119, 179, 238, 80, 72, 13, 20, 212, 218, 124, 215, 68, 122, 214, 157, 178, 85, 225, 213} result := hasher.MixIn(byteSlice, intToAdd) assert.Equal(t, expected, result) diff --git a/shared/htrutils/helpers.go b/encoding/ssz/helpers.go similarity index 98% rename from shared/htrutils/helpers.go rename to encoding/ssz/helpers.go index ad585a106b..04a1b69392 100644 --- a/shared/htrutils/helpers.go +++ b/encoding/ssz/helpers.go @@ -1,5 +1,5 @@ -// Package htrutils defines HashTreeRoot utility functions. -package htrutils +// Package ssz defines HashTreeRoot utility functions. +package ssz import ( "bytes" diff --git a/shared/htrutils/helpers_test.go b/encoding/ssz/helpers_test.go similarity index 86% rename from shared/htrutils/helpers_test.go rename to encoding/ssz/helpers_test.go index a71b4ef5f9..b414b9e471 100644 --- a/shared/htrutils/helpers_test.go +++ b/encoding/ssz/helpers_test.go @@ -1,11 +1,11 @@ -package htrutils_test +package ssz_test import ( "testing" "github.com/prysmaticlabs/go-bitfield" "github.com/prysmaticlabs/prysm/crypto/hash" - "github.com/prysmaticlabs/prysm/shared/htrutils" + "github.com/prysmaticlabs/prysm/encoding/ssz" "github.com/prysmaticlabs/prysm/shared/testutil/assert" "github.com/prysmaticlabs/prysm/shared/testutil/require" ) @@ -18,7 +18,7 @@ func TestBitlistRoot(t *testing.T) { bfield := bitfield.NewBitlist(capacity) expected := [32]byte{176, 76, 194, 203, 142, 166, 117, 79, 148, 194, 231, 64, 60, 245, 142, 32, 201, 2, 58, 152, 53, 12, 132, 40, 41, 102, 224, 189, 103, 41, 211, 202} - result, err := htrutils.BitlistRoot(hasher, bfield, capacity) + result, err := ssz.BitlistRoot(hasher, bfield, capacity) require.NoError(t, err) assert.Equal(t, expected, result) } @@ -33,7 +33,7 @@ func TestBitwiseMerkleize(t *testing.T) { limit := uint64(2) expected := [32]byte{194, 32, 213, 52, 220, 127, 18, 240, 43, 151, 19, 79, 188, 175, 142, 177, 208, 46, 96, 20, 18, 231, 208, 29, 120, 102, 122, 17, 46, 31, 155, 30} - result, err := htrutils.BitwiseMerkleize(hasher, chunks, count, limit) + result, err := ssz.BitwiseMerkleize(hasher, chunks, count, limit) require.NoError(t, err) assert.Equal(t, expected, result) } @@ -47,7 +47,7 @@ func TestBitwiseMerkleizeOverLimit(t *testing.T) { count := uint64(2) limit := uint64(1) - _, err := htrutils.BitwiseMerkleize(hasher, chunks, count, limit) + _, err := ssz.BitwiseMerkleize(hasher, chunks, count, limit) assert.ErrorContains(t, merkleizingListLimitError, err) } @@ -61,7 +61,7 @@ func TestBitwiseMerkleizeArrays(t *testing.T) { limit := uint64(2) expected := [32]byte{138, 81, 210, 194, 151, 231, 249, 241, 64, 118, 209, 58, 145, 109, 225, 89, 118, 110, 159, 220, 193, 183, 203, 124, 166, 24, 65, 26, 160, 215, 233, 219} - result, err := htrutils.BitwiseMerkleizeArrays(hasher, chunks, count, limit) + result, err := ssz.BitwiseMerkleizeArrays(hasher, chunks, count, limit) require.NoError(t, err) assert.Equal(t, expected, result) } @@ -75,7 +75,7 @@ func TestBitwiseMerkleizeArraysOverLimit(t *testing.T) { count := uint64(2) limit := uint64(1) - _, err := htrutils.BitwiseMerkleizeArrays(hasher, chunks, count, limit) + _, err := ssz.BitwiseMerkleizeArrays(hasher, chunks, count, limit) assert.ErrorContains(t, merkleizingListLimitError, err) } @@ -86,7 +86,7 @@ func TestPack(t *testing.T) { } expected := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 1, 2, 3, 5, 8, 13, 21, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} - result, err := htrutils.Pack(byteSlice2D) + result, err := ssz.Pack(byteSlice2D) require.NoError(t, err) assert.Equal(t, len(expected), len(result[0])) for i, v := range expected { @@ -98,6 +98,6 @@ func TestMixInLength(t *testing.T) { byteSlice := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32} length := []byte{1, 2, 3} expected := [32]byte{105, 60, 167, 169, 197, 220, 122, 99, 59, 14, 250, 12, 251, 62, 135, 239, 29, 68, 140, 1, 6, 36, 207, 44, 64, 221, 76, 230, 237, 218, 150, 88} - result := htrutils.MixInLength(byteSlice, length) + result := ssz.MixInLength(byteSlice, length) assert.Equal(t, expected, result) } diff --git a/shared/htrutils/htrutils.go b/encoding/ssz/htrutils.go similarity index 74% rename from shared/htrutils/htrutils.go rename to encoding/ssz/htrutils.go index 624c121cc4..2bf0391673 100644 --- a/shared/htrutils/htrutils.go +++ b/encoding/ssz/htrutils.go @@ -1,5 +1,4 @@ -// Package htrutils defines HashTreeRoot utility functions. -package htrutils +package ssz import ( "bytes" @@ -56,22 +55,22 @@ func CheckpointRoot(hasher HashFn, checkpoint *ethpb.Checkpoint) ([32]byte, erro return BitwiseMerkleize(hasher, fieldRoots, uint64(len(fieldRoots)), uint64(len(fieldRoots))) } -// HistoricalRootsRoot computes the HashTreeRoot Merkleization of -// a list of [32]byte historical block roots according to the Ethereum -// Simple Serialize specification. -func HistoricalRootsRoot(historicalRoots [][]byte) ([32]byte, error) { - result, err := BitwiseMerkleize(hash.CustomSHA256Hasher(), historicalRoots, uint64(len(historicalRoots)), params.BeaconConfig().HistoricalRootsLimit) +// ByteArrayRootWithLimit computes the HashTreeRoot Merkleization of +// a list of [32]byte roots according to the Ethereum Simple Serialize +// specification. +func ByteArrayRootWithLimit(roots [][]byte, limit uint64) ([32]byte, error) { + result, err := BitwiseMerkleize(hash.CustomSHA256Hasher(), roots, uint64(len(roots)), limit) if err != nil { - return [32]byte{}, errors.Wrap(err, "could not compute historical roots merkleization") + return [32]byte{}, errors.Wrap(err, "could not compute byte array merkleization") } - historicalRootsBuf := new(bytes.Buffer) - if err := binary.Write(historicalRootsBuf, binary.LittleEndian, uint64(len(historicalRoots))); err != nil { - return [32]byte{}, errors.Wrap(err, "could not marshal historical roots length") + buf := new(bytes.Buffer) + if err := binary.Write(buf, binary.LittleEndian, uint64(len(roots))); err != nil { + return [32]byte{}, errors.Wrap(err, "could not marshal byte array length") } // We need to mix in the length of the slice. - historicalRootsOutput := make([]byte, 32) - copy(historicalRootsOutput, historicalRootsBuf.Bytes()) - mixedLen := MixInLength(result, historicalRootsOutput) + output := make([]byte, 32) + copy(output, buf.Bytes()) + mixedLen := MixInLength(result, output) return mixedLen, nil } diff --git a/shared/htrutils/htrutils_test.go b/encoding/ssz/htrutils_test.go similarity index 82% rename from shared/htrutils/htrutils_test.go rename to encoding/ssz/htrutils_test.go index 5590fb5dd3..7c4018af0d 100644 --- a/shared/htrutils/htrutils_test.go +++ b/encoding/ssz/htrutils_test.go @@ -1,11 +1,11 @@ -package htrutils_test +package ssz_test import ( "testing" "github.com/prysmaticlabs/prysm/crypto/hash" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" - "github.com/prysmaticlabs/prysm/shared/htrutils" "github.com/prysmaticlabs/prysm/shared/testutil/assert" "github.com/prysmaticlabs/prysm/shared/testutil/require" ) @@ -14,7 +14,7 @@ func TestUint64Root(t *testing.T) { uintVal := uint64(1234567890) expected := [32]byte{210, 2, 150, 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} - result := htrutils.Uint64Root(uintVal) + result := ssz.Uint64Root(uintVal) assert.Equal(t, expected, result) } @@ -26,7 +26,7 @@ func TestForkRoot(t *testing.T) { } expected := [32]byte{19, 46, 77, 103, 92, 175, 247, 33, 100, 64, 17, 111, 199, 145, 69, 38, 217, 112, 6, 16, 149, 201, 225, 144, 192, 228, 197, 172, 157, 78, 114, 140} - result, err := htrutils.ForkRoot(&testFork) + result, err := ssz.ForkRoot(&testFork) require.NoError(t, err) assert.Equal(t, expected, result) } @@ -39,16 +39,16 @@ func TestCheckPointRoot(t *testing.T) { } expected := [32]byte{228, 65, 39, 109, 183, 249, 167, 232, 125, 239, 25, 155, 207, 4, 84, 174, 176, 229, 175, 224, 62, 33, 215, 254, 170, 220, 132, 65, 246, 128, 68, 194} - result, err := htrutils.CheckpointRoot(testHasher, &testCheckpoint) + result, err := ssz.CheckpointRoot(testHasher, &testCheckpoint) require.NoError(t, err) assert.Equal(t, expected, result) } -func TestHistoricalRootsRoot(t *testing.T) { +func TestByteArrayRootWithLimit(t *testing.T) { testHistoricalRoots := [][]byte{{123}, {234}} expected := [32]byte{70, 204, 150, 196, 89, 138, 190, 205, 65, 207, 120, 166, 179, 247, 147, 20, 29, 133, 117, 116, 151, 234, 129, 32, 22, 15, 79, 178, 98, 73, 132, 152} - result, err := htrutils.HistoricalRootsRoot(testHistoricalRoots) + result, err := ssz.ByteArrayRootWithLimit(testHistoricalRoots, 16777216) require.NoError(t, err) assert.Equal(t, expected, result) } @@ -57,7 +57,7 @@ func TestSlashingsRoot(t *testing.T) { testSlashingsRoot := []uint64{123, 234} expected := [32]byte{123, 0, 0, 0, 0, 0, 0, 0, 234, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} - result, err := htrutils.SlashingsRoot(testSlashingsRoot) + result, err := ssz.SlashingsRoot(testSlashingsRoot) require.NoError(t, err) assert.Equal(t, expected, result) } diff --git a/shared/htrutils/merkleize.go b/encoding/ssz/merkleize.go similarity index 98% rename from shared/htrutils/merkleize.go rename to encoding/ssz/merkleize.go index 928c4b061a..67caa55783 100644 --- a/shared/htrutils/merkleize.go +++ b/encoding/ssz/merkleize.go @@ -1,5 +1,4 @@ -// Package htrutils defines HashTreeRoot utility functions. -package htrutils +package ssz import ( "github.com/prysmaticlabs/prysm/container/trie" diff --git a/shared/htrutils/merkleize_test.go b/encoding/ssz/merkleize_test.go similarity index 73% rename from shared/htrutils/merkleize_test.go rename to encoding/ssz/merkleize_test.go index 18de02a479..612c1a4386 100644 --- a/shared/htrutils/merkleize_test.go +++ b/encoding/ssz/merkleize_test.go @@ -1,10 +1,10 @@ -package htrutils_test +package ssz_test import ( "testing" "github.com/prysmaticlabs/prysm/crypto/hash" - "github.com/prysmaticlabs/prysm/shared/htrutils" + "github.com/prysmaticlabs/prysm/encoding/ssz" "github.com/prysmaticlabs/prysm/shared/testutil/assert" ) @@ -12,12 +12,12 @@ func TestGetDepth(t *testing.T) { trieSize := uint64(896745231) expected := uint8(30) - result := htrutils.Depth(trieSize) + result := ssz.Depth(trieSize) assert.Equal(t, expected, result) } func TestMerkleizeCountGreaterThanLimit(t *testing.T) { - hashFn := htrutils.NewHasherFunc(hash.CustomSHA256Hasher()) + hashFn := ssz.NewHasherFunc(hash.CustomSHA256Hasher()) count := uint64(2) limit := uint64(1) chunks := [][]byte{{}} @@ -30,11 +30,11 @@ func TestMerkleizeCountGreaterThanLimit(t *testing.T) { t.Errorf("The code did not panic.") } }() - htrutils.Merkleize(hashFn, count, limit, leafIndexer) + ssz.Merkleize(hashFn, count, limit, leafIndexer) } func TestMerkleizeLimitAndCountAreZero(t *testing.T) { - hashFn := htrutils.NewHasherFunc(hash.CustomSHA256Hasher()) + hashFn := ssz.NewHasherFunc(hash.CustomSHA256Hasher()) count := uint64(0) limit := uint64(0) chunks := [][]byte{{}} @@ -42,12 +42,12 @@ func TestMerkleizeLimitAndCountAreZero(t *testing.T) { return chunks[i] } expected := [32]byte{} - result := htrutils.Merkleize(hashFn, count, limit, leafIndexer) + result := ssz.Merkleize(hashFn, count, limit, leafIndexer) assert.Equal(t, expected, result) } func TestMerkleizeNormalPath(t *testing.T) { - hashFn := htrutils.NewHasherFunc(hash.CustomSHA256Hasher()) + hashFn := ssz.NewHasherFunc(hash.CustomSHA256Hasher()) count := uint64(2) limit := uint64(3) chunks := [][]byte{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}} @@ -55,12 +55,12 @@ func TestMerkleizeNormalPath(t *testing.T) { return chunks[i] } expected := [32]byte{95, 27, 253, 237, 215, 58, 147, 198, 175, 194, 180, 231, 154, 130, 205, 68, 146, 112, 225, 86, 6, 103, 186, 82, 7, 142, 33, 189, 174, 56, 199, 173} - result := htrutils.Merkleize(hashFn, count, limit, leafIndexer) + result := ssz.Merkleize(hashFn, count, limit, leafIndexer) assert.Equal(t, expected, result) } func TestConstructProofCountGreaterThanLimit(t *testing.T) { - hashFn := htrutils.NewHasherFunc(hash.CustomSHA256Hasher()) + hashFn := ssz.NewHasherFunc(hash.CustomSHA256Hasher()) count := uint64(2) limit := uint64(1) chunks := [][]byte{{}} @@ -73,11 +73,11 @@ func TestConstructProofCountGreaterThanLimit(t *testing.T) { t.Errorf("The code did not panic.") } }() - htrutils.ConstructProof(hashFn, count, limit, leafIndexer, index) + ssz.ConstructProof(hashFn, count, limit, leafIndexer, index) } func TestConstructProofIndexGreaterThanEqualToLimit(t *testing.T) { - hashFn := htrutils.NewHasherFunc(hash.CustomSHA256Hasher()) + hashFn := ssz.NewHasherFunc(hash.CustomSHA256Hasher()) count := uint64(1) limit := uint64(1) chunks := [][]byte{{}} @@ -90,11 +90,11 @@ func TestConstructProofIndexGreaterThanEqualToLimit(t *testing.T) { t.Errorf("The code did not panic.") } }() - htrutils.ConstructProof(hashFn, count, limit, leafIndexer, index) + ssz.ConstructProof(hashFn, count, limit, leafIndexer, index) } func TestConstructProofNormalPath(t *testing.T) { - hashFn := htrutils.NewHasherFunc(hash.CustomSHA256Hasher()) + hashFn := ssz.NewHasherFunc(hash.CustomSHA256Hasher()) count := uint64(2) limit := uint64(3) chunks := [][]byte{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}} @@ -106,7 +106,7 @@ func TestConstructProofNormalPath(t *testing.T) { {1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169, 39, 89, 251, 75}, } - result := htrutils.ConstructProof(hashFn, count, limit, leafIndexer, index) + result := ssz.ConstructProof(hashFn, count, limit, leafIndexer, index) assert.Equal(t, len(expected), len(result)) for i, v := range expected { assert.DeepEqual(t, result[i], v) diff --git a/proto/prysm/v1alpha1/attestation/aggregation/attestations/BUILD.bazel b/proto/prysm/v1alpha1/attestation/aggregation/attestations/BUILD.bazel index d6de399434..f01e950ff9 100644 --- a/proto/prysm/v1alpha1/attestation/aggregation/attestations/BUILD.bazel +++ b/proto/prysm/v1alpha1/attestation/aggregation/attestations/BUILD.bazel @@ -31,11 +31,11 @@ go_test( deps = [ "//config/features:go_default_library", "//crypto/bls:go_default_library", + "//encoding/ssz:go_default_library", "//proto/prysm/v1alpha1:go_default_library", "//proto/prysm/v1alpha1/attestation/aggregation:go_default_library", "//proto/prysm/v1alpha1/attestation/aggregation/testing:go_default_library", "//shared/params:go_default_library", - "//shared/sszutil:go_default_library", "//shared/testutil/assert:go_default_library", "//shared/testutil/require:go_default_library", "@com_github_prysmaticlabs_go_bitfield//:go_default_library", diff --git a/proto/prysm/v1alpha1/attestation/aggregation/attestations/attestations_test.go b/proto/prysm/v1alpha1/attestation/aggregation/attestations/attestations_test.go index d90e3f0727..58dcc3aed6 100644 --- a/proto/prysm/v1alpha1/attestation/aggregation/attestations/attestations_test.go +++ b/proto/prysm/v1alpha1/attestation/aggregation/attestations/attestations_test.go @@ -9,11 +9,11 @@ import ( "github.com/prysmaticlabs/go-bitfield" "github.com/prysmaticlabs/prysm/config/features" "github.com/prysmaticlabs/prysm/crypto/bls" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation/aggregation" aggtesting "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/attestation/aggregation/testing" "github.com/prysmaticlabs/prysm/shared/params" - "github.com/prysmaticlabs/prysm/shared/sszutil" "github.com/prysmaticlabs/prysm/shared/testutil/assert" "github.com/prysmaticlabs/prysm/shared/testutil/require" "github.com/sirupsen/logrus" @@ -54,7 +54,7 @@ func TestAggregateAttestations_AggregatePair(t *testing.T) { for _, tt := range tests { got, err := AggregatePair(tt.a1, tt.a2) require.NoError(t, err) - require.Equal(t, true, sszutil.DeepEqual(got, tt.want)) + require.Equal(t, true, ssz.DeepEqual(got, tt.want)) } } diff --git a/proto/prysm/v1alpha1/cloners_test.go b/proto/prysm/v1alpha1/cloners_test.go index 54ddfd7c11..d65a648ca5 100644 --- a/proto/prysm/v1alpha1/cloners_test.go +++ b/proto/prysm/v1alpha1/cloners_test.go @@ -1,17 +1,18 @@ -package eth +package eth_test import ( "math/rand" "reflect" "testing" + v1alpha1 "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/shared/testutil/assert" ) func TestCopyETH1Data(t *testing.T) { data := genEth1Data() - got := CopyETH1Data(data) + got := v1alpha1.CopyETH1Data(data) if !reflect.DeepEqual(got, data) { t.Errorf("CopyETH1Data() = %v, want %v", got, data) } @@ -21,7 +22,7 @@ func TestCopyETH1Data(t *testing.T) { func TestCopyPendingAttestation(t *testing.T) { pa := genPendingAttestation() - got := CopyPendingAttestation(pa) + got := v1alpha1.CopyPendingAttestation(pa) if !reflect.DeepEqual(got, pa) { t.Errorf("CopyPendingAttestation() = %v, want %v", got, pa) } @@ -31,7 +32,7 @@ func TestCopyPendingAttestation(t *testing.T) { func TestCopyAttestation(t *testing.T) { att := genAttestation() - got := CopyAttestation(att) + got := v1alpha1.CopyAttestation(att) if !reflect.DeepEqual(got, att) { t.Errorf("CopyAttestation() = %v, want %v", got, att) } @@ -40,7 +41,7 @@ func TestCopyAttestation(t *testing.T) { func TestCopyAttestationData(t *testing.T) { att := genAttData() - got := CopyAttestationData(att) + got := v1alpha1.CopyAttestationData(att) if !reflect.DeepEqual(got, att) { t.Errorf("CopyAttestationData() = %v, want %v", got, att) } @@ -50,7 +51,7 @@ func TestCopyAttestationData(t *testing.T) { func TestCopyCheckpoint(t *testing.T) { cp := genCheckpoint() - got := CopyCheckpoint(cp) + got := v1alpha1.CopyCheckpoint(cp) if !reflect.DeepEqual(got, cp) { t.Errorf("CopyCheckpoint() = %v, want %v", got, cp) } @@ -60,7 +61,7 @@ func TestCopyCheckpoint(t *testing.T) { func TestCopySignedBeaconBlock(t *testing.T) { blk := genSignedBeaconBlock() - got := CopySignedBeaconBlock(blk) + got := v1alpha1.CopySignedBeaconBlock(blk) if !reflect.DeepEqual(got, blk) { t.Errorf("CopySignedBeaconBlock() = %v, want %v", got, blk) } @@ -70,7 +71,7 @@ func TestCopySignedBeaconBlock(t *testing.T) { func TestCopyBeaconBlock(t *testing.T) { blk := genBeaconBlock() - got := CopyBeaconBlock(blk) + got := v1alpha1.CopyBeaconBlock(blk) if !reflect.DeepEqual(got, blk) { t.Errorf("CopyBeaconBlock() = %v, want %v", got, blk) } @@ -80,7 +81,7 @@ func TestCopyBeaconBlock(t *testing.T) { func TestCopyBeaconBlockBody(t *testing.T) { body := genBeaconBlockBody() - got := CopyBeaconBlockBody(body) + got := v1alpha1.CopyBeaconBlockBody(body) if !reflect.DeepEqual(got, body) { t.Errorf("CopyBeaconBlockBody() = %v, want %v", got, body) } @@ -90,7 +91,7 @@ func TestCopyBeaconBlockBody(t *testing.T) { func TestCopySignedBeaconBlockAltair(t *testing.T) { sbb := genSignedBeaconBlockAltair() - got := CopySignedBeaconBlockAltair(sbb) + got := v1alpha1.CopySignedBeaconBlockAltair(sbb) if !reflect.DeepEqual(got, sbb) { t.Errorf("CopySignedBeaconBlockAltair() = %v, want %v", got, sbb) } @@ -100,7 +101,7 @@ func TestCopySignedBeaconBlockAltair(t *testing.T) { func TestCopyBeaconBlockAltair(t *testing.T) { b := genBeaconBlockAltair() - got := CopyBeaconBlockAltair(b) + got := v1alpha1.CopyBeaconBlockAltair(b) if !reflect.DeepEqual(got, b) { t.Errorf("CopyBeaconBlockAltair() = %v, want %v", got, b) } @@ -110,7 +111,7 @@ func TestCopyBeaconBlockAltair(t *testing.T) { func TestCopyBeaconBlockBodyAltair(t *testing.T) { bb := genBeaconBlockBodyAltair() - got := CopyBeaconBlockBodyAltair(bb) + got := v1alpha1.CopyBeaconBlockBodyAltair(bb) if !reflect.DeepEqual(got, bb) { t.Errorf("CopyBeaconBlockBodyAltair() = %v, want %v", got, bb) } @@ -120,7 +121,7 @@ func TestCopyBeaconBlockBodyAltair(t *testing.T) { func TestCopyProposerSlashings(t *testing.T) { ps := genProposerSlashings(10) - got := CopyProposerSlashings(ps) + got := v1alpha1.CopyProposerSlashings(ps) if !reflect.DeepEqual(got, ps) { t.Errorf("CopyProposerSlashings() = %v, want %v", got, ps) } @@ -130,7 +131,7 @@ func TestCopyProposerSlashings(t *testing.T) { func TestCopyProposerSlashing(t *testing.T) { ps := genProposerSlashing() - got := CopyProposerSlashing(ps) + got := v1alpha1.CopyProposerSlashing(ps) if !reflect.DeepEqual(got, ps) { t.Errorf("CopyProposerSlashing() = %v, want %v", got, ps) } @@ -140,7 +141,7 @@ func TestCopyProposerSlashing(t *testing.T) { func TestCopySignedBeaconBlockHeader(t *testing.T) { sbh := genSignedBeaconBlockHeader() - got := CopySignedBeaconBlockHeader(sbh) + got := v1alpha1.CopySignedBeaconBlockHeader(sbh) if !reflect.DeepEqual(got, sbh) { t.Errorf("CopySignedBeaconBlockHeader() = %v, want %v", got, sbh) } @@ -150,7 +151,7 @@ func TestCopySignedBeaconBlockHeader(t *testing.T) { func TestCopyBeaconBlockHeader(t *testing.T) { bh := genBeaconBlockHeader() - got := CopyBeaconBlockHeader(bh) + got := v1alpha1.CopyBeaconBlockHeader(bh) if !reflect.DeepEqual(got, bh) { t.Errorf("CopyBeaconBlockHeader() = %v, want %v", got, bh) } @@ -160,7 +161,7 @@ func TestCopyBeaconBlockHeader(t *testing.T) { func TestCopyAttesterSlashings(t *testing.T) { as := genAttesterSlashings(10) - got := CopyAttesterSlashings(as) + got := v1alpha1.CopyAttesterSlashings(as) if !reflect.DeepEqual(got, as) { t.Errorf("CopyAttesterSlashings() = %v, want %v", got, as) } @@ -170,7 +171,7 @@ func TestCopyAttesterSlashings(t *testing.T) { func TestCopyIndexedAttestation(t *testing.T) { ia := genIndexedAttestation() - got := CopyIndexedAttestation(ia) + got := v1alpha1.CopyIndexedAttestation(ia) if !reflect.DeepEqual(got, ia) { t.Errorf("CopyIndexedAttestation() = %v, want %v", got, ia) } @@ -180,7 +181,7 @@ func TestCopyIndexedAttestation(t *testing.T) { func TestCopyAttestations(t *testing.T) { atts := genAttestations(10) - got := CopyAttestations(atts) + got := v1alpha1.CopyAttestations(atts) if !reflect.DeepEqual(got, atts) { t.Errorf("CopyAttestations() = %v, want %v", got, atts) } @@ -190,7 +191,7 @@ func TestCopyAttestations(t *testing.T) { func TestCopyDeposits(t *testing.T) { d := genDeposits(10) - got := CopyDeposits(d) + got := v1alpha1.CopyDeposits(d) if !reflect.DeepEqual(got, d) { t.Errorf("CopyDeposits() = %v, want %v", got, d) } @@ -200,7 +201,7 @@ func TestCopyDeposits(t *testing.T) { func TestCopyDeposit(t *testing.T) { d := genDeposit() - got := CopyDeposit(d) + got := v1alpha1.CopyDeposit(d) if !reflect.DeepEqual(got, d) { t.Errorf("CopyDeposit() = %v, want %v", got, d) } @@ -210,7 +211,7 @@ func TestCopyDeposit(t *testing.T) { func TestCopyDepositData(t *testing.T) { dd := genDepositData() - got := CopyDepositData(dd) + got := v1alpha1.CopyDepositData(dd) if !reflect.DeepEqual(got, dd) { t.Errorf("CopyDepositData() = %v, want %v", got, dd) } @@ -220,7 +221,7 @@ func TestCopyDepositData(t *testing.T) { func TestCopySignedVoluntaryExits(t *testing.T) { sv := genSignedVoluntaryExits(10) - got := CopySignedVoluntaryExits(sv) + got := v1alpha1.CopySignedVoluntaryExits(sv) if !reflect.DeepEqual(got, sv) { t.Errorf("CopySignedVoluntaryExits() = %v, want %v", got, sv) } @@ -230,7 +231,7 @@ func TestCopySignedVoluntaryExits(t *testing.T) { func TestCopySignedVoluntaryExit(t *testing.T) { sv := genSignedVoluntaryExit() - got := CopySignedVoluntaryExit(sv) + got := v1alpha1.CopySignedVoluntaryExit(sv) if !reflect.DeepEqual(got, sv) { t.Errorf("CopySignedVoluntaryExit() = %v, want %v", got, sv) } @@ -240,7 +241,7 @@ func TestCopySignedVoluntaryExit(t *testing.T) { func TestCopyValidator(t *testing.T) { v := genValidator() - got := CopyValidator(v) + got := v1alpha1.CopyValidator(v) if !reflect.DeepEqual(got, v) { t.Errorf("CopyValidator() = %v, want %v", got, v) } @@ -250,7 +251,7 @@ func TestCopyValidator(t *testing.T) { func TestCopySyncCommitteeMessage(t *testing.T) { scm := genSyncCommitteeMessage() - got := CopySyncCommitteeMessage(scm) + got := v1alpha1.CopySyncCommitteeMessage(scm) if !reflect.DeepEqual(got, scm) { t.Errorf("CopySyncCommitteeMessage() = %v, want %v", got, scm) } @@ -260,7 +261,7 @@ func TestCopySyncCommitteeMessage(t *testing.T) { func TestCopySyncCommitteeContribution(t *testing.T) { scc := genSyncCommitteeContribution() - got := CopySyncCommitteeContribution(scc) + got := v1alpha1.CopySyncCommitteeContribution(scc) if !reflect.DeepEqual(got, scc) { t.Errorf("CopySyncCommitteeContribution() = %v, want %v", got, scc) } @@ -270,7 +271,7 @@ func TestCopySyncCommitteeContribution(t *testing.T) { func TestCopySyncAggregate(t *testing.T) { sa := genSyncAggregate() - got := CopySyncAggregate(sa) + got := v1alpha1.CopySyncAggregate(sa) if !reflect.DeepEqual(got, sa) { t.Errorf("CopySyncAggregate() = %v, want %v", got, sa) } @@ -280,7 +281,7 @@ func TestCopySyncAggregate(t *testing.T) { func TestCopyPendingAttestationSlice(t *testing.T) { tests := []struct { name string - input []*PendingAttestation + input []*v1alpha1.PendingAttestation }{ { name: "nil", @@ -288,11 +289,11 @@ func TestCopyPendingAttestationSlice(t *testing.T) { }, { name: "empty", - input: []*PendingAttestation{}, + input: []*v1alpha1.PendingAttestation{}, }, { name: "correct copy", - input: []*PendingAttestation{ + input: []*v1alpha1.PendingAttestation{ genPendingAttestation(), genPendingAttestation(), }, @@ -300,7 +301,7 @@ func TestCopyPendingAttestationSlice(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - if got := CopyPendingAttestationSlice(tt.input); !reflect.DeepEqual(got, tt.input) { + if got := v1alpha1.CopyPendingAttestationSlice(tt.input); !reflect.DeepEqual(got, tt.input) { t.Errorf("CopyPendingAttestationSlice() = %v, want %v", got, tt.input) } }) @@ -321,24 +322,24 @@ func bytes() []byte { return b } -func genAttestation() *Attestation { - return &Attestation{ +func genAttestation() *v1alpha1.Attestation { + return &v1alpha1.Attestation{ AggregationBits: bytes(), Data: genAttData(), Signature: bytes(), } } -func genAttestations(num int) []*Attestation { - atts := make([]*Attestation, num) +func genAttestations(num int) []*v1alpha1.Attestation { + atts := make([]*v1alpha1.Attestation, num) for i := 0; i < num; i++ { atts[i] = genAttestation() } return atts } -func genAttData() *AttestationData { - return &AttestationData{ +func genAttData() *v1alpha1.AttestationData { + return &v1alpha1.AttestationData{ Slot: 1, CommitteeIndex: 2, BeaconBlockRoot: bytes(), @@ -347,23 +348,23 @@ func genAttData() *AttestationData { } } -func genCheckpoint() *Checkpoint { - return &Checkpoint{ +func genCheckpoint() *v1alpha1.Checkpoint { + return &v1alpha1.Checkpoint{ Epoch: 1, Root: bytes(), } } -func genEth1Data() *Eth1Data { - return &Eth1Data{ +func genEth1Data() *v1alpha1.Eth1Data { + return &v1alpha1.Eth1Data{ DepositRoot: bytes(), DepositCount: 4, BlockHash: bytes(), } } -func genPendingAttestation() *PendingAttestation { - return &PendingAttestation{ +func genPendingAttestation() *v1alpha1.PendingAttestation { + return &v1alpha1.PendingAttestation{ AggregationBits: bytes(), Data: genAttData(), InclusionDelay: 3, @@ -371,15 +372,15 @@ func genPendingAttestation() *PendingAttestation { } } -func genSignedBeaconBlock() *SignedBeaconBlock { - return &SignedBeaconBlock{ +func genSignedBeaconBlock() *v1alpha1.SignedBeaconBlock { + return &v1alpha1.SignedBeaconBlock{ Block: genBeaconBlock(), Signature: bytes(), } } -func genBeaconBlock() *BeaconBlock { - return &BeaconBlock{ +func genBeaconBlock() *v1alpha1.BeaconBlock { + return &v1alpha1.BeaconBlock{ Slot: 4, ProposerIndex: 5, ParentRoot: bytes(), @@ -388,8 +389,8 @@ func genBeaconBlock() *BeaconBlock { } } -func genBeaconBlockBody() *BeaconBlockBody { - return &BeaconBlockBody{ +func genBeaconBlockBody() *v1alpha1.BeaconBlockBody { + return &v1alpha1.BeaconBlockBody{ RandaoReveal: bytes(), Eth1Data: genEth1Data(), Graffiti: bytes(), @@ -401,46 +402,46 @@ func genBeaconBlockBody() *BeaconBlockBody { } } -func genProposerSlashing() *ProposerSlashing { - return &ProposerSlashing{ +func genProposerSlashing() *v1alpha1.ProposerSlashing { + return &v1alpha1.ProposerSlashing{ Header_1: genSignedBeaconBlockHeader(), Header_2: genSignedBeaconBlockHeader(), } } -func genProposerSlashings(num int) []*ProposerSlashing { - ps := make([]*ProposerSlashing, num) +func genProposerSlashings(num int) []*v1alpha1.ProposerSlashing { + ps := make([]*v1alpha1.ProposerSlashing, num) for i := 0; i < num; i++ { ps[i] = genProposerSlashing() } return ps } -func genAttesterSlashing() *AttesterSlashing { - return &AttesterSlashing{ +func genAttesterSlashing() *v1alpha1.AttesterSlashing { + return &v1alpha1.AttesterSlashing{ Attestation_1: genIndexedAttestation(), Attestation_2: genIndexedAttestation(), } } -func genIndexedAttestation() *IndexedAttestation { - return &IndexedAttestation{ +func genIndexedAttestation() *v1alpha1.IndexedAttestation { + return &v1alpha1.IndexedAttestation{ AttestingIndices: []uint64{1, 2, 3}, Data: genAttData(), Signature: bytes(), } } -func genAttesterSlashings(num int) []*AttesterSlashing { - as := make([]*AttesterSlashing, num) +func genAttesterSlashings(num int) []*v1alpha1.AttesterSlashing { + as := make([]*v1alpha1.AttesterSlashing, num) for i := 0; i < num; i++ { as[i] = genAttesterSlashing() } return as } -func genBeaconBlockHeader() *BeaconBlockHeader { - return &BeaconBlockHeader{ +func genBeaconBlockHeader() *v1alpha1.BeaconBlockHeader { + return &v1alpha1.BeaconBlockHeader{ Slot: 10, ProposerIndex: 15, ParentRoot: bytes(), @@ -449,15 +450,15 @@ func genBeaconBlockHeader() *BeaconBlockHeader { } } -func genSignedBeaconBlockHeader() *SignedBeaconBlockHeader { - return &SignedBeaconBlockHeader{ +func genSignedBeaconBlockHeader() *v1alpha1.SignedBeaconBlockHeader { + return &v1alpha1.SignedBeaconBlockHeader{ Header: genBeaconBlockHeader(), Signature: bytes(), } } -func genDepositData() *Deposit_Data { - return &Deposit_Data{ +func genDepositData() *v1alpha1.Deposit_Data { + return &v1alpha1.Deposit_Data{ PublicKey: bytes(), WithdrawalCredentials: bytes(), Amount: 20000, @@ -465,45 +466,45 @@ func genDepositData() *Deposit_Data { } } -func genDeposit() *Deposit { - return &Deposit{ +func genDeposit() *v1alpha1.Deposit { + return &v1alpha1.Deposit{ Data: genDepositData(), Proof: [][]byte{bytes(), bytes(), bytes(), bytes()}, } } -func genDeposits(num int) []*Deposit { - d := make([]*Deposit, num) +func genDeposits(num int) []*v1alpha1.Deposit { + d := make([]*v1alpha1.Deposit, num) for i := 0; i < num; i++ { d[i] = genDeposit() } return d } -func genVoluntaryExit() *VoluntaryExit { - return &VoluntaryExit{ +func genVoluntaryExit() *v1alpha1.VoluntaryExit { + return &v1alpha1.VoluntaryExit{ Epoch: 5432, ValidatorIndex: 888888, } } -func genSignedVoluntaryExit() *SignedVoluntaryExit { - return &SignedVoluntaryExit{ +func genSignedVoluntaryExit() *v1alpha1.SignedVoluntaryExit { + return &v1alpha1.SignedVoluntaryExit{ Exit: genVoluntaryExit(), Signature: bytes(), } } -func genSignedVoluntaryExits(num int) []*SignedVoluntaryExit { - sv := make([]*SignedVoluntaryExit, num) +func genSignedVoluntaryExits(num int) []*v1alpha1.SignedVoluntaryExit { + sv := make([]*v1alpha1.SignedVoluntaryExit, num) for i := 0; i < num; i++ { sv[i] = genSignedVoluntaryExit() } return sv } -func genValidator() *Validator { - return &Validator{ +func genValidator() *v1alpha1.Validator { + return &v1alpha1.Validator{ PublicKey: bytes(), WithdrawalCredentials: bytes(), EffectiveBalance: 12345, @@ -515,8 +516,8 @@ func genValidator() *Validator { } } -func genSyncCommitteeContribution() *SyncCommitteeContribution { - return &SyncCommitteeContribution{ +func genSyncCommitteeContribution() *v1alpha1.SyncCommitteeContribution { + return &v1alpha1.SyncCommitteeContribution{ Slot: 12333, BlockRoot: bytes(), SubcommitteeIndex: 4444, @@ -525,15 +526,15 @@ func genSyncCommitteeContribution() *SyncCommitteeContribution { } } -func genSyncAggregate() *SyncAggregate { - return &SyncAggregate{ +func genSyncAggregate() *v1alpha1.SyncAggregate { + return &v1alpha1.SyncAggregate{ SyncCommitteeBits: bytes(), SyncCommitteeSignature: bytes(), } } -func genBeaconBlockBodyAltair() *BeaconBlockBodyAltair { - return &BeaconBlockBodyAltair{ +func genBeaconBlockBodyAltair() *v1alpha1.BeaconBlockBodyAltair { + return &v1alpha1.BeaconBlockBodyAltair{ RandaoReveal: bytes(), Eth1Data: genEth1Data(), Graffiti: bytes(), @@ -546,8 +547,8 @@ func genBeaconBlockBodyAltair() *BeaconBlockBodyAltair { } } -func genBeaconBlockAltair() *BeaconBlockAltair { - return &BeaconBlockAltair{ +func genBeaconBlockAltair() *v1alpha1.BeaconBlockAltair { + return &v1alpha1.BeaconBlockAltair{ Slot: 123455, ProposerIndex: 55433, ParentRoot: bytes(), @@ -556,15 +557,15 @@ func genBeaconBlockAltair() *BeaconBlockAltair { } } -func genSignedBeaconBlockAltair() *SignedBeaconBlockAltair { - return &SignedBeaconBlockAltair{ +func genSignedBeaconBlockAltair() *v1alpha1.SignedBeaconBlockAltair { + return &v1alpha1.SignedBeaconBlockAltair{ Block: genBeaconBlockAltair(), Signature: bytes(), } } -func genSyncCommitteeMessage() *SyncCommitteeMessage { - return &SyncCommitteeMessage{ +func genSyncCommitteeMessage() *v1alpha1.SyncCommitteeMessage { + return &v1alpha1.SyncCommitteeMessage{ Slot: 424555, BlockRoot: bytes(), ValidatorIndex: 5443, diff --git a/shared/params/BUILD.bazel b/shared/params/BUILD.bazel index b23b85645a..96f409b8eb 100644 --- a/shared/params/BUILD.bazel +++ b/shared/params/BUILD.bazel @@ -46,10 +46,10 @@ go_test( "@consensus_spec_tests_minimal//:test_data", "@eth2_networks//:configs", ], - embed = [":go_default_library"], gotags = ["develop"], race = "on", deps = [ + ":go_default_library", "//shared/testutil/assert:go_default_library", "//shared/testutil/require:go_default_library", "@com_github_sirupsen_logrus//:go_default_library", diff --git a/shared/params/checktags_test.go b/shared/params/checktags_test.go index 07bc61ea8f..ab04c005c5 100644 --- a/shared/params/checktags_test.go +++ b/shared/params/checktags_test.go @@ -1,6 +1,6 @@ // +build !develop -package params +package params_test import ( log "github.com/sirupsen/logrus" diff --git a/shared/params/loader.go b/shared/params/loader.go index 2066e84fe0..1324309593 100644 --- a/shared/params/loader.go +++ b/shared/params/loader.go @@ -32,7 +32,7 @@ func LoadChainConfigFile(chainConfigFileName string) { } if !strings.HasPrefix(line, "#") && strings.Contains(line, "0x") { - parts := replaceHexStringWithYAMLFormat(line) + parts := ReplaceHexStringWithYAMLFormat(line) lines[i] = strings.Join(parts, "\n") } } @@ -50,7 +50,8 @@ func LoadChainConfigFile(chainConfigFileName string) { OverrideBeaconConfig(conf) } -func replaceHexStringWithYAMLFormat(line string) []string { +// ReplaceHexStringWithYAMLFormat will replace hex strings that the yaml parser will understand. +func ReplaceHexStringWithYAMLFormat(line string) []string { parts := strings.Split(line, "0x") decoded, err := hex.DecodeString(parts[1]) if err != nil { diff --git a/shared/params/loader_test.go b/shared/params/loader_test.go index 81768939d2..53bbb49ab0 100644 --- a/shared/params/loader_test.go +++ b/shared/params/loader_test.go @@ -1,4 +1,4 @@ -package params +package params_test import ( "io/ioutil" @@ -8,6 +8,7 @@ import ( "testing" "github.com/bazelbuild/rules_go/go/tools/bazel" + "github.com/prysmaticlabs/prysm/shared/params" "github.com/prysmaticlabs/prysm/shared/testutil/assert" "github.com/prysmaticlabs/prysm/shared/testutil/require" "gopkg.in/yaml.v2" @@ -15,7 +16,7 @@ import ( func TestLoadConfigFileMainnet(t *testing.T) { // See https://media.githubusercontent.com/media/ethereum/consensus-spec-tests/master/tests/minimal/config/phase0.yaml - assertVals := func(name string, fields []string, c1, c2 *BeaconChainConfig) { + assertVals := func(name string, fields []string, c1, c2 *params.BeaconChainConfig) { // Misc params. assert.Equal(t, c1.MaxCommitteesPerSlot, c2.MaxCommitteesPerSlot, "%s: MaxCommitteesPerSlot", name) assert.Equal(t, c1.TargetCommitteeSize, c2.TargetCommitteeSize, "%s: TargetCommitteeSize", name) @@ -105,16 +106,16 @@ func TestLoadConfigFileMainnet(t *testing.T) { t.Run("mainnet", func(t *testing.T) { mainnetConfigFile := presetsFilePath(t, "mainnet") - LoadChainConfigFile(mainnetConfigFile) + params.LoadChainConfigFile(mainnetConfigFile) fields := fieldsFromYaml(t, mainnetConfigFile) - assertVals("mainnet", fields, MainnetConfig(), BeaconConfig()) + assertVals("mainnet", fields, params.MainnetConfig(), params.BeaconConfig()) }) t.Run("minimal", func(t *testing.T) { minimalConfigFile := presetsFilePath(t, "minimal") - LoadChainConfigFile(minimalConfigFile) + params.LoadChainConfigFile(minimalConfigFile) fields := fieldsFromYaml(t, minimalConfigFile) - assertVals("minimal", fields, MinimalSpecConfig(), BeaconConfig()) + assertVals("minimal", fields, params.MinimalSpecConfig(), params.BeaconConfig()) }) } @@ -122,19 +123,19 @@ func TestLoadConfigFile_OverwriteCorrectly(t *testing.T) { file, err := ioutil.TempFile("", "") require.NoError(t, err) // Set current config to minimal config - OverrideBeaconConfig(MinimalSpecConfig()) + params.OverrideBeaconConfig(params.MinimalSpecConfig()) // load empty config file, so that it defaults to mainnet values - LoadChainConfigFile(file.Name()) - if BeaconConfig().MinGenesisTime != MainnetConfig().MinGenesisTime { + params.LoadChainConfigFile(file.Name()) + if params.BeaconConfig().MinGenesisTime != params.MainnetConfig().MinGenesisTime { t.Errorf("Expected MinGenesisTime to be set to mainnet value: %d found: %d", - MainnetConfig().MinGenesisTime, - BeaconConfig().MinGenesisTime) + params.MainnetConfig().MinGenesisTime, + params.BeaconConfig().MinGenesisTime) } - if BeaconConfig().SlotsPerEpoch != MainnetConfig().SlotsPerEpoch { + if params.BeaconConfig().SlotsPerEpoch != params.MainnetConfig().SlotsPerEpoch { t.Errorf("Expected SlotsPerEpoch to be set to mainnet value: %d found: %d", - MainnetConfig().SlotsPerEpoch, - BeaconConfig().SlotsPerEpoch) + params.MainnetConfig().SlotsPerEpoch, + params.BeaconConfig().SlotsPerEpoch) } } @@ -198,7 +199,7 @@ func Test_replaceHexStringWithYAMLFormat(t *testing.T) { }, } for _, line := range testLines { - parts := replaceHexStringWithYAMLFormat(line.line) + parts := params.ReplaceHexStringWithYAMLFormat(line.line) res := strings.Join(parts, "\n") if res != line.wanted { @@ -243,7 +244,7 @@ func fieldsFromYaml(t *testing.T, fp string) []string { return keys } -func assertYamlFieldsMatch(t *testing.T, name string, fields []string, c1, c2 *BeaconChainConfig) { +func assertYamlFieldsMatch(t *testing.T, name string, fields []string, c1, c2 *params.BeaconChainConfig) { // Ensure all fields from the yaml file exist, were set, and correctly match the expected value. ft1 := reflect.TypeOf(*c1) for _, field := range fields { diff --git a/shared/params/testnet_config_test.go b/shared/params/testnet_config_test.go index 9d516621c1..d84786988c 100644 --- a/shared/params/testnet_config_test.go +++ b/shared/params/testnet_config_test.go @@ -1,4 +1,4 @@ -package params +package params_test import ( "path" diff --git a/shared/params/testnet_prater_config_test.go b/shared/params/testnet_prater_config_test.go index dbefd9d52a..31b5acb706 100644 --- a/shared/params/testnet_prater_config_test.go +++ b/shared/params/testnet_prater_config_test.go @@ -1,12 +1,14 @@ -package params +package params_test import ( "testing" + + "github.com/prysmaticlabs/prysm/shared/params" ) func TestPraterConfigMatchesUpstreamYaml(t *testing.T) { configFP := testnetConfigFilePath(t, "prater") - LoadChainConfigFile(configFP) + params.LoadChainConfigFile(configFP) fields := fieldsFromYaml(t, configFP) - assertYamlFieldsMatch(t, "prater", fields, BeaconConfig(), PraterConfig()) + assertYamlFieldsMatch(t, "prater", fields, params.BeaconConfig(), params.PraterConfig()) } diff --git a/shared/sszutil/BUILD.bazel b/shared/sszutil/BUILD.bazel deleted file mode 100644 index 7cca24611c..0000000000 --- a/shared/sszutil/BUILD.bazel +++ /dev/null @@ -1,23 +0,0 @@ -load("@prysm//tools/go:def.bzl", "go_library", "go_test") - -go_library( - name = "go_default_library", - srcs = ["deep_equal.go"], - importpath = "github.com/prysmaticlabs/prysm/shared/sszutil", - visibility = ["//visibility:public"], - deps = [ - "@com_github_prysmaticlabs_eth2_types//:go_default_library", - "@org_golang_google_protobuf//proto:go_default_library", - ], -) - -go_test( - name = "go_default_test", - size = "small", - srcs = ["deep_equal_test.go"], - deps = [ - ":go_default_library", - "//proto/prysm/v1alpha1:go_default_library", - "//shared/testutil/assert:go_default_library", - ], -) diff --git a/shared/testutil/assert/assertions.go b/shared/testutil/assert/assertions.go index 4dd0c6797b..f2afd6eb12 100644 --- a/shared/testutil/assert/assertions.go +++ b/shared/testutil/assert/assertions.go @@ -31,12 +31,12 @@ func DeepNotEqual(tb assertions.AssertionTestingTB, expected, actual interface{} assertions.DeepNotEqual(tb.Errorf, expected, actual, msg...) } -// DeepSSZEqual compares values using sszutil.DeepEqual. +// DeepSSZEqual compares values using ssz.DeepEqual. func DeepSSZEqual(tb assertions.AssertionTestingTB, expected, actual interface{}, msg ...interface{}) { assertions.DeepSSZEqual(tb.Errorf, expected, actual, msg...) } -// DeepNotSSZEqual compares values using sszutil.DeepEqual. +// DeepNotSSZEqual compares values using ssz.DeepEqual. func DeepNotSSZEqual(tb assertions.AssertionTestingTB, expected, actual interface{}, msg ...interface{}) { assertions.DeepNotSSZEqual(tb.Errorf, expected, actual, msg...) } diff --git a/shared/testutil/assertions/BUILD.bazel b/shared/testutil/assertions/BUILD.bazel index 73253dbd7b..dfd5ae657d 100644 --- a/shared/testutil/assertions/BUILD.bazel +++ b/shared/testutil/assertions/BUILD.bazel @@ -6,7 +6,7 @@ go_library( importpath = "github.com/prysmaticlabs/prysm/shared/testutil/assertions", visibility = ["//visibility:public"], deps = [ - "//shared/sszutil:go_default_library", + "//encoding/ssz:go_default_library", "@com_github_d4l3k_messagediff//:go_default_library", "@com_github_sirupsen_logrus//hooks/test:go_default_library", "@org_golang_google_protobuf//proto:go_default_library", diff --git a/shared/testutil/assertions/assertions.go b/shared/testutil/assertions/assertions.go index bdf697c699..fa867dc85f 100644 --- a/shared/testutil/assertions/assertions.go +++ b/shared/testutil/assertions/assertions.go @@ -8,7 +8,7 @@ import ( "strings" "github.com/d4l3k/messagediff" - "github.com/prysmaticlabs/prysm/shared/sszutil" + "github.com/prysmaticlabs/prysm/encoding/ssz" "github.com/sirupsen/logrus/hooks/test" "google.golang.org/protobuf/proto" ) @@ -58,9 +58,9 @@ func DeepNotEqual(loggerFn assertionLoggerFn, expected, actual interface{}, msg } } -// DeepSSZEqual compares values using sszutil.DeepEqual. +// DeepSSZEqual compares values using ssz.DeepEqual. func DeepSSZEqual(loggerFn assertionLoggerFn, expected, actual interface{}, msg ...interface{}) { - if !sszutil.DeepEqual(expected, actual) { + if !ssz.DeepEqual(expected, actual) { errMsg := parseMsg("Values are not equal", msg...) _, file, line, _ := runtime.Caller(2) diff, _ := messagediff.PrettyDiff(expected, actual) @@ -68,9 +68,9 @@ func DeepSSZEqual(loggerFn assertionLoggerFn, expected, actual interface{}, msg } } -// DeepNotSSZEqual compares values using sszutil.DeepEqual. +// DeepNotSSZEqual compares values using ssz.DeepEqual. func DeepNotSSZEqual(loggerFn assertionLoggerFn, expected, actual interface{}, msg ...interface{}) { - if sszutil.DeepEqual(expected, actual) { + if ssz.DeepEqual(expected, actual) { errMsg := parseMsg("Values are equal", msg...) _, file, line, _ := runtime.Caller(2) loggerFn("%s:%d %s, want: %#v, got: %#v", filepath.Base(file), line, errMsg, expected, actual) diff --git a/tools/pcli/BUILD.bazel b/tools/pcli/BUILD.bazel index dfeb6f574d..09a70d3561 100644 --- a/tools/pcli/BUILD.bazel +++ b/tools/pcli/BUILD.bazel @@ -12,10 +12,10 @@ go_library( deps = [ "//beacon-chain/core/transition:go_default_library", "//beacon-chain/state/v1:go_default_library", + "//encoding/ssz:go_default_library", "//proto/prysm/v1alpha1:go_default_library", "//proto/prysm/v1alpha1/wrapper:go_default_library", "//runtime/version:go_default_library", - "//shared/sszutil:go_default_library", "@com_github_ferranbt_fastssz//:go_default_library", "@com_github_kr_pretty//:go_default_library", "@com_github_sirupsen_logrus//:go_default_library", diff --git a/tools/pcli/main.go b/tools/pcli/main.go index d9af06a357..e728bd4277 100644 --- a/tools/pcli/main.go +++ b/tools/pcli/main.go @@ -13,10 +13,10 @@ import ( "github.com/kr/pretty" "github.com/prysmaticlabs/prysm/beacon-chain/core/transition" v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1" + "github.com/prysmaticlabs/prysm/encoding/ssz" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper" "github.com/prysmaticlabs/prysm/runtime/version" - "github.com/prysmaticlabs/prysm/shared/sszutil" log "github.com/sirupsen/logrus" "github.com/urfave/cli/v2" prefixed "github.com/x-cray/logrus-prefixed-formatter" @@ -191,7 +191,7 @@ func main() { if err := dataFetcher(expectedPostStatePath, expectedState); err != nil { log.Fatal(err) } - if !sszutil.DeepEqual(expectedState, postState.InnerStateUnsafe()) { + if !ssz.DeepEqual(expectedState, postState.InnerStateUnsafe()) { diff, _ := messagediff.PrettyDiff(expectedState, postState.InnerStateUnsafe()) log.Errorf("Derived state differs from provided post state: %s", diff) }