mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-07-23 05:06:43 +00:00
Merge remote-tracking branch 'upstream/develop' into bzz
This commit is contained in:
zelig
commit
0501ff41d0
20 changed files with 644 additions and 1890 deletions
|
|
@ -12,7 +12,7 @@ import (
|
|||
"github.com/ethereum/go-ethereum/tests"
|
||||
)
|
||||
|
||||
var blocktestCmd = cli.Command{
|
||||
var blocktestCommand = cli.Command{
|
||||
Action: runBlockTest,
|
||||
Name: "blocktest",
|
||||
Usage: `loads a block test file`,
|
||||
159
cmd/geth/chaincmd.go
Normal file
159
cmd/geth/chaincmd.go
Normal file
|
|
@ -0,0 +1,159 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"github.com/codegangsta/cli"
|
||||
"github.com/ethereum/go-ethereum/cmd/utils"
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/ethereum/go-ethereum/core"
|
||||
"github.com/ethereum/go-ethereum/core/state"
|
||||
"github.com/ethereum/go-ethereum/core/types"
|
||||
"github.com/ethereum/go-ethereum/logger/glog"
|
||||
)
|
||||
|
||||
var (
|
||||
importCommand = cli.Command{
|
||||
Action: importChain,
|
||||
Name: "import",
|
||||
Usage: `import a blockchain file`,
|
||||
}
|
||||
exportCommand = cli.Command{
|
||||
Action: exportChain,
|
||||
Name: "export",
|
||||
Usage: `export blockchain into file`,
|
||||
}
|
||||
upgradedbCommand = cli.Command{
|
||||
Action: upgradeDB,
|
||||
Name: "upgradedb",
|
||||
Usage: "upgrade chainblock database",
|
||||
}
|
||||
removedbCommand = cli.Command{
|
||||
Action: removeDB,
|
||||
Name: "removedb",
|
||||
Usage: "Remove blockchain and state databases",
|
||||
}
|
||||
dumpCommand = cli.Command{
|
||||
Action: dump,
|
||||
Name: "dump",
|
||||
Usage: `dump a specific block from storage`,
|
||||
Description: `
|
||||
The arguments are interpreted as block numbers or hashes.
|
||||
Use "ethereum dump 0" to dump the genesis block.
|
||||
`,
|
||||
}
|
||||
)
|
||||
|
||||
func importChain(ctx *cli.Context) {
|
||||
if len(ctx.Args()) != 1 {
|
||||
utils.Fatalf("This command requires an argument.")
|
||||
}
|
||||
chain, blockDB, stateDB, extraDB := utils.MakeChain(ctx)
|
||||
start := time.Now()
|
||||
err := utils.ImportChain(chain, ctx.Args().First())
|
||||
closeAll(blockDB, stateDB, extraDB)
|
||||
if err != nil {
|
||||
utils.Fatalf("Import error: %v", err)
|
||||
}
|
||||
fmt.Printf("Import done in %v", time.Since(start))
|
||||
}
|
||||
|
||||
func exportChain(ctx *cli.Context) {
|
||||
if len(ctx.Args()) != 1 {
|
||||
utils.Fatalf("This command requires an argument.")
|
||||
}
|
||||
chain, _, _, _ := utils.MakeChain(ctx)
|
||||
start := time.Now()
|
||||
if err := utils.ExportChain(chain, ctx.Args().First()); err != nil {
|
||||
utils.Fatalf("Export error: %v\n", err)
|
||||
}
|
||||
fmt.Printf("Export done in %v", time.Since(start))
|
||||
}
|
||||
|
||||
func removeDB(ctx *cli.Context) {
|
||||
confirm, err := utils.PromptConfirm("Remove local databases?")
|
||||
if err != nil {
|
||||
utils.Fatalf("%v", err)
|
||||
}
|
||||
|
||||
if confirm {
|
||||
fmt.Println("Removing chain and state databases...")
|
||||
start := time.Now()
|
||||
|
||||
os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "blockchain"))
|
||||
os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "state"))
|
||||
|
||||
fmt.Printf("Removed in %v\n", time.Since(start))
|
||||
} else {
|
||||
fmt.Println("Operation aborted")
|
||||
}
|
||||
}
|
||||
|
||||
func upgradeDB(ctx *cli.Context) {
|
||||
glog.Infoln("Upgrading blockchain database")
|
||||
|
||||
chain, blockDB, stateDB, extraDB := utils.MakeChain(ctx)
|
||||
v, _ := blockDB.Get([]byte("BlockchainVersion"))
|
||||
bcVersion := int(common.NewValue(v).Uint())
|
||||
if bcVersion == 0 {
|
||||
bcVersion = core.BlockChainVersion
|
||||
}
|
||||
|
||||
// Export the current chain.
|
||||
filename := fmt.Sprintf("blockchain_%d_%s.chain", bcVersion, time.Now().Format("20060102_150405"))
|
||||
exportFile := filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), filename)
|
||||
if err := utils.ExportChain(chain, exportFile); err != nil {
|
||||
utils.Fatalf("Unable to export chain for reimport %s", err)
|
||||
}
|
||||
closeAll(blockDB, stateDB, extraDB)
|
||||
os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "blockchain"))
|
||||
os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "state"))
|
||||
|
||||
// Import the chain file.
|
||||
chain, blockDB, stateDB, extraDB = utils.MakeChain(ctx)
|
||||
blockDB.Put([]byte("BlockchainVersion"), common.NewValue(core.BlockChainVersion).Bytes())
|
||||
err := utils.ImportChain(chain, exportFile)
|
||||
closeAll(blockDB, stateDB, extraDB)
|
||||
if err != nil {
|
||||
utils.Fatalf("Import error %v (a backup is made in %s, use the import command to import it)", err, exportFile)
|
||||
} else {
|
||||
os.Remove(exportFile)
|
||||
glog.Infoln("Import finished")
|
||||
}
|
||||
}
|
||||
|
||||
func dump(ctx *cli.Context) {
|
||||
chain, _, stateDB, _ := utils.MakeChain(ctx)
|
||||
for _, arg := range ctx.Args() {
|
||||
var block *types.Block
|
||||
if hashish(arg) {
|
||||
block = chain.GetBlock(common.HexToHash(arg))
|
||||
} else {
|
||||
num, _ := strconv.Atoi(arg)
|
||||
block = chain.GetBlockByNumber(uint64(num))
|
||||
}
|
||||
if block == nil {
|
||||
fmt.Println("{}")
|
||||
utils.Fatalf("block not found")
|
||||
} else {
|
||||
state := state.New(block.Root(), stateDB)
|
||||
fmt.Printf("%s\n", state.Dump())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// hashish returns true for strings that look like hashes.
|
||||
func hashish(x string) bool {
|
||||
_, err := strconv.Atoi(x)
|
||||
return err != nil
|
||||
}
|
||||
|
||||
func closeAll(dbs ...common.Database) {
|
||||
for _, db := range dbs {
|
||||
db.Close()
|
||||
}
|
||||
}
|
||||
216
cmd/geth/main.go
216
cmd/geth/main.go
|
|
@ -24,31 +24,27 @@ import (
|
|||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
_ "net/http/pprof"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/codegangsta/cli"
|
||||
"github.com/ethereum/ethash"
|
||||
"github.com/ethereum/go-ethereum/accounts"
|
||||
"github.com/ethereum/go-ethereum/cmd/utils"
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/ethereum/go-ethereum/core"
|
||||
"github.com/ethereum/go-ethereum/core/state"
|
||||
"github.com/ethereum/go-ethereum/core/types"
|
||||
"github.com/ethereum/go-ethereum/eth"
|
||||
"github.com/ethereum/go-ethereum/logger"
|
||||
"github.com/mattn/go-colorable"
|
||||
"github.com/mattn/go-isatty"
|
||||
)
|
||||
import _ "net/http/pprof"
|
||||
|
||||
const (
|
||||
ClientIdentifier = "Geth"
|
||||
Version = "0.9.25"
|
||||
Version = "0.9.26"
|
||||
)
|
||||
|
||||
var (
|
||||
|
|
@ -68,7 +64,12 @@ func init() {
|
|||
app.Action = run
|
||||
app.HideVersion = true // we have a command to print the version
|
||||
app.Commands = []cli.Command{
|
||||
blocktestCmd,
|
||||
blocktestCommand,
|
||||
importCommand,
|
||||
exportCommand,
|
||||
upgradedbCommand,
|
||||
removedbCommand,
|
||||
dumpCommand,
|
||||
{
|
||||
Action: makedag,
|
||||
Name: "makedag",
|
||||
|
|
@ -193,15 +194,6 @@ nodes.
|
|||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Action: dump,
|
||||
Name: "dump",
|
||||
Usage: `dump a specific block from storage`,
|
||||
Description: `
|
||||
The arguments are interpreted as block numbers or hashes.
|
||||
Use "ethereum dump 0" to dump the genesis block.
|
||||
`,
|
||||
},
|
||||
{
|
||||
Action: console,
|
||||
Name: "console",
|
||||
|
|
@ -221,26 +213,6 @@ The JavaScript VM exposes a node admin interface as well as the Ðapp
|
|||
JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console
|
||||
`,
|
||||
},
|
||||
{
|
||||
Action: importchain,
|
||||
Name: "import",
|
||||
Usage: `import a blockchain file`,
|
||||
},
|
||||
{
|
||||
Action: exportchain,
|
||||
Name: "export",
|
||||
Usage: `export blockchain into file`,
|
||||
},
|
||||
{
|
||||
Action: upgradeDb,
|
||||
Name: "upgradedb",
|
||||
Usage: "upgrade chainblock database",
|
||||
},
|
||||
{
|
||||
Action: removeDb,
|
||||
Name: "removedb",
|
||||
Usage: "Remove blockchain and state databases",
|
||||
},
|
||||
}
|
||||
app.Flags = []cli.Flag{
|
||||
utils.IdentityFlag,
|
||||
|
|
@ -284,17 +256,12 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso
|
|||
utils.SolcPathFlag,
|
||||
}
|
||||
app.Before = func(ctx *cli.Context) error {
|
||||
utils.SetupLogger(ctx)
|
||||
if ctx.GlobalBool(utils.PProfEanbledFlag.Name) {
|
||||
utils.StartPProf(ctx)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// missing:
|
||||
// flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file")
|
||||
// flag.BoolVar(&DiffTool, "difftool", false, "creates output for diff'ing. Sets LogLevel=0")
|
||||
// flag.StringVar(&DiffType, "diff", "all", "sets the level of diff output [vm, all]. Has no effect if difftool=false")
|
||||
|
||||
}
|
||||
|
||||
func main() {
|
||||
|
|
@ -379,13 +346,13 @@ func unlockAccount(ctx *cli.Context, am *accounts.Manager, account string) (pass
|
|||
var err error
|
||||
// Load startup keys. XXX we are going to need a different format
|
||||
|
||||
if len(account) == 0 {
|
||||
if !((len(account) == 40) || (len(account) == 42)) { // with or without 0x
|
||||
utils.Fatalf("Invalid account address '%s'", account)
|
||||
}
|
||||
// Attempt to unlock the account 3 times
|
||||
attempts := 3
|
||||
for tries := 0; tries < attempts; tries++ {
|
||||
msg := fmt.Sprintf("Unlocking account %s...%s | Attempt %d/%d", account[:8], account[len(account)-6:], tries+1, attempts)
|
||||
msg := fmt.Sprintf("Unlocking account %s | Attempt %d/%d", account, tries+1, attempts)
|
||||
passphrase = getPassPhrase(ctx, msg, false)
|
||||
err = am.Unlock(common.HexToAddress(account), passphrase)
|
||||
if err == nil {
|
||||
|
|
@ -433,7 +400,7 @@ func startEth(ctx *cli.Context, eth *eth.Ethereum) {
|
|||
}
|
||||
|
||||
func accountList(ctx *cli.Context) {
|
||||
am := utils.GetAccountManager(ctx)
|
||||
am := utils.MakeAccountManager(ctx)
|
||||
accts, err := am.Accounts()
|
||||
if err != nil {
|
||||
utils.Fatalf("Could not list accounts: %v", err)
|
||||
|
|
@ -475,7 +442,7 @@ func getPassPhrase(ctx *cli.Context, desc string, confirmation bool) (passphrase
|
|||
}
|
||||
|
||||
func accountCreate(ctx *cli.Context) {
|
||||
am := utils.GetAccountManager(ctx)
|
||||
am := utils.MakeAccountManager(ctx)
|
||||
passphrase := getPassPhrase(ctx, "Your new account is locked with a password. Please give a password. Do not forget this password.", true)
|
||||
acct, err := am.NewAccount(passphrase)
|
||||
if err != nil {
|
||||
|
|
@ -494,7 +461,7 @@ func importWallet(ctx *cli.Context) {
|
|||
utils.Fatalf("Could not read wallet file: %v", err)
|
||||
}
|
||||
|
||||
am := utils.GetAccountManager(ctx)
|
||||
am := utils.MakeAccountManager(ctx)
|
||||
passphrase := getPassPhrase(ctx, "", false)
|
||||
|
||||
acct, err := am.ImportPreSaleKey(keyJson, passphrase)
|
||||
|
|
@ -509,7 +476,7 @@ func accountImport(ctx *cli.Context) {
|
|||
if len(keyfile) == 0 {
|
||||
utils.Fatalf("keyfile must be given as argument")
|
||||
}
|
||||
am := utils.GetAccountManager(ctx)
|
||||
am := utils.MakeAccountManager(ctx)
|
||||
passphrase := getPassPhrase(ctx, "Your new account is locked with a password. Please give a password. Do not forget this password.", true)
|
||||
acct, err := am.Import(keyfile, passphrase)
|
||||
if err != nil {
|
||||
|
|
@ -518,153 +485,6 @@ func accountImport(ctx *cli.Context) {
|
|||
fmt.Printf("Address: %x\n", acct)
|
||||
}
|
||||
|
||||
func importchain(ctx *cli.Context) {
|
||||
if len(ctx.Args()) != 1 {
|
||||
utils.Fatalf("This command requires an argument.")
|
||||
}
|
||||
|
||||
cfg := utils.MakeEthConfig(ClientIdentifier, Version, ctx)
|
||||
cfg.SkipBcVersionCheck = true
|
||||
|
||||
ethereum, err := eth.New(cfg)
|
||||
if err != nil {
|
||||
utils.Fatalf("%v\n", err)
|
||||
}
|
||||
|
||||
chainmgr := ethereum.ChainManager()
|
||||
start := time.Now()
|
||||
err = utils.ImportChain(chainmgr, ctx.Args().First())
|
||||
if err != nil {
|
||||
utils.Fatalf("Import error: %v\n", err)
|
||||
}
|
||||
|
||||
// force database flush
|
||||
ethereum.BlockDb().Flush()
|
||||
ethereum.StateDb().Flush()
|
||||
ethereum.ExtraDb().Flush()
|
||||
|
||||
fmt.Printf("Import done in %v", time.Since(start))
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func exportchain(ctx *cli.Context) {
|
||||
if len(ctx.Args()) != 1 {
|
||||
utils.Fatalf("This command requires an argument.")
|
||||
}
|
||||
|
||||
cfg := utils.MakeEthConfig(ClientIdentifier, nodeNameVersion, ctx)
|
||||
cfg.SkipBcVersionCheck = true
|
||||
|
||||
ethereum, err := eth.New(cfg)
|
||||
if err != nil {
|
||||
utils.Fatalf("%v\n", err)
|
||||
}
|
||||
|
||||
chainmgr := ethereum.ChainManager()
|
||||
start := time.Now()
|
||||
err = utils.ExportChain(chainmgr, ctx.Args().First())
|
||||
if err != nil {
|
||||
utils.Fatalf("Export error: %v\n", err)
|
||||
}
|
||||
fmt.Printf("Export done in %v", time.Since(start))
|
||||
return
|
||||
}
|
||||
|
||||
func removeDb(ctx *cli.Context) {
|
||||
confirm, err := utils.PromptConfirm("Remove local databases?")
|
||||
if err != nil {
|
||||
utils.Fatalf("%v", err)
|
||||
}
|
||||
|
||||
if confirm {
|
||||
fmt.Println("Removing chain and state databases...")
|
||||
start := time.Now()
|
||||
|
||||
os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "blockchain"))
|
||||
os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "state"))
|
||||
|
||||
fmt.Printf("Removed in %v\n", time.Since(start))
|
||||
} else {
|
||||
fmt.Println("Operation aborted")
|
||||
}
|
||||
}
|
||||
|
||||
func upgradeDb(ctx *cli.Context) {
|
||||
fmt.Println("Upgrade blockchain DB")
|
||||
|
||||
cfg := utils.MakeEthConfig(ClientIdentifier, Version, ctx)
|
||||
cfg.SkipBcVersionCheck = true
|
||||
|
||||
ethereum, err := eth.New(cfg)
|
||||
if err != nil {
|
||||
utils.Fatalf("%v\n", err)
|
||||
}
|
||||
|
||||
v, _ := ethereum.BlockDb().Get([]byte("BlockchainVersion"))
|
||||
bcVersion := int(common.NewValue(v).Uint())
|
||||
|
||||
if bcVersion == 0 {
|
||||
bcVersion = core.BlockChainVersion
|
||||
}
|
||||
|
||||
filename := fmt.Sprintf("blockchain_%d_%s.chain", bcVersion, time.Now().Format("20060102_150405"))
|
||||
exportFile := filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), filename)
|
||||
|
||||
err = utils.ExportChain(ethereum.ChainManager(), exportFile)
|
||||
if err != nil {
|
||||
utils.Fatalf("Unable to export chain for reimport %s\n", err)
|
||||
}
|
||||
|
||||
ethereum.BlockDb().Close()
|
||||
ethereum.StateDb().Close()
|
||||
ethereum.ExtraDb().Close()
|
||||
|
||||
os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "blockchain"))
|
||||
os.RemoveAll(filepath.Join(ctx.GlobalString(utils.DataDirFlag.Name), "state"))
|
||||
|
||||
ethereum, err = eth.New(cfg)
|
||||
if err != nil {
|
||||
utils.Fatalf("%v\n", err)
|
||||
}
|
||||
|
||||
ethereum.BlockDb().Put([]byte("BlockchainVersion"), common.NewValue(core.BlockChainVersion).Bytes())
|
||||
|
||||
err = utils.ImportChain(ethereum.ChainManager(), exportFile)
|
||||
if err != nil {
|
||||
utils.Fatalf("Import error %v (a backup is made in %s, use the import command to import it)\n", err, exportFile)
|
||||
}
|
||||
|
||||
// force database flush
|
||||
ethereum.BlockDb().Flush()
|
||||
ethereum.StateDb().Flush()
|
||||
ethereum.ExtraDb().Flush()
|
||||
|
||||
os.Remove(exportFile)
|
||||
|
||||
fmt.Println("Import finished")
|
||||
}
|
||||
|
||||
func dump(ctx *cli.Context) {
|
||||
chainmgr, _, stateDb := utils.GetChain(ctx)
|
||||
for _, arg := range ctx.Args() {
|
||||
var block *types.Block
|
||||
if hashish(arg) {
|
||||
block = chainmgr.GetBlock(common.HexToHash(arg))
|
||||
} else {
|
||||
num, _ := strconv.Atoi(arg)
|
||||
block = chainmgr.GetBlockByNumber(uint64(num))
|
||||
}
|
||||
if block == nil {
|
||||
fmt.Println("{}")
|
||||
utils.Fatalf("block not found")
|
||||
} else {
|
||||
statedb := state.New(block.Root(), stateDb)
|
||||
fmt.Printf("%s\n", statedb.Dump())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func makedag(ctx *cli.Context) {
|
||||
args := ctx.Args()
|
||||
wrongArgs := func() {
|
||||
|
|
@ -707,9 +527,3 @@ func version(c *cli.Context) {
|
|||
fmt.Printf("GOPATH=%s\n", os.Getenv("GOPATH"))
|
||||
fmt.Printf("GOROOT=%s\n", runtime.GOROOT())
|
||||
}
|
||||
|
||||
// hashish returns true for strings that look like hashes.
|
||||
func hashish(x string) bool {
|
||||
_, err := strconv.Atoi(x)
|
||||
return err != nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ window.filter = filter;
|
|||
var amount = parseInt( value.value );
|
||||
console.log("transact: ", to.value, " => ", amount)
|
||||
|
||||
contract.sendTransaction({from: eth.accounts[0]}).send( to.value, amount );
|
||||
contract.send.sendTransaction(to.value, amount ,{from: eth.accounts[0]});
|
||||
|
||||
to.value = "";
|
||||
value.value = "";
|
||||
|
|
|
|||
|
|
@ -86,6 +86,10 @@ func init() {
|
|||
utils.BlockchainVersionFlag,
|
||||
utils.NetworkIdFlag,
|
||||
}
|
||||
app.Before = func(ctx *cli.Context) error {
|
||||
utils.SetupLogger(ctx)
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
func main() {
|
||||
|
|
|
|||
108
cmd/utils/cmd.go
108
cmd/utils/cmd.go
|
|
@ -40,6 +40,10 @@ import (
|
|||
"github.com/peterh/liner"
|
||||
)
|
||||
|
||||
const (
|
||||
importBatchSize = 2500
|
||||
)
|
||||
|
||||
var interruptCallbacks = []func(os.Signal){}
|
||||
|
||||
// Register interrupt handlers callbacks
|
||||
|
|
@ -125,10 +129,17 @@ func initDataDir(Datadir string) {
|
|||
}
|
||||
}
|
||||
|
||||
// Fatalf formats a message to standard output and exits the program.
|
||||
// Fatalf formats a message to standard error and exits the program.
|
||||
// The message is also printed to standard output if standard error
|
||||
// is redirected to a different file.
|
||||
func Fatalf(format string, args ...interface{}) {
|
||||
fmt.Fprintf(os.Stderr, "Fatal: "+format+"\n", args...)
|
||||
fmt.Fprintf(os.Stdout, "Fatal: "+format+"\n", args...)
|
||||
w := io.MultiWriter(os.Stdout, os.Stderr)
|
||||
outf, _ := os.Stdout.Stat()
|
||||
errf, _ := os.Stderr.Stat()
|
||||
if outf != nil && errf != nil && os.SameFile(outf, errf) {
|
||||
w = os.Stderr
|
||||
}
|
||||
fmt.Fprintf(w, "Fatal: "+format+"\n", args...)
|
||||
logger.Flush()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
|
@ -166,53 +177,86 @@ func FormatTransactionData(data string) []byte {
|
|||
return d
|
||||
}
|
||||
|
||||
func ImportChain(chainmgr *core.ChainManager, fn string) error {
|
||||
fmt.Printf("importing blockchain '%s'\n", fn)
|
||||
fh, err := os.OpenFile(fn, os.O_RDONLY, os.ModePerm)
|
||||
func ImportChain(chain *core.ChainManager, fn string) error {
|
||||
// Watch for Ctrl-C while the import is running.
|
||||
// If a signal is received, the import will stop at the next batch.
|
||||
interrupt := make(chan os.Signal, 1)
|
||||
stop := make(chan struct{})
|
||||
signal.Notify(interrupt, os.Interrupt)
|
||||
defer signal.Stop(interrupt)
|
||||
defer close(interrupt)
|
||||
go func() {
|
||||
if _, ok := <-interrupt; ok {
|
||||
glog.Info("caught interrupt during import, will stop at next batch")
|
||||
}
|
||||
close(stop)
|
||||
}()
|
||||
checkInterrupt := func() bool {
|
||||
select {
|
||||
case <-stop:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
glog.Infoln("Importing blockchain", fn)
|
||||
fh, err := os.Open(fn)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer fh.Close()
|
||||
|
||||
chainmgr.Reset()
|
||||
stream := rlp.NewStream(fh, 0)
|
||||
var i, n int
|
||||
|
||||
batchSize := 2500
|
||||
blocks := make(types.Blocks, batchSize)
|
||||
|
||||
for ; ; i++ {
|
||||
// Run actual the import.
|
||||
blocks := make(types.Blocks, importBatchSize)
|
||||
n := 0
|
||||
for batch := 0; ; batch++ {
|
||||
// Load a batch of RLP blocks.
|
||||
if checkInterrupt() {
|
||||
return fmt.Errorf("interrupted")
|
||||
}
|
||||
i := 0
|
||||
for ; i < importBatchSize; i++ {
|
||||
var b types.Block
|
||||
if err := stream.Decode(&b); err == io.EOF {
|
||||
break
|
||||
} else if err != nil {
|
||||
return fmt.Errorf("at block %d: %v", i, err)
|
||||
return fmt.Errorf("at block %d: %v", n, err)
|
||||
}
|
||||
|
||||
blocks[n] = &b
|
||||
blocks[i] = &b
|
||||
n++
|
||||
|
||||
if n == batchSize {
|
||||
if _, err := chainmgr.InsertChain(blocks); err != nil {
|
||||
return fmt.Errorf("invalid block %v", err)
|
||||
}
|
||||
n = 0
|
||||
blocks = make(types.Blocks, batchSize)
|
||||
if i == 0 {
|
||||
break
|
||||
}
|
||||
// Import the batch.
|
||||
if checkInterrupt() {
|
||||
return fmt.Errorf("interrupted")
|
||||
}
|
||||
if hasAllBlocks(chain, blocks[:i]) {
|
||||
glog.Infof("skipping batch %d, all blocks present [%x / %x]",
|
||||
batch, blocks[0].Hash().Bytes()[:4], blocks[i-1].Hash().Bytes()[:4])
|
||||
continue
|
||||
}
|
||||
if _, err := chain.InsertChain(blocks[:i]); err != nil {
|
||||
return fmt.Errorf("invalid block %d: %v", n, err)
|
||||
}
|
||||
}
|
||||
|
||||
if n > 0 {
|
||||
if _, err := chainmgr.InsertChain(blocks[:n]); err != nil {
|
||||
return fmt.Errorf("invalid block %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
fmt.Printf("imported %d blocks\n", i)
|
||||
return nil
|
||||
}
|
||||
|
||||
func hasAllBlocks(chain *core.ChainManager, bs []*types.Block) bool {
|
||||
for _, b := range bs {
|
||||
if !chain.HasBlock(b.Hash()) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func ExportChain(chainmgr *core.ChainManager, fn string) error {
|
||||
fmt.Printf("exporting blockchain '%s'\n", fn)
|
||||
glog.Infoln("Exporting blockchain to", fn)
|
||||
fh, err := os.OpenFile(fn, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
@ -221,6 +265,6 @@ func ExportChain(chainmgr *core.ChainManager, fn string) error {
|
|||
if err := chainmgr.Export(fh); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("exported blockchain\n")
|
||||
glog.Infoln("Exported blockchain to", fn)
|
||||
return nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -265,7 +265,8 @@ var (
|
|||
}
|
||||
)
|
||||
|
||||
func GetNAT(ctx *cli.Context) nat.Interface {
|
||||
// MakeNAT creates a port mapper from set command line flags.
|
||||
func MakeNAT(ctx *cli.Context) nat.Interface {
|
||||
natif, err := nat.Parse(ctx.GlobalString(NATFlag.Name))
|
||||
if err != nil {
|
||||
Fatalf("Option %s: %v", NATFlag.Name, err)
|
||||
|
|
@ -273,7 +274,8 @@ func GetNAT(ctx *cli.Context) nat.Interface {
|
|||
return natif
|
||||
}
|
||||
|
||||
func GetNodeKey(ctx *cli.Context) (key *ecdsa.PrivateKey) {
|
||||
// MakeNodeKey creates a node key from set command line flags.
|
||||
func MakeNodeKey(ctx *cli.Context) (key *ecdsa.PrivateKey) {
|
||||
hex, file := ctx.GlobalString(NodeKeyHexFlag.Name), ctx.GlobalString(NodeKeyFileFlag.Name)
|
||||
var err error
|
||||
switch {
|
||||
|
|
@ -291,21 +293,12 @@ func GetNodeKey(ctx *cli.Context) (key *ecdsa.PrivateKey) {
|
|||
return key
|
||||
}
|
||||
|
||||
// MakeEthConfig creates ethereum options from set command line flags.
|
||||
func MakeEthConfig(clientID, version string, ctx *cli.Context) *eth.Config {
|
||||
// Set verbosity on glog
|
||||
glog.SetV(ctx.GlobalInt(VerbosityFlag.Name))
|
||||
glog.CopyStandardLogTo("INFO")
|
||||
// Set the log type
|
||||
//glog.SetToStderr(ctx.GlobalBool(LogToStdErrFlag.Name))
|
||||
glog.SetToStderr(true)
|
||||
// Set the log dir
|
||||
glog.SetLogDir(ctx.GlobalString(LogFileFlag.Name))
|
||||
|
||||
customName := ctx.GlobalString(IdentityFlag.Name)
|
||||
if len(customName) > 0 {
|
||||
clientID += "/" + customName
|
||||
}
|
||||
|
||||
return ð.Config{
|
||||
Name: common.MakeName(clientID, version),
|
||||
DataDir: ctx.GlobalString(DataDirFlag.Name),
|
||||
|
|
@ -318,15 +311,15 @@ func MakeEthConfig(clientID, version string, ctx *cli.Context) *eth.Config {
|
|||
LogJSON: ctx.GlobalString(LogJSONFlag.Name),
|
||||
Etherbase: ctx.GlobalString(EtherbaseFlag.Name),
|
||||
MinerThreads: ctx.GlobalInt(MinerThreadsFlag.Name),
|
||||
AccountManager: GetAccountManager(ctx),
|
||||
AccountManager: MakeAccountManager(ctx),
|
||||
VmDebug: ctx.GlobalBool(VMDebugFlag.Name),
|
||||
MaxPeers: ctx.GlobalInt(MaxPeersFlag.Name),
|
||||
MaxPendingPeers: ctx.GlobalInt(MaxPendingPeersFlag.Name),
|
||||
Port: ctx.GlobalString(ListenPortFlag.Name),
|
||||
NAT: GetNAT(ctx),
|
||||
NAT: MakeNAT(ctx),
|
||||
NatSpec: ctx.GlobalBool(NatspecEnabledFlag.Name),
|
||||
Discovery: !ctx.GlobalBool(NoDiscoverFlag.Name),
|
||||
NodeKey: GetNodeKey(ctx),
|
||||
NodeKey: MakeNodeKey(ctx),
|
||||
Shh: ctx.GlobalBool(WhisperEnabledFlag.Name),
|
||||
Bzz: ctx.GlobalBool(SwarmEnabledFlag.Name),
|
||||
BzzPort: ctx.GlobalString(SwarmProxyPortFlag.Name),
|
||||
|
|
@ -338,35 +331,39 @@ func MakeEthConfig(clientID, version string, ctx *cli.Context) *eth.Config {
|
|||
}
|
||||
}
|
||||
|
||||
func GetChain(ctx *cli.Context) (*core.ChainManager, common.Database, common.Database) {
|
||||
dataDir := ctx.GlobalString(DataDirFlag.Name)
|
||||
|
||||
blockDb, err := ethdb.NewLDBDatabase(filepath.Join(dataDir, "blockchain"))
|
||||
if err != nil {
|
||||
Fatalf("Could not open database: %v", err)
|
||||
// SetupLogger configures glog from the logging-related command line flags.
|
||||
func SetupLogger(ctx *cli.Context) {
|
||||
glog.SetV(ctx.GlobalInt(VerbosityFlag.Name))
|
||||
glog.CopyStandardLogTo("INFO")
|
||||
glog.SetToStderr(true)
|
||||
glog.SetLogDir(ctx.GlobalString(LogFileFlag.Name))
|
||||
}
|
||||
|
||||
stateDb, err := ethdb.NewLDBDatabase(filepath.Join(dataDir, "state"))
|
||||
if err != nil {
|
||||
// MakeChain creates a chain manager from set command line flags.
|
||||
func MakeChain(ctx *cli.Context) (chain *core.ChainManager, blockDB, stateDB, extraDB common.Database) {
|
||||
dd := ctx.GlobalString(DataDirFlag.Name)
|
||||
var err error
|
||||
if blockDB, err = ethdb.NewLDBDatabase(filepath.Join(dd, "blockchain")); err != nil {
|
||||
Fatalf("Could not open database: %v", err)
|
||||
}
|
||||
|
||||
extraDb, err := ethdb.NewLDBDatabase(filepath.Join(dataDir, "extra"))
|
||||
if err != nil {
|
||||
if stateDB, err = ethdb.NewLDBDatabase(filepath.Join(dd, "state")); err != nil {
|
||||
Fatalf("Could not open database: %v", err)
|
||||
}
|
||||
if extraDB, err = ethdb.NewLDBDatabase(filepath.Join(dd, "extra")); err != nil {
|
||||
Fatalf("Could not open database: %v", err)
|
||||
}
|
||||
|
||||
eventMux := new(event.TypeMux)
|
||||
pow := ethash.New()
|
||||
chainManager := core.NewChainManager(blockDb, stateDb, pow, eventMux)
|
||||
txPool := core.NewTxPool(eventMux, chainManager.State, chainManager.GasLimit)
|
||||
blockProcessor := core.NewBlockProcessor(stateDb, extraDb, pow, txPool, chainManager, eventMux)
|
||||
chainManager.SetProcessor(blockProcessor)
|
||||
|
||||
return chainManager, blockDb, stateDb
|
||||
chain = core.NewChainManager(blockDB, stateDB, pow, eventMux)
|
||||
txpool := core.NewTxPool(eventMux, chain.State, chain.GasLimit)
|
||||
proc := core.NewBlockProcessor(stateDB, extraDB, pow, txpool, chain, eventMux)
|
||||
chain.SetProcessor(proc)
|
||||
return chain, blockDB, stateDB, extraDB
|
||||
}
|
||||
|
||||
func GetAccountManager(ctx *cli.Context) *accounts.Manager {
|
||||
// MakeChain creates an account manager from set command line flags.
|
||||
func MakeAccountManager(ctx *cli.Context) *accounts.Manager {
|
||||
dataDir := ctx.GlobalString(DataDirFlag.Name)
|
||||
ks := crypto.NewKeyStorePassphrase(filepath.Join(dataDir, "keystore"))
|
||||
return accounts.NewManager(ks)
|
||||
|
|
|
|||
|
|
@ -40,11 +40,6 @@ type BlockProcessor struct {
|
|||
|
||||
txpool *TxPool
|
||||
|
||||
// The last attempted block is mainly used for debugging purposes
|
||||
// This does not have to be a valid block and will be set during
|
||||
// 'Process' & canonical validation.
|
||||
lastAttemptedBlock *types.Block
|
||||
|
||||
events event.Subscription
|
||||
|
||||
eventMux *event.TypeMux
|
||||
|
|
@ -188,8 +183,6 @@ func (sm *BlockProcessor) Process(block *types.Block) (logs state.Logs, err erro
|
|||
}
|
||||
|
||||
func (sm *BlockProcessor) processWithParent(block, parent *types.Block) (logs state.Logs, err error) {
|
||||
sm.lastAttemptedBlock = block
|
||||
|
||||
// Create a new state based on the parent's root (e.g., create copy)
|
||||
state := state.New(parent.Root(), sm.db)
|
||||
|
||||
|
|
@ -255,6 +248,12 @@ func (sm *BlockProcessor) processWithParent(block, parent *types.Block) (logs st
|
|||
return
|
||||
}
|
||||
|
||||
// store the receipts
|
||||
err = putReceipts(sm.extraDb, block.Hash(), receipts)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Calculate the td for this block
|
||||
//td = CalculateTD(block, parent)
|
||||
// Sync the current block's state to the database
|
||||
|
|
@ -268,23 +267,9 @@ func (sm *BlockProcessor) processWithParent(block, parent *types.Block) (logs st
|
|||
putTx(sm.extraDb, tx, block, uint64(i))
|
||||
}
|
||||
|
||||
receiptsRlp := block.Receipts().RlpEncode()
|
||||
sm.extraDb.Put(append(receiptsPre, block.Hash().Bytes()...), receiptsRlp)
|
||||
|
||||
return state.Logs(), nil
|
||||
}
|
||||
|
||||
func (self *BlockProcessor) GetBlockReceipts(bhash common.Hash) (receipts types.Receipts, err error) {
|
||||
var rdata []byte
|
||||
rdata, err = self.extraDb.Get(append(receiptsPre, bhash[:]...))
|
||||
|
||||
if err == nil {
|
||||
err = rlp.DecodeBytes(rdata, &receipts)
|
||||
}
|
||||
return
|
||||
|
||||
}
|
||||
|
||||
// See YP section 4.3.4. "Block Header Validity"
|
||||
// Validates a block. Returns an error if the block is invalid.
|
||||
func (sm *BlockProcessor) ValidateHeader(block, parent *types.Header, checkPow bool) error {
|
||||
|
|
@ -391,13 +376,25 @@ func (sm *BlockProcessor) VerifyUncles(statedb *state.StateDB, block, parent *ty
|
|||
return nil
|
||||
}
|
||||
|
||||
func (sm *BlockProcessor) GetLogs(block *types.Block) (logs state.Logs, err error) {
|
||||
if !sm.bc.HasBlock(block.Header().ParentHash) {
|
||||
return nil, ParentError(block.Header().ParentHash)
|
||||
// GetBlockReceipts returns the receipts beloniging to the block hash
|
||||
func (sm *BlockProcessor) GetBlockReceipts(bhash common.Hash) (receipts types.Receipts, err error) {
|
||||
return getBlockReceipts(sm.extraDb, bhash)
|
||||
}
|
||||
|
||||
sm.lastAttemptedBlock = block
|
||||
// GetLogs returns the logs of the given block. This method is using a two step approach
|
||||
// where it tries to get it from the (updated) method which gets them from the receipts or
|
||||
// the depricated way by re-processing the block.
|
||||
func (sm *BlockProcessor) GetLogs(block *types.Block) (logs state.Logs, err error) {
|
||||
receipts, err := sm.GetBlockReceipts(block.Hash())
|
||||
if err == nil && len(receipts) > 0 {
|
||||
// coalesce logs
|
||||
for _, receipt := range receipts {
|
||||
logs = append(logs, receipt.Logs()...)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// TODO: remove backward compatibility
|
||||
var (
|
||||
parent = sm.bc.GetBlock(block.Header().ParentHash)
|
||||
state = state.New(parent.Root(), sm.db)
|
||||
|
|
@ -408,6 +405,16 @@ func (sm *BlockProcessor) GetLogs(block *types.Block) (logs state.Logs, err erro
|
|||
return state.Logs(), nil
|
||||
}
|
||||
|
||||
func getBlockReceipts(db common.Database, bhash common.Hash) (receipts types.Receipts, err error) {
|
||||
var rdata []byte
|
||||
rdata, err = db.Get(append(receiptsPre, bhash[:]...))
|
||||
|
||||
if err == nil {
|
||||
err = rlp.DecodeBytes(rdata, &receipts)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func putTx(db common.Database, tx *types.Transaction, block *types.Block, i uint64) {
|
||||
rlpEnc, err := rlp.EncodeToBytes(tx)
|
||||
if err != nil {
|
||||
|
|
@ -431,3 +438,19 @@ func putTx(db common.Database, tx *types.Transaction, block *types.Block, i uint
|
|||
}
|
||||
db.Put(append(tx.Hash().Bytes(), 0x0001), rlpMeta)
|
||||
}
|
||||
|
||||
func putReceipts(db common.Database, hash common.Hash, receipts types.Receipts) error {
|
||||
storageReceipts := make([]*types.ReceiptForStorage, len(receipts))
|
||||
for i, receipt := range receipts {
|
||||
storageReceipts[i] = (*types.ReceiptForStorage)(receipt)
|
||||
}
|
||||
|
||||
bytes, err := rlp.EncodeToBytes(storageReceipts)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
db.Put(append(receiptsPre, hash[:]...), bytes)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,6 +5,8 @@ import (
|
|||
"testing"
|
||||
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/ethereum/go-ethereum/core/state"
|
||||
"github.com/ethereum/go-ethereum/core/types"
|
||||
"github.com/ethereum/go-ethereum/ethdb"
|
||||
"github.com/ethereum/go-ethereum/event"
|
||||
"github.com/ethereum/go-ethereum/pow/ezp"
|
||||
|
|
@ -35,3 +37,33 @@ func TestNumber(t *testing.T) {
|
|||
t.Errorf("didn't expect block number error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestPutReceipt(t *testing.T) {
|
||||
db, _ := ethdb.NewMemDatabase()
|
||||
|
||||
var addr common.Address
|
||||
addr[0] = 1
|
||||
var hash common.Hash
|
||||
hash[0] = 2
|
||||
|
||||
receipt := new(types.Receipt)
|
||||
receipt.SetLogs(state.Logs{&state.Log{
|
||||
Address: addr,
|
||||
Topics: []common.Hash{hash},
|
||||
Data: []byte("hi"),
|
||||
Number: 42,
|
||||
TxHash: hash,
|
||||
TxIndex: 0,
|
||||
BlockHash: hash,
|
||||
Index: 0,
|
||||
}})
|
||||
|
||||
putReceipts(db, hash, types.Receipts{receipt})
|
||||
receipts, err := getBlockReceipts(db, hash)
|
||||
if err != nil {
|
||||
t.Error("got err:", err)
|
||||
}
|
||||
if len(receipts) != 1 {
|
||||
t.Error("expected to get 1 receipt, got", len(receipts))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,7 +2,9 @@ package core
|
|||
|
||||
import "github.com/ethereum/go-ethereum/common"
|
||||
|
||||
var badHashes = []common.Hash{
|
||||
common.HexToHash("f269c503aed286caaa0d114d6a5320e70abbc2febe37953207e76a2873f2ba79"),
|
||||
common.HexToHash("38f5bbbffd74804820ffa4bab0cd540e9de229725afb98c1a7e57936f4a714bc"),
|
||||
// Set of manually tracked bad hashes (usually hard forks)
|
||||
var BadHashes = map[common.Hash]bool{
|
||||
common.HexToHash("f269c503aed286caaa0d114d6a5320e70abbc2febe37953207e76a2873f2ba79"): true,
|
||||
common.HexToHash("38f5bbbffd74804820ffa4bab0cd540e9de229725afb98c1a7e57936f4a714bc"): true,
|
||||
common.HexToHash("7064455b364775a16afbdecd75370e912c6e2879f202eda85b9beae547fff3ac"): true,
|
||||
}
|
||||
|
|
|
|||
|
|
@ -121,7 +121,7 @@ func NewChainManager(blockDb, stateDb common.Database, pow pow.PoW, mux *event.T
|
|||
bc.setLastState()
|
||||
|
||||
// Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain
|
||||
for _, hash := range badHashes {
|
||||
for hash, _ := range BadHashes {
|
||||
if block := bc.GetBlock(hash); block != nil {
|
||||
glog.V(logger.Error).Infof("Found bad hash. Reorganising chain to state %x\n", block.ParentHash().Bytes()[:4])
|
||||
block = bc.GetBlock(block.ParentHash())
|
||||
|
|
@ -548,18 +548,21 @@ func (self *ChainManager) InsertChain(chain types.Blocks) (int, error) {
|
|||
tstart = time.Now()
|
||||
)
|
||||
|
||||
// check the nonce in parallel to the block processing
|
||||
// this speeds catching up significantly
|
||||
nonceErrCh := make(chan error)
|
||||
go func() {
|
||||
nonceErrCh <- verifyNonces(self.pow, chain)
|
||||
}()
|
||||
|
||||
for i, block := range chain {
|
||||
if block == nil {
|
||||
continue
|
||||
}
|
||||
|
||||
if BadHashes[block.Hash()] {
|
||||
err := fmt.Errorf("Found known bad hash in chain %x", block.Hash())
|
||||
blockErr(block, err)
|
||||
return i, err
|
||||
}
|
||||
|
||||
// create a nonce channel for parallisation of the nonce check
|
||||
nonceErrCh := make(chan error)
|
||||
go verifyBlockNonce(self.pow, block, nonceErrCh)
|
||||
|
||||
// Setting block.Td regardless of error (known for example) prevents errors down the line
|
||||
// in the protocol handler
|
||||
block.Td = new(big.Int).Set(CalcTD(block, self.GetBlock(block.ParentHash())))
|
||||
|
|
@ -568,13 +571,14 @@ func (self *ChainManager) InsertChain(chain types.Blocks) (int, error) {
|
|||
// all others will fail too (unless a known block is returned).
|
||||
logs, err := self.processor.Process(block)
|
||||
if err != nil {
|
||||
// empty the nonce channel
|
||||
<-nonceErrCh
|
||||
|
||||
if IsKnownBlockErr(err) {
|
||||
stats.ignored++
|
||||
continue
|
||||
}
|
||||
|
||||
// Do not penelise on future block. We'll need a block queue eventually that will queue
|
||||
// future block for future use
|
||||
if err == BlockFutureErr {
|
||||
block.SetQueued(true)
|
||||
self.futureBlocks.Push(block)
|
||||
|
|
@ -593,18 +597,23 @@ func (self *ChainManager) InsertChain(chain types.Blocks) (int, error) {
|
|||
|
||||
return i, err
|
||||
}
|
||||
// Wait and check nonce channel and make sure it checks out fine
|
||||
// otherwise return the error
|
||||
if err := <-nonceErrCh; err != nil {
|
||||
return i, err
|
||||
}
|
||||
|
||||
cblock := self.currentBlock
|
||||
// Write block to database. Eventually we'll have to improve on this and throw away blocks that are
|
||||
// not in the canonical chain.
|
||||
self.write(block)
|
||||
// Compare the TD of the last known block in the canonical chain to make sure it's greater.
|
||||
// At this point it's possible that a different chain (fork) becomes the new canonical chain.
|
||||
if block.Td.Cmp(self.td) > 0 {
|
||||
// chain fork
|
||||
if block.ParentHash() != cblock.Hash() {
|
||||
// during split we merge two different chains and create the new canonical chain
|
||||
self.merge(cblock, block)
|
||||
err := self.merge(cblock, block)
|
||||
if err != nil {
|
||||
return i, err
|
||||
}
|
||||
|
||||
queue[i] = ChainSplitEvent{block, logs}
|
||||
queueEvent.splitCount++
|
||||
|
|
@ -637,19 +646,16 @@ func (self *ChainManager) InsertChain(chain types.Blocks) (int, error) {
|
|||
queue[i] = ChainSideEvent{block, logs}
|
||||
queueEvent.sideCount++
|
||||
}
|
||||
// Write block to database. Eventually we'll have to improve on this and throw away blocks that are
|
||||
// not in the canonical chain.
|
||||
self.write(block)
|
||||
// Delete from future blocks
|
||||
self.futureBlocks.Delete(block.Hash())
|
||||
|
||||
stats.processed++
|
||||
|
||||
}
|
||||
|
||||
// check and wait for the nonce error channel and
|
||||
// make sure no nonce error was thrown in the process
|
||||
err := <-nonceErrCh
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
if (stats.queued > 0 || stats.processed > 0 || stats.ignored > 0) && bool(glog.V(logger.Info)) {
|
||||
tend := time.Since(tstart)
|
||||
start, end := chain[0], chain[len(chain)-1]
|
||||
|
|
@ -663,7 +669,7 @@ func (self *ChainManager) InsertChain(chain types.Blocks) (int, error) {
|
|||
|
||||
// diff takes two blocks, an old chain and a new chain and will reconstruct the blocks and inserts them
|
||||
// to be part of the new canonical chain.
|
||||
func (self *ChainManager) diff(oldBlock, newBlock *types.Block) types.Blocks {
|
||||
func (self *ChainManager) diff(oldBlock, newBlock *types.Block) (types.Blocks, error) {
|
||||
var (
|
||||
newChain types.Blocks
|
||||
commonBlock *types.Block
|
||||
|
|
@ -674,14 +680,20 @@ func (self *ChainManager) diff(oldBlock, newBlock *types.Block) types.Blocks {
|
|||
// first reduce whoever is higher bound
|
||||
if oldBlock.NumberU64() > newBlock.NumberU64() {
|
||||
// reduce old chain
|
||||
for oldBlock = oldBlock; oldBlock.NumberU64() != newBlock.NumberU64(); oldBlock = self.GetBlock(oldBlock.ParentHash()) {
|
||||
for oldBlock = oldBlock; oldBlock != nil && oldBlock.NumberU64() != newBlock.NumberU64(); oldBlock = self.GetBlock(oldBlock.ParentHash()) {
|
||||
}
|
||||
} else {
|
||||
// reduce new chain and append new chain blocks for inserting later on
|
||||
for newBlock = newBlock; newBlock.NumberU64() != oldBlock.NumberU64(); newBlock = self.GetBlock(newBlock.ParentHash()) {
|
||||
for newBlock = newBlock; newBlock != nil && newBlock.NumberU64() != oldBlock.NumberU64(); newBlock = self.GetBlock(newBlock.ParentHash()) {
|
||||
newChain = append(newChain, newBlock)
|
||||
}
|
||||
}
|
||||
if oldBlock == nil {
|
||||
return nil, fmt.Errorf("Invalid old chain")
|
||||
}
|
||||
if newBlock == nil {
|
||||
return nil, fmt.Errorf("Invalid new chain")
|
||||
}
|
||||
|
||||
numSplit := newBlock.Number()
|
||||
for {
|
||||
|
|
@ -692,6 +704,12 @@ func (self *ChainManager) diff(oldBlock, newBlock *types.Block) types.Blocks {
|
|||
newChain = append(newChain, newBlock)
|
||||
|
||||
oldBlock, newBlock = self.GetBlock(oldBlock.ParentHash()), self.GetBlock(newBlock.ParentHash())
|
||||
if oldBlock == nil {
|
||||
return nil, fmt.Errorf("Invalid old chain")
|
||||
}
|
||||
if newBlock == nil {
|
||||
return nil, fmt.Errorf("Invalid new chain")
|
||||
}
|
||||
}
|
||||
|
||||
if glog.V(logger.Info) {
|
||||
|
|
@ -699,17 +717,22 @@ func (self *ChainManager) diff(oldBlock, newBlock *types.Block) types.Blocks {
|
|||
glog.Infof("Fork detected @ %x. Reorganising chain from #%v %x to %x", commonHash[:4], numSplit, oldStart.Hash().Bytes()[:4], newStart.Hash().Bytes()[:4])
|
||||
}
|
||||
|
||||
return newChain
|
||||
return newChain, nil
|
||||
}
|
||||
|
||||
// merge merges two different chain to the new canonical chain
|
||||
func (self *ChainManager) merge(oldBlock, newBlock *types.Block) {
|
||||
newChain := self.diff(oldBlock, newBlock)
|
||||
func (self *ChainManager) merge(oldBlock, newBlock *types.Block) error {
|
||||
newChain, err := self.diff(oldBlock, newBlock)
|
||||
if err != nil {
|
||||
return fmt.Errorf("chain reorg failed: %v", err)
|
||||
}
|
||||
|
||||
// insert blocks. Order does not matter. Last block will be written in ImportChain itself which creates the new head properly
|
||||
for _, block := range newChain {
|
||||
self.insert(block)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (self *ChainManager) update() {
|
||||
|
|
@ -802,9 +825,17 @@ func verifyNonces(pow pow.PoW, blocks []*types.Block) error {
|
|||
func verifyNonce(pow pow.PoW, in <-chan *types.Block, done chan<- error) {
|
||||
for block := range in {
|
||||
if !pow.Verify(block) {
|
||||
done <- ValidationError("Block(#%v) nonce is invalid (= %x)", block.Number(), block.Nonce)
|
||||
done <- ValidationError("Block (#%v / %x) nonce is invalid (= %x)", block.Number(), block.Hash(), block.Nonce)
|
||||
} else {
|
||||
done <- nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func verifyBlockNonce(pow pow.PoW, block *types.Block, done chan<- error) {
|
||||
if !pow.Verify(block) {
|
||||
done <- ValidationError("Block (#%v / %x) nonce is invalid (= %x)", block.Number(), block.Hash(), block.Nonce)
|
||||
} else {
|
||||
done <- nil
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,9 +3,7 @@ package core
|
|||
import (
|
||||
"github.com/ethereum/go-ethereum/accounts"
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/ethereum/go-ethereum/eth/downloader"
|
||||
"github.com/ethereum/go-ethereum/event"
|
||||
"github.com/ethereum/go-ethereum/p2p"
|
||||
)
|
||||
|
||||
// TODO move this to types?
|
||||
|
|
@ -14,11 +12,7 @@ type Backend interface {
|
|||
BlockProcessor() *BlockProcessor
|
||||
ChainManager() *ChainManager
|
||||
TxPool() *TxPool
|
||||
PeerCount() int
|
||||
IsListening() bool
|
||||
Peers() []*p2p.Peer
|
||||
BlockDb() common.Database
|
||||
StateDb() common.Database
|
||||
EventMux() *event.TypeMux
|
||||
Downloader() *downloader.Downloader
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,15 +29,22 @@ func (self *Log) EncodeRLP(w io.Writer) error {
|
|||
}
|
||||
|
||||
func (self *Log) String() string {
|
||||
return fmt.Sprintf(`log: %x %x %x`, self.Address, self.Topics, self.Data)
|
||||
return fmt.Sprintf(`log: %x %x %x %x %d %x %d`, self.Address, self.Topics, self.Data, self.TxHash, self.TxIndex, self.BlockHash, self.Index)
|
||||
}
|
||||
|
||||
type Logs []*Log
|
||||
|
||||
func (self Logs) String() (ret string) {
|
||||
for _, log := range self {
|
||||
ret += fmt.Sprintf("%v", log)
|
||||
}
|
||||
type LogForStorage Log
|
||||
|
||||
return "[" + ret + "]"
|
||||
func (self *LogForStorage) EncodeRLP(w io.Writer) error {
|
||||
return rlp.Encode(w, []interface{}{
|
||||
self.Address,
|
||||
self.Topics,
|
||||
self.Data,
|
||||
self.Number,
|
||||
self.TxHash,
|
||||
self.TxIndex,
|
||||
self.BlockHash,
|
||||
self.Index,
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,10 +26,39 @@ func (self *Receipt) SetLogs(logs state.Logs) {
|
|||
self.logs = logs
|
||||
}
|
||||
|
||||
func (self *Receipt) Logs() state.Logs {
|
||||
return self.logs
|
||||
}
|
||||
|
||||
func (self *Receipt) EncodeRLP(w io.Writer) error {
|
||||
return rlp.Encode(w, []interface{}{self.PostState, self.CumulativeGasUsed, self.Bloom, self.logs})
|
||||
}
|
||||
|
||||
func (self *Receipt) DecodeRLP(s *rlp.Stream) error {
|
||||
var r struct {
|
||||
PostState []byte
|
||||
CumulativeGasUsed *big.Int
|
||||
Bloom Bloom
|
||||
Logs state.Logs
|
||||
}
|
||||
if err := s.Decode(&r); err != nil {
|
||||
return err
|
||||
}
|
||||
self.PostState, self.CumulativeGasUsed, self.Bloom, self.logs = r.PostState, r.CumulativeGasUsed, r.Bloom, r.Logs
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
type ReceiptForStorage Receipt
|
||||
|
||||
func (self *ReceiptForStorage) EncodeRLP(w io.Writer) error {
|
||||
storageLogs := make([]*state.LogForStorage, len(self.logs))
|
||||
for i, log := range self.logs {
|
||||
storageLogs[i] = (*state.LogForStorage)(log)
|
||||
}
|
||||
return rlp.Encode(w, []interface{}{self.PostState, self.CumulativeGasUsed, self.Bloom, storageLogs})
|
||||
}
|
||||
|
||||
func (self *Receipt) RlpEncode() []byte {
|
||||
bytes, err := rlp.EncodeToBytes(self)
|
||||
if err != nil {
|
||||
|
|
|
|||
|
|
@ -7,7 +7,10 @@ import (
|
|||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"gopkg.in/fatih/set.v0"
|
||||
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/ethereum/go-ethereum/core"
|
||||
"github.com/ethereum/go-ethereum/core/types"
|
||||
"github.com/ethereum/go-ethereum/event"
|
||||
"github.com/ethereum/go-ethereum/logger"
|
||||
|
|
@ -75,6 +78,7 @@ type Downloader struct {
|
|||
queue *queue // Scheduler for selecting the hashes to download
|
||||
peers *peerSet // Set of active peers from which download can proceed
|
||||
checks map[common.Hash]*crossCheck // Pending cross checks to verify a hash chain
|
||||
banned *set.SetNonTS // Set of hashes we've received and banned
|
||||
|
||||
// Callbacks
|
||||
hasBlock hashCheckFn
|
||||
|
|
@ -100,6 +104,7 @@ type Block struct {
|
|||
}
|
||||
|
||||
func New(mux *event.TypeMux, hasBlock hashCheckFn, getBlock getBlockFn) *Downloader {
|
||||
// Create the base downloader
|
||||
downloader := &Downloader{
|
||||
mux: mux,
|
||||
queue: newQueue(),
|
||||
|
|
@ -110,6 +115,11 @@ func New(mux *event.TypeMux, hasBlock hashCheckFn, getBlock getBlockFn) *Downloa
|
|||
hashCh: make(chan hashPack, 1),
|
||||
blockCh: make(chan blockPack, 1),
|
||||
}
|
||||
// Inject all the known bad hashes
|
||||
downloader.banned = set.NewNonTS()
|
||||
for hash, _ := range core.BadHashes {
|
||||
downloader.banned.Add(hash)
|
||||
}
|
||||
return downloader
|
||||
}
|
||||
|
||||
|
|
@ -280,6 +290,12 @@ func (d *Downloader) fetchHashes(p *peer, h common.Hash) error {
|
|||
glog.V(logger.Debug).Infof("Peer (%s) responded with empty hash set\n", active.id)
|
||||
return errEmptyHashSet
|
||||
}
|
||||
for _, hash := range hashPack.hashes {
|
||||
if d.banned.Has(hash) {
|
||||
glog.V(logger.Debug).Infof("Peer (%s) sent a known invalid chain\n", active.id)
|
||||
return ErrInvalidChain
|
||||
}
|
||||
}
|
||||
// Determine if we're done fetching hashes (queue up all pending), and continue if not done
|
||||
done, index := false, 0
|
||||
for index, head = range hashPack.hashes {
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@ package eth
|
|||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"math/big"
|
||||
"sync"
|
||||
"time"
|
||||
|
|
@ -359,7 +358,7 @@ func (pm *ProtocolManager) verifyTd(peer *peer, request newBlockMsgData) error {
|
|||
func (pm *ProtocolManager) BroadcastBlock(hash common.Hash, block *types.Block) {
|
||||
// Broadcast block to a batch of peers not knowing about it
|
||||
peers := pm.peers.PeersWithoutBlock(hash)
|
||||
peers = peers[:int(math.Sqrt(float64(len(peers))))]
|
||||
//peers = peers[:int(math.Sqrt(float64(len(peers))))]
|
||||
for _, peer := range peers {
|
||||
peer.sendNewBlock(block)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -70,6 +70,7 @@ func (pm *ProtocolManager) processBlocks() error {
|
|||
// Try to inset the blocks, drop the originating peer if there's an error
|
||||
index, err := pm.chainman.InsertChain(raw)
|
||||
if err != nil {
|
||||
glog.V(logger.Debug).Infoln("Downloaded block import failed:", err)
|
||||
pm.removePeer(blocks[index].OriginPeer)
|
||||
pm.downloader.Cancel()
|
||||
return err
|
||||
|
|
@ -84,12 +85,10 @@ func (pm *ProtocolManager) processBlocks() error {
|
|||
func (pm *ProtocolManager) synchronise(peer *peer) {
|
||||
// Short circuit if no peers are available
|
||||
if peer == nil {
|
||||
glog.V(logger.Debug).Infoln("Synchronisation canceled: no peers available")
|
||||
return
|
||||
}
|
||||
// Make sure the peer's TD is higher than our own. If not drop.
|
||||
if peer.td.Cmp(pm.chainman.Td()) <= 0 {
|
||||
glog.V(logger.Debug).Infoln("Synchronisation canceled: peer's total difficulty is too small")
|
||||
return
|
||||
}
|
||||
// FIXME if we have the hash in our chain and the TD of the peer is
|
||||
|
|
|
|||
1488
jsre/ethereum_js.go
1488
jsre/ethereum_js.go
File diff suppressed because it is too large
Load diff
|
|
@ -289,6 +289,10 @@ func (self *worker) push() {
|
|||
func (self *worker) makeCurrent() {
|
||||
block := self.chain.NewBlock(self.coinbase)
|
||||
parent := self.chain.GetBlock(block.ParentHash())
|
||||
// TMP fix for build server ...
|
||||
if parent == nil {
|
||||
return
|
||||
}
|
||||
|
||||
if block.Time() <= parent.Time() {
|
||||
block.Header().Time = parent.Header().Time + 1
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ func TestAutoDiscRace(t *testing.T) {
|
|||
}
|
||||
|
||||
// Check that they all return the correct result within the deadline.
|
||||
deadline := time.After(550 * time.Millisecond)
|
||||
deadline := time.After(2 * time.Second)
|
||||
for i := 0; i < cap(results); i++ {
|
||||
select {
|
||||
case <-deadline:
|
||||
|
|
|
|||
Loading…
Reference in a new issue