From e22bcb78a530d07ef63e8ba3e332199c7c860ac6 Mon Sep 17 00:00:00 2001 From: Taylor Gerring Date: Wed, 25 Mar 2015 16:50:30 +0100 Subject: Update response types + tests To coincide with recent type conversion --- rpc/responses.go | 137 +++++++++++++++++++++++++++++--------------------- rpc/responses_test.go | 123 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 202 insertions(+), 58 deletions(-) create mode 100644 rpc/responses_test.go (limited to 'rpc') diff --git a/rpc/responses.go b/rpc/responses.go index 993f467ea..f5f3a33f3 100644 --- a/rpc/responses.go +++ b/rpc/responses.go @@ -6,14 +6,14 @@ import ( "math/big" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" ) type BlockRes struct { fullTx bool - BlockNumber int64 `json:"number"` + BlockNumber *big.Int `json:"number"` BlockHash common.Hash `json:"hash"` ParentHash common.Hash `json:"parentHash"` Nonce [8]byte `json:"nonce"` @@ -22,13 +22,13 @@ type BlockRes struct { TransactionRoot common.Hash `json:"transactionRoot"` StateRoot common.Hash `json:"stateRoot"` Miner common.Address `json:"miner"` - Difficulty int64 `json:"difficulty"` - TotalDifficulty int64 `json:"totalDifficulty"` - Size int64 `json:"size"` + Difficulty *big.Int `json:"difficulty"` + TotalDifficulty *big.Int `json:"totalDifficulty"` + Size *big.Int `json:"size"` ExtraData []byte `json:"extraData"` - GasLimit int64 `json:"gasLimit"` + GasLimit *big.Int `json:"gasLimit"` MinGasPrice int64 `json:"minGasPrice"` - GasUsed int64 `json:"gasUsed"` + GasUsed *big.Int `json:"gasUsed"` UnixTimestamp int64 `json:"timestamp"` Transactions []*TransactionRes `json:"transactions"` Uncles []common.Hash `json:"uncles"` @@ -58,7 +58,7 @@ func (b *BlockRes) MarshalJSON() ([]byte, error) { } // convert strict types to hexified strings - ext.BlockNumber = common.ToHex(big.NewInt(b.BlockNumber).Bytes()) + ext.BlockNumber = common.ToHex(b.BlockNumber.Bytes()) ext.BlockHash = b.BlockHash.Hex() ext.ParentHash = b.ParentHash.Hex() ext.Nonce = common.ToHex(b.Nonce[:]) @@ -67,13 +67,13 @@ func (b *BlockRes) MarshalJSON() ([]byte, error) { ext.TransactionRoot = b.TransactionRoot.Hex() ext.StateRoot = b.StateRoot.Hex() ext.Miner = b.Miner.Hex() - ext.Difficulty = common.ToHex(big.NewInt(b.Difficulty).Bytes()) - ext.TotalDifficulty = common.ToHex(big.NewInt(b.TotalDifficulty).Bytes()) - ext.Size = common.ToHex(big.NewInt(b.Size).Bytes()) + ext.Difficulty = common.ToHex(b.Difficulty.Bytes()) + ext.TotalDifficulty = common.ToHex(b.TotalDifficulty.Bytes()) + ext.Size = common.ToHex(b.Size.Bytes()) // ext.ExtraData = common.ToHex(b.ExtraData) - ext.GasLimit = common.ToHex(big.NewInt(b.GasLimit).Bytes()) + ext.GasLimit = common.ToHex(b.GasLimit.Bytes()) // ext.MinGasPrice = common.ToHex(big.NewInt(b.MinGasPrice).Bytes()) - ext.GasUsed = common.ToHex(big.NewInt(b.GasUsed).Bytes()) + ext.GasUsed = common.ToHex(b.GasUsed.Bytes()) ext.UnixTimestamp = common.ToHex(big.NewInt(b.UnixTimestamp).Bytes()) ext.Transactions = make([]interface{}, len(b.Transactions)) if b.fullTx { @@ -99,7 +99,7 @@ func NewBlockRes(block *types.Block) *BlockRes { } res := new(BlockRes) - res.BlockNumber = block.Number().Int64() + res.BlockNumber = block.Number() res.BlockHash = block.Hash() res.ParentHash = block.ParentHash() res.Nonce = block.Header().Nonce @@ -108,15 +108,13 @@ func NewBlockRes(block *types.Block) *BlockRes { res.TransactionRoot = block.Header().TxHash res.StateRoot = block.Root() res.Miner = block.Header().Coinbase - res.Difficulty = block.Difficulty().Int64() - if block.Td != nil { - res.TotalDifficulty = block.Td.Int64() - } - res.Size = int64(block.Size()) + res.Difficulty = block.Difficulty() + res.TotalDifficulty = block.Td + res.Size = big.NewInt(int64(block.Size())) // res.ExtraData = - res.GasLimit = block.GasLimit().Int64() + res.GasLimit = block.GasLimit() // res.MinGasPrice = - res.GasUsed = block.GasUsed().Int64() + res.GasUsed = block.GasUsed() res.UnixTimestamp = block.Time() res.Transactions = make([]*TransactionRes, len(block.Transactions())) for i, tx := range block.Transactions() { @@ -135,47 +133,47 @@ func NewBlockRes(block *types.Block) *BlockRes { type TransactionRes struct { Hash common.Hash `json:"hash"` - Nonce int64 `json:"nonce"` + Nonce uint64 `json:"nonce"` BlockHash common.Hash `json:"blockHash,omitempty"` BlockNumber int64 `json:"blockNumber,omitempty"` TxIndex int64 `json:"transactionIndex,omitempty"` From common.Address `json:"from"` To *common.Address `json:"to"` - Value int64 `json:"value"` - Gas int64 `json:"gas"` - GasPrice int64 `json:"gasPrice"` + 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 string `json:"hash"` - Nonce string `json:"nonce"` - BlockHash string `json:"blockHash,omitempty"` - BlockNumber string `json:"blockNumber,omitempty"` - TxIndex string `json:"transactionIndex,omitempty"` - From string `json:"from"` - To string `json:"to"` - Value string `json:"value"` - Gas string `json:"gas"` - GasPrice string `json:"gasPrice"` - Input string `json:"input"` + Hash string `json:"hash"` + Nonce string `json:"nonce"` + BlockHash string `json:"blockHash,omitempty"` + BlockNumber string `json:"blockNumber,omitempty"` + TxIndex string `json:"transactionIndex,omitempty"` + From string `json:"from"` + To interface{} `json:"to"` + Value string `json:"value"` + Gas string `json:"gas"` + GasPrice string `json:"gasPrice"` + Input string `json:"input"` } ext.Hash = t.Hash.Hex() - ext.Nonce = common.ToHex(big.NewInt(t.Nonce).Bytes()) + ext.Nonce = common.ToHex(big.NewInt(int64(t.Nonce)).Bytes()) ext.BlockHash = t.BlockHash.Hex() ext.BlockNumber = common.ToHex(big.NewInt(t.BlockNumber).Bytes()) ext.TxIndex = common.ToHex(big.NewInt(t.TxIndex).Bytes()) ext.From = t.From.Hex() if t.To == nil { - ext.To = "0x00" + ext.To = nil } else { ext.To = t.To.Hex() } - ext.Value = common.ToHex(big.NewInt(t.Value).Bytes()) - ext.Gas = common.ToHex(big.NewInt(t.Gas).Bytes()) - ext.GasPrice = common.ToHex(big.NewInt(t.GasPrice).Bytes()) + ext.Value = common.ToHex(t.Value.Bytes()) + ext.Gas = common.ToHex(t.Gas.Bytes()) + ext.GasPrice = common.ToHex(t.GasPrice.Bytes()) ext.Input = common.ToHex(t.Input) return json.Marshal(ext) @@ -184,12 +182,12 @@ func (t *TransactionRes) MarshalJSON() ([]byte, error) { func NewTransactionRes(tx *types.Transaction) *TransactionRes { var v = new(TransactionRes) v.Hash = tx.Hash() - v.Nonce = int64(tx.Nonce()) + v.Nonce = tx.Nonce() v.From, _ = tx.From() v.To = tx.To() - v.Value = tx.Value().Int64() - v.Gas = tx.Gas().Int64() - v.GasPrice = tx.GasPrice().Int64() + v.Value = tx.Value() + v.Gas = tx.Gas() + v.GasPrice = tx.GasPrice() v.Input = tx.Data() return v } @@ -218,25 +216,48 @@ type FilterWhisperRes struct { } type LogRes struct { - Address string `json:"address"` - Topics []string `json:"topics"` - Data string `json:"data"` - Number uint64 `json:"number"` + Address common.Address `json:"address"` + Topics []common.Hash `json:"topics"` + Data []byte `json:"data"` + Number uint64 `json:"number"` +} + +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.Number = log.Number() + for j, topic := range log.Topics() { + l.Topics[j] = topic + } + return l +} + +func (l *LogRes) MarshalJSON() ([]byte, error) { + var ext struct { + Address string `json:"address"` + Topics []string `json:"topics"` + Data string `json:"data"` + Number string `json:"number"` + } + + ext.Address = l.Address.Hex() + ext.Data = common.Bytes2Hex(l.Data) + ext.Number = common.Bytes2Hex(big.NewInt(int64(l.Number)).Bytes()) + ext.Topics = make([]string, len(l.Topics)) + for i, v := range l.Topics { + ext.Topics[i] = v.Hex() + } + + return json.Marshal(ext) } func NewLogsRes(logs state.Logs) (ls []LogRes) { ls = make([]LogRes, len(logs)) for i, log := range logs { - var l LogRes - l.Topics = make([]string, len(log.Topics())) - l.Address = log.Address().Hex() - l.Data = common.ToHex(log.Data()) - l.Number = log.Number() - for j, topic := range log.Topics() { - l.Topics[j] = topic.Hex() - } - ls[i] = l + ls[i] = NewLogRes(log) } return diff --git a/rpc/responses_test.go b/rpc/responses_test.go new file mode 100644 index 000000000..278939830 --- /dev/null +++ b/rpc/responses_test.go @@ -0,0 +1,123 @@ +package rpc + +import ( + "encoding/json" + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" +) + +func TestNewBlockRes(t *testing.T) { + parentHash := common.HexToHash("0x01") + coinbase := common.HexToAddress("0x01") + root := common.HexToHash("0x01") + difficulty := common.Big1 + nonce := uint64(1) + extra := "" + block := types.NewBlock(parentHash, coinbase, root, difficulty, nonce, extra) + + _ = NewBlockRes(block) +} + +func TestBlockRes(t *testing.T) { + v := &BlockRes{ + BlockNumber: big.NewInt(0), + BlockHash: common.HexToHash("0x0"), + ParentHash: common.HexToHash("0x0"), + Nonce: [8]byte{0, 0, 0, 0, 0, 0, 0, 0}, + Sha3Uncles: common.HexToHash("0x0"), + LogsBloom: types.BytesToBloom([]byte{0}), + TransactionRoot: common.HexToHash("0x0"), + StateRoot: common.HexToHash("0x0"), + Miner: common.HexToAddress("0x0"), + Difficulty: big.NewInt(0), + TotalDifficulty: big.NewInt(0), + Size: big.NewInt(0), + ExtraData: []byte{}, + GasLimit: big.NewInt(0), + MinGasPrice: int64(0), + GasUsed: big.NewInt(0), + UnixTimestamp: int64(0), + // Transactions []*TransactionRes `json:"transactions"` + // Uncles []common.Hash `json:"uncles"` + } + + _, _ = json.Marshal(v) + + // fmt.Println(string(j)) + +} + +func TestTransactionRes(t *testing.T) { + a := common.HexToAddress("0x0") + v := &TransactionRes{ + Hash: common.HexToHash("0x0"), + Nonce: uint64(0), + BlockHash: common.HexToHash("0x0"), + BlockNumber: int64(0), + TxIndex: int64(0), + From: common.HexToAddress("0x0"), + To: &a, + Value: big.NewInt(0), + Gas: big.NewInt(0), + GasPrice: big.NewInt(0), + Input: []byte{0}, + } + + _, _ = json.Marshal(v) +} + +func TestNewTransactionRes(t *testing.T) { + to := common.HexToAddress("0x02") + amount := big.NewInt(1) + gasAmount := big.NewInt(1) + gasPrice := big.NewInt(1) + data := []byte{1, 2, 3} + tx := types.NewTransactionMessage(to, amount, gasAmount, gasPrice, data) + + _ = NewTransactionRes(tx) +} + +func TestLogRes(t *testing.T) { + topics := make([]common.Hash, 3) + topics = append(topics, common.HexToHash("0x00")) + topics = append(topics, common.HexToHash("0x10")) + topics = append(topics, common.HexToHash("0x20")) + + v := &LogRes{ + Topics: topics, + Address: common.HexToAddress("0x0"), + Data: []byte{1, 2, 3}, + Number: uint64(5), + } + + _, _ = json.Marshal(v) +} + +func MakeStateLog(num int) state.Log { + address := common.HexToAddress("0x0") + data := []byte{1, 2, 3} + number := uint64(num) + topics := make([]common.Hash, 3) + topics = append(topics, common.HexToHash("0x00")) + topics = append(topics, common.HexToHash("0x10")) + topics = append(topics, common.HexToHash("0x20")) + log := state.NewLog(address, topics, data, number) + return log +} + +func TestNewLogRes(t *testing.T) { + log := MakeStateLog(0) + _ = NewLogRes(log) +} + +func TestNewLogsRes(t *testing.T) { + logs := make([]state.Log, 3) + logs[0] = MakeStateLog(1) + logs[1] = MakeStateLog(2) + logs[2] = MakeStateLog(3) + _ = NewLogsRes(logs) +} -- cgit v1.2.3