aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--cmd/geth/main.go20
-rw-r--r--cmd/utils/flags.go6
-rw-r--r--eth/api.go47
-rw-r--r--eth/backend.go76
-rw-r--r--eth/config.go1
-rw-r--r--eth/gen_config.go5
-rw-r--r--miner/stress_clique.go217
-rw-r--r--miner/stress_ethash.go197
8 files changed, 489 insertions, 80 deletions
diff --git a/cmd/geth/main.go b/cmd/geth/main.go
index 4b86382bd..7b8a8244e 100644
--- a/cmd/geth/main.go
+++ b/cmd/geth/main.go
@@ -336,26 +336,18 @@ func startNode(ctx *cli.Context, stack *node.Node) {
if err := stack.Service(&ethereum); err != nil {
utils.Fatalf("Ethereum service not running: %v", err)
}
- // Use a reduced number of threads if requested
- threads := ctx.GlobalInt(utils.MinerLegacyThreadsFlag.Name)
- if ctx.GlobalIsSet(utils.MinerThreadsFlag.Name) {
- threads = ctx.GlobalInt(utils.MinerThreadsFlag.Name)
- }
- if threads > 0 {
- type threaded interface {
- SetThreads(threads int)
- }
- if th, ok := ethereum.Engine().(threaded); ok {
- th.SetThreads(threads)
- }
- }
// Set the gas price to the limits from the CLI and start mining
gasprice := utils.GlobalBig(ctx, utils.MinerLegacyGasPriceFlag.Name)
if ctx.IsSet(utils.MinerGasPriceFlag.Name) {
gasprice = utils.GlobalBig(ctx, utils.MinerGasPriceFlag.Name)
}
ethereum.TxPool().SetGasPrice(gasprice)
- if err := ethereum.StartMining(true); err != nil {
+
+ threads := ctx.GlobalInt(utils.MinerLegacyThreadsFlag.Name)
+ if ctx.GlobalIsSet(utils.MinerThreadsFlag.Name) {
+ threads = ctx.GlobalInt(utils.MinerThreadsFlag.Name)
+ }
+ if err := ethereum.StartMining(threads); err != nil {
utils.Fatalf("Failed to start mining: %v", err)
}
}
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
index c9a936dd5..b9a33ffe7 100644
--- a/cmd/utils/flags.go
+++ b/cmd/utils/flags.go
@@ -1130,12 +1130,6 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) {
if ctx.GlobalIsSet(CacheFlag.Name) || ctx.GlobalIsSet(CacheGCFlag.Name) {
cfg.TrieCache = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheGCFlag.Name) / 100
}
- if ctx.GlobalIsSet(MinerLegacyThreadsFlag.Name) {
- cfg.MinerThreads = ctx.GlobalInt(MinerLegacyThreadsFlag.Name)
- }
- if ctx.GlobalIsSet(MinerThreadsFlag.Name) {
- cfg.MinerThreads = ctx.GlobalInt(MinerThreadsFlag.Name)
- }
if ctx.GlobalIsSet(MinerNotifyFlag.Name) {
cfg.MinerNotify = strings.Split(ctx.GlobalString(MinerNotifyFlag.Name), ",")
}
diff --git a/eth/api.go b/eth/api.go
index 4b0ba8edb..708f75a78 100644
--- a/eth/api.go
+++ b/eth/api.go
@@ -24,6 +24,7 @@ import (
"io"
"math/big"
"os"
+ "runtime"
"strings"
"time"
@@ -34,7 +35,6 @@ import (
"github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/internal/ethapi"
- "github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rlp"
"github.com/ethereum/go-ethereum/rpc"
@@ -94,47 +94,22 @@ func NewPrivateMinerAPI(e *Ethereum) *PrivateMinerAPI {
return &PrivateMinerAPI{e: e}
}
-// Start the miner with the given number of threads. If threads is nil the number
-// of workers started is equal to the number of logical CPUs that are usable by
-// this process. If mining is already running, this method adjust the number of
-// threads allowed to use and updates the minimum price required by the transaction
-// pool.
+// Start starts the miner with the given number of threads. If threads is nil,
+// the number of workers started is equal to the number of logical CPUs that are
+// usable by this process. If mining is already running, this method adjust the
+// number of threads allowed to use and updates the minimum price required by the
+// transaction pool.
func (api *PrivateMinerAPI) Start(threads *int) error {
- // Set the number of threads if the seal engine supports it
if threads == nil {
- threads = new(int)
- } else if *threads == 0 {
- *threads = -1 // Disable the miner from within
+ return api.e.StartMining(runtime.NumCPU())
}
- type threaded interface {
- SetThreads(threads int)
- }
- if th, ok := api.e.engine.(threaded); ok {
- log.Info("Updated mining threads", "threads", *threads)
- th.SetThreads(*threads)
- }
- // Start the miner and return
- if !api.e.IsMining() {
- // Propagate the initial price point to the transaction pool
- api.e.lock.RLock()
- price := api.e.gasPrice
- api.e.lock.RUnlock()
- api.e.txPool.SetGasPrice(price)
- return api.e.StartMining(true)
- }
- return nil
+ return api.e.StartMining(*threads)
}
-// Stop the miner
-func (api *PrivateMinerAPI) Stop() bool {
- type threaded interface {
- SetThreads(threads int)
- }
- if th, ok := api.e.engine.(threaded); ok {
- th.SetThreads(-1)
- }
+// Stop terminates the miner, both at the consensus engine level as well as at
+// the block creation level.
+func (api *PrivateMinerAPI) Stop() {
api.e.StopMining()
- return true
}
// SetExtra sets the extra data string that is included when this miner mines a block.
diff --git a/eth/backend.go b/eth/backend.go
index 648175acf..c530d3c7c 100644
--- a/eth/backend.go
+++ b/eth/backend.go
@@ -102,12 +102,18 @@ func (s *Ethereum) AddLesServer(ls LesServer) {
// New creates a new Ethereum object (including the
// initialisation of the common Ethereum object)
func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) {
+ // Ensure configuration values are compatible and sane
if config.SyncMode == downloader.LightSync {
return nil, errors.New("can't run eth.Ethereum in light sync mode, use les.LightEthereum")
}
if !config.SyncMode.IsValid() {
return nil, fmt.Errorf("invalid sync mode %d", config.SyncMode)
}
+ if config.MinerGasPrice == nil || config.MinerGasPrice.Cmp(common.Big0) <= 0 {
+ log.Warn("Sanitizing invalid miner gas price", "provided", config.MinerGasPrice, "updated", DefaultConfig.MinerGasPrice)
+ config.MinerGasPrice = new(big.Int).Set(DefaultConfig.MinerGasPrice)
+ }
+ // Assemble the Ethereum object
chainDb, err := CreateDB(ctx, config, "chaindata")
if err != nil {
return nil, err
@@ -333,32 +339,66 @@ func (s *Ethereum) SetEtherbase(etherbase common.Address) {
s.miner.SetEtherbase(etherbase)
}
-func (s *Ethereum) StartMining(local bool) error {
- eb, err := s.Etherbase()
- if err != nil {
- log.Error("Cannot start mining without etherbase", "err", err)
- return fmt.Errorf("etherbase missing: %v", err)
+// StartMining starts the miner with the given number of CPU threads. If mining
+// is already running, this method adjust the number of threads allowed to use
+// and updates the minimum price required by the transaction pool.
+func (s *Ethereum) StartMining(threads int) error {
+ // Update the thread count within the consensus engine
+ type threaded interface {
+ SetThreads(threads int)
}
- if clique, ok := s.engine.(*clique.Clique); ok {
- wallet, err := s.accountManager.Find(accounts.Account{Address: eb})
- if wallet == nil || err != nil {
- log.Error("Etherbase account unavailable locally", "err", err)
- return fmt.Errorf("signer missing: %v", err)
+ if th, ok := s.engine.(threaded); ok {
+ log.Info("Updated mining threads", "threads", threads)
+ if threads == 0 {
+ threads = -1 // Disable the miner from within
}
- clique.Authorize(eb, wallet.SignHash)
+ th.SetThreads(threads)
}
- if local {
- // If local (CPU) mining is started, we can disable the transaction rejection
- // mechanism introduced to speed sync times. CPU mining on mainnet is ludicrous
- // so none will ever hit this path, whereas marking sync done on CPU mining
- // will ensure that private networks work in single miner mode too.
+ // If the miner was not running, initialize it
+ if !s.IsMining() {
+ // Propagate the initial price point to the transaction pool
+ s.lock.RLock()
+ price := s.gasPrice
+ s.lock.RUnlock()
+ s.txPool.SetGasPrice(price)
+
+ // Configure the local mining addess
+ eb, err := s.Etherbase()
+ if err != nil {
+ log.Error("Cannot start mining without etherbase", "err", err)
+ return fmt.Errorf("etherbase missing: %v", err)
+ }
+ if clique, ok := s.engine.(*clique.Clique); ok {
+ wallet, err := s.accountManager.Find(accounts.Account{Address: eb})
+ if wallet == nil || err != nil {
+ log.Error("Etherbase account unavailable locally", "err", err)
+ return fmt.Errorf("signer missing: %v", err)
+ }
+ clique.Authorize(eb, wallet.SignHash)
+ }
+ // If mining is started, we can disable the transaction rejection mechanism
+ // introduced to speed sync times.
atomic.StoreUint32(&s.protocolManager.acceptTxs, 1)
+
+ go s.miner.Start(eb)
}
- go s.miner.Start(eb)
return nil
}
-func (s *Ethereum) StopMining() { s.miner.Stop() }
+// StopMining terminates the miner, both at the consensus engine level as well as
+// at the block creation level.
+func (s *Ethereum) StopMining() {
+ // Update the thread count within the consensus engine
+ type threaded interface {
+ SetThreads(threads int)
+ }
+ if th, ok := s.engine.(threaded); ok {
+ th.SetThreads(-1)
+ }
+ // Stop the block creating itself
+ s.miner.Stop()
+}
+
func (s *Ethereum) IsMining() bool { return s.miner.Mining() }
func (s *Ethereum) Miner() *miner.Miner { return s.miner }
diff --git a/eth/config.go b/eth/config.go
index 1398a5514..5b2eca585 100644
--- a/eth/config.go
+++ b/eth/config.go
@@ -97,7 +97,6 @@ type Config struct {
// Mining-related options
Etherbase common.Address `toml:",omitempty"`
- MinerThreads int `toml:",omitempty"`
MinerNotify []string `toml:",omitempty"`
MinerExtraData []byte `toml:",omitempty"`
MinerGasPrice *big.Int
diff --git a/eth/gen_config.go b/eth/gen_config.go
index 62556be7e..a72e35bcd 100644
--- a/eth/gen_config.go
+++ b/eth/gen_config.go
@@ -31,7 +31,6 @@ func (c Config) MarshalTOML() (interface{}, error) {
TrieCache int
TrieTimeout time.Duration
Etherbase common.Address `toml:",omitempty"`
- MinerThreads int `toml:",omitempty"`
MinerNotify []string `toml:",omitempty"`
MinerExtraData hexutil.Bytes `toml:",omitempty"`
MinerGasPrice *big.Int
@@ -55,7 +54,6 @@ func (c Config) MarshalTOML() (interface{}, error) {
enc.TrieCache = c.TrieCache
enc.TrieTimeout = c.TrieTimeout
enc.Etherbase = c.Etherbase
- enc.MinerThreads = c.MinerThreads
enc.MinerNotify = c.MinerNotify
enc.MinerExtraData = c.MinerExtraData
enc.MinerGasPrice = c.MinerGasPrice
@@ -134,9 +132,6 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
if dec.Etherbase != nil {
c.Etherbase = *dec.Etherbase
}
- if dec.MinerThreads != nil {
- c.MinerThreads = *dec.MinerThreads
- }
if dec.MinerNotify != nil {
c.MinerNotify = dec.MinerNotify
}
diff --git a/miner/stress_clique.go b/miner/stress_clique.go
new file mode 100644
index 000000000..8545b9413
--- /dev/null
+++ b/miner/stress_clique.go
@@ -0,0 +1,217 @@
+// Copyright 2018 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/>.
+
+// +build none
+
+// This file contains a miner stress test based on the Clique consensus engine.
+package main
+
+import (
+ "bytes"
+ "crypto/ecdsa"
+ "fmt"
+ "io/ioutil"
+ "math/big"
+ "math/rand"
+ "os"
+ "time"
+
+ "github.com/ethereum/go-ethereum/accounts/keystore"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/fdlimit"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/eth"
+ "github.com/ethereum/go-ethereum/eth/downloader"
+ "github.com/ethereum/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/node"
+ "github.com/ethereum/go-ethereum/p2p"
+ "github.com/ethereum/go-ethereum/p2p/discover"
+ "github.com/ethereum/go-ethereum/params"
+)
+
+func main() {
+ log.Root().SetHandler(log.LvlFilterHandler(log.LvlInfo, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
+ fdlimit.Raise(2048)
+
+ // Generate a batch of accounts to seal and fund with
+ faucets := make([]*ecdsa.PrivateKey, 128)
+ for i := 0; i < len(faucets); i++ {
+ faucets[i], _ = crypto.GenerateKey()
+ }
+ sealers := make([]*ecdsa.PrivateKey, 4)
+ for i := 0; i < len(sealers); i++ {
+ sealers[i], _ = crypto.GenerateKey()
+ }
+ // Create a Clique network based off of the Rinkeby config
+ genesis := makeGenesis(faucets, sealers)
+
+ var (
+ nodes []*node.Node
+ enodes []string
+ )
+ for _, sealer := range sealers {
+ // Start the node and wait until it's up
+ node, err := makeSealer(genesis, enodes)
+ if err != nil {
+ panic(err)
+ }
+ defer node.Stop()
+
+ for node.Server().NodeInfo().Ports.Listener == 0 {
+ time.Sleep(250 * time.Millisecond)
+ }
+ // Connect the node to al the previous ones
+ for _, enode := range enodes {
+ enode, err := discover.ParseNode(enode)
+ if err != nil {
+ panic(err)
+ }
+ node.Server().AddPeer(enode)
+ }
+ // Start tracking the node and it's enode url
+ nodes = append(nodes, node)
+
+ enode := fmt.Sprintf("enode://%s@127.0.0.1:%d", node.Server().NodeInfo().ID, node.Server().NodeInfo().Ports.Listener)
+ enodes = append(enodes, enode)
+
+ // Inject the signer key and start sealing with it
+ store := node.AccountManager().Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore)
+ signer, err := store.ImportECDSA(sealer, "")
+ if err != nil {
+ panic(err)
+ }
+ if err := store.Unlock(signer, ""); err != nil {
+ panic(err)
+ }
+ }
+ // Iterate over all the nodes and start signing with them
+ time.Sleep(3 * time.Second)
+
+ for _, node := range nodes {
+ var ethereum *eth.Ethereum
+ if err := node.Service(&ethereum); err != nil {
+ panic(err)
+ }
+ if err := ethereum.StartMining(1); err != nil {
+ panic(err)
+ }
+ }
+ time.Sleep(3 * time.Second)
+
+ // Start injecting transactions from the faucet like crazy
+ nonces := make([]uint64, len(faucets))
+ for {
+ index := rand.Intn(len(faucets))
+
+ // Fetch the accessor for the relevant signer
+ var ethereum *eth.Ethereum
+ if err := nodes[index%len(nodes)].Service(&ethereum); err != nil {
+ panic(err)
+ }
+ // Create a self transaction and inject into the pool
+ tx, err := types.SignTx(types.NewTransaction(nonces[index], crypto.PubkeyToAddress(faucets[index].PublicKey), new(big.Int), 21000, big.NewInt(100000000000), nil), types.HomesteadSigner{}, faucets[index])
+ if err != nil {
+ panic(err)
+ }
+ if err := ethereum.TxPool().AddLocal(tx); err != nil {
+ panic(err)
+ }
+ nonces[index]++
+
+ // Wait if we're too saturated
+ if pend, _ := ethereum.TxPool().Stats(); pend > 2048 {
+ time.Sleep(100 * time.Millisecond)
+ }
+ }
+}
+
+// makeGenesis creates a custom Clique genesis block based on some pre-defined
+// signer and faucet accounts.
+func makeGenesis(faucets []*ecdsa.PrivateKey, sealers []*ecdsa.PrivateKey) *core.Genesis {
+ // Create a Clique network based off of the Rinkeby config
+ genesis := core.DefaultRinkebyGenesisBlock()
+ genesis.GasLimit = 25000000
+
+ genesis.Config.ChainID = big.NewInt(18)
+ genesis.Config.Clique.Period = 1
+ genesis.Config.EIP150Hash = common.Hash{}
+
+ genesis.Alloc = core.GenesisAlloc{}
+ for _, faucet := range faucets {
+ genesis.Alloc[crypto.PubkeyToAddress(faucet.PublicKey)] = core.GenesisAccount{
+ Balance: new(big.Int).Exp(big.NewInt(2), big.NewInt(128), nil),
+ }
+ }
+ // Sort the signers and embed into the extra-data section
+ signers := make([]common.Address, len(sealers))
+ for i, sealer := range sealers {
+ signers[i] = crypto.PubkeyToAddress(sealer.PublicKey)
+ }
+ 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]
+ }
+ }
+ }
+ genesis.ExtraData = make([]byte, 32+len(signers)*common.AddressLength+65)
+ for i, signer := range signers {
+ copy(genesis.ExtraData[32+i*common.AddressLength:], signer[:])
+ }
+ // Return the genesis block for initialization
+ return genesis
+}
+
+func makeSealer(genesis *core.Genesis, nodes []string) (*node.Node, error) {
+ // Define the basic configurations for the Ethereum node
+ datadir, _ := ioutil.TempDir("", "")
+
+ config := &node.Config{
+ Name: "geth",
+ Version: params.Version,
+ DataDir: datadir,
+ P2P: p2p.Config{
+ ListenAddr: "0.0.0.0:0",
+ NoDiscovery: true,
+ MaxPeers: 25,
+ },
+ NoUSB: true,
+ }
+ // Start the node and configure a full Ethereum node on it
+ stack, err := node.New(config)
+ if err != nil {
+ return nil, err
+ }
+ if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
+ return eth.New(ctx, &eth.Config{
+ Genesis: genesis,
+ NetworkId: genesis.Config.ChainID.Uint64(),
+ SyncMode: downloader.FullSync,
+ DatabaseCache: 256,
+ DatabaseHandles: 256,
+ TxPool: core.DefaultTxPoolConfig,
+ GPO: eth.DefaultConfig.GPO,
+ MinerGasPrice: big.NewInt(1),
+ MinerRecommit: time.Second,
+ })
+ }); err != nil {
+ return nil, err
+ }
+ // Start the node and return if successful
+ return stack, stack.Start()
+}
diff --git a/miner/stress_ethash.go b/miner/stress_ethash.go
new file mode 100644
index 000000000..4ed8aeee4
--- /dev/null
+++ b/miner/stress_ethash.go
@@ -0,0 +1,197 @@
+// Copyright 2018 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/>.
+
+// +build none
+
+// This file contains a miner stress test based on the Ethash consensus engine.
+package main
+
+import (
+ "crypto/ecdsa"
+ "fmt"
+ "io/ioutil"
+ "math/big"
+ "math/rand"
+ "os"
+ "path/filepath"
+ "time"
+
+ "github.com/ethereum/go-ethereum/accounts/keystore"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/fdlimit"
+ "github.com/ethereum/go-ethereum/consensus/ethash"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/eth"
+ "github.com/ethereum/go-ethereum/eth/downloader"
+ "github.com/ethereum/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/node"
+ "github.com/ethereum/go-ethereum/p2p"
+ "github.com/ethereum/go-ethereum/p2p/discover"
+ "github.com/ethereum/go-ethereum/params"
+)
+
+func main() {
+ log.Root().SetHandler(log.LvlFilterHandler(log.LvlInfo, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
+ fdlimit.Raise(2048)
+
+ // Generate a batch of accounts to seal and fund with
+ faucets := make([]*ecdsa.PrivateKey, 128)
+ for i := 0; i < len(faucets); i++ {
+ faucets[i], _ = crypto.GenerateKey()
+ }
+ // Pre-generate the ethash mining DAG so we don't race
+ ethash.MakeDataset(1, filepath.Join(os.Getenv("HOME"), ".ethash"))
+
+ // Create an Ethash network based off of the Ropsten config
+ genesis := makeGenesis(faucets)
+
+ var (
+ nodes []*node.Node
+ enodes []string
+ )
+ for i := 0; i < 4; i++ {
+ // Start the node and wait until it's up
+ node, err := makeMiner(genesis, enodes)
+ if err != nil {
+ panic(err)
+ }
+ defer node.Stop()
+
+ for node.Server().NodeInfo().Ports.Listener == 0 {
+ time.Sleep(250 * time.Millisecond)
+ }
+ // Connect the node to al the previous ones
+ for _, enode := range enodes {
+ enode, err := discover.ParseNode(enode)
+ if err != nil {
+ panic(err)
+ }
+ node.Server().AddPeer(enode)
+ }
+ // Start tracking the node and it's enode url
+ nodes = append(nodes, node)
+
+ enode := fmt.Sprintf("enode://%s@127.0.0.1:%d", node.Server().NodeInfo().ID, node.Server().NodeInfo().Ports.Listener)
+ enodes = append(enodes, enode)
+
+ // Inject the signer key and start sealing with it
+ store := node.AccountManager().Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore)
+ if _, err := store.NewAccount(""); err != nil {
+ panic(err)
+ }
+ }
+ // Iterate over all the nodes and start signing with them
+ time.Sleep(3 * time.Second)
+
+ for _, node := range nodes {
+ var ethereum *eth.Ethereum
+ if err := node.Service(&ethereum); err != nil {
+ panic(err)
+ }
+ if err := ethereum.StartMining(1); err != nil {
+ panic(err)
+ }
+ }
+ time.Sleep(3 * time.Second)
+
+ // Start injecting transactions from the faucets like crazy
+ nonces := make([]uint64, len(faucets))
+ for {
+ index := rand.Intn(len(faucets))
+
+ // Fetch the accessor for the relevant signer
+ var ethereum *eth.Ethereum
+ if err := nodes[index%len(nodes)].Service(&ethereum); err != nil {
+ panic(err)
+ }
+ // Create a self transaction and inject into the pool
+ tx, err := types.SignTx(types.NewTransaction(nonces[index], crypto.PubkeyToAddress(faucets[index].PublicKey), new(big.Int), 21000, big.NewInt(100000000000+rand.Int63n(65536)), nil), types.HomesteadSigner{}, faucets[index])
+ if err != nil {
+ panic(err)
+ }
+ if err := ethereum.TxPool().AddLocal(tx); err != nil {
+ panic(err)
+ }
+ nonces[index]++
+
+ // Wait if we're too saturated
+ if pend, _ := ethereum.TxPool().Stats(); pend > 2048 {
+ time.Sleep(100 * time.Millisecond)
+ }
+ }
+}
+
+// makeGenesis creates a custom Ethash genesis block based on some pre-defined
+// faucet accounts.
+func makeGenesis(faucets []*ecdsa.PrivateKey) *core.Genesis {
+ genesis := core.DefaultTestnetGenesisBlock()
+ genesis.Difficulty = params.MinimumDifficulty
+ genesis.GasLimit = 25000000
+
+ genesis.Config.ChainID = big.NewInt(18)
+ genesis.Config.EIP150Hash = common.Hash{}
+
+ genesis.Alloc = core.GenesisAlloc{}
+ for _, faucet := range faucets {
+ genesis.Alloc[crypto.PubkeyToAddress(faucet.PublicKey)] = core.GenesisAccount{
+ Balance: new(big.Int).Exp(big.NewInt(2), big.NewInt(128), nil),
+ }
+ }
+ return genesis
+}
+
+func makeMiner(genesis *core.Genesis, nodes []string) (*node.Node, error) {
+ // Define the basic configurations for the Ethereum node
+ datadir, _ := ioutil.TempDir("", "")
+
+ config := &node.Config{
+ Name: "geth",
+ Version: params.Version,
+ DataDir: datadir,
+ P2P: p2p.Config{
+ ListenAddr: "0.0.0.0:0",
+ NoDiscovery: true,
+ MaxPeers: 25,
+ },
+ NoUSB: true,
+ UseLightweightKDF: true,
+ }
+ // Start the node and configure a full Ethereum node on it
+ stack, err := node.New(config)
+ if err != nil {
+ return nil, err
+ }
+ if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
+ return eth.New(ctx, &eth.Config{
+ Genesis: genesis,
+ NetworkId: genesis.Config.ChainID.Uint64(),
+ SyncMode: downloader.FullSync,
+ DatabaseCache: 256,
+ DatabaseHandles: 256,
+ TxPool: core.DefaultTxPoolConfig,
+ GPO: eth.DefaultConfig.GPO,
+ Ethash: eth.DefaultConfig.Ethash,
+ MinerGasPrice: big.NewInt(1),
+ MinerRecommit: time.Second,
+ })
+ }); err != nil {
+ return nil, err
+ }
+ // Start the node and return if successful
+ return stack, stack.Start()
+}
generated by cgit (git 2.34.1) at 2024-11-14 06:33:48 +0800