diff --git a/common/bytes.go b/common/bytes.go
index 2d885ac74606efee97e370b17a465f40b94310cb..5bdacd810ad14073b9bda1f54860140aab2f6be3 100644
--- a/common/bytes.go
+++ b/common/bytes.go
@@ -127,6 +127,11 @@ func CopyBytes(b []byte) (copiedBytes []byte) {
return
}
+func HasHexPrefix(str string) bool {
+ l := len(str)
+ return l >= 2 && str[0:2] == "0x"
+}
+
func IsHex(str string) bool {
l := len(str)
return l >= 4 && l%2 == 0 && str[0:2] == "0x"
diff --git a/rpc/api.go b/rpc/api.go
index afd242aa3d5400208808a852a095bdba2155d127..30ba1ddc1d014b6c26cc1db6f3c0e38c6fc8c9fc 100644
--- a/rpc/api.go
+++ b/rpc/api.go
@@ -2,6 +2,7 @@ package rpc
import (
"encoding/json"
+ // "fmt"
"math/big"
"sync"
@@ -112,7 +113,11 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
}
block := NewBlockRes(api.xeth().EthBlockByHash(args.Hash), false)
- *reply = common.ToHex(big.NewInt(int64(len(block.Transactions))).Bytes())
+ if block == nil {
+ *reply = nil
+ } else {
+ *reply = common.ToHex(big.NewInt(int64(len(block.Transactions))).Bytes())
+ }
case "eth_getBlockTransactionCountByNumber":
args := new(BlockNumArg)
if err := json.Unmarshal(req.Params, &args); err != nil {
@@ -192,9 +197,9 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
*reply = br
case "eth_getTransactionByHash":
- // HashIndexArgs used, but only the "Hash" part we need.
- args := new(HashIndexArgs)
+ args := new(HashArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
}
tx, bhash, bnum, txi := api.xeth().EthTransactionByHash(args.Hash)
if tx != nil {
@@ -212,11 +217,16 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
block := api.xeth().EthBlockByHash(args.Hash)
br := NewBlockRes(block, true)
+ if br == nil {
+ *reply = nil
+ }
if args.Index >= int64(len(br.Transactions)) || args.Index < 0 {
- return NewValidationError("Index", "does not exist")
+ // return NewValidationError("Index", "does not exist")
+ *reply = nil
+ } else {
+ *reply = br.Transactions[args.Index]
}
- *reply = br.Transactions[args.Index]
case "eth_getTransactionByBlockNumberAndIndex":
args := new(BlockNumIndexArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
@@ -225,11 +235,16 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
block := api.xeth().EthBlockByNumber(args.BlockNumber)
v := NewBlockRes(block, true)
+ if v == nil {
+ *reply = nil
+ }
if args.Index >= int64(len(v.Transactions)) || args.Index < 0 {
- return NewValidationError("Index", "does not exist")
+ // return NewValidationError("Index", "does not exist")
+ *reply = nil
+ } else {
+ *reply = v.Transactions[args.Index]
}
- *reply = v.Transactions[args.Index]
case "eth_getUncleByBlockHashAndIndex":
args := new(HashIndexArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
@@ -243,13 +258,11 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
}
if args.Index >= int64(len(br.Uncles)) || args.Index < 0 {
- return NewValidationError("Index", "does not exist")
+ // return NewValidationError("Index", "does not exist")
+ *reply = nil
+ } else {
+ *reply = br.Uncles[args.Index]
}
-
- uhash := br.Uncles[args.Index]
- uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash.String()), false)
-
- *reply = uncle
case "eth_getUncleByBlockNumberAndIndex":
args := new(BlockNumIndexArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
@@ -265,13 +278,11 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
}
if args.Index >= int64(len(v.Uncles)) || args.Index < 0 {
- return NewValidationError("Index", "does not exist")
+ // return NewValidationError("Index", "does not exist")
+ *reply = nil
+ } else {
+ *reply = v.Uncles[args.Index]
}
-
- uhash := v.Uncles[args.Index]
- uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash.String()), false)
-
- *reply = uncle
case "eth_getCompilers":
c := []string{""}
*reply = c
diff --git a/rpc/args.go b/rpc/args.go
index 70618a01a48eed2575ede5644fe6b6b344b12fc3..cebabf4ba90a0b9dbbfc8825c44f5fa16e05a620 100644
--- a/rpc/args.go
+++ b/rpc/args.go
@@ -41,7 +41,11 @@ func blockHeight(raw interface{}, number *int64) error {
case "pending":
*number = -2
default:
- *number = common.String2Big(str).Int64()
+ if common.HasHexPrefix(str) {
+ *number = common.String2Big(str).Int64()
+ } else {
+ return NewInvalidTypeError("blockNumber", "is not a valid string")
+ }
}
return nil
@@ -1021,12 +1025,15 @@ func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1)
}
- var argstr string
- argstr, ok := obj[0].To.(string)
- if !ok {
- return NewInvalidTypeError("to", "is not a string")
+ if obj[0].To == nil {
+ args.To = ""
+ } else {
+ argstr, ok := obj[0].To.(string)
+ if !ok {
+ return NewInvalidTypeError("to", "is not a string")
+ }
+ args.To = argstr
}
- args.To = argstr
t := make([]string, len(obj[0].Topics))
for i, j := range obj[0].Topics {
diff --git a/rpc/args_test.go b/rpc/args_test.go
index 902f8013e4910938da12b431705011339e84bdf1..b88bab28055c7155063bab7d1d2d947c39cefe95 100644
--- a/rpc/args_test.go
+++ b/rpc/args_test.go
@@ -1805,6 +1805,16 @@ func TestWhisperFilterArgsEmpty(t *testing.T) {
}
}
+func TestWhisperFilterArgsToInt(t *testing.T) {
+ input := `[{"to": 2}]`
+
+ args := new(WhisperFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestWhisperFilterArgsToBool(t *testing.T) {
input := `[{"topics": ["0x68656c6c6f20776f726c64"], "to": false}]`
@@ -1815,6 +1825,21 @@ func TestWhisperFilterArgsToBool(t *testing.T) {
}
}
+func TestWhisperFilterArgsToMissing(t *testing.T) {
+ input := `[{"topics": ["0x68656c6c6f20776f726c64"]}]`
+ expected := new(WhisperFilterArgs)
+ expected.To = ""
+
+ args := new(WhisperFilterArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err)
+ }
+
+ if args.To != expected.To {
+ t.Errorf("To shoud be %v but is %v", expected.To, args.To)
+ }
+}
+
func TestWhisperFilterArgsTopicInt(t *testing.T) {
input := `[{"topics": [6], "to": "0x34ag445g3455b34"}]`
@@ -2090,6 +2115,51 @@ func TestHashIndexArgsInvalidIndex(t *testing.T) {
}
}
+func TestHashArgs(t *testing.T) {
+ input := `["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"]`
+ expected := new(HashIndexArgs)
+ expected.Hash = "0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b"
+
+ args := new(HashArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err)
+ }
+
+ if expected.Hash != args.Hash {
+ t.Errorf("Hash shoud be %#v but is %#v", expected.Hash, args.Hash)
+ }
+}
+
+func TestHashArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(HashArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestHashArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(HashArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestHashArgsInvalidHash(t *testing.T) {
+ input := `[7]`
+
+ args := new(HashArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestSubmitWorkArgs(t *testing.T) {
input := `["0x0000000000000001", "0x1234567890abcdef1234567890abcdef", "0xD1GE5700000000000000000000000000"]`
expected := new(SubmitWorkArgs)
diff --git a/rpc/responses.go b/rpc/responses.go
index 3d1687cb68d05eb28170f8f96482f249d51302b6..52a2f714c17769e0051c4796e5dd49e5e42e0371 100644
--- a/rpc/responses.go
+++ b/rpc/responses.go
@@ -28,7 +28,7 @@ type BlockRes struct {
GasUsed *hexnum `json:"gasUsed"`
UnixTimestamp *hexnum `json:"timestamp"`
Transactions []*TransactionRes `json:"transactions"`
- Uncles []*hexdata `json:"uncles"`
+ Uncles []*UncleRes `json:"uncles"`
}
func (b *BlockRes) MarshalJSON() ([]byte, error) {
@@ -73,7 +73,10 @@ func (b *BlockRes) MarshalJSON() ([]byte, error) {
ext.GasUsed = b.GasUsed
ext.UnixTimestamp = b.UnixTimestamp
ext.Transactions = b.Transactions
- ext.Uncles = b.Uncles
+ ext.Uncles = make([]*hexdata, len(b.Uncles))
+ for i, u := range b.Uncles {
+ ext.Uncles[i] = u.BlockHash
+ }
return json.Marshal(ext)
} else {
var ext struct {
@@ -119,14 +122,15 @@ func (b *BlockRes) MarshalJSON() ([]byte, error) {
for i, tx := range b.Transactions {
ext.Transactions[i] = tx.Hash
}
- ext.Uncles = b.Uncles
+ ext.Uncles = make([]*hexdata, len(b.Uncles))
+ for i, u := range b.Uncles {
+ ext.Uncles[i] = u.BlockHash
+ }
return json.Marshal(ext)
}
}
func NewBlockRes(block *types.Block, fullTx bool) *BlockRes {
- // TODO respect fullTx flag
-
if block == nil {
return nil
}
@@ -159,9 +163,9 @@ func NewBlockRes(block *types.Block, fullTx bool) *BlockRes {
res.Transactions[i].TxIndex = newHexNum(i)
}
- res.Uncles = make([]*hexdata, len(block.Uncles()))
+ res.Uncles = make([]*UncleRes, len(block.Uncles()))
for i, uncle := range block.Uncles() {
- res.Uncles[i] = newHexData(uncle.Hash())
+ res.Uncles[i] = NewUncleRes(uncle)
}
return res
@@ -182,6 +186,10 @@ type TransactionRes struct {
}
func NewTransactionRes(tx *types.Transaction) *TransactionRes {
+ if tx == nil {
+ return nil
+ }
+
var v = new(TransactionRes)
v.Hash = newHexData(tx.Hash())
v.Nonce = newHexNum(tx.Nonce())
@@ -198,6 +206,49 @@ func NewTransactionRes(tx *types.Transaction) *TransactionRes {
return v
}
+type UncleRes struct {
+ BlockNumber *hexnum `json:"number"`
+ BlockHash *hexdata `json:"hash"`
+ ParentHash *hexdata `json:"parentHash"`
+ Nonce *hexdata `json:"nonce"`
+ Sha3Uncles *hexdata `json:"sha3Uncles"`
+ ReceiptHash *hexdata `json:"receiptHash"`
+ LogsBloom *hexdata `json:"logsBloom"`
+ TransactionRoot *hexdata `json:"transactionsRoot"`
+ StateRoot *hexdata `json:"stateRoot"`
+ Miner *hexdata `json:"miner"`
+ Difficulty *hexnum `json:"difficulty"`
+ ExtraData *hexdata `json:"extraData"`
+ GasLimit *hexnum `json:"gasLimit"`
+ GasUsed *hexnum `json:"gasUsed"`
+ UnixTimestamp *hexnum `json:"timestamp"`
+}
+
+func NewUncleRes(h *types.Header) *UncleRes {
+ if h == nil {
+ return nil
+ }
+
+ var v = new(UncleRes)
+ v.BlockNumber = newHexNum(h.Number)
+ v.BlockHash = newHexData(h.Hash())
+ v.ParentHash = newHexData(h.ParentHash)
+ v.Sha3Uncles = newHexData(h.UncleHash)
+ v.Nonce = newHexData(h.Nonce[:])
+ v.LogsBloom = newHexData(h.Bloom)
+ v.TransactionRoot = newHexData(h.TxHash)
+ v.StateRoot = newHexData(h.Root)
+ v.Miner = newHexData(h.Coinbase)
+ v.Difficulty = newHexNum(h.Difficulty)
+ v.ExtraData = newHexData(h.Extra)
+ v.GasLimit = newHexNum(h.GasLimit)
+ v.GasUsed = newHexNum(h.GasUsed)
+ v.UnixTimestamp = newHexNum(h.Time)
+ v.ReceiptHash = newHexData(h.ReceiptHash)
+
+ return v
+}
+
// type FilterLogRes struct {
// Hash string `json:"hash"`
// Address string `json:"address"`
diff --git a/xeth/xeth.go b/xeth/xeth.go
index b203e45deee9c70b329c1c7bf2ea7c83efb5e6d2..825f26017c6de1a11ee487a85acf0b6de759170b 100644
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@@ -196,7 +196,7 @@ func (self *XEth) EthTransactionByHash(hash string) (tx *types.Transaction, blha
// meta
var txExtra struct {
BlockHash common.Hash
- BlockIndex int64
+ BlockIndex uint64
Index uint64
}
@@ -205,8 +205,10 @@ func (self *XEth) EthTransactionByHash(hash string) (tx *types.Transaction, blha
err := rlp.Decode(r, &txExtra)
if err == nil {
blhash = txExtra.BlockHash
- blnum = big.NewInt(txExtra.BlockIndex)
+ blnum = big.NewInt(int64(txExtra.BlockIndex))
txi = txExtra.Index
+ } else {
+ pipelogger.Errorln(err)
}
return