prysm-pulse/validator/interop.go
terence tsao 798bbbdc82 Cold start for interop (#3437)
* coldstart flags for validator

* WIP beacon node flags

* wip beacon chain, flag fix in validator, arg fix in validator

* checkpoint

* Added interop service

* working on mock chainstart

* save the state lol

* fix tests

* Save genesis validators

* gaz

* fix validator help flags

* WaitForChainStart actually waits for genesis time

* cold start fixes

* cache

* change back

* allow for genesis state too

* remove logs

* increase mmap size

* dont process if head doesn't exist

* add 10ms tolerance

* enable libp2p debug at debug, fix pubsub

* works with checkpt

* initialize justified and finalized in db

* Removed preloadStatePath from blockchain service

* Clean up

* Write to disk for now post state

* revert b466dd536f8eadbdae2264a545a755370223d917

* Builds

* Only RPC test fails now

* use minimal config, no demo config

* clean up branch

* Lint

* resolve lint

* more lint fixes

* lint

* fix viz

* Fixing RPC test

* skip before epoch 2

* RPC time out

* Fixed ordering

* rename

* remove some dbg statements

* ensure index is correct

* fix some panics

* getting closer

* fix tests

* Fix private key

* Fixed RPC test

* Fixed beacon chain build for docker

* Add interop.go to validator go_image

* Fixed docker build

* handle errors

* skip test, skip disconnecting peers

* Fixed docker build

* tolerance for attestation processing

* revert copy

* clearer err message parse

* fix launching from dep contract
2019-09-11 13:38:35 -05:00

62 lines
1.4 KiB
Go

package main
import (
"encoding/hex"
"os"
"path/filepath"
"github.com/prysmaticlabs/prysm/shared/bls"
"github.com/prysmaticlabs/prysm/shared/interop"
"github.com/prysmaticlabs/prysm/shared/keystore"
)
func loadUnencryptedKeys(path string) (map[string]*keystore.Key, error) {
log.Warn("Loading encrypted keys from disk. Do not do this in production!")
pth, err := filepath.Abs(path)
if err != nil {
return nil, err
}
r, err := os.Open(pth)
if err != nil {
return nil, err
}
validatorKeysUnecrypted, _, err := parseUnencryptedKeysFile(r)
if err != nil {
return nil, err
}
validatorKeys := make(map[string]*keystore.Key)
for _, item := range validatorKeysUnecrypted {
priv, err := bls.SecretKeyFromBytes(item)
if err != nil {
return nil, err
}
k, err := keystore.NewKeyFromBLS(priv)
if err != nil {
return nil, err
}
validatorKeys[hex.EncodeToString(priv.PublicKey().Marshal())] = k
}
return validatorKeys, nil
}
func interopValidatorKeys(idx, count uint64) (map[string]*keystore.Key, error) {
log.Warn("Using interop deterministic generated validator keys.")
sks, _, err := interop.DeterministicallyGenerateKeys(idx, count)
if err != nil {
return nil, err
}
validatorKeys := make(map[string]*keystore.Key)
for _, priv := range sks {
k, err := keystore.NewKeyFromBLS(priv)
if err != nil {
return nil, err
}
validatorKeys[hex.EncodeToString(priv.PublicKey().Marshal())] = k
}
return validatorKeys, nil
}