interesting
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #2984 from karalabe/fix-head-sub 

core/types, ethclient: fix broken subscriptions
This commit is contained in:
bas-vk 2016-09-09 16:20:52 +02:00 committed by GitHub
parent 6fb8ae2bd6 b6b5ec8f75
commit b7f6404168
5 changed files with 132 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
core/types/json.go
View File

@ -26,6 +26,13 @@ import (
type hexBytes []byte
func (b *hexBytes) MarshalJSON() ([]byte, error) {
if b != nil {
return []byte(fmt.Sprintf(`"0x%x"`, []byte(*b))), nil
}
return nil, nil
}
func (b *hexBytes) UnmarshalJSON(input []byte) error {
if len(input) < 2 || input[0] != '"' || input[len(input)-1] != '"' {
return fmt.Errorf("cannot unmarshal non-string into hexBytes")
@ -44,6 +51,13 @@ func (b *hexBytes) UnmarshalJSON(input []byte) error {
type hexBig big.Int
func (b *hexBig) MarshalJSON() ([]byte, error) {
if b != nil {
return []byte(fmt.Sprintf(`"0x%x"`, (*big.Int)(b))), nil
}
return nil, nil
}
func (b *hexBig) UnmarshalJSON(input []byte) error {
raw, err := checkHexNumber(input)
if err != nil {
@ -59,6 +73,13 @@ func (b *hexBig) UnmarshalJSON(input []byte) error {
type hexUint64 uint64
func (b *hexUint64) MarshalJSON() ([]byte, error) {
if b != nil {
return []byte(fmt.Sprintf(`"0x%x"`, *(*uint64)(b))), nil
}
return nil, nil
}
func (b *hexUint64) UnmarshalJSON(input []byte) error {
raw, err := checkHexNumber(input)
if err != nil {

77
core/types/json_test.go
View File

@ -2,6 +2,7 @@ package types
import (
"encoding/json"
"reflect"
"testing"
"github.com/ethereum/go-ethereum/common"
@ -44,6 +45,31 @@ func TestUnmarshalHeader(t *testing.T) {
}
}
func TestMarshalHeader(t *testing.T) {
for name, test := range unmarshalHeaderTests {
if test.wantError != nil {
continue
}
var original *Header
json.Unmarshal([]byte(test.input), &original)
blob, err := json.Marshal(original)
if err != nil {
t.Errorf("test %q: failed to marshal header: %v", name, err)
continue
}
var proced *Header
if err := json.Unmarshal(blob, &proced); err != nil {
t.Errorf("Test %q: failed to unmarshal marhsalled header: %v", name, err)
continue
}
if !reflect.DeepEqual(original, proced) {
t.Errorf("test %q: header mismatch: have %+v, want %+v", name, proced, original)
continue
}
}
}
var unmarshalTransactionTests = map[string]struct {
input string
wantHash common.Hash
@ -94,6 +120,32 @@ func TestUnmarshalTransaction(t *testing.T) {
}
}
func TestMarshalTransaction(t *testing.T) {
for name, test := range unmarshalTransactionTests {
if test.wantError != nil {
continue
}
var original *Transaction
json.Unmarshal([]byte(test.input), &original)
blob, err := json.Marshal(original)
if err != nil {
t.Errorf("test %q: failed to marshal transaction: %v", name, err)
continue
}
var proced *Transaction
if err := json.Unmarshal(blob, &proced); err != nil {
t.Errorf("Test %q: failed to unmarshal marhsalled transaction: %v", name, err)
continue
}
proced.Hash() // hack private fields to pass deep equal
if !reflect.DeepEqual(original, proced) {
t.Errorf("test %q: transaction mismatch: have %+v, want %+v", name, proced, original)
continue
}
}
}
var unmarshalReceiptTests = map[string]struct {
input string
wantError error
@ -119,6 +171,31 @@ func TestUnmarshalReceipt(t *testing.T) {
}
}
func TestMarshalReceipt(t *testing.T) {
for name, test := range unmarshalReceiptTests {
if test.wantError != nil {
continue
}
var original *Receipt
json.Unmarshal([]byte(test.input), &original)
blob, err := json.Marshal(original)
if err != nil {
t.Errorf("test %q: failed to marshal receipt: %v", name, err)
continue
}
var proced *Receipt
if err := json.Unmarshal(blob, &proced); err != nil {
t.Errorf("Test %q: failed to unmarshal marhsalled receipt: %v", name, err)
continue
}
if !reflect.DeepEqual(original, proced) {
t.Errorf("test %q: receipt mismatch: have %+v, want %+v", name, proced, original)
continue
}
}
}
func checkError(t *testing.T, testname string, got, want error) bool {
if got == nil {
if want != nil {

15
core/types/receipt.go
View File

@ -84,6 +84,21 @@ func (r *Receipt) DecodeRLP(s *rlp.Stream) error {
return nil
}
// MarshalJSON encodes receipts into the web3 RPC response block format.
func (r *Receipt) MarshalJSON() ([]byte, error) {
root := common.BytesToHash(r.PostState)
return json.Marshal(&jsonReceipt{
PostState: &root,
CumulativeGasUsed: (*hexBig)(r.CumulativeGasUsed),
Bloom: &r.Bloom,
Logs: &r.Logs,
TxHash: &r.TxHash,
ContractAddress: &r.ContractAddress,
GasUsed: (*hexBig)(r.GasUsed),
})
}
// UnmarshalJSON decodes the web3 RPC receipt format.
func (r *Receipt) UnmarshalJSON(input []byte) error {
var dec jsonReceipt

18
core/types/transaction.go
View File

@ -128,6 +128,24 @@ func (tx *Transaction) DecodeRLP(s *rlp.Stream) error {
return err
}
// MarshalJSON encodes transactions into the web3 RPC response block format.
func (tx *Transaction) MarshalJSON() ([]byte, error) {
hash, v := tx.Hash(), uint64(tx.data.V)
return json.Marshal(&jsonTransaction{
Hash: &hash,
AccountNonce: (*hexUint64)(&tx.data.AccountNonce),
Price: (*hexBig)(tx.data.Price),
GasLimit: (*hexBig)(tx.data.GasLimit),
Recipient: tx.data.Recipient,
Amount: (*hexBig)(tx.data.Amount),
Payload: (*hexBytes)(&tx.data.Payload),
V: (*hexUint64)(&v),
R: (*hexBig)(tx.data.R),
S: (*hexBig)(tx.data.S),
})
}
// UnmarshalJSON decodes the web3 RPC transaction format.
func (tx *Transaction) UnmarshalJSON(input []byte) error {
var dec jsonTransaction

2
ethclient/ethclient.go
View File

@ -227,7 +227,7 @@ func (ec *Client) SyncProgress(ctx context.Context) (*ethereum.SyncProgress, err
// SubscribeNewHead subscribes to notifications about the current blockchain head
// on the given channel.
func (ec *Client) SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (ethereum.Subscription, error) {
return ec.c.EthSubscribe(ctx, ch, "newBlocks", map[string]struct{}{})
return ec.c.EthSubscribe(ctx, ch, "newHeads", map[string]struct{}{})
}
// State Access