Merge branch 'develop' of github.com-obscure:ethereum/go-ethereum into develop

cmd/ethereum/js.go

@@ -91,6 +91,7 @@ func newJSRE(ethereum *eth.Ethereum, libPath string) *jsre {
 func (js *jsre) apiBindings() {
 
 	ethApi := rpc.NewEthereumApi(js.xeth, js.ethereum.DataDir)
+	ethApi.Close()
 	//js.re.Bind("jeth", rpc.NewJeth(ethApi, js.re.ToVal))
 
 	jeth := rpc.NewJeth(ethApi, js.re.ToVal, js.re)

cmd/ethtest/main.go

@@ -33,12 +33,12 @@ import (
 	"strings"
 
 	"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/core/vm"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/logger"
-	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/tests/helper"
-	"github.com/ethereum/go-ethereum/core/vm"
 )
 
 type Log struct {
@@ -80,8 +80,7 @@ func StateObjectFromAccount(db common.Database, addr string, account Account) *s
 }
 
 type VmTest struct {
-	Callcreates interface{}
-	//Env         map[string]string
+	Callcreates   interface{}
 	Env           Env
 	Exec          map[string]string
 	Transaction   map[string]string
@@ -219,7 +218,7 @@ func RunVmTest(r io.Reader) (failed int) {
 }
 
 func main() {
-	//helper.Logger.SetLogLevel(5)
+	helper.Logger.SetLogLevel(5)
 	vm.Debug = true
 
 	if len(os.Args) > 1 {

eth/backend.go

@@ -13,6 +13,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/event"
@@ -21,7 +22,6 @@ import (
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/nat"
-	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/whisper"
 )
 
@@ -141,8 +141,8 @@ type Ethereum struct {
 	Mining          bool
 	DataDir         string
 	version         string
-	ProtocolVersion int
-	NetworkId       int
+	protocolVersion int
+	networkId       int
 }
 
 func New(config *Config) (*Ethereum, error) {
@@ -177,15 +177,16 @@ func New(config *Config) (*Ethereum, error) {
 	servlogger.Infof("Protocol Version: %v, Network Id: %v", config.ProtocolVersion, config.NetworkId)
 
 	eth := &Ethereum{
-		shutdownChan: make(chan bool),
-		blockDb:      blockDb,
-		stateDb:      stateDb,
-		extraDb:      extraDb,
-		eventMux:     &event.TypeMux{},
-		// logger:         servlogsystem,
-		accountManager: config.AccountManager,
-		DataDir:        config.DataDir,
-		version:        config.Name, // TODO should separate from Name
+		shutdownChan:    make(chan bool),
+		blockDb:         blockDb,
+		stateDb:         stateDb,
+		extraDb:         extraDb,
+		eventMux:        &event.TypeMux{},
+		accountManager:  config.AccountManager,
+		DataDir:         config.DataDir,
+		version:         config.Name, // TODO should separate from Name
+		protocolVersion: config.ProtocolVersion,
+		networkId:       config.NetworkId,
 	}
 
 	eth.chainManager = core.NewChainManager(blockDb, stateDb, eth.EventMux())
@@ -324,6 +325,8 @@ func (s *Ethereum) PeerCount() int                       { return s.net.PeerCoun
 func (s *Ethereum) Peers() []*p2p.Peer                   { return s.net.Peers() }
 func (s *Ethereum) MaxPeers() int                        { return s.net.MaxPeers }
 func (s *Ethereum) Version() string                      { return s.version }
+func (s *Ethereum) ProtocolVersion() int                 { return s.protocolVersion }
+func (s *Ethereum) NetworkId() int                       { return s.networkId }
 
 // Start the ethereum
 func (s *Ethereum) Start() error {

logger/logsystem.go

@@ -14,17 +14,17 @@ type LogSystem interface {
 
 // NewStdLogSystem creates a LogSystem that prints to the given writer.
 // The flag values are defined package log.
-func NewStdLogSystem(writer io.Writer, flags int, level LogLevel) LogSystem {
+func NewStdLogSystem(writer io.Writer, flags int, level LogLevel) *StdLogSystem {
 	logger := log.New(writer, "", flags)
-	return &stdLogSystem{logger, uint32(level)}
+	return &StdLogSystem{logger, uint32(level)}
 }
 
-type stdLogSystem struct {
+type StdLogSystem struct {
 	logger *log.Logger
 	level  uint32
 }
 
-func (t *stdLogSystem) LogPrint(msg LogMsg) {
+func (t *StdLogSystem) LogPrint(msg LogMsg) {
 	stdmsg, ok := msg.(stdMsg)
 	if ok {
 		if t.GetLogLevel() >= stdmsg.Level() {
@@ -33,11 +33,11 @@ func (t *stdLogSystem) LogPrint(msg LogMsg) {
 	}
 }
 
-func (t *stdLogSystem) SetLogLevel(i LogLevel) {
+func (t *StdLogSystem) SetLogLevel(i LogLevel) {
 	atomic.StoreUint32(&t.level, uint32(i))
 }
 
-func (t *stdLogSystem) GetLogLevel() LogLevel {
+func (t *StdLogSystem) GetLogLevel() LogLevel {
 	return LogLevel(atomic.LoadUint32(&t.level))
 }
 

p2p/testlog_test.go

@@ -15,11 +15,8 @@ func testlog(t *testing.T) testLogger {
 	return l
 }
 
-func (testLogger) GetLogLevel() logger.LogLevel { return logger.DebugDetailLevel }
-func (testLogger) SetLogLevel(logger.LogLevel)  {}
-
-func (l testLogger) LogPrint(level logger.LogLevel, msg string) {
-	l.t.Logf("%s", msg)
+func (l testLogger) LogPrint(msg logger.LogMsg) {
+	l.t.Logf("%s", msg.String())
 }
 
 func (testLogger) detach() {

rpc/api.go

@@ -44,6 +44,10 @@ func (api *EthereumApi) xethAtStateNum(num int64) *xeth.XEth {
 	return api.xeth().AtStateNum(num)
 }
 
+func (api *EthereumApi) Close() {
+	api.db.Close()
+}
+
 func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error {
 	// Spec at https://github.com/ethereum/wiki/wiki/Generic-JSON-RPC
 	rpclogger.Debugf("%s %s", req.Method, req.Params)
@@ -58,7 +62,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
 	case "web3_clientVersion":
 		*reply = api.xeth().Backend().Version()
 	case "net_version":
-		return NewNotImplementedError(req.Method)
+		*reply = string(api.xeth().Backend().ProtocolVersion())
 	case "net_listening":
 		*reply = api.xeth().IsListening()
 	case "net_peerCount":

rpc/args.go

@@ -467,7 +467,7 @@ func (args *BlockFilterArgs) UnmarshalJSON(b []byte) (err error) {
 
 	switch fromstr {
 	case "latest":
-		args.Earliest = 0
+		args.Earliest = -1
 	default:
 		args.Earliest = int64(common.Big(obj[0].FromBlock.(string)).Int64())
 	}
@@ -479,9 +479,9 @@ func (args *BlockFilterArgs) UnmarshalJSON(b []byte) (err error) {
 
 	switch tostr {
 	case "latest":
-		args.Latest = 0
-	case "pending":
 		args.Latest = -1
+	case "pending":
+		args.Latest = -2
 	default:
 		args.Latest = int64(common.Big(obj[0].ToBlock.(string)).Int64())
 	}
@@ -775,8 +775,7 @@ func (args *SubmitWorkArgs) UnmarshalJSON(b []byte) (err error) {
 		return NewDecodeParamError("Nonce is not a string")
 	}
 
-	args.Nonce = common.BytesToNumber(common.Hex2Bytes(objstr))
-
+	args.Nonce = common.String2Big(objstr).Uint64()
 	if objstr, ok = obj[1].(string); !ok {
 		return NewDecodeParamError("Header is not a string")
 	}

rpc/args_test.go

@@ -5,6 +5,8 @@ import (
 	"encoding/json"
 	"math/big"
 	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
 )
 
 func TestSha3(t *testing.T) {
@@ -440,8 +442,8 @@ func TestBlockFilterArgsWords(t *testing.T) {
   "toBlock": "pending"
   }]`
 	expected := new(BlockFilterArgs)
-	expected.Earliest = 0
-	expected.Latest = -1
+	expected.Earliest = -1
+	expected.Latest = -2
 
 	args := new(BlockFilterArgs)
 	if err := json.Unmarshal([]byte(input), &args); err != nil {
@@ -651,6 +653,10 @@ func TestFilterStringArgs(t *testing.T) {
 		t.Error(err)
 	}
 
+	if err := args.requirements(); err != nil {
+		t.Error(err)
+	}
+
 	if expected.Word != args.Word {
 		t.Errorf("Word shoud be %#v but is %#v", expected.Word, args.Word)
 	}
@@ -720,3 +726,28 @@ func TestHashIndexArgs(t *testing.T) {
 		t.Errorf("Index shoud be %#v but is %#v", expected.Index, args.Index)
 	}
 }
+
+func TestSubmitWorkArgs(t *testing.T) {
+	input := `["0x0000000000000001", "0x1234567890abcdef1234567890abcdef", "0xD1GE5700000000000000000000000000"]`
+	expected := new(SubmitWorkArgs)
+	expected.Nonce = 1
+	expected.Header = common.HexToHash("0x1234567890abcdef1234567890abcdef")
+	expected.Digest = common.HexToHash("0xD1GE5700000000000000000000000000")
+
+	args := new(SubmitWorkArgs)
+	if err := json.Unmarshal([]byte(input), &args); err != nil {
+		t.Error(err)
+	}
+
+	if expected.Nonce != args.Nonce {
+		t.Errorf("Nonce shoud be %d but is %d", expected.Nonce, args.Nonce)
+	}
+
+	if expected.Header != args.Header {
+		t.Errorf("Header shoud be %#v but is %#v", expected.Header, args.Header)
+	}
+
+	if expected.Digest != args.Digest {
+		t.Errorf("Digest shoud be %#v but is %#v", expected.Digest, args.Digest)
+	}
+}

tests/helper/init.go

@@ -7,7 +7,7 @@ import (
 	logpkg "github.com/ethereum/go-ethereum/logger"
 )
 
-var Logger logpkg.LogSystem
+var Logger *logpkg.StdLogSystem
 var Log = logpkg.NewLogger("TEST")
 
 func init() {

xeth/xeth.go

@@ -12,6 +12,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts"
 	"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/crypto"
 	"github.com/ethereum/go-ethereum/event"
@@ -19,7 +20,6 @@ import (
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/miner"
 	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/whisper"
 )
 
@@ -50,6 +50,8 @@ type Backend interface {
 	StartMining() error
 	StopMining()
 	Version() string
+	ProtocolVersion() int
+	NetworkId() int
 }
 
 // Frontend should be implemented by users of XEth. Its methods are