From ba563eb96cb266059dda6ff33262fa6e8a6abd9a Mon Sep 17 00:00:00 2001 From: noot <36753753+noot@users.noreply.github.com> Date: Sat, 8 Sep 2018 08:42:34 -0700 Subject: [PATCH 1/2] Elizabeth/aura (#18) * added bootnodes to bootnodes.go and added authorities array to GoerliChainConfig in params/config.go * Seal() returns errUnauthorized if not authorized to sign block * verifySeal now checks if signer of block was correct signer at that turn --- consensus/aura/aura.go | 76 ++++++++++++++++++++++++++---------------- params/config.go | 8 ++--- 2 files changed, 51 insertions(+), 33 deletions(-) diff --git a/consensus/aura/aura.go b/consensus/aura/aura.go index fb58d9a3ea..a823f790c8 100644 --- a/consensus/aura/aura.go +++ b/consensus/aura/aura.go @@ -454,27 +454,35 @@ func (a *Aura) verifySeal(chain consensus.ChainReader, header *types.Header, par return errUnknownBlock } // Retrieve the snapshot needed to verify this header and cache it - snap, err := a.snapshot(chain, number-1, header.ParentHash, parents) - if err != nil { - return err - } + // snap, err := a.snapshot(chain, number-1, header.ParentHash, parents) + // if err != nil { + // return err + // } // Resolve the authorization key and check against signers signer, err := ecrecover(header, a.signatures) if err != nil { return err } - if _, ok := snap.Signers[signer]; !ok { + + ts := header.Time.Uint64() + step := ts % a.config.Period + turn := step % uint64(len(a.config.Authorities)) + if signer != a.config.Authorities[turn] { + // not authorized to sign return errUnauthorized } - for seen, recent := range snap.Recents { - if recent == signer { - // Signer is among recents, only fail if the current block doesn't shift it out - if limit := uint64(len(snap.Signers)/2 + 1); seen > number-limit { - return errUnauthorized - } - } - } + // if _, ok := snap.Signers[signer]; !ok { + // return errUnauthorized + // } + // for seen, recent := range snap.Recents { + // if recent == signer { + // // Signer is among recents, only fail if the current block doesn't shift it out + // if limit := uint64(len(snap.Signers)/2 + 1); seen > number-limit { + // return errUnauthorized + // } + // } + // } // Ensure that the difficulty corresponds to the turn-ness of the signer //inturn := snap.inturn(header.Number.Uint64(), signer) //if inturn && header.Difficulty.Cmp(diffInTurn) != 0 { @@ -591,24 +599,34 @@ func (a *Aura) Seal(chain consensus.ChainReader, block *types.Block, results cha signer, signFn := a.signer, a.signFn a.lock.RUnlock() - // Bail out if we're unauthorized to sign a block - snap, err := a.snapshot(chain, number-1, header.ParentHash, nil) - if err != nil { - return err - } - if _, authorized := snap.Signers[signer]; !authorized { + + // check if authorized to sign + step := uint64(time.Now().Unix()) % a.config.Period + turn := step % uint64(len(a.config.Authorities)) + if a.signer != a.config.Authorities[turn] { + // not authorized to sign return errUnauthorized } - // If we're amongst the recent signers, wait for the next block - for seen, recent := range snap.Recents { - if recent == signer { - // Signer is among recents, only wait if the current block doesn't shift it out - if limit := uint64(len(snap.Signers)/2 + 1); number < limit || seen > number-limit { - log.Info("Signed recently, must wait for others") - return nil - } - } - } + + // Bail out if we're unauthorized to sign a block + // snap, err := a.snapshot(chain, number-1, header.ParentHash, nil) + // if err != nil { + // return err + // } + // if _, authorized := snap.Signers[signer]; !authorized { + // return errUnauthorized + // } + // // If we're amongst the recent signers, wait for the next block + // for seen, recent := range snap.Recents { + // if recent == signer { + // // Signer is among recents, only wait if the current block doesn't shift it out + // if limit := uint64(len(snap.Signers)/2 + 1); number < limit || seen > number-limit { + // log.Info("Signed recently, must wait for others") + // return nil + // } + // } + // } + // Sweet, the protocol permits us to sign the block, wait for our time delay := time.Unix(header.Time.Int64(), 0).Sub(time.Now()) // nolint: gosimple //if header.Difficulty.Cmp(diffNoTurn) == 0 { diff --git a/params/config.go b/params/config.go index f5498846ce..6df937e71b 100644 --- a/params/config.go +++ b/params/config.go @@ -92,10 +92,10 @@ var ( ByzantiumBlock: big.NewInt(0), ConstantinopleBlock: nil, Aura: &AuraConfig{ - Period: 15, + Period: 4, Epoch: 30000, - Authorities: []string{ - "0x540a9fe3d2381016dec8ffba7235c6fb00b0f942", + Authorities: []common.Address{ + common.HexToAddress("0x540a9fe3d2381016dec8ffba7235c6fb00b0f942"), }, Difficulty: big.NewInt(131072), }, @@ -166,7 +166,7 @@ type CliqueConfig struct { type AuraConfig struct { Period uint64 `json:"period"` // Number of seconds between blocks to enforce Epoch uint64 `json:"epoch"` // Epoch length to reset votes and checkpoint - Authorities []string `json:"authorities"` // list of addresses of authorities + Authorities []common.Address `json:"authorities"` // list of addresses of authorities Difficulty *big.Int `json:"difficulty"` // Constant block difficulty } From 5e09cee3e18dcc6cba22af2eda2190436f9d4dee Mon Sep 17 00:00:00 2001 From: Priom Chowdhury Date: Sat, 8 Sep 2018 13:17:52 -0400 Subject: [PATCH 2/2] Goerli flag keeps connecting to Mainnet (#20) * go modules added; preparing to write aura consensus * adding goerli flag * goerli flag added * adding configs * core/vm: Hide read only flag from Interpreter interface (#17461) (#6) Makes Interface interface a bit more stateless and abstract. Obviously this change is dictated by EVMC design. The EVMC tries to keep the responsibility for EVM features totally inside the VMs, if feasible. This makes VM "stateless" because VM does not need to pass any information between executions, all information is included in parameters of the execute function. * configuring genesis * removing duplicate imports * adding configs for aura api * configuring goerli cli flag * flag function fix * typo fix * goerli flag finalized * config mod --- cmd/geth/main.go | 1 + params/config.go | 15 +++++++++------ 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/cmd/geth/main.go b/cmd/geth/main.go index 134d5a4c01..c22160555c 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -120,6 +120,7 @@ var ( utils.DeveloperPeriodFlag, utils.TestnetFlag, utils.RinkebyFlag, + utils.GoerliFlag, utils.VMEnableDebugFlag, utils.NetworkIdFlag, utils.RPCCORSDomainFlag, diff --git a/params/config.go b/params/config.go index 6df937e71b..5fe8bb1b82 100644 --- a/params/config.go +++ b/params/config.go @@ -28,6 +28,7 @@ var ( MainnetGenesisHash = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3") TestnetGenesisHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d") RinkebyGenesisHash = common.HexToHash("0x6341fd3daf94b748c72ced5a5b26028f2474f5f00d824504e4fa37a75767e177") + GoerliGenesisHash = common.HexToHash("0X0000000000000000000000000000000000000000000000000000000000000000") ) var ( @@ -81,15 +82,15 @@ var ( // GoerliChainConfig contains the chain parameters to run a node on the Goerli test network. GoerliChainConfig = &ChainConfig{ - ChainID: big.NewInt(6283), - HomesteadBlock: big.NewInt(0), + ChainID: big.NewInt(5), + HomesteadBlock: big.NewInt(2), DAOForkBlock: nil, DAOForkSupport: true, - EIP150Block: big.NewInt(0), + EIP150Block: big.NewInt(2), EIP150Hash: common.HexToHash("0X0000000000000000000000000000000000000000000000000000000000000000"), - EIP155Block: big.NewInt(0), - EIP158Block: big.NewInt(0), - ByzantiumBlock: big.NewInt(0), + EIP155Block: big.NewInt(3), + EIP158Block: big.NewInt(3), + ByzantiumBlock: big.NewInt(1035301), ConstantinopleBlock: nil, Aura: &AuraConfig{ Period: 4, @@ -115,6 +116,8 @@ var ( // adding flags to the config to also have to set these fields. AllCliqueProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, nil, &CliqueConfig{Period: 0, Epoch: 30000}, nil} + AuraProtocolChanges = &ChainConfig{big.NewInt(5), big.NewInt(2), nil, false, big.NewInt(2), common.Hash{}, big.NewInt(3), big.NewInt(3), big.NewInt(1035301), nil, nil, nil, &AuraConfig{Period: 15, Epoch: 30000, Authorities: []string{"0x540a9fe3d2381016dec8ffba7235c6fb00b0f942"}, Difficulty: big.NewInt(131072)}} + TestChainConfig = &ChainConfig{big.NewInt(1), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, new(EthashConfig), nil, nil} TestRules = TestChainConfig.Rules(new(big.Int)) )