forked from mirror/go-ethereum
consensus/clique: Proof of Authority (#3753)
This PR is a prototype implementation of plugable consensus engines and the Clique PoA protocol ethereum/EIPs#225release/1.6
Péter Szilágyi
8 years ago
committed by
Felix Lange
parent
bfe5eb7f8c
commit
feeccdf4ec
@ -0,0 +1,97 @@ |
||||
// Copyright 2017 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package clique |
||||
|
||||
import ( |
||||
"github.com/ethereum/go-ethereum/common" |
||||
"github.com/ethereum/go-ethereum/consensus" |
||||
"github.com/ethereum/go-ethereum/core/types" |
||||
"github.com/ethereum/go-ethereum/rpc" |
||||
) |
||||
|
||||
// API is a user facing RPC API to allow controlling the signer and voting
|
||||
// mechanisms of the proof-of-authority scheme.
|
||||
type API struct { |
||||
chain consensus.ChainReader |
||||
clique *Clique |
||||
} |
||||
|
||||
// GetSnapshot retrieves the state snapshot at a given block.
|
||||
func (api *API) GetSnapshot(number *rpc.BlockNumber) (interface{}, error) { |
||||
// Retrieve the requested block number (or current if none requested)
|
||||
var header *types.Header |
||||
if number == nil || *number == rpc.LatestBlockNumber { |
||||
header = api.chain.CurrentHeader() |
||||
} else { |
||||
header = api.chain.GetHeaderByNumber(uint64(number.Int64())) |
||||
} |
||||
// Ensure we have an actually valid block and return its snapshot
|
||||
if header == nil { |
||||
return nil, errUnknownBlock |
||||
} |
||||
return api.clique.snapshot(api.chain, header.Number.Uint64(), header.Hash(), nil) |
||||
} |
||||
|
||||
// GetSigners retrieves the list of authorized signers at the specified block.
|
||||
func (api *API) GetSigners(number *rpc.BlockNumber) ([]common.Address, error) { |
||||
// Retrieve the requested block number (or current if none requested)
|
||||
var header *types.Header |
||||
if number == nil || *number == rpc.LatestBlockNumber { |
||||
header = api.chain.CurrentHeader() |
||||
} else { |
||||
header = api.chain.GetHeaderByNumber(uint64(number.Int64())) |
||||
} |
||||
// Ensure we have an actually valid block and return the signers from its snapshot
|
||||
if header == nil { |
||||
return nil, errUnknownBlock |
||||
} |
||||
snap, err := api.clique.snapshot(api.chain, header.Number.Uint64(), header.Hash(), nil) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return snap.signers(), nil |
||||
} |
||||
|
||||
// Proposals returns the current proposals the node tries to uphold and vote on.
|
||||
func (api *API) Proposals() map[common.Address]bool { |
||||
api.clique.lock.RLock() |
||||
defer api.clique.lock.RUnlock() |
||||
|
||||
proposals := make(map[common.Address]bool) |
||||
for address, auth := range api.clique.proposals { |
||||
proposals[address] = auth |
||||
} |
||||
return proposals |
||||
} |
||||
|
||||
// Propose injects a new authorization proposal that the signer will attempt to
|
||||
// push through.
|
||||
func (api *API) Propose(address common.Address, auth bool) { |
||||
api.clique.lock.Lock() |
||||
defer api.clique.lock.Unlock() |
||||
|
||||
api.clique.proposals[address] = auth |
||||
} |
||||
|
||||
// Discard drops a currently running proposal, stopping the signer from casting
|
||||
// further votes (either for or against).
|
||||
func (api *API) Discard(address common.Address) { |
||||
api.clique.lock.Lock() |
||||
defer api.clique.lock.Unlock() |
||||
|
||||
delete(api.clique.proposals, address) |
||||
} |
||||
@ -0,0 +1,638 @@ |
||||
// Copyright 2017 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
// Package clique implements the proof-of-authority consensus engine.
|
||||
package clique |
||||
|
||||
import ( |
||||
"bytes" |
||||
"errors" |
||||
"math/big" |
||||
"math/rand" |
||||
"sync" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/accounts" |
||||
"github.com/ethereum/go-ethereum/common" |
||||
"github.com/ethereum/go-ethereum/common/hexutil" |
||||
"github.com/ethereum/go-ethereum/consensus" |
||||
"github.com/ethereum/go-ethereum/core/state" |
||||
"github.com/ethereum/go-ethereum/core/types" |
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
"github.com/ethereum/go-ethereum/crypto/sha3" |
||||
"github.com/ethereum/go-ethereum/ethdb" |
||||
"github.com/ethereum/go-ethereum/log" |
||||
"github.com/ethereum/go-ethereum/params" |
||||
"github.com/ethereum/go-ethereum/rlp" |
||||
"github.com/ethereum/go-ethereum/rpc" |
||||
lru "github.com/hashicorp/golang-lru" |
||||
) |
||||
|
||||
const ( |
||||
checkpointInterval = 1024 // Number of blocks after which to save the vote snapshot to the database
|
||||
inmemorySnapshots = 128 // Number of recent vote snapshots to keep in memory
|
||||
inmemorySignatures = 1024 // Number of recent blocks to keep in memory
|
||||
|
||||
wiggleTime = 500 * time.Millisecond // Random delay (per signer) to allow concurrent signers
|
||||
) |
||||
|
||||
// Clique proof-of-authority protocol constants.
|
||||
var ( |
||||
epochLength = uint64(30000) // Default number of blocks after which to checkpoint and reset the pending votes
|
||||
blockPeriod = uint64(15) // Default minimum difference between two consecutive block's timestamps
|
||||
|
||||
extraVanity = 32 // Fixed number of extra-data prefix bytes reserved for signer vanity
|
||||
extraSeal = 65 // Fixed number of extra-data suffix bytes reserved for signer seal
|
||||
|
||||
nonceAuthVote = hexutil.MustDecode("0xffffffffffffffff") // Magic nonce number to vote on adding a new signer
|
||||
nonceDropVote = hexutil.MustDecode("0x0000000000000000") // Magic nonce number to vote on removing a signer.
|
||||
|
||||
uncleHash = types.CalcUncleHash(nil) // Always Keccak256(RLP([])) as uncles are meaningless outside of PoW.
|
||||
|
||||
diffInTurn = big.NewInt(2) // Block difficulty for in-turn signatures
|
||||
diffNoTurn = big.NewInt(1) // Block difficulty for out-of-turn signatures
|
||||
) |
||||
|
||||
// Various error messages to mark blocks invalid. These should be private to
|
||||
// prevent engine specific errors from being referenced in the remainder of the
|
||||
// codebase, inherently breaking if the engine is swapped out. Please put common
|
||||
// error types into the consensus package.
|
||||
var ( |
||||
// errUnknownBlock is returned when the list of signers is requested for a block
|
||||
// that is not part of the local blockchain.
|
||||
errUnknownBlock = errors.New("unknown block") |
||||
|
||||
// errInvalidCheckpointBeneficiary is returned if a checkpoint/epoch transition
|
||||
// block has a beneficiary set to non zeroes.
|
||||
errInvalidCheckpointBeneficiary = errors.New("beneficiary in checkpoint block non-zero") |
||||
|
||||
// errInvalidVote is returned if a nonce value is something else that the two
|
||||
// allowed constants of 0x00..0 or 0xff..f.
|
||||
errInvalidVote = errors.New("vote nonce not 0x00..0 or 0xff..f") |
||||
|
||||
// errInvalidCheckpointVote is returned if a checkpoint/epoch transition block
|
||||
// has a vote nonce set to non zeroes.
|
||||
errInvalidCheckpointVote = errors.New("vote nonce in checkpoint block non-zero") |
||||
|
||||
// errMissingVanity is returned if a block's extra-data section is shorter than
|
||||
// 32 bytes, which is required to store the signer vanity.
|
||||
errMissingVanity = errors.New("extra-data 32 byte vanity prefix missing") |
||||
|
||||
// errMissingSignature is returned if a block's extra-data section doesn't seem
|
||||
// to contain a 65 byte secp256k1 signature.
|
||||
errMissingSignature = errors.New("extra-data 65 byte suffix signature missing") |
||||
|
||||
// errExtraSigners is returned if non-checkpoint block contain signer data in
|
||||
// their extra-data fields.
|
||||
errExtraSigners = errors.New("non-checkpoint block contains extra signer list") |
||||
|
||||
// drrInvalidCheckpointSigners is returned if a checkpoint block contains an
|
||||
// invalid list of signers (i.e. non divisible by 20 bytes, or not the correct
|
||||
// ones).
|
||||
drrInvalidCheckpointSigners = errors.New("invalid signer list on checkpoint block") |
||||
|
||||
// errInvalidMixDigest is returned if a block's mix digest is non zero.
|
||||
errInvalidMixDigest = errors.New("non-zero mix digest") |
||||
|
||||
// errInvalidUncleHash is returned if a block contains an non-empty uncle list.
|
||||
errInvalidUncleHash = errors.New("non empty uncle hash") |
||||
|
||||
// errInvalidDifficulty is returned if the difficulty of a block is not either
|
||||
// of 1 or 2, or if the value does not match the turn of the signer.
|
||||
errInvalidDifficulty = errors.New("invalid difficulty") |
||||
|
||||
// ErrInvalidTimestamp is returned if the timestamp of a block is lower than
|
||||
// the previous block's timestamp + the minimum block period.
|
||||
ErrInvalidTimestamp = errors.New("invalid timestamp") |
||||
|
||||
// errInvalidVotingChain is returned if an authorization list is attempted to
|
||||
// be modified via out-of-range or non-contiguous headers.
|
||||
errInvalidVotingChain = errors.New("invalid voting chain") |
||||
|
||||
// errUnauthorized is returned if a header is signed by a non authorized entity.
|
||||
errUnauthorized = errors.New("unauthorized") |
||||
) |
||||
|
||||
// SignerFn is a signer callback function to request a hash to be signed by a
|
||||
// backing account.
|
||||
type SignerFn func(accounts.Account, []byte) ([]byte, error) |
||||
|
||||
// sigHash returns the hash which is used as input for the proof-of-authority
|
||||
// signing. It is the hash of the entire header apart from the 65 byte signature
|
||||
// contained at the end of the extra data.
|
||||
//
|
||||
// Note, the method requires the extra data to be at least 65 bytes, otherwise it
|
||||
// panics. This is done to avoid accidentally using both forms (signature present
|
||||
// or not), which could be abused to produce different hashes for the same header.
|
||||
func sigHash(header *types.Header) (hash common.Hash) { |
||||
hasher := sha3.NewKeccak256() |
||||
|
||||
rlp.Encode(hasher, []interface{}{ |
||||
header.ParentHash, |
||||
header.UncleHash, |
||||
header.Coinbase, |
||||
header.Root, |
||||
header.TxHash, |
||||
header.ReceiptHash, |
||||
header.Bloom, |
||||
header.Difficulty, |
||||
header.Number, |
||||
header.GasLimit, |
||||
header.GasUsed, |
||||
header.Time, |
||||
header.Extra[:len(header.Extra)-65], // Yes, this will panic if extra is too short
|
||||
header.MixDigest, |
||||
header.Nonce, |
||||
}) |
||||
hasher.Sum(hash[:0]) |
||||
return hash |
||||
} |
||||
|
||||
// ecrecover extracts the Ethereum account address from a signed header.
|
||||
func ecrecover(header *types.Header) (common.Address, error) { |
||||
// Retrieve the signature from the header extra-data
|
||||
if len(header.Extra) < extraSeal { |
||||
return common.Address{}, errMissingSignature |
||||
} |
||||
signature := header.Extra[len(header.Extra)-extraSeal:] |
||||
|
||||
// Recover the public key and the Ethereum address
|
||||
pubkey, err := crypto.Ecrecover(sigHash(header).Bytes(), signature) |
||||
if err != nil { |
||||
return common.Address{}, err |
||||
} |
||||
var signer common.Address |
||||
copy(signer[:], crypto.Keccak256(pubkey[1:])[12:]) |
||||
|
||||
return signer, nil |
||||
} |
||||
|
||||
// Clique is the proof-of-authority consensus engine proposed to support the
|
||||
// Ethereum testnet following the Ropsten attacks.
|
||||
type Clique struct { |
||||
config *params.CliqueConfig // Consensus engine configuration parameters
|
||||
db ethdb.Database // Database to store and retrieve snapshot checkpoints
|
||||
|
||||
recents *lru.ARCCache // Snapshots for recent block to speed up reorgs
|
||||
signatures *lru.ARCCache // Signatures of recent blocks to speed up mining
|
||||
|
||||
proposals map[common.Address]bool // Current list of proposals we are pushing
|
||||
|
||||
signer common.Address // Ethereum address of the signing key
|
||||
signFn SignerFn // Signer function to authorize hashes with
|
||||
lock sync.RWMutex // Protects the signer fields
|
||||
} |
||||
|
||||
// New creates a Clique proof-of-authority consensus engine with the initial
|
||||
// signers set to the ones provided by the user.
|
||||
func New(config *params.CliqueConfig, db ethdb.Database) *Clique { |
||||
// Set any missing consensus parameters to their defaults
|
||||
conf := *config |
||||
if conf.Epoch == 0 { |
||||
conf.Epoch = epochLength |
||||
} |
||||
if conf.Period == 0 { |
||||
conf.Period = blockPeriod |
||||
} |
||||
// Allocate the snapshot caches and create the engine
|
||||
recents, _ := lru.NewARC(inmemorySnapshots) |
||||
signatures, _ := lru.NewARC(inmemorySignatures) |
||||
|
||||
return &Clique{ |
||||
config: &conf, |
||||
db: db, |
||||
recents: recents, |
||||
signatures: signatures, |
||||
proposals: make(map[common.Address]bool), |
||||
} |
||||
} |
||||
|
||||
// VerifyHeader checks whether a header conforms to the consensus rules.
|
||||
func (c *Clique) VerifyHeader(chain consensus.ChainReader, header *types.Header, seal bool) error { |
||||
return c.verifyHeader(chain, header, nil) |
||||
} |
||||
|
||||
// VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers. The
|
||||
// method returns a quit channel to abort the operations and a results channel to
|
||||
// retrieve the async verifications (the order is that of the input slice).
|
||||
func (c *Clique) VerifyHeaders(chain consensus.ChainReader, headers []*types.Header, seals []bool) (chan<- struct{}, <-chan error) { |
||||
abort := make(chan struct{}) |
||||
results := make(chan error, len(headers)) |
||||
|
||||
go func() { |
||||
for i, header := range headers { |
||||
err := c.verifyHeader(chain, header, headers[:i]) |
||||
|
||||
select { |
||||
case <-abort: |
||||
return |
||||
case results <- err: |
||||
} |
||||
} |
||||
}() |
||||
return abort, results |
||||
} |
||||
|
||||
// verifyHeader checks whether a header conforms to the consensus rules.The
|
||||
// caller may optionally pass in a batch of parents (ascending order) to avoid
|
||||
// looking those up from the database. This is useful for concurrently verifying
|
||||
// a batch of new headers.
|
||||
func (c *Clique) verifyHeader(chain consensus.ChainReader, header *types.Header, parents []*types.Header) error { |
||||
if header.Number == nil { |
||||
return errUnknownBlock |
||||
} |
||||
number := header.Number.Uint64() |
||||
|
||||
// Don't waste time checking blocks from the future
|
||||
if header.Time.Cmp(big.NewInt(time.Now().Unix())) > 0 { |
||||
return consensus.ErrFutureBlock |
||||
} |
||||
// Checkpoint blocks need to enforce zero beneficiary
|
||||
checkpoint := (number % c.config.Epoch) == 0 |
||||
if checkpoint && header.Coinbase != (common.Address{}) { |
||||
return errInvalidCheckpointBeneficiary |
||||
} |
||||
// Nonces must be 0x00..0 or 0xff..f, zeroes enforced on checkpoints
|
||||
if !bytes.Equal(header.Nonce[:], nonceAuthVote) && !bytes.Equal(header.Nonce[:], nonceDropVote) { |
||||
return errInvalidVote |
||||
} |
||||
if checkpoint && !bytes.Equal(header.Nonce[:], nonceDropVote) { |
||||
return errInvalidCheckpointVote |
||||
} |
||||
// Check that the extra-data contains both the vanity and signature
|
||||
if len(header.Extra) < extraVanity { |
||||
return errMissingVanity |
||||
} |
||||
if len(header.Extra) < extraVanity+extraSeal { |
||||
return errMissingSignature |
||||
} |
||||
// Ensure that the extra-data contains a signer list on checkpoint, but none otherwise
|
||||
signersBytes := len(header.Extra) - extraVanity - extraSeal |
||||
if !checkpoint && signersBytes != 0 { |
||||
return errExtraSigners |
||||
} |
||||
if checkpoint && signersBytes%common.AddressLength != 0 { |
||||
return drrInvalidCheckpointSigners |
||||
} |
||||
// Ensure that the mix digest is zero as we don't have fork protection currently
|
||||
if header.MixDigest != (common.Hash{}) { |
||||
return errInvalidMixDigest |
||||
} |
||||
// Ensure that the block doesn't contain any uncles which are meaningless in PoA
|
||||
if header.UncleHash != uncleHash { |
||||
return errInvalidUncleHash |
||||
} |
||||
// Ensure that the block's difficulty is meaningful (may not be correct at this point)
|
||||
if number > 0 { |
||||
if header.Difficulty == nil || (header.Difficulty.Cmp(diffInTurn) != 0 && header.Difficulty.Cmp(diffNoTurn) != 0) { |
||||
return errInvalidDifficulty |
||||
} |
||||
} |
||||
// All basic checks passed, verify cascading fields
|
||||
return c.verifyCascadingFields(chain, header, parents) |
||||
} |
||||
|
||||
// verifyCascadingFields verifies all the header fields that are not standalone,
|
||||
// rather depend on a batch of previous headers. The caller may optionally pass
|
||||
// in a batch of parents (ascending order) to avoid looking those up from the
|
||||
// database. This is useful for concurrently verifying a batch of new headers.
|
||||
func (c *Clique) verifyCascadingFields(chain consensus.ChainReader, header *types.Header, parents []*types.Header) error { |
||||
// The genesis block is the always valid dead-end
|
||||
number := header.Number.Uint64() |
||||
if number == 0 { |
||||
return nil |
||||
} |
||||
// Ensure that the block's timestamp isn't too close to it's parent
|
||||
var parent *types.Header |
||||
if len(parents) > 0 { |
||||
parent = parents[len(parents)-1] |
||||
} else { |
||||
parent = chain.GetHeader(header.ParentHash, number-1) |
||||
} |
||||
if parent == nil || parent.Number.Uint64() != number-1 || parent.Hash() != header.ParentHash { |
||||
return consensus.ErrUnknownAncestor |
||||
} |
||||
if parent.Time.Uint64()+c.config.Period > header.Time.Uint64() { |
||||
return ErrInvalidTimestamp |
||||
} |
||||
// Retrieve the snapshot needed to verify this header and cache it
|
||||
snap, err := c.snapshot(chain, number-1, header.ParentHash, parents) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
// If the block is a checkpoint block, verify the signer list
|
||||
if number%c.config.Epoch == 0 { |
||||
signers := make([]byte, len(snap.Signers)*common.AddressLength) |
||||
for i, signer := range snap.signers() { |
||||
copy(signers[i*common.AddressLength:], signer[:]) |
||||
} |
||||
extraSuffix := len(header.Extra) - extraSeal |
||||
if !bytes.Equal(header.Extra[extraVanity:extraSuffix], signers) { |
||||
return drrInvalidCheckpointSigners |
||||
} |
||||
} |
||||
// All basic checks passed, verify the seal and return
|
||||
return c.verifySeal(chain, header, parents) |
||||
} |
||||
|
||||
// snapshot retrieves the authorization snapshot at a given point in time.
|
||||
func (c *Clique) snapshot(chain consensus.ChainReader, number uint64, hash common.Hash, parents []*types.Header) (*snapshot, error) { |
||||
// Search for a snapshot in memory or on disk for checkpoints
|
||||
var ( |
||||
headers []*types.Header |
||||
snap *snapshot |
||||
) |
||||
for snap == nil { |
||||
// If an in-memory snapshot was found, use that
|
||||
if s, ok := c.recents.Get(hash); ok { |
||||
snap = s.(*snapshot) |
||||
break |
||||
} |
||||
// If an on-disk checkpoint snapshot can be found, use that
|
||||
if number%checkpointInterval == 0 { |
||||
if s, err := loadSnapshot(c.config, c.db, hash); err == nil { |
||||
log.Trace("Loaded voting snapshot form disk", "number", number, "hash", hash) |
||||
snap = s |
||||
break |
||||
} |
||||
} |
||||
// If we're at block zero, make a snapshot
|
||||
if number == 0 { |
||||
genesis := chain.GetHeaderByNumber(0) |
||||
if err := c.VerifyHeader(chain, genesis, false); err != nil { |
||||
return nil, err |
||||
} |
||||
signers := make([]common.Address, (len(genesis.Extra)-extraVanity-extraSeal)/common.AddressLength) |
||||
for i := 0; i < len(signers); i++ { |
||||
copy(signers[i][:], genesis.Extra[extraVanity+i*common.AddressLength:]) |
||||
} |
||||
snap = newSnapshot(c.config, 0, genesis.Hash(), signers) |
||||
if err := snap.store(c.db); err != nil { |
||||
return nil, err |
||||
} |
||||
log.Trace("Stored genesis voting snapshot to disk") |
||||
break |
||||
} |
||||
// No snapshot for this header, gather the header and move backward
|
||||
var header *types.Header |
||||
if len(parents) > 0 { |
||||
// If we have explicit parents, pick from there (enforced)
|
||||
header = parents[len(parents)-1] |
||||
if header.Hash() != hash || header.Number.Uint64() != number { |
||||
return nil, consensus.ErrUnknownAncestor |
||||
} |
||||
parents = parents[:len(parents)-1] |
||||
} else { |
||||
// No explicit parents (or no more left), reach out to the database
|
||||
header = chain.GetHeader(hash, number) |
||||
if header == nil { |
||||
return nil, consensus.ErrUnknownAncestor |
||||
} |
||||
} |
||||
headers = append(headers, header) |
||||
number, hash = number-1, header.ParentHash |
||||
} |
||||
// Previous snapshot found, apply any pending headers on top of it
|
||||
for i := 0; i < len(headers)/2; i++ { |
||||
headers[i], headers[len(headers)-1-i] = headers[len(headers)-1-i], headers[i] |
||||
} |
||||
snap, err := snap.apply(headers) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
c.recents.Add(snap.Hash, snap) |
||||
|
||||
// If we've generated a new checkpoint snapshot, save to disk
|
||||
if snap.Number%checkpointInterval == 0 && len(headers) > 0 { |
||||
if err = snap.store(c.db); err != nil { |
||||
return nil, err |
||||
} |
||||
log.Trace("Stored voting snapshot to disk", "number", snap.Number, "hash", snap.Hash) |
||||
} |
||||
return snap, err |
||||
} |
||||
|
||||
// VerifyUncles implements consensus.Engine, always returning an error for any
|
||||
// uncles as this consensus mechanism doesn't permit uncles.
|
||||
func (c *Clique) VerifyUncles(chain consensus.ChainReader, block *types.Block) error { |
||||
if len(block.Uncles()) > 0 { |
||||
return errors.New("uncles not allowed") |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// VerifySeal implements consensus.Engine, checking whether the signature contained
|
||||
// in the header satisfies the consensus protocol requirements.
|
||||
func (c *Clique) VerifySeal(chain consensus.ChainReader, header *types.Header) error { |
||||
return c.verifySeal(chain, header, nil) |
||||
} |
||||
|
||||
// verifySeal checks whether the signature contained in the header satisfies the
|
||||
// consensus protocol requirements. The method accepts an optional list of parent
|
||||
// headers that aren't yet part of the local blockchain to generate the snapshots
|
||||
// from.
|
||||
func (c *Clique) verifySeal(chain consensus.ChainReader, header *types.Header, parents []*types.Header) error { |
||||
// Verifying the genesis block is not supported
|
||||
number := header.Number.Uint64() |
||||
if number == 0 { |
||||
return errUnknownBlock |
||||
} |
||||
// Retrieve the snapshot needed to verify this header and cache it
|
||||
snap, err := c.snapshot(chain, number-1, header.ParentHash, parents) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
c.recents.Add(snap.Hash, snap) |
||||
|
||||
// Resolve the authorization key and check against signers
|
||||
signer, err := ecrecover(header) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
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 doens't shift it out
|
||||
if limit := uint64(len(snap.Signers)/2 + 1); seen > number-limit { |
||||
return errUnauthorized |
||||
} |
||||
} |
||||
} |
||||
// Ensure that the difficulty corresponts to the turn-ness of the signer
|
||||
inturn := snap.inturn(header.Number.Uint64(), signer) |
||||
if inturn && header.Difficulty.Cmp(diffInTurn) != 0 { |
||||
return errInvalidDifficulty |
||||
} |
||||
if !inturn && header.Difficulty.Cmp(diffNoTurn) != 0 { |
||||
return errInvalidDifficulty |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// Prepare implements consensus.Engine, preparing all the consensus fields of the
|
||||
// header for running the transactions on top.
|
||||
func (c *Clique) Prepare(chain consensus.ChainReader, header *types.Header) error { |
||||
// If the block isn't a checkpoint, cast a random vote (good enough fror now)
|
||||
header.Coinbase = common.Address{} |
||||
header.Nonce = types.BlockNonce{} |
||||
|
||||
number := header.Number.Uint64() |
||||
if number%c.config.Epoch != 0 { |
||||
c.lock.RLock() |
||||
if len(c.proposals) > 0 { |
||||
addresses := make([]common.Address, 0, len(c.proposals)) |
||||
for address := range c.proposals { |
||||
addresses = append(addresses, address) |
||||
} |
||||
header.Coinbase = addresses[rand.Intn(len(addresses))] |
||||
if c.proposals[header.Coinbase] { |
||||
copy(header.Nonce[:], nonceAuthVote) |
||||
} else { |
||||
copy(header.Nonce[:], nonceDropVote) |
||||
} |
||||
} |
||||
c.lock.RUnlock() |
||||
} |
||||
// Assemble the voting snapshot and set the correct difficulty
|
||||
snap, err := c.snapshot(chain, number-1, header.ParentHash, nil) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
header.Difficulty = diffNoTurn |
||||
if snap.inturn(header.Number.Uint64(), c.signer) { |
||||
header.Difficulty = diffInTurn |
||||
} |
||||
// Ensure the extra data has all it's components
|
||||
if len(header.Extra) < extraVanity { |
||||
header.Extra = append(header.Extra, bytes.Repeat([]byte{0x00}, extraVanity-len(header.Extra))...) |
||||
} |
||||
header.Extra = header.Extra[:extraVanity] |
||||
|
||||
if number%c.config.Epoch == 0 { |
||||
for _, signer := range snap.signers() { |
||||
header.Extra = append(header.Extra, signer[:]...) |
||||
} |
||||
} |
||||
header.Extra = append(header.Extra, make([]byte, extraSeal)...) |
||||
|
||||
// Mix digest is reserved for now, set to empty
|
||||
header.MixDigest = common.Hash{} |
||||
|
||||
// Ensure the timestamp has the correct delay
|
||||
parent := chain.GetHeader(header.ParentHash, number-1) |
||||
if parent == nil { |
||||
return consensus.ErrUnknownAncestor |
||||
} |
||||
header.Time = new(big.Int).Add(parent.Time, new(big.Int).SetUint64(c.config.Period)) |
||||
if header.Time.Int64() < time.Now().Unix() { |
||||
header.Time = big.NewInt(time.Now().Unix()) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// Finalize implements consensus.Engine, ensuring no uncles are set, nor block
|
||||
// rewards given, and returns the final block.
|
||||
func (c *Clique) Finalize(chain consensus.ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) { |
||||
// No block rewards in PoA, so the state remains as is and uncles are dropped
|
||||
header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number)) |
||||
header.UncleHash = types.CalcUncleHash(nil) |
||||
|
||||
// Assemble and return the final block for sealing
|
||||
return types.NewBlock(header, txs, nil, receipts), nil |
||||
} |
||||
|
||||
// Authorize injects a private key into the consensus engine to mint new blocks
|
||||
// with.
|
||||
func (c *Clique) Authorize(signer common.Address, signFn SignerFn) { |
||||
c.lock.Lock() |
||||
defer c.lock.Unlock() |
||||
|
||||
c.signer = signer |
||||
c.signFn = signFn |
||||
} |
||||
|
||||
// Seal implements consensus.Engine, attempting to create a sealed block using
|
||||
// the local signing credentials.
|
||||
func (c *Clique) Seal(chain consensus.ChainReader, block *types.Block, stop <-chan struct{}) (*types.Block, error) { |
||||
header := block.Header() |
||||
|
||||
// Sealing the genesis block is not supported
|
||||
number := header.Number.Uint64() |
||||
if number == 0 { |
||||
return nil, errUnknownBlock |
||||
} |
||||
// Don't hold the signer fields for the entire sealing procedure
|
||||
c.lock.RLock() |
||||
signer, signFn := c.signer, c.signFn |
||||
c.lock.RUnlock() |
||||
|
||||
// Bail out if we're unauthorized to sign a block
|
||||
snap, err := c.snapshot(chain, number-1, header.ParentHash, nil) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
if _, authorized := snap.Signers[signer]; !authorized { |
||||
return nil, errUnauthorized |
||||
} |
||||
// If we're amongs 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 doens't shift it out
|
||||
if limit := uint64(len(snap.Signers)/2 + 1); seen > number-limit { |
||||
log.Info("Signed recently, must wait for others") |
||||
<-stop |
||||
return nil, nil |
||||
} |
||||
} |
||||
} |
||||
// Sweet, the protocol permits us to sign the block, wait for our time
|
||||
delay := time.Unix(header.Time.Int64(), 0).Sub(time.Now()) |
||||
if header.Difficulty.Cmp(diffNoTurn) == 0 { |
||||
// It's not our turn explicitly to sign, delay it a bit
|
||||
wiggle := time.Duration(len(snap.Signers)/2+1) * wiggleTime |
||||
delay += time.Duration(rand.Int63n(int64(wiggle))) |
||||
|
||||
log.Trace("Out-of-turn signing requested", "wiggle", common.PrettyDuration(wiggle)) |
||||
} |
||||
log.Trace("Waiting for slot to sign and propagate", "delay", common.PrettyDuration(delay)) |
||||
|
||||
select { |
||||
case <-stop: |
||||
return nil, nil |
||||
case <-time.After(delay): |
||||
} |
||||
// Sign all the things!
|
||||
sighash, err := signFn(accounts.Account{Address: signer}, sigHash(header).Bytes()) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
copy(header.Extra[len(header.Extra)-extraSeal:], sighash) |
||||
|
||||
return block.WithSeal(header), nil |
||||
} |
||||
|
||||
// APIs implements consensus.Engine, returning the user facing RPC API to allow
|
||||
// controlling the signer voting.
|
||||
func (c *Clique) APIs(chain consensus.ChainReader) []rpc.API { |
||||
return []rpc.API{{ |
||||
Namespace: "clique", |
||||
Version: "1.0", |
||||
Service: &API{chain: chain, clique: c}, |
||||
Public: false, |
||||
}} |
||||
} |
||||
@ -0,0 +1,299 @@ |
||||
// Copyright 2017 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package clique |
||||
|
||||
import ( |
||||
"bytes" |
||||
"encoding/json" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
"github.com/ethereum/go-ethereum/core/types" |
||||
"github.com/ethereum/go-ethereum/ethdb" |
||||
"github.com/ethereum/go-ethereum/params" |
||||
) |
||||
|
||||
// vote represents a single vote that an authorized signer made to modify the
|
||||
// list of authorizations.
|
||||
type vote struct { |
||||
Signer common.Address `json:"signer"` // Authorized signer that cast this vote
|
||||
Block uint64 `json:"block"` // Block number the vote was cast in (expire old votes)
|
||||
Address common.Address `json:"address"` // Account being voted on to change its authorization
|
||||
Authorize bool `json:"authorize"` // Whether to authorize or deauthorize the voted account
|
||||
} |
||||
|
||||
// tally is a simple vote tally to keep the current score of votes. Votes that
|
||||
// go against the proposal aren't counted since it's equivalent to not voting.
|
||||
type tally struct { |
||||
Authorize bool `json:"authorize"` // Whether the vote it about authorizing or kicking someone
|
||||
Votes int `json:"votes"` // Number of votes until now wanting to pass the proposal
|
||||
} |
||||
|
||||
// snapshot is the state of the authorization voting at a given point in time.
|
||||
type snapshot struct { |
||||
config *params.CliqueConfig // Consensus engine parameters to fine tune behavior
|
||||
|
||||
Number uint64 `json:"number"` // Block number where the snapshot was created
|
||||
Hash common.Hash `json:"hash"` // Block hash where the snapshot was created
|
||||
Signers map[common.Address]struct{} `json:"signers"` // Set of authorized signers at this moment
|
||||
Recents map[uint64]common.Address `json:"recents"` // Set of recent signers for spam protections
|
||||
Votes []*vote `json:"votes"` // List of votes cast in chronological order
|
||||
Tally map[common.Address]tally `json:"tally"` // Current vote tally to avoid recalculating
|
||||
} |
||||
|
||||
// newSnapshot create a new snapshot with the specified startup parameters. This
|
||||
// method does not initialize the set of recent signers, so only ever use if for
|
||||
// the genesis block.
|
||||
func newSnapshot(config *params.CliqueConfig, number uint64, hash common.Hash, signers []common.Address) *snapshot { |
||||
snap := &snapshot{ |
||||
config: config, |
||||
Number: number, |
||||
Hash: hash, |
||||
Signers: make(map[common.Address]struct{}), |
||||
Recents: make(map[uint64]common.Address), |
||||
Tally: make(map[common.Address]tally), |
||||
} |
||||
for _, signer := range signers { |
||||
snap.Signers[signer] = struct{}{} |
||||
} |
||||
return snap |
||||
} |
||||
|
||||
// loadSnapshot loads an existing snapshot from the database.
|
||||
func loadSnapshot(config *params.CliqueConfig, db ethdb.Database, hash common.Hash) (*snapshot, error) { |
||||
blob, err := db.Get(append([]byte("clique-"), hash[:]...)) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
snap := new(snapshot) |
||||
if err := json.Unmarshal(blob, snap); err != nil { |
||||
return nil, err |
||||
} |
||||
snap.config = config |
||||
|
||||
return snap, nil |
||||
} |
||||
|
||||
// store inserts the snapshot into the database.
|
||||
func (s *snapshot) store(db ethdb.Database) error { |
||||
blob, err := json.Marshal(s) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
return db.Put(append([]byte("clique-"), s.Hash[:]...), blob) |
||||
} |
||||
|
||||
// copy creates a deep copy of the snapshot, though not the individual votes.
|
||||
func (s *snapshot) copy() *snapshot { |
||||
cpy := &snapshot{ |
||||
config: s.config, |
||||
Number: s.Number, |
||||
Hash: s.Hash, |
||||
Signers: make(map[common.Address]struct{}), |
||||
Recents: make(map[uint64]common.Address), |
||||
Votes: make([]*vote, len(s.Votes)), |
||||
Tally: make(map[common.Address]tally), |
||||
} |
||||
for signer := range s.Signers { |
||||
cpy.Signers[signer] = struct{}{} |
||||
} |
||||
for block, signer := range s.Recents { |
||||
cpy.Recents[block] = signer |
||||
} |
||||
for address, tally := range s.Tally { |
||||
cpy.Tally[address] = tally |
||||
} |
||||
copy(cpy.Votes, s.Votes) |
||||
|
||||
return cpy |
||||
} |
||||
|
||||
// cast adds a new vote into the tally.
|
||||
func (s *snapshot) cast(address common.Address, authorize bool) bool { |
||||
// Ensure the vote is meaningful
|
||||
_, signer := s.Signers[address] |
||||
if (signer && authorize) || (!signer && !authorize) { |
||||
return false |
||||
} |
||||
// Cast the vote into an existing or new tally
|
||||
if old, ok := s.Tally[address]; ok { |
||||
old.Votes++ |
||||
s.Tally[address] = old |
||||
} else { |
||||
s.Tally[address] = tally{Authorize: authorize, Votes: 1} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// uncast removes a previously cast vote from the tally.
|
||||
func (s *snapshot) uncast(address common.Address, authorize bool) bool { |
||||
// If there's no tally, it's a dangling vote, just drop
|
||||
tally, ok := s.Tally[address] |
||||
if !ok { |
||||
return false |
||||
} |
||||
// Ensure we only revert counted votes
|
||||
if tally.Authorize != authorize { |
||||
return false |
||||
} |
||||
// Otherwise revert the vote
|
||||
if tally.Votes > 1 { |
||||
tally.Votes-- |
||||
s.Tally[address] = tally |
||||
} else { |
||||
delete(s.Tally, address) |
||||
} |
||||
return true |
||||
} |
||||
|
||||
// apply creates a new authorization snapshot by applying the given headers to
|
||||
// the original one.
|
||||
func (s *snapshot) apply(headers []*types.Header) (*snapshot, error) { |
||||
// Allow passing in no headers for cleaner code
|
||||
if len(headers) == 0 { |
||||
return s, nil |
||||
} |
||||
// Sanity check that the headers can be applied
|
||||
for i := 0; i < len(headers)-1; i++ { |
||||
if headers[i+1].Number.Uint64() != headers[i].Number.Uint64()+1 { |
||||
return nil, errInvalidVotingChain |
||||
} |
||||
} |
||||
if headers[0].Number.Uint64() != s.Number+1 { |
||||
return nil, errInvalidVotingChain |
||||
} |
||||
// Iterate through the headers and create a new snapshot
|
||||
snap := s.copy() |
||||
|
||||
for _, header := range headers { |
||||
// Remove any votes on checkpoint blocks
|
||||
number := header.Number.Uint64() |
||||
if number%s.config.Epoch == 0 { |
||||
snap.Votes = nil |
||||
snap.Tally = make(map[common.Address]tally) |
||||
} |
||||
// Delete the oldest signer from the recent list to allow it signing again
|
||||
if limit := uint64(len(snap.Signers)/2 + 1); number >= limit { |
||||
delete(snap.Recents, number-limit) |
||||
} |
||||
// Resolve the authorization key and check against signers
|
||||
signer, err := ecrecover(header) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
if _, ok := snap.Signers[signer]; !ok { |
||||
return nil, errUnauthorized |
||||
} |
||||
for _, recent := range snap.Recents { |
||||
if recent == signer { |
||||
return nil, errUnauthorized |
||||
} |
||||
} |
||||
snap.Recents[number] = signer |
||||
|
||||
// Header authorized, discard any previous votes from the signer
|
||||
for i, vote := range snap.Votes { |
||||
if vote.Signer == signer && vote.Address == header.Coinbase { |
||||
// Uncast the vote from the cached tally
|
||||
snap.uncast(vote.Address, vote.Authorize) |
||||
|
||||
// Uncast the vote from the chronological list
|
||||
snap.Votes = append(snap.Votes[:i], snap.Votes[i+1:]...) |
||||
break // only one vote allowed
|
||||
} |
||||
} |
||||
// Tally up the new vote from the signer
|
||||
var authorize bool |
||||
switch { |
||||
case bytes.Compare(header.Nonce[:], nonceAuthVote) == 0: |
||||
authorize = true |
||||
case bytes.Compare(header.Nonce[:], nonceDropVote) == 0: |
||||
authorize = false |
||||
default: |
||||
return nil, errInvalidVote |
||||
} |
||||
if snap.cast(header.Coinbase, authorize) { |
||||
snap.Votes = append(snap.Votes, &vote{ |
||||
Signer: signer, |
||||
Block: number, |
||||
Address: header.Coinbase, |
||||
Authorize: authorize, |
||||
}) |
||||
} |
||||
// If the vote passed, update the list of signers
|
||||
if tally := snap.Tally[header.Coinbase]; tally.Votes > len(snap.Signers)/2 { |
||||
if tally.Authorize { |
||||
snap.Signers[header.Coinbase] = struct{}{} |
||||
} else { |
||||
delete(snap.Signers, header.Coinbase) |
||||
|
||||
// Signer list shrunk, delete any leftover recent caches
|
||||
if limit := uint64(len(snap.Signers)/2 + 1); number >= limit { |
||||
delete(snap.Recents, number-limit) |
||||
} |
||||
// Discard any previous votes the deauthorized signer cast
|
||||
for i := 0; i < len(snap.Votes); i++ { |
||||
if snap.Votes[i].Signer == header.Coinbase { |
||||
// Uncast the vote from the cached tally
|
||||
snap.uncast(snap.Votes[i].Address, snap.Votes[i].Authorize) |
||||
|
||||
// Uncast the vote from the chronological list
|
||||
snap.Votes = append(snap.Votes[:i], snap.Votes[i+1:]...) |
||||
|
||||
i-- |
||||
} |
||||
} |
||||
} |
||||
// Discard any previous votes around the just changed account
|
||||
for i := 0; i < len(snap.Votes); i++ { |
||||
if snap.Votes[i].Address == header.Coinbase { |
||||
snap.Votes = append(snap.Votes[:i], snap.Votes[i+1:]...) |
||||
i-- |
||||
} |
||||
} |
||||
delete(snap.Tally, header.Coinbase) |
||||
} |
||||
} |
||||
snap.Number += uint64(len(headers)) |
||||
snap.Hash = headers[len(headers)-1].Hash() |
||||
|
||||
return snap, nil |
||||
} |
||||
|
||||
// signers retrieves the list of authorized signers in ascending order.
|
||||
func (s *snapshot) signers() []common.Address { |
||||
signers := make([]common.Address, 0, len(s.Signers)) |
||||
for signer := range s.Signers { |
||||
signers = append(signers, signer) |
||||
} |
||||
for i := 0; i < len(signers); i++ { |
||||
for j := i + 1; j < len(signers); j++ { |
||||
if bytes.Compare(signers[i][:], signers[j][:]) > 0 { |
||||
signers[i], signers[j] = signers[j], signers[i] |
||||
} |
||||
} |
||||
} |
||||
return signers |
||||
} |
||||
|
||||
// inturn returns if a signer at a given block height is in-turn or not.
|
||||
func (s *snapshot) inturn(number uint64, signer common.Address) bool { |
||||
signers, offset := s.signers(), 0 |
||||
for offset < len(signers) && signers[offset] != signer { |
||||
offset++ |
||||
} |
||||
return (number % uint64(len(signers))) == uint64(offset) |
||||
} |
||||
@ -0,0 +1,404 @@ |
||||
// Copyright 2017 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package clique |
||||
|
||||
import ( |
||||
"bytes" |
||||
"crypto/ecdsa" |
||||
"math/big" |
||||
"testing" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
"github.com/ethereum/go-ethereum/core" |
||||
"github.com/ethereum/go-ethereum/core/types" |
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
"github.com/ethereum/go-ethereum/ethdb" |
||||
"github.com/ethereum/go-ethereum/params" |
||||
) |
||||
|
||||
type testerVote struct { |
||||
signer string |
||||
voted string |
||||
auth bool |
||||
} |
||||
|
||||
// testerAccountPool is a pool to maintain currently active tester accounts,
|
||||
// mapped from textual names used in the tests below to actual Ethereum private
|
||||
// keys capable of signing transactions.
|
||||
type testerAccountPool struct { |
||||
accounts map[string]*ecdsa.PrivateKey |
||||
} |
||||
|
||||
func newTesterAccountPool() *testerAccountPool { |
||||
return &testerAccountPool{ |
||||
accounts: make(map[string]*ecdsa.PrivateKey), |
||||
} |
||||
} |
||||
|
||||
func (ap *testerAccountPool) sign(header *types.Header, signer string) { |
||||
// Ensure we have a persistent key for the signer
|
||||
if ap.accounts[signer] == nil { |
||||
ap.accounts[signer], _ = crypto.GenerateKey() |
||||
} |
||||
// Sign the header and embed the signature in extra data
|
||||
sig, _ := crypto.Sign(sigHash(header).Bytes(), ap.accounts[signer]) |
||||
copy(header.Extra[len(header.Extra)-65:], sig) |
||||
} |
||||
|
||||
func (ap *testerAccountPool) address(account string) common.Address { |
||||
// Ensure we have a persistent key for the account
|
||||
if ap.accounts[account] == nil { |
||||
ap.accounts[account], _ = crypto.GenerateKey() |
||||
} |
||||
// Resolve and return the Ethereum address
|
||||
return crypto.PubkeyToAddress(ap.accounts[account].PublicKey) |
||||
} |
||||
|
||||
// testerChainReader implements consensus.ChainReader to access the genesis
|
||||
// block. All other methods and requests will panic.
|
||||
type testerChainReader struct { |
||||
db ethdb.Database |
||||
} |
||||
|
||||
func (r *testerChainReader) Config() *params.ChainConfig { panic("not supported") } |
||||
func (r *testerChainReader) CurrentHeader() *types.Header { panic("not supported") } |
||||
func (r *testerChainReader) GetHeader(common.Hash, uint64) *types.Header { panic("not supported") } |
||||
func (r *testerChainReader) GetBlock(common.Hash, uint64) *types.Block { panic("not supported") } |
||||
func (r *testerChainReader) GetHeaderByNumber(number uint64) *types.Header { |
||||
if number == 0 { |
||||
return core.GetHeader(r.db, core.GetCanonicalHash(r.db, 0), 0) |
||||
} |
||||
panic("not supported") |
||||
} |
||||
|
||||
// Tests that voting is evaluated correctly for various simple and complex scenarios.
|
||||
func TestVoting(t *testing.T) { |
||||
// Define the various voting scenarios to test
|
||||
tests := []struct { |
||||
epoch uint64 |
||||
signers []string |
||||
votes []testerVote |
||||
results []string |
||||
}{ |
||||
{ |
||||
// Single signer, no votes cast
|
||||
signers: []string{"A"}, |
||||
votes: []testerVote{{signer: "A"}}, |
||||
results: []string{"A"}, |
||||
}, { |
||||
// Single signer, voting to add two others (only accept first, second needs 2 votes)
|
||||
signers: []string{"A"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "B", auth: true}, |
||||
{signer: "B"}, |
||||
{signer: "A", voted: "C", auth: true}, |
||||
}, |
||||
results: []string{"A", "B"}, |
||||
}, { |
||||
// Two signers, voting to add three others (only accept first two, third needs 3 votes already)
|
||||
signers: []string{"A", "B"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "C", auth: true}, |
||||
{signer: "B", voted: "C", auth: true}, |
||||
{signer: "A", voted: "D", auth: true}, |
||||
{signer: "B", voted: "D", auth: true}, |
||||
{signer: "C"}, |
||||
{signer: "A", voted: "E", auth: true}, |
||||
{signer: "B", voted: "E", auth: true}, |
||||
}, |
||||
results: []string{"A", "B", "C", "D"}, |
||||
}, { |
||||
// Single signer, dropping itself (weird, but one less cornercase by explicitly allowing this)
|
||||
signers: []string{"A"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "A", auth: false}, |
||||
}, |
||||
results: []string{}, |
||||
}, { |
||||
// Two signers, actually needing mutual consent to drop either of them (not fulfilled)
|
||||
signers: []string{"A", "B"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "B", auth: false}, |
||||
}, |
||||
results: []string{"A", "B"}, |
||||
}, { |
||||
// Two signers, actually needing mutual consent to drop either of them (fulfilled)
|
||||
signers: []string{"A", "B"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "B", auth: false}, |
||||
{signer: "B", voted: "B", auth: false}, |
||||
}, |
||||
results: []string{"A"}, |
||||
}, { |
||||
// Three signers, two of them deciding to drop the third
|
||||
signers: []string{"A", "B", "C"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "C", auth: false}, |
||||
{signer: "B", voted: "C", auth: false}, |
||||
}, |
||||
results: []string{"A", "B"}, |
||||
}, { |
||||
// Four signers, consensus of two not being enough to drop anyone
|
||||
signers: []string{"A", "B", "C", "D"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "C", auth: false}, |
||||
{signer: "B", voted: "C", auth: false}, |
||||
}, |
||||
results: []string{"A", "B", "C", "D"}, |
||||
}, { |
||||
// Four signers, consensus of three already being enough to drop someone
|
||||
signers: []string{"A", "B", "C", "D"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "D", auth: false}, |
||||
{signer: "B", voted: "D", auth: false}, |
||||
{signer: "C", voted: "D", auth: false}, |
||||
}, |
||||
results: []string{"A", "B", "C"}, |
||||
}, { |
||||
// Authorizations are counted once per signer per target
|
||||
signers: []string{"A", "B"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "C", auth: true}, |
||||
{signer: "B"}, |
||||
{signer: "A", voted: "C", auth: true}, |
||||
{signer: "B"}, |
||||
{signer: "A", voted: "C", auth: true}, |
||||
}, |
||||
results: []string{"A", "B"}, |
||||
}, { |
||||
// Authorizing multiple accounts concurrently is permitted
|
||||
signers: []string{"A", "B"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "C", auth: true}, |
||||
{signer: "B"}, |
||||
{signer: "A", voted: "D", auth: true}, |
||||
{signer: "B"}, |
||||
{signer: "A"}, |
||||
{signer: "B", voted: "D", auth: true}, |
||||
{signer: "A"}, |
||||
{signer: "B", voted: "C", auth: true}, |
||||
}, |
||||
results: []string{"A", "B", "C", "D"}, |
||||
}, { |
||||
// Deauthorizations are counted once per signer per target
|
||||
signers: []string{"A", "B"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "B", auth: false}, |
||||
{signer: "B"}, |
||||
{signer: "A", voted: "B", auth: false}, |
||||
{signer: "B"}, |
||||
{signer: "A", voted: "B", auth: false}, |
||||
}, |
||||
results: []string{"A", "B"}, |
||||
}, { |
||||
// Deauthorizing multiple accounts concurrently is permitted
|
||||
signers: []string{"A", "B", "C", "D"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "C", auth: false}, |
||||
{signer: "B"}, |
||||
{signer: "C"}, |
||||
{signer: "A", voted: "D", auth: false}, |
||||
{signer: "B"}, |
||||
{signer: "C"}, |
||||
{signer: "A"}, |
||||
{signer: "B", voted: "D", auth: false}, |
||||
{signer: "C", voted: "D", auth: false}, |
||||
{signer: "A"}, |
||||
{signer: "B", voted: "C", auth: false}, |
||||
}, |
||||
results: []string{"A", "B"}, |
||||
}, { |
||||
// Votes from deauthorized signers are discarded immediately (deauth votes)
|
||||
signers: []string{"A", "B", "C"}, |
||||
votes: []testerVote{ |
||||
{signer: "C", voted: "B", auth: false}, |
||||
{signer: "A", voted: "C", auth: false}, |
||||
{signer: "B", voted: "C", auth: false}, |
||||
{signer: "A", voted: "B", auth: false}, |
||||
}, |
||||
results: []string{"A", "B"}, |
||||
}, { |
||||
// Votes from deauthorized signers are discarded immediately (auth votes)
|
||||
signers: []string{"A", "B", "C"}, |
||||
votes: []testerVote{ |
||||
{signer: "C", voted: "B", auth: false}, |
||||
{signer: "A", voted: "C", auth: false}, |
||||
{signer: "B", voted: "C", auth: false}, |
||||
{signer: "A", voted: "B", auth: false}, |
||||
}, |
||||
results: []string{"A", "B"}, |
||||
}, { |
||||
// Cascading changes are not allowed, only the the account being voted on may change
|
||||
signers: []string{"A", "B", "C", "D"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "C", auth: false}, |
||||
{signer: "B"}, |
||||
{signer: "C"}, |
||||
{signer: "A", voted: "D", auth: false}, |
||||
{signer: "B", voted: "C", auth: false}, |
||||
{signer: "C"}, |
||||
{signer: "A"}, |
||||
{signer: "B", voted: "D", auth: false}, |
||||
{signer: "C", voted: "D", auth: false}, |
||||
}, |
||||
results: []string{"A", "B", "C"}, |
||||
}, { |
||||
// Changes reaching consensus out of bounds (via a deauth) execute on touch
|
||||
signers: []string{"A", "B", "C", "D"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "C", auth: false}, |
||||
{signer: "B"}, |
||||
{signer: "C"}, |
||||
{signer: "A", voted: "D", auth: false}, |
||||
{signer: "B", voted: "C", auth: false}, |
||||
{signer: "C"}, |
||||
{signer: "A"}, |
||||
{signer: "B", voted: "D", auth: false}, |
||||
{signer: "C", voted: "D", auth: false}, |
||||
{signer: "A"}, |
||||
{signer: "C", voted: "C", auth: true}, |
||||
}, |
||||
results: []string{"A", "B"}, |
||||
}, { |
||||
// Changes reaching consensus out of bounds (via a deauth) may go out of consensus on first touch
|
||||
signers: []string{"A", "B", "C", "D"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "C", auth: false}, |
||||
{signer: "B"}, |
||||
{signer: "C"}, |
||||
{signer: "A", voted: "D", auth: false}, |
||||
{signer: "B", voted: "C", auth: false}, |
||||
{signer: "C"}, |
||||
{signer: "A"}, |
||||
{signer: "B", voted: "D", auth: false}, |
||||
{signer: "C", voted: "D", auth: false}, |
||||
{signer: "A"}, |
||||
{signer: "B", voted: "C", auth: true}, |
||||
}, |
||||
results: []string{"A", "B", "C"}, |
||||
}, { |
||||
// Ensure that pending votes don't survive authorization status changes. This
|
||||
// corner case can only appear if a signer is quickly added, remove and then
|
||||
// readded (or the inverse), while one of the original voters dropped. If a
|
||||
// past vote is left cached in the system somewhere, this will interfere with
|
||||
// the final signer outcome.
|
||||
signers: []string{"A", "B", "C", "D", "E"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "F", auth: true}, // Authorize F, 3 votes needed
|
||||
{signer: "B", voted: "F", auth: true}, |
||||
{signer: "C", voted: "F", auth: true}, |
||||
{signer: "D", voted: "F", auth: false}, // Deauthorize F, 4 votes needed (leave A's previous vote "unchanged")
|
||||
{signer: "E", voted: "F", auth: false}, |
||||
{signer: "B", voted: "F", auth: false}, |
||||
{signer: "C", voted: "F", auth: false}, |
||||
{signer: "D", voted: "F", auth: true}, // Almost authorize F, 2/3 votes needed
|
||||
{signer: "E", voted: "F", auth: true}, |
||||
{signer: "B", voted: "A", auth: false}, // Deauthorize A, 3 votes needed
|
||||
{signer: "C", voted: "A", auth: false}, |
||||
{signer: "D", voted: "A", auth: false}, |
||||
{signer: "B", voted: "F", auth: true}, // Finish authorizing F, 3/3 votes needed
|
||||
}, |
||||
results: []string{"B", "C", "D", "E", "F"}, |
||||
}, { |
||||
// Epoch transitions reset all votes to allow chain checkpointing
|
||||
epoch: 3, |
||||
signers: []string{"A", "B"}, |
||||
votes: []testerVote{ |
||||
{signer: "A", voted: "C", auth: true}, |
||||
{signer: "B"}, |
||||
{signer: "A"}, // Checkpoint block, (don't vote here, it's validated outside of snapshots)
|
||||
{signer: "B", voted: "C", auth: true}, |
||||
}, |
||||
results: []string{"A", "B"}, |
||||
}, |
||||
} |
||||
// Run through the scenarios and test them
|
||||
for i, tt := range tests { |
||||
// Create the account pool and generate the initial set of signers
|
||||
accounts := newTesterAccountPool() |
||||
|
||||
signers := make([]common.Address, len(tt.signers)) |
||||
for j, signer := range tt.signers { |
||||
signers[j] = accounts.address(signer) |
||||
} |
||||
for j := 0; j < len(signers); j++ { |
||||
for k := j + 1; k < len(signers); k++ { |
||||
if bytes.Compare(signers[j][:], signers[k][:]) > 0 { |
||||
signers[j], signers[k] = signers[k], signers[j] |
||||
} |
||||
} |
||||
} |
||||
// Create the genesis block with the initial set of signers
|
||||
genesis := &core.Genesis{ |
||||
ExtraData: make([]byte, extraVanity+common.AddressLength*len(signers)+extraSeal), |
||||
} |
||||
for j, signer := range signers { |
||||
copy(genesis.ExtraData[extraVanity+j*common.AddressLength:], signer[:]) |
||||
} |
||||
// Create a pristine blockchain with the genesis injected
|
||||
db, _ := ethdb.NewMemDatabase() |
||||
genesis.Commit(db) |
||||
|
||||
// Assemble a chain of headers from the cast votes
|
||||
headers := make([]*types.Header, len(tt.votes)) |
||||
for j, vote := range tt.votes { |
||||
headers[j] = &types.Header{ |
||||
Number: big.NewInt(int64(j) + 1), |
||||
Time: big.NewInt(int64(j) * int64(blockPeriod)), |
||||
Coinbase: accounts.address(vote.voted), |
||||
Extra: make([]byte, extraVanity+extraSeal), |
||||
} |
||||
if j > 0 { |
||||
headers[j].ParentHash = headers[j-1].Hash() |
||||
} |
||||
if vote.auth { |
||||
copy(headers[j].Nonce[:], nonceAuthVote) |
||||
} |
||||
accounts.sign(headers[j], vote.signer) |
||||
} |
||||
// Pass all the headers through clique and ensure tallying succeeds
|
||||
head := headers[len(headers)-1] |
||||
|
||||
snap, err := New(¶ms.CliqueConfig{Epoch: tt.epoch}, db).snapshot(&testerChainReader{db: db}, head.Number.Uint64(), head.Hash(), headers) |
||||
if err != nil { |
||||
t.Errorf("test %d: failed to create voting snapshot: %v", i, err) |
||||
continue |
||||
} |
||||
// Verify the final list of signers against the expected ones
|
||||
signers = make([]common.Address, len(tt.results)) |
||||
for j, signer := range tt.results { |
||||
signers[j] = accounts.address(signer) |
||||
} |
||||
for j := 0; j < len(signers); j++ { |
||||
for k := j + 1; k < len(signers); k++ { |
||||
if bytes.Compare(signers[j][:], signers[k][:]) > 0 { |
||||
signers[j], signers[k] = signers[k], signers[j] |
||||
} |
||||
} |
||||
} |
||||
result := snap.signers() |
||||
if len(result) != len(signers) { |
||||
t.Errorf("test %d: signers mismatch: have %x, want %x", i, result, signers) |
||||
continue |
||||
} |
||||
for j := 0; j < len(result); j++ { |
||||
if !bytes.Equal(result[j][:], signers[j][:]) { |
||||
t.Errorf("test %d, signer %d: signer mismatch: have %x, want %x", i, j, result[j], signers[j]) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue