forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-19 10:22:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'aura-dev' of github.com:goerli/go-ethereum-aura into aura-dev

Browse source
This commit is contained in:
priom 2018-09-08 13:18:07 -04:00
commit 4eacd1dc7b
3 changed files with 61 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
cmd/geth/main.go
View file

@ -120,6 +120,7 @@ var (
utils.DeveloperPeriodFlag,
utils.TestnetFlag,
utils.RinkebyFlag,
utils.GoerliFlag,
utils.VMEnableDebugFlag,
utils.NetworkIdFlag,
utils.RPCCORSDomainFlag,

76
consensus/aura/aura.go
View file

@ -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 {

23
params/config.go
View file

@ -28,6 +28,7 @@ var (
MainnetGenesisHash = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3")
TestnetGenesisHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d")
RinkebyGenesisHash = common.HexToHash("0x6341fd3daf94b748c72ced5a5b26028f2474f5f00d824504e4fa37a75767e177")
GoerliGenesisHash = common.HexToHash("0X0000000000000000000000000000000000000000000000000000000000000000")
)
var (
@ -81,21 +82,21 @@ 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: 15,
Period: 4,
Epoch: 30000,
Authorities: []string{
"0x540a9fe3d2381016dec8ffba7235c6fb00b0f942",
Authorities: []common.Address{
common.HexToAddress("0x540a9fe3d2381016dec8ffba7235c6fb00b0f942"),
},
Difficulty: big.NewInt(131072),
},
@ -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))
)
@ -166,7 +169,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
}