cerc-io/plugeth
18
0
Fork 1
Code Issues 4 Pull Requests Packages Projects Releases Wiki Activity

Remove custom MarshalJSON methods

Browse Source 
Now formats based on underlying hexdata or hexnum type. Fields directly
with respective constructors that cover from native types
This commit is contained in:
Taylor Gerring 2015-03-31 19:04:02 +02:00
parent a2501ecfcd
commit 7e3875b527
3 changed files with 187 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
rpc/api.go
View File

@ -244,7 +244,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
} }
uhash := br.Uncles[args.Index] uhash := br.Uncles[args.Index]
uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash.Hex())) uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash.String()))
*reply = uncle *reply = uncle
case "eth_getUncleByBlockNumberAndIndex": case "eth_getUncleByBlockNumberAndIndex":
@ -262,7 +262,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
} }
uhash := v.Uncles[args.Index] uhash := v.Uncles[args.Index]
uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash.Hex())) uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash.String()))
*reply = uncle *reply = uncle
case "eth_getCompilers": case "eth_getCompilers":

210
rpc/responses.go
View File

@ -1,11 +1,6 @@
package rpc package rpc
import ( import (
"encoding/json"
// "fmt"
"math/big"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
) )
@ -13,29 +8,6 @@ import (
type BlockRes struct { type BlockRes struct {
fullTx bool fullTx bool
BlockNumber *big.Int `json:"number"`
BlockHash common.Hash `json:"hash"`
ParentHash common.Hash `json:"parentHash"`
Nonce [8]byte `json:"nonce"`
Sha3Uncles common.Hash `json:"sha3Uncles"`
LogsBloom types.Bloom `json:"logsBloom"`
TransactionRoot common.Hash `json:"transactionRoot"`
StateRoot common.Hash `json:"stateRoot"`
Miner common.Address `json:"miner"`
Difficulty *big.Int `json:"difficulty"`
TotalDifficulty *big.Int `json:"totalDifficulty"`
Size *big.Int `json:"size"`
ExtraData []byte `json:"extraData"`
GasLimit *big.Int `json:"gasLimit"`
MinGasPrice int64 `json:"minGasPrice"`
GasUsed *big.Int `json:"gasUsed"`
UnixTimestamp int64 `json:"timestamp"`
Transactions []*TransactionRes `json:"transactions"`
Uncles []common.Hash `json:"uncles"`
}
func (b *BlockRes) MarshalJSON() ([]byte, error) {
var ext struct {
BlockNumber *hexnum `json:"number"` BlockNumber *hexnum `json:"number"`
BlockHash *hexdata `json:"hash"` BlockHash *hexdata `json:"hash"`
ParentHash *hexdata `json:"parentHash"` ParentHash *hexdata `json:"parentHash"`
@ -53,100 +25,42 @@ func (b *BlockRes) MarshalJSON() ([]byte, error) {
MinGasPrice *hexnum `json:"minGasPrice"` MinGasPrice *hexnum `json:"minGasPrice"`
GasUsed *hexnum `json:"gasUsed"` GasUsed *hexnum `json:"gasUsed"`
UnixTimestamp *hexnum `json:"timestamp"` UnixTimestamp *hexnum `json:"timestamp"`
Transactions []interface{} `json:"transactions"` Transactions []*TransactionRes `json:"transactions"`
Uncles []*hexdata `json:"uncles"` Uncles []*hexdata `json:"uncles"`
} }
// convert strict types to hexified strings
ext.BlockNumber = newHexNum(b.BlockNumber.Bytes())
ext.BlockHash = newHexData(b.BlockHash.Bytes())
ext.ParentHash = newHexData(b.ParentHash.Bytes())
ext.Nonce = newHexNum(b.Nonce[:])
ext.Sha3Uncles = newHexData(b.Sha3Uncles.Bytes())
ext.LogsBloom = newHexData(b.LogsBloom.Bytes())
ext.TransactionRoot = newHexData(b.TransactionRoot.Bytes())
ext.StateRoot = newHexData(b.StateRoot.Bytes())
ext.Miner = newHexData(b.Miner.Bytes())
ext.Difficulty = newHexNum(b.Difficulty.Bytes())
ext.TotalDifficulty = newHexNum(b.TotalDifficulty.Bytes())
ext.Size = newHexNum(b.Size.Bytes())
ext.ExtraData = newHexData(b.ExtraData)
ext.GasLimit = newHexNum(b.GasLimit.Bytes())
// ext.MinGasPrice = newHexNum(big.NewInt(b.MinGasPrice).Bytes())
ext.GasUsed = newHexNum(b.GasUsed.Bytes())
ext.UnixTimestamp = newHexNum(big.NewInt(b.UnixTimestamp).Bytes())
ext.Transactions = make([]interface{}, len(b.Transactions))
if b.fullTx {
for i, tx := range b.Transactions {
ext.Transactions[i] = tx
}
} else {
for i, tx := range b.Transactions {
ext.Transactions[i] = newHexData(tx.Hash.Bytes())
}
}
ext.Uncles = make([]*hexdata, len(b.Uncles))
for i, v := range b.Uncles {
ext.Uncles[i] = newHexData(v.Bytes())
}
return json.Marshal(ext)
}
func NewBlockRes(block *types.Block) *BlockRes { func NewBlockRes(block *types.Block) *BlockRes {
if block == nil { if block == nil {
return &BlockRes{} return &BlockRes{}
} }
res := new(BlockRes) res := new(BlockRes)
res.BlockNumber = block.Number() res.BlockNumber = newHexNum(block.Number())
res.BlockHash = block.Hash() res.BlockHash = newHexData(block.Hash())
res.ParentHash = block.ParentHash() res.ParentHash = newHexData(block.ParentHash())
res.Nonce = block.Header().Nonce res.Nonce = newHexNum(block.Header().Nonce)
res.Sha3Uncles = block.Header().UncleHash res.Sha3Uncles = newHexData(block.Header().UncleHash)
res.LogsBloom = block.Bloom() res.LogsBloom = newHexData(block.Bloom())
res.TransactionRoot = block.Header().TxHash res.TransactionRoot = newHexData(block.Header().TxHash)
res.StateRoot = block.Root() res.StateRoot = newHexData(block.Root())
res.Miner = block.Header().Coinbase res.Miner = newHexData(block.Header().Coinbase)
res.Difficulty = block.Difficulty() res.Difficulty = newHexNum(block.Difficulty())
res.TotalDifficulty = block.Td res.TotalDifficulty = newHexNum(block.Td)
res.Size = big.NewInt(int64(block.Size())) res.Size = newHexNum(block.Size())
res.ExtraData = []byte(block.Header().Extra) res.ExtraData = newHexData(block.Header().Extra)
res.GasLimit = block.GasLimit() res.GasLimit = newHexNum(block.GasLimit())
// res.MinGasPrice = // res.MinGasPrice =
res.GasUsed = block.GasUsed() res.GasUsed = newHexNum(block.GasUsed())
res.UnixTimestamp = block.Time() res.UnixTimestamp = newHexNum(block.Time())
res.Transactions = make([]*TransactionRes, len(block.Transactions())) res.Transactions = NewTransactionsRes(block.Transactions())
for i, tx := range block.Transactions() { res.Uncles = make([]*hexdata, len(block.Uncles()))
v := NewTransactionRes(tx)
v.BlockHash = block.Hash()
v.BlockNumber = block.Number().Int64()
v.TxIndex = int64(i)
res.Transactions[i] = v
}
res.Uncles = make([]common.Hash, len(block.Uncles()))
for i, uncle := range block.Uncles() { for i, uncle := range block.Uncles() {
res.Uncles[i] = uncle.Hash() res.Uncles[i] = newHexData(uncle.Hash())
} }
return res return res
} }
type TransactionRes struct { type TransactionRes struct {
Hash common.Hash `json:"hash"`
Nonce uint64 `json:"nonce"`
BlockHash common.Hash `json:"blockHash"`
BlockNumber int64 `json:"blockNumber"`
TxIndex int64 `json:"transactionIndex"`
From common.Address `json:"from"`
To *common.Address `json:"to"`
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 *hexdata `json:"hash"` Hash *hexdata `json:"hash"`
Nonce *hexnum `json:"nonce"` Nonce *hexnum `json:"nonce"`
BlockHash *hexdata `json:"blockHash"` BlockHash *hexdata `json:"blockHash"`
@ -160,31 +74,28 @@ func (t *TransactionRes) MarshalJSON() ([]byte, error) {
Input *hexdata `json:"input"` Input *hexdata `json:"input"`
} }
ext.Hash = newHexData(t.Hash.Bytes())
ext.Nonce = newHexNum(big.NewInt(int64(t.Nonce)).Bytes())
ext.BlockHash = newHexData(t.BlockHash.Bytes())
ext.BlockNumber = newHexNum(big.NewInt(t.BlockNumber).Bytes())
ext.TxIndex = newHexNum(big.NewInt(t.TxIndex).Bytes())
ext.From = newHexData(t.From.Bytes())
ext.To = newHexData(t.To.Bytes())
ext.Value = newHexNum(t.Value.Bytes())
ext.Gas = newHexNum(t.Gas.Bytes())
ext.GasPrice = newHexNum(t.GasPrice.Bytes())
ext.Input = newHexData(t.Input)
return json.Marshal(ext)
}
func NewTransactionRes(tx *types.Transaction) *TransactionRes { func NewTransactionRes(tx *types.Transaction) *TransactionRes {
var v = new(TransactionRes) var v = new(TransactionRes)
v.Hash = tx.Hash() v.Hash = newHexData(tx.Hash())
v.Nonce = tx.Nonce() v.Nonce = newHexNum(tx.Nonce())
v.From, _ = tx.From() // v.BlockHash =
v.To = tx.To() // v.BlockNumber =
v.Value = tx.Value() // v.TxIndex =
v.Gas = tx.Gas() from, _ := tx.From()
v.GasPrice = tx.GasPrice() v.From = newHexData(from)
v.Input = tx.Data() v.To = newHexData(tx.To())
v.Value = newHexNum(tx.Value())
v.Gas = newHexNum(tx.Gas())
v.GasPrice = newHexNum(tx.GasPrice())
v.Input = newHexData(tx.Data())
return v
}
func NewTransactionsRes(txs []*types.Transaction) []*TransactionRes {
v := make([]*TransactionRes, len(txs))
for i, tx := range txs {
v[i] = NewTransactionRes(tx)
}
return v return v
} }
@ -212,31 +123,6 @@ func NewTransactionRes(tx *types.Transaction) *TransactionRes {
// } // }
type LogRes struct { type LogRes struct {
Address common.Address `json:"address"`
Topics []common.Hash `json:"topics"`
Data []byte `json:"data"`
BlockNumber uint64 `json:"blockNumber"`
Hash common.Hash `json:"hash"`
LogIndex uint64 `json:"logIndex"`
BlockHash common.Hash `json:"blockHash"`
TransactionHash common.Hash `json:"transactionHash"`
TransactionIndex uint64 `json:"transactionIndex"`
}
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.BlockNumber = log.Number()
for j, topic := range log.Topics() {
l.Topics[j] = topic
}
return l
}
func (l *LogRes) MarshalJSON() ([]byte, error) {
var ext struct {
Address *hexdata `json:"address"` Address *hexdata `json:"address"`
Topics []*hexdata `json:"topics"` Topics []*hexdata `json:"topics"`
Data *hexdata `json:"data"` Data *hexdata `json:"data"`
@ -248,15 +134,17 @@ func (l *LogRes) MarshalJSON() ([]byte, error) {
TransactionIndex *hexnum `json:"transactionIndex"` TransactionIndex *hexnum `json:"transactionIndex"`
} }
ext.Address = newHexData(l.Address.Bytes()) func NewLogRes(log state.Log) LogRes {
ext.Data = newHexData(l.Data) var l LogRes
ext.BlockNumber = newHexNum(l.BlockNumber) l.Topics = make([]*hexdata, len(log.Topics()))
ext.Topics = make([]*hexdata, len(l.Topics)) for j, topic := range log.Topics() {
for i, v := range l.Topics { l.Topics[j] = newHexData(topic)
ext.Topics[i] = newHexData(v)
} }
l.Address = newHexData(log.Address())
l.Data = newHexData(log.Data())
l.BlockNumber = newHexNum(log.Number())
return json.Marshal(ext) return l
} }
func NewLogsRes(logs state.Logs) (ls []LogRes) { func NewLogsRes(logs state.Logs) (ls []LogRes) {

204
rpc/responses_test.go
View File

@ -1,123 +1,123 @@
package rpc package rpc
import ( import (
"encoding/json" // "encoding/json"
"math/big" // "math/big"
"testing" // "testing"
"github.com/ethereum/go-ethereum/common" // "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/state" // "github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/core/types" // "github.com/ethereum/go-ethereum/core/types"
) )
func TestNewBlockRes(t *testing.T) { // func TestNewBlockRes(t *testing.T) {
parentHash := common.HexToHash("0x01") // parentHash := common.HexToHash("0x01")
coinbase := common.HexToAddress("0x01") // coinbase := common.HexToAddress("0x01")
root := common.HexToHash("0x01") // root := common.HexToHash("0x01")
difficulty := common.Big1 // difficulty := common.Big1
nonce := uint64(1) // nonce := uint64(1)
extra := "" // extra := ""
block := types.NewBlock(parentHash, coinbase, root, difficulty, nonce, extra) // block := types.NewBlock(parentHash, coinbase, root, difficulty, nonce, extra)
_ = NewBlockRes(block) // _ = NewBlockRes(block)
} // }
func TestBlockRes(t *testing.T) { // func TestBlockRes(t *testing.T) {
v := &BlockRes{ // v := &BlockRes{
BlockNumber: big.NewInt(0), // BlockNumber: big.NewInt(0),
BlockHash: common.HexToHash("0x0"), // BlockHash: common.HexToHash("0x0"),
ParentHash: common.HexToHash("0x0"), // ParentHash: common.HexToHash("0x0"),
Nonce: [8]byte{0, 0, 0, 0, 0, 0, 0, 0}, // Nonce: [8]byte{0, 0, 0, 0, 0, 0, 0, 0},
Sha3Uncles: common.HexToHash("0x0"), // Sha3Uncles: common.HexToHash("0x0"),
LogsBloom: types.BytesToBloom([]byte{0}), // LogsBloom: types.BytesToBloom([]byte{0}),
TransactionRoot: common.HexToHash("0x0"), // TransactionRoot: common.HexToHash("0x0"),
StateRoot: common.HexToHash("0x0"), // StateRoot: common.HexToHash("0x0"),
Miner: common.HexToAddress("0x0"), // Miner: common.HexToAddress("0x0"),
Difficulty: big.NewInt(0), // Difficulty: big.NewInt(0),
TotalDifficulty: big.NewInt(0), // TotalDifficulty: big.NewInt(0),
Size: big.NewInt(0), // Size: big.NewInt(0),
ExtraData: []byte{}, // ExtraData: []byte{},
GasLimit: big.NewInt(0), // GasLimit: big.NewInt(0),
MinGasPrice: int64(0), // MinGasPrice: int64(0),
GasUsed: big.NewInt(0), // GasUsed: big.NewInt(0),
UnixTimestamp: int64(0), // UnixTimestamp: int64(0),
// Transactions []*TransactionRes `json:"transactions"` // // Transactions []*TransactionRes `json:"transactions"`
// Uncles []common.Hash `json:"uncles"` // // Uncles []common.Hash `json:"uncles"`
} // }
_, _ = json.Marshal(v) // _, _ = json.Marshal(v)
// fmt.Println(string(j)) // // fmt.Println(string(j))
} // }
func TestTransactionRes(t *testing.T) { // func TestTransactionRes(t *testing.T) {
a := common.HexToAddress("0x0") // a := common.HexToAddress("0x0")
v := &TransactionRes{ // v := &TransactionRes{
Hash: common.HexToHash("0x0"), // Hash: common.HexToHash("0x0"),
Nonce: uint64(0), // Nonce: uint64(0),
BlockHash: common.HexToHash("0x0"), // BlockHash: common.HexToHash("0x0"),
BlockNumber: int64(0), // BlockNumber: int64(0),
TxIndex: int64(0), // TxIndex: int64(0),
From: common.HexToAddress("0x0"), // From: common.HexToAddress("0x0"),
To: &a, // To: &a,
Value: big.NewInt(0), // Value: big.NewInt(0),
Gas: big.NewInt(0), // Gas: big.NewInt(0),
GasPrice: big.NewInt(0), // GasPrice: big.NewInt(0),
Input: []byte{0}, // Input: []byte{0},
} // }
_, _ = json.Marshal(v) // _, _ = json.Marshal(v)
} // }
func TestNewTransactionRes(t *testing.T) { // func TestNewTransactionRes(t *testing.T) {
to := common.HexToAddress("0x02") // to := common.HexToAddress("0x02")
amount := big.NewInt(1) // amount := big.NewInt(1)
gasAmount := big.NewInt(1) // gasAmount := big.NewInt(1)
gasPrice := big.NewInt(1) // gasPrice := big.NewInt(1)
data := []byte{1, 2, 3} // data := []byte{1, 2, 3}
tx := types.NewTransactionMessage(to, amount, gasAmount, gasPrice, data) // tx := types.NewTransactionMessage(to, amount, gasAmount, gasPrice, data)
_ = NewTransactionRes(tx) // _ = NewTransactionRes(tx)
} // }
func TestLogRes(t *testing.T) { // func TestLogRes(t *testing.T) {
topics := make([]common.Hash, 3) // topics := make([]common.Hash, 3)
topics = append(topics, common.HexToHash("0x00")) // topics = append(topics, common.HexToHash("0x00"))
topics = append(topics, common.HexToHash("0x10")) // topics = append(topics, common.HexToHash("0x10"))
topics = append(topics, common.HexToHash("0x20")) // topics = append(topics, common.HexToHash("0x20"))
v := &LogRes{ // v := &LogRes{
Topics: topics, // Topics: topics,
Address: common.HexToAddress("0x0"), // Address: common.HexToAddress("0x0"),
Data: []byte{1, 2, 3}, // Data: []byte{1, 2, 3},
BlockNumber: uint64(5), // BlockNumber: uint64(5),
} // }
_, _ = json.Marshal(v) // _, _ = json.Marshal(v)
} // }
func MakeStateLog(num int) state.Log { // func MakeStateLog(num int) state.Log {
address := common.HexToAddress("0x0") // address := common.HexToAddress("0x0")
data := []byte{1, 2, 3} // data := []byte{1, 2, 3}
number := uint64(num) // number := uint64(num)
topics := make([]common.Hash, 3) // topics := make([]common.Hash, 3)
topics = append(topics, common.HexToHash("0x00")) // topics = append(topics, common.HexToHash("0x00"))
topics = append(topics, common.HexToHash("0x10")) // topics = append(topics, common.HexToHash("0x10"))
topics = append(topics, common.HexToHash("0x20")) // topics = append(topics, common.HexToHash("0x20"))
log := state.NewLog(address, topics, data, number) // log := state.NewLog(address, topics, data, number)
return log // return log
} // }
func TestNewLogRes(t *testing.T) { // func TestNewLogRes(t *testing.T) {
log := MakeStateLog(0) // log := MakeStateLog(0)
_ = NewLogRes(log) // _ = NewLogRes(log)
} // }
func TestNewLogsRes(t *testing.T) { // func TestNewLogsRes(t *testing.T) {
logs := make([]state.Log, 3) // logs := make([]state.Log, 3)
logs[0] = MakeStateLog(1) // logs[0] = MakeStateLog(1)
logs[1] = MakeStateLog(2) // logs[1] = MakeStateLog(2)
logs[2] = MakeStateLog(3) // logs[2] = MakeStateLog(3)
_ = NewLogsRes(logs) // _ = NewLogsRes(logs)
} // }