headrush
/
go-ethereum
forked from mirror/go-ethereum
1
1
Fork 0
Code Issues Pull Requests 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
release/1.0.1
Taylor Gerring 10 years ago
parent a2501ecfcd
commit 7e3875b527
3 changed files with 202 additions and 314 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 4
      rpc/api.go
  2. 278
      rpc/responses.go
  3. 234
      rpc/responses_test.go

4
rpc/api.go
Unescape 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":

278
rpc/responses.go
Unescape 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,84 +8,25 @@ import (
type BlockRes struct { type BlockRes struct {
fullTx bool fullTx bool
BlockNumber *big.Int `json:"number"` BlockNumber *hexnum `json:"number"`
BlockHash common.Hash `json:"hash"` BlockHash *hexdata `json:"hash"`
ParentHash common.Hash `json:"parentHash"` ParentHash *hexdata `json:"parentHash"`
Nonce [8]byte `json:"nonce"` Nonce *hexnum `json:"nonce"`
Sha3Uncles common.Hash `json:"sha3Uncles"` Sha3Uncles *hexdata `json:"sha3Uncles"`
LogsBloom types.Bloom `json:"logsBloom"` LogsBloom *hexdata `json:"logsBloom"`
TransactionRoot common.Hash `json:"transactionRoot"` TransactionRoot *hexdata `json:"transactionRoot"`
StateRoot common.Hash `json:"stateRoot"` StateRoot *hexdata `json:"stateRoot"`
Miner common.Address `json:"miner"` Miner *hexdata `json:"miner"`
Difficulty *big.Int `json:"difficulty"` Difficulty *hexnum `json:"difficulty"`
TotalDifficulty *big.Int `json:"totalDifficulty"` TotalDifficulty *hexnum `json:"totalDifficulty"`
Size *big.Int `json:"size"` Size *hexnum `json:"size"`
ExtraData []byte `json:"extraData"` ExtraData *hexdata `json:"extraData"`
GasLimit *big.Int `json:"gasLimit"` GasLimit *hexnum `json:"gasLimit"`
MinGasPrice int64 `json:"minGasPrice"` MinGasPrice *hexnum `json:"minGasPrice"`
GasUsed *big.Int `json:"gasUsed"` GasUsed *hexnum `json:"gasUsed"`
UnixTimestamp int64 `json:"timestamp"` UnixTimestamp *hexnum `json:"timestamp"`
Transactions []*TransactionRes `json:"transactions"` Transactions []*TransactionRes `json:"transactions"`
Uncles []common.Hash `json:"uncles"` Uncles []*hexdata `json:"uncles"`
}
func (b *BlockRes) MarshalJSON() ([]byte, error) {
var ext struct {
BlockNumber *hexnum `json:"number"`
BlockHash *hexdata `json:"hash"`
ParentHash *hexdata `json:"parentHash"`
Nonce *hexnum `json:"nonce"`
Sha3Uncles *hexdata `json:"sha3Uncles"`
LogsBloom *hexdata `json:"logsBloom"`
TransactionRoot *hexdata `json:"transactionRoot"`
StateRoot *hexdata `json:"stateRoot"`
Miner *hexdata `json:"miner"`
Difficulty *hexnum `json:"difficulty"`
TotalDifficulty *hexnum `json:"totalDifficulty"`
Size *hexnum `json:"size"`
ExtraData *hexdata `json:"extraData"`
GasLimit *hexnum `json:"gasLimit"`
MinGasPrice *hexnum `json:"minGasPrice"`
GasUsed *hexnum `json:"gasUsed"`
UnixTimestamp *hexnum `json:"timestamp"`
Transactions []interface{} `json:"transactions"`
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 {
@ -99,92 +35,67 @@ func NewBlockRes(block *types.Block) *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"` Hash *hexdata `json:"hash"`
Nonce uint64 `json:"nonce"` Nonce *hexnum `json:"nonce"`
BlockHash common.Hash `json:"blockHash"` BlockHash *hexdata `json:"blockHash"`
BlockNumber int64 `json:"blockNumber"` BlockNumber *hexnum `json:"blockNumber"`
TxIndex int64 `json:"transactionIndex"` TxIndex *hexnum `json:"transactionIndex"`
From common.Address `json:"from"` From *hexdata `json:"from"`
To *common.Address `json:"to"` To *hexdata `json:"to"`
Value *big.Int `json:"value"` Value *hexnum `json:"value"`
Gas *big.Int `json:"gas"` Gas *hexnum `json:"gas"`
GasPrice *big.Int `json:"gasPrice"` GasPrice *hexnum `json:"gasPrice"`
Input []byte `json:"input"` Input *hexdata `json:"input"`
}
func (t *TransactionRes) MarshalJSON() ([]byte, error) {
var ext struct {
Hash *hexdata `json:"hash"`
Nonce *hexnum `json:"nonce"`
BlockHash *hexdata `json:"blockHash"`
BlockNumber *hexnum `json:"blockNumber"`
TxIndex *hexnum `json:"transactionIndex"`
From *hexdata `json:"from"`
To *hexdata `json:"to"`
Value *hexnum `json:"value"`
Gas *hexnum `json:"gas"`
GasPrice *hexnum `json:"gasPrice"`
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,51 +123,28 @@ func NewTransactionRes(tx *types.Transaction) *TransactionRes {
// } // }
type LogRes struct { type LogRes struct {
Address common.Address `json:"address"` Address *hexdata `json:"address"`
Topics []common.Hash `json:"topics"` Topics []*hexdata `json:"topics"`
Data []byte `json:"data"` Data *hexdata `json:"data"`
BlockNumber uint64 `json:"blockNumber"` BlockNumber *hexnum `json:"blockNumber"`
Hash common.Hash `json:"hash"` Hash *hexdata `json:"hash"`
LogIndex uint64 `json:"logIndex"` LogIndex *hexnum `json:"logIndex"`
BlockHash common.Hash `json:"blockHash"` BlockHash *hexdata `json:"blockHash"`
TransactionHash common.Hash `json:"transactionHash"` TransactionHash *hexdata `json:"transactionHash"`
TransactionIndex uint64 `json:"transactionIndex"` TransactionIndex *hexnum `json:"transactionIndex"`
} }
func NewLogRes(log state.Log) LogRes { func NewLogRes(log state.Log) LogRes {
var l LogRes var l LogRes
l.Topics = make([]common.Hash, len(log.Topics())) l.Topics = make([]*hexdata, len(log.Topics()))
l.Address = log.Address()
l.Data = log.Data()
l.BlockNumber = log.Number()
for j, topic := range log.Topics() { for j, topic := range log.Topics() {
l.Topics[j] = topic l.Topics[j] = newHexData(topic)
}
return l
}
func (l *LogRes) MarshalJSON() ([]byte, error) {
var ext struct {
Address *hexdata `json:"address"`
Topics []*hexdata `json:"topics"`
Data *hexdata `json:"data"`
BlockNumber *hexnum `json:"blockNumber"`
Hash *hexdata `json:"hash"`
LogIndex *hexnum `json:"logIndex"`
BlockHash *hexdata `json:"blockHash"`
TransactionHash *hexdata `json:"transactionHash"`
TransactionIndex *hexnum `json:"transactionIndex"`
} }
l.Address = newHexData(log.Address())
l.Data = newHexData(log.Data())
l.BlockNumber = newHexNum(log.Number())
ext.Address = newHexData(l.Address.Bytes()) return l
ext.Data = newHexData(l.Data)
ext.BlockNumber = newHexNum(l.BlockNumber)
ext.Topics = make([]*hexdata, len(l.Topics))
for i, v := range l.Topics {
ext.Topics[i] = newHexData(v)
}
return json.Marshal(ext)
} }
func NewLogsRes(logs state.Logs) (ls []LogRes) { func NewLogsRes(logs state.Logs) (ls []LogRes) {

234
rpc/responses_test.go
Unescape 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)
} // }

Write Preview
Loading…
Cancel
Save