status-im
/
op-geth
mirror of https://github.com/status-im/op-geth.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

This commit is contained in:
obscuren 2015-03-23 18:30:11 +01:00
parent c8e9ca0483 90c710fd26
commit f2f65c1a65
10 changed files with 74 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
cmd/ethereum/js.go
View File

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

9
cmd/ethtest/main.go
View File

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

27
eth/backend.go
View File

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

12
logger/logsystem.go
View File

@ -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))
}

7
p2p/testlog_test.go
View File

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

6
rpc/api.go
View File

@ -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":

9
rpc/args.go
View File

@ -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")
}

35
rpc/args_test.go
View File

@ -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)
}
}

2
tests/helper/init.go
View File

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

4
xeth/xeth.go
View File

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