prysm-pulse/validator/testing/protection_history.go
Victor Farazdagi a069738c20
ETH2 Types: Slot (#8408)
* update shared/params

* update eth2-types deps

* update protobufs

* update shared/*

* fix testutil/state

* update beacon-chain/state

* update beacon-chain/db

* update tests

* fix test

* update beacon-chain/core

* update beacon-chain/blockchain

* update beacon-chain/cache

* beacon-chain/forkchoice

* update beacon-chain/operations

* update beacon-chain/p2p

* update beacon-chain/rpc

* update sync/initial-sync

* update deps

* update deps

* go fmt

* update beacon-chain/sync

* update endtoend/

* bazel build //beacon-chain - works w/o issues

* update slasher code

* udpate tools/

* update validator/

* update fastssz

* fix build

* fix test building

* update tests

* update ethereumapis deps

* fix tests

* update state/stategen

* fix build

* fix test

* add FarFutureSlot

* go imports

* Radek's suggestions

* Ivan's suggestions

* type conversions

* Nishant's suggestions

* add more tests to rpc_send_request

* fix test

* clean up

* fix conflicts

Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
Co-authored-by: nisdas <nishdas93@gmail.com>
2021-02-16 07:45:34 +00:00

115 lines
4.0 KiB
Go

package testing
import (
"fmt"
"github.com/prysmaticlabs/eth2-types"
"github.com/prysmaticlabs/prysm/shared/bls"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/rand"
"github.com/prysmaticlabs/prysm/validator/db/kv"
"github.com/prysmaticlabs/prysm/validator/slashing-protection/local/standard-protection-format/format"
)
// MockSlashingProtectionJSON creates a mock, full slashing protection JSON struct
// using attesting and proposing histories provided.
func MockSlashingProtectionJSON(
publicKeys [][48]byte,
attestingHistories [][]*kv.AttestationRecord,
proposalHistories []kv.ProposalHistoryForPubkey,
) (*format.EIPSlashingProtectionFormat, error) {
standardProtectionFormat := &format.EIPSlashingProtectionFormat{}
standardProtectionFormat.Metadata.GenesisValidatorsRoot = fmt.Sprintf("%#x", bytesutil.PadTo([]byte{32}, 32))
standardProtectionFormat.Metadata.InterchangeFormatVersion = format.InterchangeFormatVersion
for i := 0; i < len(publicKeys); i++ {
data := &format.ProtectionData{
Pubkey: fmt.Sprintf("%#x", publicKeys[i]),
}
if len(attestingHistories) > 0 {
for _, att := range attestingHistories[i] {
data.SignedAttestations = append(data.SignedAttestations, &format.SignedAttestation{
TargetEpoch: fmt.Sprintf("%d", att.Target),
SourceEpoch: fmt.Sprintf("%d", att.Source),
SigningRoot: fmt.Sprintf("%#x", att.SigningRoot),
})
}
}
if len(proposalHistories) > 0 {
for _, proposal := range proposalHistories[i].Proposals {
block := &format.SignedBlock{
Slot: fmt.Sprintf("%d", proposal.Slot),
SigningRoot: fmt.Sprintf("%#x", proposal.SigningRoot),
}
data.SignedBlocks = append(data.SignedBlocks, block)
}
}
standardProtectionFormat.Data = append(standardProtectionFormat.Data, data)
}
return standardProtectionFormat, nil
}
// MockAttestingAndProposalHistories given a number of validators, creates mock attesting
// and proposing histories within WEAK_SUBJECTIVITY_PERIOD bounds.
func MockAttestingAndProposalHistories(numValidators int) ([][]*kv.AttestationRecord, []kv.ProposalHistoryForPubkey) {
// deduplicate and transform them into our internal format.
attData := make([][]*kv.AttestationRecord, numValidators)
proposalData := make([]kv.ProposalHistoryForPubkey, numValidators)
gen := rand.NewGenerator()
for v := 0; v < numValidators; v++ {
latestTarget := types.Epoch(gen.Intn(int(params.BeaconConfig().WeakSubjectivityPeriod) / 1000))
// If 0, we change the value to 1 as the we compute source by doing (target-1)
// to prevent any underflows in this setup helper.
if latestTarget == 0 {
latestTarget = 1
}
historicalAtts := make([]*kv.AttestationRecord, 0)
proposals := make([]kv.Proposal, 0)
for i := types.Epoch(1); i < latestTarget; i++ {
signingRoot := [32]byte{}
signingRootStr := fmt.Sprintf("%d", i)
copy(signingRoot[:], signingRootStr)
historicalAtts = append(historicalAtts, &kv.AttestationRecord{
Source: i - 1,
Target: i,
SigningRoot: signingRoot,
})
}
for i := types.Epoch(1); i <= latestTarget; i++ {
signingRoot := [32]byte{}
signingRootStr := fmt.Sprintf("%d", i)
copy(signingRoot[:], signingRootStr)
proposals = append(proposals, kv.Proposal{
Slot: types.Slot(i),
SigningRoot: signingRoot[:],
})
}
proposalData[v] = kv.ProposalHistoryForPubkey{Proposals: proposals}
attData[v] = historicalAtts
}
return attData, proposalData
}
// CreateRandomPubKeys --
func CreateRandomPubKeys(numValidators int) ([][48]byte, error) {
pubKeys := make([][48]byte, numValidators)
for i := 0; i < numValidators; i++ {
randKey, err := bls.RandKey()
if err != nil {
return nil, err
}
copy(pubKeys[i][:], randKey.PublicKey().Marshal())
}
return pubKeys, nil
}
// CreateMockRoots --
func CreateMockRoots(numRoots int) [][32]byte {
roots := make([][32]byte, numRoots)
for i := 0; i < numRoots; i++ {
var rt [32]byte
copy(rt[:], fmt.Sprintf("%d", i))
}
return roots
}