forked from mirror/go-ethereum
obscuren
10 years ago
commit
239e17de12
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,434 @@ |
||||
package rpc |
||||
|
||||
import ( |
||||
"bytes" |
||||
"encoding/json" |
||||
"math/big" |
||||
"testing" |
||||
) |
||||
|
||||
func TestSha3(t *testing.T) { |
||||
input := `["0x68656c6c6f20776f726c64"]` |
||||
expected := "0x68656c6c6f20776f726c64" |
||||
|
||||
args := new(Sha3Args) |
||||
json.Unmarshal([]byte(input), &args) |
||||
|
||||
if args.Data != expected { |
||||
t.Error("got %s expected %s", input, expected) |
||||
} |
||||
} |
||||
|
||||
func TestGetBalanceArgs(t *testing.T) { |
||||
input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "0x1f"]` |
||||
expected := new(GetBalanceArgs) |
||||
expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1" |
||||
expected.BlockNumber = 31 |
||||
|
||||
args := new(GetBalanceArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if err := args.requirements(); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if args.Address != expected.Address { |
||||
t.Errorf("Address should be %v but is %v", expected.Address, args.Address) |
||||
} |
||||
|
||||
if args.BlockNumber != expected.BlockNumber { |
||||
t.Errorf("BlockNumber should be %v but is %v", expected.BlockNumber, args.BlockNumber) |
||||
} |
||||
} |
||||
|
||||
func TestGetBlockByHashArgs(t *testing.T) { |
||||
input := `["0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331", true]` |
||||
expected := new(GetBlockByHashArgs) |
||||
expected.BlockHash = "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331" |
||||
expected.Transactions = true |
||||
|
||||
args := new(GetBlockByHashArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if args.BlockHash != expected.BlockHash { |
||||
t.Errorf("BlockHash should be %v but is %v", expected.BlockHash, args.BlockHash) |
||||
} |
||||
|
||||
if args.Transactions != expected.Transactions { |
||||
t.Errorf("Transactions should be %v but is %v", expected.Transactions, args.Transactions) |
||||
} |
||||
} |
||||
|
||||
func TestGetBlockByNumberArgs(t *testing.T) { |
||||
input := `["0x1b4", false]` |
||||
expected := new(GetBlockByNumberArgs) |
||||
expected.BlockNumber = 436 |
||||
expected.Transactions = false |
||||
|
||||
args := new(GetBlockByNumberArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if args.BlockNumber != expected.BlockNumber { |
||||
t.Errorf("BlockHash should be %v but is %v", expected.BlockNumber, args.BlockNumber) |
||||
} |
||||
|
||||
if args.Transactions != expected.Transactions { |
||||
t.Errorf("Transactions should be %v but is %v", expected.Transactions, args.Transactions) |
||||
} |
||||
} |
||||
|
||||
func TestNewTxArgs(t *testing.T) { |
||||
input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155", |
||||
"to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675", |
||||
"gas": "0x76c0", |
||||
"gasPrice": "0x9184e72a000", |
||||
"value": "0x9184e72a000", |
||||
"data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"}]` |
||||
expected := new(NewTxArgs) |
||||
expected.From = "0xb60e8dd61c5d32be8058bb8eb970870f07233155" |
||||
expected.To = "0xd46e8dd67c5d32be8058bb8eb970870f072445675" |
||||
expected.Gas = big.NewInt(30400) |
||||
expected.GasPrice = big.NewInt(10000000000000) |
||||
expected.Value = big.NewInt(10000000000000) |
||||
expected.Data = "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675" |
||||
|
||||
args := new(NewTxArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.From != args.From { |
||||
t.Errorf("From shoud be %#v but is %#v", expected.From, args.From) |
||||
} |
||||
|
||||
if expected.To != args.To { |
||||
t.Errorf("To shoud be %#v but is %#v", expected.To, args.To) |
||||
} |
||||
|
||||
if bytes.Compare(expected.Gas.Bytes(), args.Gas.Bytes()) != 0 { |
||||
t.Errorf("Gas shoud be %#v but is %#v", expected.Gas.Bytes(), args.Gas.Bytes()) |
||||
} |
||||
|
||||
if bytes.Compare(expected.GasPrice.Bytes(), args.GasPrice.Bytes()) != 0 { |
||||
t.Errorf("GasPrice shoud be %#v but is %#v", expected.GasPrice, args.GasPrice) |
||||
} |
||||
|
||||
if bytes.Compare(expected.Value.Bytes(), args.Value.Bytes()) != 0 { |
||||
t.Errorf("Value shoud be %#v but is %#v", expected.Value, args.Value) |
||||
} |
||||
|
||||
if expected.Data != args.Data { |
||||
t.Errorf("Data shoud be %#v but is %#v", expected.Data, args.Data) |
||||
} |
||||
} |
||||
|
||||
func TestGetStorageArgs(t *testing.T) { |
||||
input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"]` |
||||
expected := new(GetStorageArgs) |
||||
expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1" |
||||
expected.BlockNumber = -1 |
||||
|
||||
args := new(GetStorageArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if err := args.requirements(); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.Address != args.Address { |
||||
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address) |
||||
} |
||||
|
||||
if expected.BlockNumber != args.BlockNumber { |
||||
t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber) |
||||
} |
||||
} |
||||
|
||||
func TestGetStorageAtArgs(t *testing.T) { |
||||
input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "0x0", "0x2"]` |
||||
expected := new(GetStorageAtArgs) |
||||
expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1" |
||||
expected.Key = "0x0" |
||||
expected.BlockNumber = 2 |
||||
|
||||
args := new(GetStorageAtArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if err := args.requirements(); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.Address != args.Address { |
||||
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address) |
||||
} |
||||
|
||||
if expected.Key != args.Key { |
||||
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address) |
||||
} |
||||
|
||||
if expected.BlockNumber != args.BlockNumber { |
||||
t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber) |
||||
} |
||||
} |
||||
|
||||
func TestGetTxCountArgs(t *testing.T) { |
||||
input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"]` |
||||
expected := new(GetTxCountArgs) |
||||
expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1" |
||||
expected.BlockNumber = -1 |
||||
|
||||
args := new(GetTxCountArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if err := args.requirements(); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.Address != args.Address { |
||||
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address) |
||||
} |
||||
|
||||
if expected.BlockNumber != args.BlockNumber { |
||||
t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber) |
||||
} |
||||
} |
||||
|
||||
func TestGetDataArgs(t *testing.T) { |
||||
input := `["0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8", "latest"]` |
||||
expected := new(GetDataArgs) |
||||
expected.Address = "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8" |
||||
expected.BlockNumber = -1 |
||||
|
||||
args := new(GetDataArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if err := args.requirements(); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.Address != args.Address { |
||||
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address) |
||||
} |
||||
|
||||
if expected.BlockNumber != args.BlockNumber { |
||||
t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber) |
||||
} |
||||
} |
||||
|
||||
func TestFilterOptions(t *testing.T) { |
||||
input := `[{ |
||||
"fromBlock": "0x1", |
||||
"toBlock": "0x2", |
||||
"limit": "0x3", |
||||
"offset": "0x0", |
||||
"address": "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8", |
||||
"topics": ["0x12341234"]}]` |
||||
expected := new(FilterOptions) |
||||
expected.Earliest = 1 |
||||
expected.Latest = 2 |
||||
expected.Max = 3 |
||||
expected.Skip = 0 |
||||
expected.Address = "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8" |
||||
// expected.Topics = []string{"0x12341234"}
|
||||
|
||||
args := new(FilterOptions) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.Earliest != args.Earliest { |
||||
t.Errorf("Earliest shoud be %#v but is %#v", expected.Earliest, args.Earliest) |
||||
} |
||||
|
||||
if expected.Latest != args.Latest { |
||||
t.Errorf("Latest shoud be %#v but is %#v", expected.Latest, args.Latest) |
||||
} |
||||
|
||||
if expected.Max != args.Max { |
||||
t.Errorf("Max shoud be %#v but is %#v", expected.Max, args.Max) |
||||
} |
||||
|
||||
if expected.Skip != args.Skip { |
||||
t.Errorf("Skip shoud be %#v but is %#v", expected.Skip, args.Skip) |
||||
} |
||||
|
||||
if expected.Address != args.Address { |
||||
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address) |
||||
} |
||||
|
||||
// if expected.Topics != args.Topics {
|
||||
// t.Errorf("Topic shoud be %#v but is %#v", expected.Topic, args.Topic)
|
||||
// }
|
||||
} |
||||
|
||||
func TestDbArgs(t *testing.T) { |
||||
input := `["0x74657374","0x6b6579","0x6d79537472696e67"]` |
||||
expected := new(DbArgs) |
||||
expected.Database = "0x74657374" |
||||
expected.Key = "0x6b6579" |
||||
expected.Value = "0x6d79537472696e67" |
||||
|
||||
args := new(DbArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if err := args.requirements(); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.Database != args.Database { |
||||
t.Errorf("Database shoud be %#v but is %#v", expected.Database, args.Database) |
||||
} |
||||
|
||||
if expected.Key != args.Key { |
||||
t.Errorf("Key shoud be %#v but is %#v", expected.Key, args.Key) |
||||
} |
||||
|
||||
if expected.Value != args.Value { |
||||
t.Errorf("Value shoud be %#v but is %#v", expected.Value, args.Value) |
||||
} |
||||
} |
||||
|
||||
func TestWhisperMessageArgs(t *testing.T) { |
||||
input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2", |
||||
"topics": ["0x68656c6c6f20776f726c64"], |
||||
"payload":"0x68656c6c6f20776f726c64", |
||||
"ttl": "0x64", |
||||
"priority": "0x64"}]` |
||||
expected := new(WhisperMessageArgs) |
||||
expected.From = "0xc931d93e97ab07fe42d923478ba2465f2" |
||||
expected.To = "" |
||||
expected.Payload = "0x68656c6c6f20776f726c64" |
||||
expected.Priority = 100 |
||||
expected.Ttl = 100 |
||||
expected.Topics = []string{"0x68656c6c6f20776f726c64"} |
||||
|
||||
args := new(WhisperMessageArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.From != args.From { |
||||
t.Errorf("From shoud be %#v but is %#v", expected.From, args.From) |
||||
} |
||||
|
||||
if expected.To != args.To { |
||||
t.Errorf("To shoud be %#v but is %#v", expected.To, args.To) |
||||
} |
||||
|
||||
if expected.Payload != args.Payload { |
||||
t.Errorf("Value shoud be %#v but is %#v", expected.Payload, args.Payload) |
||||
} |
||||
|
||||
if expected.Ttl != args.Ttl { |
||||
t.Errorf("Ttl shoud be %#v but is %#v", expected.Ttl, args.Ttl) |
||||
} |
||||
|
||||
if expected.Priority != args.Priority { |
||||
t.Errorf("Priority shoud be %#v but is %#v", expected.Priority, args.Priority) |
||||
} |
||||
|
||||
// if expected.Topics != args.Topics {
|
||||
// t.Errorf("Topic shoud be %#v but is %#v", expected.Topic, args.Topic)
|
||||
// }
|
||||
} |
||||
|
||||
func TestFilterIdArgs(t *testing.T) { |
||||
input := `["0x7"]` |
||||
expected := new(FilterIdArgs) |
||||
expected.Id = 7 |
||||
|
||||
args := new(FilterIdArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.Id != args.Id { |
||||
t.Errorf("Id shoud be %#v but is %#v", expected.Id, args.Id) |
||||
} |
||||
} |
||||
|
||||
func TestWhsiperFilterArgs(t *testing.T) { |
||||
input := `[{"topics": ["0x68656c6c6f20776f726c64"], "to": "0x34ag445g3455b34"}]` |
||||
expected := new(WhisperFilterArgs) |
||||
expected.From = "" |
||||
expected.To = "0x34ag445g3455b34" |
||||
expected.Topics = []string{"0x68656c6c6f20776f726c64"} |
||||
|
||||
args := new(WhisperFilterArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.From != args.From { |
||||
t.Errorf("From shoud be %#v but is %#v", expected.From, args.From) |
||||
} |
||||
|
||||
if expected.To != args.To { |
||||
t.Errorf("To shoud be %#v but is %#v", expected.To, args.To) |
||||
} |
||||
|
||||
// if expected.Topics != args.Topics {
|
||||
// t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
|
||||
// }
|
||||
} |
||||
|
||||
func TestCompileArgs(t *testing.T) { |
||||
input := `["contract test { function multiply(uint a) returns(uint d) { return a * 7; } }"]` |
||||
expected := new(CompileArgs) |
||||
expected.Source = `contract test { function multiply(uint a) returns(uint d) { return a * 7; } }` |
||||
|
||||
args := new(CompileArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.Source != args.Source { |
||||
t.Errorf("Source shoud be %#v but is %#v", expected.Source, args.Source) |
||||
} |
||||
} |
||||
|
||||
func TestFilterStringArgs(t *testing.T) { |
||||
input := `["pending"]` |
||||
expected := new(FilterStringArgs) |
||||
expected.Word = "pending" |
||||
|
||||
args := new(FilterStringArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.Word != args.Word { |
||||
t.Errorf("Word shoud be %#v but is %#v", expected.Word, args.Word) |
||||
} |
||||
} |
||||
|
||||
func TestWhisperIdentityArgs(t *testing.T) { |
||||
input := `["0xc931d93e97ab07fe42d923478ba2465f283"]` |
||||
expected := new(WhisperIdentityArgs) |
||||
expected.Identity = "0xc931d93e97ab07fe42d923478ba2465f283" |
||||
|
||||
args := new(WhisperIdentityArgs) |
||||
if err := json.Unmarshal([]byte(input), &args); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if expected.Identity != args.Identity { |
||||
t.Errorf("Identity shoud be %#v but is %#v", expected.Identity, args.Identity) |
||||
} |
||||
} |
||||
@ -0,0 +1,212 @@ |
||||
package rpc |
||||
|
||||
import ( |
||||
"encoding/json" |
||||
// "fmt"
|
||||
"math/big" |
||||
|
||||
"github.com/ethereum/go-ethereum/core/types" |
||||
) |
||||
|
||||
type BlockRes struct { |
||||
fullTx bool |
||||
|
||||
BlockNumber int64 `json:"number"` |
||||
BlockHash []byte `json:"hash"` |
||||
ParentHash []byte `json:"parentHash"` |
||||
Nonce []byte `json:"nonce"` |
||||
Sha3Uncles []byte `json:"sha3Uncles"` |
||||
LogsBloom []byte `json:"logsBloom"` |
||||
TransactionRoot []byte `json:"transactionRoot"` |
||||
StateRoot []byte `json:"stateRoot"` |
||||
Miner []byte `json:"miner"` |
||||
Difficulty int64 `json:"difficulty"` |
||||
TotalDifficulty int64 `json:"totalDifficulty"` |
||||
Size int64 `json:"size"` |
||||
ExtraData []byte `json:"extraData"` |
||||
GasLimit int64 `json:"gasLimit"` |
||||
MinGasPrice int64 `json:"minGasPrice"` |
||||
GasUsed int64 `json:"gasUsed"` |
||||
UnixTimestamp int64 `json:"timestamp"` |
||||
Transactions []*TransactionRes `json:"transactions"` |
||||
Uncles [][]byte `json:"uncles"` |
||||
} |
||||
|
||||
func (b *BlockRes) MarshalJSON() ([]byte, error) { |
||||
var ext struct { |
||||
BlockNumber string `json:"number"` |
||||
BlockHash string `json:"hash"` |
||||
ParentHash string `json:"parentHash"` |
||||
Nonce string `json:"nonce"` |
||||
Sha3Uncles string `json:"sha3Uncles"` |
||||
LogsBloom string `json:"logsBloom"` |
||||
TransactionRoot string `json:"transactionRoot"` |
||||
StateRoot string `json:"stateRoot"` |
||||
Miner string `json:"miner"` |
||||
Difficulty string `json:"difficulty"` |
||||
TotalDifficulty string `json:"totalDifficulty"` |
||||
Size string `json:"size"` |
||||
ExtraData string `json:"extraData"` |
||||
GasLimit string `json:"gasLimit"` |
||||
MinGasPrice string `json:"minGasPrice"` |
||||
GasUsed string `json:"gasUsed"` |
||||
UnixTimestamp string `json:"timestamp"` |
||||
Transactions []interface{} `json:"transactions"` |
||||
Uncles []string `json:"uncles"` |
||||
} |
||||
|
||||
// convert strict types to hexified strings
|
||||
ext.BlockNumber = toHex(big.NewInt(b.BlockNumber).Bytes()) |
||||
ext.BlockHash = toHex(b.BlockHash) |
||||
ext.ParentHash = toHex(b.ParentHash) |
||||
ext.Nonce = toHex(b.Nonce) |
||||
ext.Sha3Uncles = toHex(b.Sha3Uncles) |
||||
ext.LogsBloom = toHex(b.LogsBloom) |
||||
ext.TransactionRoot = toHex(b.TransactionRoot) |
||||
ext.StateRoot = toHex(b.StateRoot) |
||||
ext.Miner = toHex(b.Miner) |
||||
ext.Difficulty = toHex(big.NewInt(b.Difficulty).Bytes()) |
||||
ext.TotalDifficulty = toHex(big.NewInt(b.TotalDifficulty).Bytes()) |
||||
ext.Size = toHex(big.NewInt(b.Size).Bytes()) |
||||
// ext.ExtraData = toHex(b.ExtraData)
|
||||
ext.GasLimit = toHex(big.NewInt(b.GasLimit).Bytes()) |
||||
// ext.MinGasPrice = toHex(big.NewInt(b.MinGasPrice).Bytes())
|
||||
ext.GasUsed = toHex(big.NewInt(b.GasUsed).Bytes()) |
||||
ext.UnixTimestamp = toHex(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] = toHex(tx.Hash) |
||||
} |
||||
} |
||||
ext.Uncles = make([]string, len(b.Uncles)) |
||||
for i, v := range b.Uncles { |
||||
ext.Uncles[i] = toHex(v) |
||||
} |
||||
|
||||
return json.Marshal(ext) |
||||
} |
||||
|
||||
func NewBlockRes(block *types.Block) *BlockRes { |
||||
if block == nil { |
||||
return &BlockRes{} |
||||
} |
||||
|
||||
res := new(BlockRes) |
||||
res.BlockNumber = block.Number().Int64() |
||||
res.BlockHash = block.Hash() |
||||
res.ParentHash = block.ParentHash() |
||||
res.Nonce = block.Header().Nonce |
||||
res.Sha3Uncles = block.Header().UncleHash |
||||
res.LogsBloom = block.Bloom() |
||||
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.ExtraData =
|
||||
res.GasLimit = block.GasLimit().Int64() |
||||
// res.MinGasPrice =
|
||||
res.GasUsed = block.GasUsed().Int64() |
||||
res.UnixTimestamp = block.Time() |
||||
res.Transactions = make([]*TransactionRes, len(block.Transactions())) |
||||
for i, tx := range block.Transactions() { |
||||
v := NewTransactionRes(tx) |
||||
v.BlockHash = block.Hash() |
||||
v.BlockNumber = block.Number().Int64() |
||||
v.TxIndex = int64(i) |
||||
res.Transactions[i] = v |
||||
} |
||||
res.Uncles = make([][]byte, len(block.Uncles())) |
||||
for i, uncle := range block.Uncles() { |
||||
res.Uncles[i] = uncle.Hash() |
||||
} |
||||
return res |
||||
} |
||||
|
||||
type TransactionRes struct { |
||||
Hash []byte `json:"hash"` |
||||
Nonce int64 `json:"nonce"` |
||||
BlockHash []byte `json:"blockHash,omitempty"` |
||||
BlockNumber int64 `json:"blockNumber,omitempty"` |
||||
TxIndex int64 `json:"transactionIndex,omitempty"` |
||||
From []byte `json:"from"` |
||||
To []byte `json:"to"` |
||||
Value int64 `json:"value"` |
||||
Gas int64 `json:"gas"` |
||||
GasPrice int64 `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"` |
||||
} |
||||
|
||||
ext.Hash = toHex(t.Hash) |
||||
ext.Nonce = toHex(big.NewInt(t.Nonce).Bytes()) |
||||
ext.BlockHash = toHex(t.BlockHash) |
||||
ext.BlockNumber = toHex(big.NewInt(t.BlockNumber).Bytes()) |
||||
ext.TxIndex = toHex(big.NewInt(t.TxIndex).Bytes()) |
||||
ext.From = toHex(t.From) |
||||
ext.To = toHex(t.To) |
||||
ext.Value = toHex(big.NewInt(t.Value).Bytes()) |
||||
ext.Gas = toHex(big.NewInt(t.Gas).Bytes()) |
||||
ext.GasPrice = toHex(big.NewInt(t.GasPrice).Bytes()) |
||||
ext.Input = toHex(t.Input) |
||||
|
||||
return json.Marshal(ext) |
||||
} |
||||
|
||||
func NewTransactionRes(tx *types.Transaction) *TransactionRes { |
||||
var v = new(TransactionRes) |
||||
v.Hash = tx.Hash() |
||||
v.Nonce = int64(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.Input = tx.Data() |
||||
return v |
||||
} |
||||
|
||||
type FilterLogRes struct { |
||||
Hash string `json:"hash"` |
||||
Address string `json:"address"` |
||||
Data string `json:"data"` |
||||
BlockNumber string `json:"blockNumber"` |
||||
TransactionHash string `json:"transactionHash"` |
||||
BlockHash string `json:"blockHash"` |
||||
TransactionIndex string `json:"transactionIndex"` |
||||
LogIndex string `json:"logIndex"` |
||||
} |
||||
|
||||
type FilterWhisperRes struct { |
||||
Hash string `json:"hash"` |
||||
From string `json:"from"` |
||||
To string `json:"to"` |
||||
Expiry string `json:"expiry"` |
||||
Sent string `json:"sent"` |
||||
Ttl string `json:"ttl"` |
||||
Topics string `json:"topics"` |
||||
Payload string `json:"payload"` |
||||
WorkProved string `json:"workProved"` |
||||
} |
||||
@ -0,0 +1,25 @@ |
||||
package rpc |
||||
|
||||
import ( |
||||
"bytes" |
||||
"testing" |
||||
) |
||||
|
||||
//fromHex
|
||||
func TestFromHex(t *testing.T) { |
||||
input := "0x01" |
||||
expected := []byte{1} |
||||
result := fromHex(input) |
||||
if bytes.Compare(expected, result) != 0 { |
||||
t.Errorf("Expected % x got % x", expected, result) |
||||
} |
||||
} |
||||
|
||||
func TestFromHexOddLength(t *testing.T) { |
||||
input := "0x1" |
||||
expected := []byte{1} |
||||
result := fromHex(input) |
||||
if bytes.Compare(expected, result) != 0 { |
||||
t.Errorf("Expected % x got % x", expected, result) |
||||
} |
||||
} |
||||
Loading…
Reference in new issue