diff --git a/README.md b/README.md index 0200a57d50..22b331cbd2 100644 --- a/README.md +++ b/README.md @@ -20,7 +20,7 @@ Mist (GUI): `go get github.com/ethereum/go-ethereum/cmd/mist` -Ethereum (CLI): +Geth (CLI): `go get github.com/ethereum/go-ethereum/cmd/ethereum` @@ -32,10 +32,10 @@ Mist (GUI): godep go build -v ./cmd/mist ``` -Ethereum (CLI): +Geth (CLI): ``` -godep go build -v ./cmd/ethereum +godep go build -v ./cmd/geth ``` Instead of `build`, you can use `install` which will also install the resulting binary. @@ -61,7 +61,7 @@ Go Ethereum comes with several wrappers/executables found in [the `cmd` directory](https://github.com/ethereum/go-ethereum/tree/develop/cmd): * `mist` Official Ethereum Browser (ethereum GUI client) -* `ethereum` Ethereum CLI (ethereum command line interface client) +* `geth` Ethereum CLI (ethereum command line interface client) * `bootnode` runs a bootstrap node for the Discovery Protocol * `ethtest` test tool which runs with the [tests](https://github.com/ethereum/testes) suite: `cat file | ethtest`. @@ -73,12 +73,12 @@ Go Ethereum comes with several wrappers/executables found in Command line options ============================ -Both `mist` and `ethereum` can be configured via command line options, environment variables and config files. +Both `mist` and `geth` can be configured via command line options, environment variables and config files. To get the options available: ``` -ethereum -help +geth -help ``` For further details on options, see the [wiki](https://github.com/ethereum/go-ethereum/wiki/Command-Line-Options) diff --git a/accounts/account_manager.go b/accounts/account_manager.go index 34a2c48910..e9eb8f8165 100644 --- a/accounts/account_manager.go +++ b/accounts/account_manager.go @@ -81,13 +81,7 @@ func (am *Manager) HasAccount(addr []byte) bool { return false } -// Coinbase returns the account address that mining rewards are sent to. -func (am *Manager) Coinbase() (addr []byte, err error) { - // TODO: persist coinbase address on disk - return am.firstAddr() -} - -func (am *Manager) firstAddr() ([]byte, error) { +func (am *Manager) Primary() (addr []byte, err error) { addrs, err := am.keyStore.GetKeyAddresses() if os.IsNotExist(err) { return nil, ErrNoKeys diff --git a/cmd/geth/admin.go b/cmd/geth/admin.go index 139395dad9..3a58b88814 100644 --- a/cmd/geth/admin.go +++ b/cmd/geth/admin.go @@ -9,10 +9,10 @@ import ( "github.com/ethereum/go-ethereum/cmd/utils" "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/rlp" "github.com/ethereum/go-ethereum/rpc" - "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/xeth" "github.com/robertkrimen/otto" ) @@ -69,14 +69,13 @@ func (js *jsre) startRPC(call otto.FunctionCall) otto.Value { fmt.Println(err) return otto.FalseValue() } - dataDir := js.ethereum.DataDir l, err := net.Listen("tcp", fmt.Sprintf("%s:%d", addr, port)) if err != nil { fmt.Printf("Can't listen on %s:%d: %v", addr, port, err) return otto.FalseValue() } - go http.Serve(l, rpc.JSONRPC(xeth.New(js.ethereum, nil), dataDir)) + go http.Serve(l, rpc.JSONRPC(xeth.New(js.ethereum, nil))) return otto.TrueValue() } diff --git a/cmd/geth/js.go b/cmd/geth/js.go index 8e88a1c543..59a8469fa3 100644 --- a/cmd/geth/js.go +++ b/cmd/geth/js.go @@ -91,8 +91,7 @@ func newJSRE(ethereum *eth.Ethereum, libPath string, interactive bool) *jsre { func (js *jsre) apiBindings() { - ethApi := rpc.NewEthereumApi(js.xeth, js.ethereum.DataDir) - ethApi.Close() + ethApi := rpc.NewEthereumApi(js.xeth) //js.re.Bind("jeth", rpc.NewJeth(ethApi, js.re.ToVal)) jeth := rpc.NewJeth(ethApi, js.re.ToVal, js.re) diff --git a/cmd/geth/main.go b/cmd/geth/main.go index da505218bc..05e2e4ae65 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -221,6 +221,7 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso utils.LogJSONFlag, utils.LogLevelFlag, utils.MaxPeersFlag, + utils.EtherbaseFlag, utils.MinerThreadsFlag, utils.MiningEnabledFlag, utils.NATFlag, @@ -322,10 +323,10 @@ func startEth(ctx *cli.Context, eth *eth.Ethereum) { account := ctx.GlobalString(utils.UnlockedAccountFlag.Name) if len(account) > 0 { - if account == "coinbase" { - accbytes, err := am.Coinbase() + if account == "primary" { + accbytes, err := am.Primary() if err != nil { - utils.Fatalf("no coinbase account: %v", err) + utils.Fatalf("no primary account: %v", err) } account = common.ToHex(accbytes) } @@ -468,7 +469,6 @@ func dump(ctx *cli.Context) { } else { statedb := state.New(block.Root(), stateDb) fmt.Printf("%s\n", statedb.Dump()) - // fmt.Println(block) } } } diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index f948cdb06b..2a3e2f4476 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -96,10 +96,15 @@ var ( Name: "mine", Usage: "Enable mining", } + EtherbaseFlag = cli.StringFlag{ + Name: "etherbase", + Usage: "public address for block mining rewards. By default the address of your primary account is used", + Value: "primary", + } UnlockedAccountFlag = cli.StringFlag{ Name: "unlock", - Usage: "unlock the account given until this program exits (prompts for password). '--unlock coinbase' unlocks the primary (coinbase) account", + Usage: "unlock the account given until this program exits (prompts for password). '--unlock primary' unlocks the primary account", Value: "", } PasswordFileFlag = cli.StringFlag{ @@ -215,6 +220,7 @@ func MakeEthConfig(clientID, version string, ctx *cli.Context) *eth.Config { LogFile: ctx.GlobalString(LogFileFlag.Name), LogLevel: ctx.GlobalInt(LogLevelFlag.Name), LogJSON: ctx.GlobalString(LogJSONFlag.Name), + Etherbase: ctx.GlobalString(EtherbaseFlag.Name), MinerThreads: ctx.GlobalInt(MinerThreadsFlag.Name), AccountManager: GetAccountManager(ctx), VmDebug: ctx.GlobalBool(VMDebugFlag.Name), @@ -251,11 +257,10 @@ func GetAccountManager(ctx *cli.Context) *accounts.Manager { func StartRPC(eth *eth.Ethereum, ctx *cli.Context) { addr := ctx.GlobalString(RPCListenAddrFlag.Name) port := ctx.GlobalInt(RPCPortFlag.Name) - dataDir := ctx.GlobalString(DataDirFlag.Name) fmt.Println("Starting RPC on port: ", port) l, err := net.Listen("tcp", fmt.Sprintf("%s:%d", addr, port)) if err != nil { Fatalf("Can't listen on %s:%d: %v", addr, port, err) } - go http.Serve(l, rpc.JSONRPC(xeth.New(eth, nil), dataDir)) + go http.Serve(l, rpc.JSONRPC(xeth.New(eth, nil))) } diff --git a/eth/backend.go b/eth/backend.go index c73e767921..fed0da0169 100644 --- a/eth/backend.go +++ b/eth/backend.go @@ -63,6 +63,7 @@ type Config struct { Shh bool Dial bool + Etherbase string MinerThreads int AccountManager *accounts.Manager @@ -140,6 +141,7 @@ type Ethereum struct { Mining bool DataDir string + etherbase common.Address clientVersion string ethVersionId int netVersionId int @@ -185,6 +187,7 @@ func New(config *Config) (*Ethereum, error) { eventMux: &event.TypeMux{}, accountManager: config.AccountManager, DataDir: config.DataDir, + etherbase: common.HexToAddress(config.Etherbase), clientVersion: config.Name, // TODO should separate from Name ethVersionId: config.ProtocolVersion, netVersionId: config.NetworkId, @@ -297,15 +300,31 @@ func (s *Ethereum) ResetWithGenesisBlock(gb *types.Block) { } func (s *Ethereum) StartMining() error { - cb, err := s.accountManager.Coinbase() + eb, err := s.Etherbase() if err != nil { - servlogger.Errorf("Cannot start mining without coinbase: %v\n", err) - return fmt.Errorf("no coinbase: %v", err) + err = fmt.Errorf("Cannot start mining without etherbase address: %v", err) + servlogger.Errorln(err) + return err + } - s.miner.Start(common.BytesToAddress(cb)) + + s.miner.Start(eb) return nil } +func (s *Ethereum) Etherbase() (eb common.Address, err error) { + eb = s.etherbase + if (eb == common.Address{}) { + var ebbytes []byte + ebbytes, err = s.accountManager.Primary() + eb = common.BytesToAddress(ebbytes) + if (eb == common.Address{}) { + err = fmt.Errorf("no accounts found") + } + } + return +} + func (s *Ethereum) StopMining() { s.miner.Stop() } func (s *Ethereum) IsMining() bool { return s.miner.Mining() } func (s *Ethereum) Miner() *miner.Miner { return s.miner } diff --git a/rpc/api.go b/rpc/api.go index 534b6fc5d4..f755f07bd9 100644 --- a/rpc/api.go +++ b/rpc/api.go @@ -3,13 +3,11 @@ package rpc import ( "encoding/json" "math/big" - "path" "sync" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/xeth" ) @@ -19,15 +17,9 @@ type EthereumApi struct { db common.Database } -func NewEthereumApi(xeth *xeth.XEth, dataDir string) *EthereumApi { - // What about when dataDir is empty? - db, err := ethdb.NewLDBDatabase(path.Join(dataDir, "dapps")) - if err != nil { - panic(err) - } +func NewEthereumApi(xeth *xeth.XEth) *EthereumApi { api := &EthereumApi{ eth: xeth, - db: db, } return api @@ -44,10 +36,6 @@ 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/JSON-RPC rpclogger.Debugf("%s %s", req.Method, req.Params) @@ -343,7 +331,8 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err return err } - api.db.Put([]byte(args.Database+args.Key), args.Value) + api.xeth().DbPut([]byte(args.Database+args.Key), args.Value) + *reply = true case "db_getString": args := new(DbArgs) @@ -355,7 +344,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err return err } - res, _ := api.db.Get([]byte(args.Database + args.Key)) + res, _ := api.xeth().DbGet([]byte(args.Database + args.Key)) *reply = string(res) case "db_putHex": args := new(DbHexArgs) @@ -367,7 +356,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err return err } - api.db.Put([]byte(args.Database+args.Key), args.Value) + api.xeth().DbPut([]byte(args.Database+args.Key), args.Value) *reply = true case "db_getHex": args := new(DbHexArgs) @@ -379,7 +368,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err return err } - res, _ := api.db.Get([]byte(args.Database + args.Key)) + res, _ := api.xeth().DbGet([]byte(args.Database + args.Key)) *reply = common.ToHex(res) case "shh_version": *reply = api.xeth().WhisperVersion() diff --git a/rpc/api_test.go b/rpc/api_test.go index a00c2f3f1e..ac9b67fac8 100644 --- a/rpc/api_test.go +++ b/rpc/api_test.go @@ -6,7 +6,7 @@ import ( "testing" // "time" - "github.com/ethereum/go-ethereum/xeth" + // "github.com/ethereum/go-ethereum/xeth" ) func TestWeb3Sha3(t *testing.T) { @@ -26,49 +26,48 @@ func TestWeb3Sha3(t *testing.T) { } } -func TestDbStr(t *testing.T) { - jsonput := `{"jsonrpc":"2.0","method":"db_putString","params":["testDB","myKey","myString"],"id":64}` - jsonget := `{"jsonrpc":"2.0","method":"db_getString","params":["testDB","myKey"],"id":64}` - expected := "myString" +// func TestDbStr(t *testing.T) { +// jsonput := `{"jsonrpc":"2.0","method":"db_putString","params":["testDB","myKey","myString"],"id":64}` +// jsonget := `{"jsonrpc":"2.0","method":"db_getString","params":["testDB","myKey"],"id":64}` +// expected := "myString" - xeth := &xeth.XEth{} - api := NewEthereumApi(xeth, "") - defer api.db.Close() - var response interface{} +// xeth := &xeth.XEth{} +// api := NewEthereumApi(xeth) +// var response interface{} - var req RpcRequest - json.Unmarshal([]byte(jsonput), &req) - _ = api.GetRequestReply(&req, &response) +// var req RpcRequest +// json.Unmarshal([]byte(jsonput), &req) +// _ = api.GetRequestReply(&req, &response) - json.Unmarshal([]byte(jsonget), &req) - _ = api.GetRequestReply(&req, &response) +// json.Unmarshal([]byte(jsonget), &req) +// _ = api.GetRequestReply(&req, &response) - if response.(string) != expected { - t.Errorf("Expected %s got %s", expected, response) - } -} +// if response.(string) != expected { +// t.Errorf("Expected %s got %s", expected, response) +// } +// } -func TestDbHexStr(t *testing.T) { - jsonput := `{"jsonrpc":"2.0","method":"db_putHex","params":["testDB","beefKey","0xbeef"],"id":64}` - jsonget := `{"jsonrpc":"2.0","method":"db_getHex","params":["testDB","beefKey"],"id":64}` - expected := "0xbeef" +// func TestDbHexStr(t *testing.T) { +// jsonput := `{"jsonrpc":"2.0","method":"db_putHex","params":["testDB","beefKey","0xbeef"],"id":64}` +// jsonget := `{"jsonrpc":"2.0","method":"db_getHex","params":["testDB","beefKey"],"id":64}` +// expected := "0xbeef" - xeth := &xeth.XEth{} - api := NewEthereumApi(xeth, "") - defer api.db.Close() - var response interface{} +// xeth := &xeth.XEth{} +// api := NewEthereumApi(xeth) +// defer api.db.Close() +// var response interface{} - var req RpcRequest - json.Unmarshal([]byte(jsonput), &req) - _ = api.GetRequestReply(&req, &response) +// var req RpcRequest +// json.Unmarshal([]byte(jsonput), &req) +// _ = api.GetRequestReply(&req, &response) - json.Unmarshal([]byte(jsonget), &req) - _ = api.GetRequestReply(&req, &response) +// json.Unmarshal([]byte(jsonget), &req) +// _ = api.GetRequestReply(&req, &response) - if response.(string) != expected { - t.Errorf("Expected %s got %s", expected, response) - } -} +// if response.(string) != expected { +// t.Errorf("Expected %s got %s", expected, response) +// } +// } // func TestFilterClose(t *testing.T) { // t.Skip() diff --git a/rpc/http.go b/rpc/http.go index 3dfb677815..879ffce3b9 100644 --- a/rpc/http.go +++ b/rpc/http.go @@ -18,8 +18,8 @@ const ( ) // JSONRPC returns a handler that implements the Ethereum JSON-RPC API. -func JSONRPC(pipe *xeth.XEth, dataDir string) http.Handler { - api := NewEthereumApi(pipe, dataDir) +func JSONRPC(pipe *xeth.XEth) http.Handler { + api := NewEthereumApi(pipe) return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { // TODO this needs to be configurable diff --git a/rpc/responses.go b/rpc/responses.go index 993f467eaf..f5f3a33f3d 100644 --- a/rpc/responses.go +++ b/rpc/responses.go @@ -6,14 +6,14 @@ import ( "math/big" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" ) type BlockRes struct { fullTx bool - BlockNumber int64 `json:"number"` + BlockNumber *big.Int `json:"number"` BlockHash common.Hash `json:"hash"` ParentHash common.Hash `json:"parentHash"` Nonce [8]byte `json:"nonce"` @@ -22,13 +22,13 @@ type BlockRes struct { TransactionRoot common.Hash `json:"transactionRoot"` StateRoot common.Hash `json:"stateRoot"` Miner common.Address `json:"miner"` - Difficulty int64 `json:"difficulty"` - TotalDifficulty int64 `json:"totalDifficulty"` - Size int64 `json:"size"` + Difficulty *big.Int `json:"difficulty"` + TotalDifficulty *big.Int `json:"totalDifficulty"` + Size *big.Int `json:"size"` ExtraData []byte `json:"extraData"` - GasLimit int64 `json:"gasLimit"` + GasLimit *big.Int `json:"gasLimit"` MinGasPrice int64 `json:"minGasPrice"` - GasUsed int64 `json:"gasUsed"` + GasUsed *big.Int `json:"gasUsed"` UnixTimestamp int64 `json:"timestamp"` Transactions []*TransactionRes `json:"transactions"` Uncles []common.Hash `json:"uncles"` @@ -58,7 +58,7 @@ func (b *BlockRes) MarshalJSON() ([]byte, error) { } // convert strict types to hexified strings - ext.BlockNumber = common.ToHex(big.NewInt(b.BlockNumber).Bytes()) + ext.BlockNumber = common.ToHex(b.BlockNumber.Bytes()) ext.BlockHash = b.BlockHash.Hex() ext.ParentHash = b.ParentHash.Hex() ext.Nonce = common.ToHex(b.Nonce[:]) @@ -67,13 +67,13 @@ func (b *BlockRes) MarshalJSON() ([]byte, error) { ext.TransactionRoot = b.TransactionRoot.Hex() ext.StateRoot = b.StateRoot.Hex() ext.Miner = b.Miner.Hex() - ext.Difficulty = common.ToHex(big.NewInt(b.Difficulty).Bytes()) - ext.TotalDifficulty = common.ToHex(big.NewInt(b.TotalDifficulty).Bytes()) - ext.Size = common.ToHex(big.NewInt(b.Size).Bytes()) + ext.Difficulty = common.ToHex(b.Difficulty.Bytes()) + ext.TotalDifficulty = common.ToHex(b.TotalDifficulty.Bytes()) + ext.Size = common.ToHex(b.Size.Bytes()) // ext.ExtraData = common.ToHex(b.ExtraData) - ext.GasLimit = common.ToHex(big.NewInt(b.GasLimit).Bytes()) + ext.GasLimit = common.ToHex(b.GasLimit.Bytes()) // ext.MinGasPrice = common.ToHex(big.NewInt(b.MinGasPrice).Bytes()) - ext.GasUsed = common.ToHex(big.NewInt(b.GasUsed).Bytes()) + ext.GasUsed = common.ToHex(b.GasUsed.Bytes()) ext.UnixTimestamp = common.ToHex(big.NewInt(b.UnixTimestamp).Bytes()) ext.Transactions = make([]interface{}, len(b.Transactions)) if b.fullTx { @@ -99,7 +99,7 @@ func NewBlockRes(block *types.Block) *BlockRes { } res := new(BlockRes) - res.BlockNumber = block.Number().Int64() + res.BlockNumber = block.Number() res.BlockHash = block.Hash() res.ParentHash = block.ParentHash() res.Nonce = block.Header().Nonce @@ -108,15 +108,13 @@ func NewBlockRes(block *types.Block) *BlockRes { res.TransactionRoot = block.Header().TxHash res.StateRoot = block.Root() res.Miner = block.Header().Coinbase - res.Difficulty = block.Difficulty().Int64() - if block.Td != nil { - res.TotalDifficulty = block.Td.Int64() - } - res.Size = int64(block.Size()) + res.Difficulty = block.Difficulty() + res.TotalDifficulty = block.Td + res.Size = big.NewInt(int64(block.Size())) // res.ExtraData = - res.GasLimit = block.GasLimit().Int64() + res.GasLimit = block.GasLimit() // res.MinGasPrice = - res.GasUsed = block.GasUsed().Int64() + res.GasUsed = block.GasUsed() res.UnixTimestamp = block.Time() res.Transactions = make([]*TransactionRes, len(block.Transactions())) for i, tx := range block.Transactions() { @@ -135,47 +133,47 @@ func NewBlockRes(block *types.Block) *BlockRes { type TransactionRes struct { Hash common.Hash `json:"hash"` - Nonce int64 `json:"nonce"` + Nonce uint64 `json:"nonce"` BlockHash common.Hash `json:"blockHash,omitempty"` BlockNumber int64 `json:"blockNumber,omitempty"` TxIndex int64 `json:"transactionIndex,omitempty"` From common.Address `json:"from"` To *common.Address `json:"to"` - Value int64 `json:"value"` - Gas int64 `json:"gas"` - GasPrice int64 `json:"gasPrice"` + Value *big.Int `json:"value"` + Gas *big.Int `json:"gas"` + GasPrice *big.Int `json:"gasPrice"` Input []byte `json:"input"` } func (t *TransactionRes) MarshalJSON() ([]byte, error) { var ext struct { - Hash string `json:"hash"` - Nonce string `json:"nonce"` - BlockHash string `json:"blockHash,omitempty"` - BlockNumber string `json:"blockNumber,omitempty"` - TxIndex string `json:"transactionIndex,omitempty"` - From string `json:"from"` - To string `json:"to"` - Value string `json:"value"` - Gas string `json:"gas"` - GasPrice string `json:"gasPrice"` - Input string `json:"input"` + Hash string `json:"hash"` + Nonce string `json:"nonce"` + BlockHash string `json:"blockHash,omitempty"` + BlockNumber string `json:"blockNumber,omitempty"` + TxIndex string `json:"transactionIndex,omitempty"` + From string `json:"from"` + To interface{} `json:"to"` + Value string `json:"value"` + Gas string `json:"gas"` + GasPrice string `json:"gasPrice"` + Input string `json:"input"` } ext.Hash = t.Hash.Hex() - ext.Nonce = common.ToHex(big.NewInt(t.Nonce).Bytes()) + ext.Nonce = common.ToHex(big.NewInt(int64(t.Nonce)).Bytes()) ext.BlockHash = t.BlockHash.Hex() ext.BlockNumber = common.ToHex(big.NewInt(t.BlockNumber).Bytes()) ext.TxIndex = common.ToHex(big.NewInt(t.TxIndex).Bytes()) ext.From = t.From.Hex() if t.To == nil { - ext.To = "0x00" + ext.To = nil } else { ext.To = t.To.Hex() } - ext.Value = common.ToHex(big.NewInt(t.Value).Bytes()) - ext.Gas = common.ToHex(big.NewInt(t.Gas).Bytes()) - ext.GasPrice = common.ToHex(big.NewInt(t.GasPrice).Bytes()) + ext.Value = common.ToHex(t.Value.Bytes()) + ext.Gas = common.ToHex(t.Gas.Bytes()) + ext.GasPrice = common.ToHex(t.GasPrice.Bytes()) ext.Input = common.ToHex(t.Input) return json.Marshal(ext) @@ -184,12 +182,12 @@ func (t *TransactionRes) MarshalJSON() ([]byte, error) { func NewTransactionRes(tx *types.Transaction) *TransactionRes { var v = new(TransactionRes) v.Hash = tx.Hash() - v.Nonce = int64(tx.Nonce()) + v.Nonce = tx.Nonce() v.From, _ = tx.From() v.To = tx.To() - v.Value = tx.Value().Int64() - v.Gas = tx.Gas().Int64() - v.GasPrice = tx.GasPrice().Int64() + v.Value = tx.Value() + v.Gas = tx.Gas() + v.GasPrice = tx.GasPrice() v.Input = tx.Data() return v } @@ -218,25 +216,48 @@ type FilterWhisperRes struct { } type LogRes struct { - Address string `json:"address"` - Topics []string `json:"topics"` - Data string `json:"data"` - Number uint64 `json:"number"` + Address common.Address `json:"address"` + Topics []common.Hash `json:"topics"` + Data []byte `json:"data"` + Number uint64 `json:"number"` +} + +func NewLogRes(log state.Log) LogRes { + var l LogRes + l.Topics = make([]common.Hash, len(log.Topics())) + l.Address = log.Address() + l.Data = log.Data() + l.Number = log.Number() + for j, topic := range log.Topics() { + l.Topics[j] = topic + } + return l +} + +func (l *LogRes) MarshalJSON() ([]byte, error) { + var ext struct { + Address string `json:"address"` + Topics []string `json:"topics"` + Data string `json:"data"` + Number string `json:"number"` + } + + ext.Address = l.Address.Hex() + ext.Data = common.Bytes2Hex(l.Data) + ext.Number = common.Bytes2Hex(big.NewInt(int64(l.Number)).Bytes()) + ext.Topics = make([]string, len(l.Topics)) + for i, v := range l.Topics { + ext.Topics[i] = v.Hex() + } + + return json.Marshal(ext) } func NewLogsRes(logs state.Logs) (ls []LogRes) { ls = make([]LogRes, len(logs)) for i, log := range logs { - var l LogRes - l.Topics = make([]string, len(log.Topics())) - l.Address = log.Address().Hex() - l.Data = common.ToHex(log.Data()) - l.Number = log.Number() - for j, topic := range log.Topics() { - l.Topics[j] = topic.Hex() - } - ls[i] = l + ls[i] = NewLogRes(log) } return diff --git a/rpc/responses_test.go b/rpc/responses_test.go new file mode 100644 index 0000000000..2789398307 --- /dev/null +++ b/rpc/responses_test.go @@ -0,0 +1,123 @@ +package rpc + +import ( + "encoding/json" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" +) + +func TestNewBlockRes(t *testing.T) { + parentHash := common.HexToHash("0x01") + coinbase := common.HexToAddress("0x01") + root := common.HexToHash("0x01") + difficulty := common.Big1 + nonce := uint64(1) + extra := "" + block := types.NewBlock(parentHash, coinbase, root, difficulty, nonce, extra) + + _ = NewBlockRes(block) +} + +func TestBlockRes(t *testing.T) { + v := &BlockRes{ + BlockNumber: big.NewInt(0), + BlockHash: common.HexToHash("0x0"), + ParentHash: common.HexToHash("0x0"), + Nonce: [8]byte{0, 0, 0, 0, 0, 0, 0, 0}, + Sha3Uncles: common.HexToHash("0x0"), + LogsBloom: types.BytesToBloom([]byte{0}), + TransactionRoot: common.HexToHash("0x0"), + StateRoot: common.HexToHash("0x0"), + Miner: common.HexToAddress("0x0"), + Difficulty: big.NewInt(0), + TotalDifficulty: big.NewInt(0), + Size: big.NewInt(0), + ExtraData: []byte{}, + GasLimit: big.NewInt(0), + MinGasPrice: int64(0), + GasUsed: big.NewInt(0), + UnixTimestamp: int64(0), + // Transactions []*TransactionRes `json:"transactions"` + // Uncles []common.Hash `json:"uncles"` + } + + _, _ = json.Marshal(v) + + // fmt.Println(string(j)) + +} + +func TestTransactionRes(t *testing.T) { + a := common.HexToAddress("0x0") + v := &TransactionRes{ + Hash: common.HexToHash("0x0"), + Nonce: uint64(0), + BlockHash: common.HexToHash("0x0"), + BlockNumber: int64(0), + TxIndex: int64(0), + From: common.HexToAddress("0x0"), + To: &a, + Value: big.NewInt(0), + Gas: big.NewInt(0), + GasPrice: big.NewInt(0), + Input: []byte{0}, + } + + _, _ = json.Marshal(v) +} + +func TestNewTransactionRes(t *testing.T) { + to := common.HexToAddress("0x02") + amount := big.NewInt(1) + gasAmount := big.NewInt(1) + gasPrice := big.NewInt(1) + data := []byte{1, 2, 3} + tx := types.NewTransactionMessage(to, amount, gasAmount, gasPrice, data) + + _ = NewTransactionRes(tx) +} + +func TestLogRes(t *testing.T) { + topics := make([]common.Hash, 3) + topics = append(topics, common.HexToHash("0x00")) + topics = append(topics, common.HexToHash("0x10")) + topics = append(topics, common.HexToHash("0x20")) + + v := &LogRes{ + Topics: topics, + Address: common.HexToAddress("0x0"), + Data: []byte{1, 2, 3}, + Number: uint64(5), + } + + _, _ = json.Marshal(v) +} + +func MakeStateLog(num int) state.Log { + address := common.HexToAddress("0x0") + data := []byte{1, 2, 3} + number := uint64(num) + topics := make([]common.Hash, 3) + topics = append(topics, common.HexToHash("0x00")) + topics = append(topics, common.HexToHash("0x10")) + topics = append(topics, common.HexToHash("0x20")) + log := state.NewLog(address, topics, data, number) + return log +} + +func TestNewLogRes(t *testing.T) { + log := MakeStateLog(0) + _ = NewLogRes(log) +} + +func TestNewLogsRes(t *testing.T) { + logs := make([]state.Log, 3) + logs[0] = MakeStateLog(1) + logs[1] = MakeStateLog(2) + logs[2] = MakeStateLog(3) + _ = NewLogsRes(logs) +} diff --git a/xeth/xeth.go b/xeth/xeth.go index 445303997e..5bb271591f 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -209,6 +209,16 @@ func (self *XEth) Accounts() []string { return accountAddresses } +func (self *XEth) DbPut(key, val []byte) bool { + self.backend.ExtraDb().Put(key, val) + return true +} + +func (self *XEth) DbGet(key []byte) ([]byte, error) { + val, err := self.backend.ExtraDb().Get(key) + return val, err +} + func (self *XEth) PeerCount() int { return self.backend.PeerCount() } @@ -250,8 +260,8 @@ func (self *XEth) IsListening() bool { } func (self *XEth) Coinbase() string { - cb, _ := self.backend.AccountManager().Coinbase() - return common.ToHex(cb) + eb, _ := self.backend.Etherbase() + return eb.Hex() } func (self *XEth) NumberToHuman(balance string) string {