diff --git a/ethchain/block.go b/ethchain/block.go
index 0fb01ea5b9639d99ba314733c681d0d8f9cb743e..fc7c6b13fb012184d45f7e2881e192af0473b3e1 100644
--- a/ethchain/block.go
+++ b/ethchain/block.go
@@ -130,7 +130,7 @@ func CreateBlock(root interface{},
Nonce: Nonce,
Time: time.Now().Unix(),
Extra: extra,
- UncleSha: EmptyShaList,
+ UncleSha: EmptyShaList, //nil,
GasUsed: new(big.Int),
MinGasPrice: new(big.Int),
GasLimit: new(big.Int),
@@ -237,7 +237,9 @@ func (block *Block) SetUncles(uncles []*Block) {
block.Uncles = uncles
// Sha of the concatenated uncles
- block.UncleSha = ethcrypto.Sha3(ethutil.Encode(block.rlpUncles()))
+ //if len(uncles) > 0 {
+ // block.UncleSha = ethcrypto.Sha3(ethutil.Encode(block.rlpUncles()))
+ //}
}
func (self *Block) SetReceipts(receipts []*Receipt, txs []*Transaction) {
diff --git a/ethchain/genesis.go b/ethchain/genesis.go
index 3edbf32de5c25eeeb16dca40f151e449fdbe0985..ab6469bb4dc9c45fdc00ed1fffc24d336342c73c 100644
--- a/ethchain/genesis.go
+++ b/ethchain/genesis.go
@@ -18,8 +18,9 @@ var EmptyShaList = ethcrypto.Sha3(ethutil.Encode([]interface{}{}))
var GenesisHeader = []interface{}{
// Previous hash (none)
ZeroHash256,
- // Sha of uncles
ethcrypto.Sha3(ethutil.Encode([]interface{}{})),
+ // Empty uncles
+ //"",
// Coinbase
ZeroHash160,
// Root state
diff --git a/ethereum.go b/ethereum.go
index bb8d6db73cb7d3220bc7c5cb459a254a94a10a85..5209115daa0f13b438f360daef538d78006cd8dd 100644
--- a/ethereum.go
+++ b/ethereum.go
@@ -17,16 +17,16 @@ import (
"github.com/ethereum/eth-go/ethchain"
"github.com/ethereum/eth-go/ethcrypto"
"github.com/ethereum/eth-go/ethlog"
- "github.com/ethereum/eth-go/ethrpc"
"github.com/ethereum/eth-go/ethstate"
"github.com/ethereum/eth-go/ethutil"
"github.com/ethereum/eth-go/ethwire"
"github.com/ethereum/eth-go/event"
+ "github.com/ethereum/eth-go/rpc"
)
const (
seedTextFileUri string = "http://www.ethereum.org/servers.poc3.txt"
- seedNodeAddress = "poc-6.ethdev.com:30303"
+ seedNodeAddress = "poc-7.ethdev.com:30303"
)
var ethlogger = ethlog.NewLogger("SERV")
@@ -84,7 +84,7 @@ type Ethereum struct {
listening bool
- RpcServer *ethrpc.JsonRpcServer
+ RpcServer *rpc.JsonRpcServer
keyManager *ethcrypto.KeyManager
diff --git a/ethrpc/packages.go b/ethrpc/packages.go
deleted file mode 100644
index 087167a422be54317ae83e78b589fd4d753cb4a4..0000000000000000000000000000000000000000
--- a/ethrpc/packages.go
+++ /dev/null
@@ -1,311 +0,0 @@
-package ethrpc
-
-import (
- "encoding/json"
- "errors"
- "math/big"
- "strings"
-
- "github.com/ethereum/eth-go/ethpipe"
- "github.com/ethereum/eth-go/ethutil"
-)
-
-type EthereumApi struct {
- pipe *ethpipe.JSPipe
-}
-
-type JsonArgs interface {
- requirements() error
-}
-
-type BlockResponse struct {
- JsonResponse
-}
-type GetBlockArgs struct {
- BlockNumber int
- Hash string
-}
-
-type ErrorResponse struct {
- Error bool `json:"error"`
- ErrorText string `json:"errorText"`
-}
-
-type JsonResponse interface {
-}
-
-type SuccessRes struct {
- Error bool `json:"error"`
- Result JsonResponse `json:"result"`
-}
-
-func NewSuccessRes(object JsonResponse) string {
- e := SuccessRes{Error: false, Result: object}
- res, err := json.Marshal(e)
- if err != nil {
- // This should never happen
- panic("Creating json error response failed, help")
- }
- success := string(res)
- return success
-}
-
-func NewErrorResponse(msg string) error {
- e := ErrorResponse{Error: true, ErrorText: msg}
- res, err := json.Marshal(e)
- if err != nil {
- // This should never happen
- panic("Creating json error response failed, help")
- }
- newErr := errors.New(string(res))
- return newErr
-}
-
-func (b *GetBlockArgs) requirements() error {
- if b.BlockNumber == 0 && b.Hash == "" {
- return NewErrorResponse("GetBlock requires either a block 'number' or a block 'hash' as argument")
- }
- return nil
-}
-
-func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *string) error {
- err := args.requirements()
- if err != nil {
- return err
- }
-
- block := p.pipe.BlockByHash(args.Hash)
- *reply = NewSuccessRes(block)
- return nil
-}
-
-type NewTxArgs struct {
- Sec string
- Recipient string
- Value string
- Gas string
- GasPrice string
- Init string
- Body string
-}
-type TxResponse struct {
- Hash string
-}
-
-func (a *NewTxArgs) requirements() error {
- if a.Recipient == "" {
- return NewErrorResponse("Transact requires a 'recipient' address as argument")
- }
- if a.Value == "" {
- return NewErrorResponse("Transact requires a 'value' as argument")
- }
- if a.Gas == "" {
- return NewErrorResponse("Transact requires a 'gas' value as argument")
- }
- if a.GasPrice == "" {
- return NewErrorResponse("Transact requires a 'gasprice' value as argument")
- }
- return nil
-}
-
-func (a *NewTxArgs) requirementsContract() error {
- if a.Value == "" {
- return NewErrorResponse("Create requires a 'value' as argument")
- }
- if a.Gas == "" {
- return NewErrorResponse("Create requires a 'gas' value as argument")
- }
- if a.GasPrice == "" {
- return NewErrorResponse("Create requires a 'gasprice' value as argument")
- }
- if a.Body == "" {
- return NewErrorResponse("Create requires a 'body' value as argument")
- }
- return nil
-}
-
-func (p *EthereumApi) Transact(args *NewTxArgs, reply *string) error {
- err := args.requirements()
- if err != nil {
- return err
- }
- result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, args.Recipient, args.Value, args.Gas, args.GasPrice, args.Body)
- *reply = NewSuccessRes(result)
- return nil
-}
-
-func (p *EthereumApi) Create(args *NewTxArgs, reply *string) error {
- err := args.requirementsContract()
- if err != nil {
- return err
- }
-
- result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, "", args.Value, args.Gas, args.GasPrice, args.Body)
- *reply = NewSuccessRes(result)
- return nil
-}
-
-type PushTxArgs struct {
- Tx string
-}
-
-func (a *PushTxArgs) requirementsPushTx() error {
- if a.Tx == "" {
- return NewErrorResponse("PushTx requires a 'tx' as argument")
- }
- return nil
-}
-
-func (p *EthereumApi) PushTx(args *PushTxArgs, reply *string) error {
- err := args.requirementsPushTx()
- if err != nil {
- return err
- }
- result, _ := p.pipe.PushTx(args.Tx)
- *reply = NewSuccessRes(result)
- return nil
-}
-
-func (p *EthereumApi) GetKey(args interface{}, reply *string) error {
- *reply = NewSuccessRes(p.pipe.Key())
- return nil
-}
-
-type GetStorageArgs struct {
- Address string
- Key string
-}
-
-func (a *GetStorageArgs) requirements() error {
- if a.Address == "" {
- return NewErrorResponse("GetStorageAt requires an 'address' value as argument")
- }
- if a.Key == "" {
- return NewErrorResponse("GetStorageAt requires an 'key' value as argument")
- }
- return nil
-}
-
-type GetStorageAtRes struct {
- Key string `json:"key"`
- Value string `json:"value"`
- Address string `json:"address"`
-}
-
-func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *string) error {
- err := args.requirements()
- if err != nil {
- return err
- }
-
- state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
-
- var hx string
- if strings.Index(args.Key, "0x") == 0 {
- hx = string([]byte(args.Key)[2:])
- } else {
- // Convert the incoming string (which is a bigint) into hex
- i, _ := new(big.Int).SetString(args.Key, 10)
- hx = ethutil.Bytes2Hex(i.Bytes())
- }
- logger.Debugf("GetStorageAt(%s, %s)\n", args.Address, hx)
- value := state.Storage(ethutil.Hex2Bytes(hx))
- *reply = NewSuccessRes(GetStorageAtRes{Address: args.Address, Key: args.Key, Value: value.Str()})
- return nil
-}
-
-type GetTxCountArgs struct {
- Address string `json:"address"`
-}
-type GetTxCountRes struct {
- Nonce int `json:"nonce"`
-}
-
-func (a *GetTxCountArgs) requirements() error {
- if a.Address == "" {
- return NewErrorResponse("GetTxCountAt requires an 'address' value as argument")
- }
- return nil
-}
-
-type GetPeerCountRes struct {
- PeerCount int `json:"peerCount"`
-}
-
-func (p *EthereumApi) GetPeerCount(args *interface{}, reply *string) error {
- *reply = NewSuccessRes(GetPeerCountRes{PeerCount: p.pipe.PeerCount()})
- return nil
-}
-
-type GetListeningRes struct {
- IsListening bool `json:"isListening"`
-}
-
-func (p *EthereumApi) GetIsListening(args *interface{}, reply *string) error {
- *reply = NewSuccessRes(GetListeningRes{IsListening: p.pipe.IsListening()})
- return nil
-}
-
-type GetCoinbaseRes struct {
- Coinbase string `json:"coinbase"`
-}
-
-func (p *EthereumApi) GetCoinbase(args *interface{}, reply *string) error {
- *reply = NewSuccessRes(GetCoinbaseRes{Coinbase: p.pipe.CoinBase()})
- return nil
-}
-
-type GetMiningRes struct {
- IsMining bool `json:"isMining"`
-}
-
-func (p *EthereumApi) GetIsMining(args *interface{}, reply *string) error {
- *reply = NewSuccessRes(GetMiningRes{IsMining: p.pipe.IsMining()})
- return nil
-}
-
-func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *string) error {
- err := args.requirements()
- if err != nil {
- return err
- }
- state := p.pipe.TxCountAt(args.Address)
- *reply = NewSuccessRes(GetTxCountRes{Nonce: state})
- return nil
-}
-
-type GetBalanceArgs struct {
- Address string
-}
-
-func (a *GetBalanceArgs) requirements() error {
- if a.Address == "" {
- return NewErrorResponse("GetBalanceAt requires an 'address' value as argument")
- }
- return nil
-}
-
-type BalanceRes struct {
- Balance string `json:"balance"`
- Address string `json:"address"`
-}
-
-func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *string) error {
- err := args.requirements()
- if err != nil {
- return err
- }
- state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
- *reply = NewSuccessRes(BalanceRes{Balance: state.Balance.String(), Address: args.Address})
- return nil
-}
-
-type TestRes struct {
- JsonResponse `json:"-"`
- Answer int `json:"answer"`
-}
-
-func (p *EthereumApi) Test(args *GetBlockArgs, reply *string) error {
- *reply = NewSuccessRes(TestRes{Answer: 15})
- return nil
-}
diff --git a/ethrpc/server.go b/ethrpc/server.go
deleted file mode 100644
index 4abe29aa971b538f6e031efcf3d57f1257d0b8de..0000000000000000000000000000000000000000
--- a/ethrpc/server.go
+++ /dev/null
@@ -1,67 +0,0 @@
-package ethrpc
-
-import (
- "fmt"
- "net"
- "net/rpc"
- "net/rpc/jsonrpc"
-
- "github.com/ethereum/eth-go/ethlog"
- "github.com/ethereum/eth-go/ethpipe"
-)
-
-var logger = ethlog.NewLogger("JSON")
-
-type JsonRpcServer struct {
- quit chan bool
- listener net.Listener
- pipe *ethpipe.JSPipe
-}
-
-func (s *JsonRpcServer) exitHandler() {
-out:
- for {
- select {
- case <-s.quit:
- s.listener.Close()
- break out
- }
- }
-
- logger.Infoln("Shutdown JSON-RPC server")
-}
-
-func (s *JsonRpcServer) Stop() {
- close(s.quit)
-}
-
-func (s *JsonRpcServer) Start() {
- logger.Infoln("Starting JSON-RPC server")
- go s.exitHandler()
- rpc.Register(&EthereumApi{pipe: s.pipe})
- rpc.HandleHTTP()
-
- for {
- conn, err := s.listener.Accept()
- if err != nil {
- logger.Infoln("Error starting JSON-RPC:", err)
- break
- }
- logger.Debugln("Incoming request.")
- go jsonrpc.ServeConn(conn)
- }
-}
-
-func NewJsonRpcServer(pipe *ethpipe.JSPipe, port int) (*JsonRpcServer, error) {
- sport := fmt.Sprintf(":%d", port)
- l, err := net.Listen("tcp", sport)
- if err != nil {
- return nil, err
- }
-
- return &JsonRpcServer{
- listener: l,
- quit: make(chan bool),
- pipe: pipe,
- }, nil
-}
diff --git a/ethwire/messaging.go b/ethwire/messaging.go
index 5013f1a9745be7b2850369087c6cc9e84ef158ec..cef520547bf7bc5225a84a0c6858bf59d2d16d83 100644
--- a/ethwire/messaging.go
+++ b/ethwire/messaging.go
@@ -33,8 +33,8 @@ const (
MsgGetPeersTy = 0x04
MsgPeersTy = 0x05
- MsgStatusTy = 0x10
- MsgGetTxsTy = 0x11
+ MsgStatusTy = 0x10
+ //MsgGetTxsTy = 0x11
MsgTxTy = 0x12
MsgGetBlockHashesTy = 0x13
MsgBlockHashesTy = 0x14
@@ -44,16 +44,16 @@ const (
)
var msgTypeToString = map[MsgType]string{
- MsgHandshakeTy: "Handshake",
- MsgDiscTy: "Disconnect",
- MsgPingTy: "Ping",
- MsgPongTy: "Pong",
- MsgGetPeersTy: "Get peers",
- MsgStatusTy: "Status",
- MsgPeersTy: "Peers",
- MsgTxTy: "Transactions",
- MsgBlockTy: "Blocks",
- MsgGetTxsTy: "Get Txs",
+ MsgHandshakeTy: "Handshake",
+ MsgDiscTy: "Disconnect",
+ MsgPingTy: "Ping",
+ MsgPongTy: "Pong",
+ MsgGetPeersTy: "Get peers",
+ MsgStatusTy: "Status",
+ MsgPeersTy: "Peers",
+ MsgTxTy: "Transactions",
+ MsgBlockTy: "Blocks",
+ //MsgGetTxsTy: "Get Txs",
MsgGetBlockHashesTy: "Get block hashes",
MsgBlockHashesTy: "Block hashes",
MsgGetBlocksTy: "Get blocks",
diff --git a/peer.go b/peer.go
index 0eb2eb299d14698f5e8f3e53efd3fcda8b8fe92b..c5e7b82b54442ab6d687cf68c1da07e993cecca1 100644
--- a/peer.go
+++ b/peer.go
@@ -322,7 +322,7 @@ out:
case msg := <-p.outputQueue:
if !p.statusKnown {
switch msg.Type {
- case ethwire.MsgGetTxsTy, ethwire.MsgTxTy, ethwire.MsgGetBlockHashesTy, ethwire.MsgBlockHashesTy, ethwire.MsgGetBlocksTy, ethwire.MsgBlockTy:
+ case ethwire.MsgTxTy, ethwire.MsgGetBlockHashesTy, ethwire.MsgBlockHashesTy, ethwire.MsgGetBlocksTy, ethwire.MsgBlockTy:
break skip
}
}
@@ -457,16 +457,18 @@ func (p *Peer) HandleInbound() {
// TMP
if p.statusKnown {
switch msg.Type {
- case ethwire.MsgGetTxsTy:
- // Get the current transactions of the pool
- txs := p.ethereum.TxPool().CurrentTransactions()
- // Get the RlpData values from the txs
- txsInterface := make([]interface{}, len(txs))
- for i, tx := range txs {
- txsInterface[i] = tx.RlpData()
- }
- // Broadcast it back to the peer
- p.QueueMessage(ethwire.NewMessage(ethwire.MsgTxTy, txsInterface))
+ /*
+ case ethwire.MsgGetTxsTy:
+ // Get the current transactions of the pool
+ txs := p.ethereum.TxPool().CurrentTransactions()
+ // Get the RlpData values from the txs
+ txsInterface := make([]interface{}, len(txs))
+ for i, tx := range txs {
+ txsInterface[i] = tx.RlpData()
+ }
+ // Broadcast it back to the peer
+ p.QueueMessage(ethwire.NewMessage(ethwire.MsgTxTy, txsInterface))
+ */
case ethwire.MsgGetBlockHashesTy:
if msg.Data.Len() < 2 {
@@ -687,10 +689,10 @@ func (self *Peer) handleStatus(msg *ethwire.Msg) {
var (
//protoVersion = c.Get(0).Uint()
- netVersion = c.Get(0).Uint()
- td = c.Get(1).BigInt()
- bestHash = c.Get(2).Bytes()
- genesis = c.Get(3).Bytes()
+ netVersion = c.Get(1).Uint()
+ td = c.Get(2).BigInt()
+ bestHash = c.Get(3).Bytes()
+ genesis = c.Get(4).Bytes()
)
if bytes.Compare(self.ethereum.ChainManager().Genesis().Hash(), genesis) != 0 {