plugeth/rpc/api.go

770 lines
20 KiB
Go
Raw Normal View History

2014-10-21 11:24:48 +00:00
package rpc
import (
2015-03-06 03:37:45 +00:00
"encoding/json"
2014-10-21 11:24:48 +00:00
"math/big"
"strings"
"sync"
"time"
2014-10-21 11:24:48 +00:00
"github.com/ethereum/go-ethereum/core"
2015-02-05 19:55:03 +00:00
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/ethutil"
2015-02-26 10:14:54 +00:00
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/event/filter"
"github.com/ethereum/go-ethereum/state"
2014-10-31 13:30:08 +00:00
"github.com/ethereum/go-ethereum/xeth"
2014-10-21 11:24:48 +00:00
)
2015-02-24 16:32:11 +00:00
var (
2015-02-24 18:54:18 +00:00
defaultGasPrice = big.NewInt(10000000000000)
defaultGas = big.NewInt(10000)
filterTickerTime = 15 * time.Second
)
type EthereumApi struct {
2015-02-26 10:14:54 +00:00
eth *xeth.XEth
xethMu sync.RWMutex
mux *event.TypeMux
quit chan struct{}
filterManager *filter.FilterManager
logMut sync.RWMutex
logs map[int]*logFilter
messagesMut sync.RWMutex
messages map[int]*whisperFilter
2015-02-17 15:54:52 +00:00
// Register keeps a list of accounts and transaction data
regmut sync.Mutex
register map[string][]*NewTxArgs
db ethutil.Database
2015-02-25 08:57:49 +00:00
2015-03-02 15:36:48 +00:00
// defaultBlockAge int64
}
func NewEthereumApi(eth *xeth.XEth) *EthereumApi {
db, _ := ethdb.NewLDBDatabase("dapps")
api := &EthereumApi{
2015-03-02 15:36:48 +00:00
eth: eth,
mux: eth.Backend().EventMux(),
quit: make(chan struct{}),
filterManager: filter.NewFilterManager(eth.Backend().EventMux()),
logs: make(map[int]*logFilter),
messages: make(map[int]*whisperFilter),
db: db,
// defaultBlockAge: -1,
}
go api.filterManager.Start()
go api.start()
return api
}
2015-03-02 15:36:48 +00:00
// func (self *EthereumApi) setStateByBlockNumber(num int64) {
// chain := self.xeth().Backend().ChainManager()
// var block *types.Block
2015-02-26 11:06:10 +00:00
2015-03-02 15:36:48 +00:00
// if self.defaultBlockAge < 0 {
// num = chain.CurrentBlock().Number().Int64() + num + 1
// }
// block = chain.GetBlockByNumber(uint64(num))
2015-02-26 11:06:10 +00:00
2015-03-02 15:36:48 +00:00
// if block != nil {
2015-03-09 16:55:01 +00:00
// self.useState(state.New(block.Root(), self.xeth().Backend().StateDb()))
2015-03-02 15:36:48 +00:00
// } else {
// self.useState(chain.State())
// }
// }
2015-02-26 11:06:10 +00:00
2015-02-24 18:54:18 +00:00
func (self *EthereumApi) start() {
timer := time.NewTicker(filterTickerTime)
2015-03-02 15:36:48 +00:00
// events := self.mux.Subscribe(core.ChainEvent{})
2015-02-26 10:14:54 +00:00
2015-02-24 18:54:18 +00:00
done:
for {
select {
2015-03-02 15:36:48 +00:00
// case ev := <-events.Chan():
// switch ev.(type) {
// case core.ChainEvent:
// if self.defaultBlockAge < 0 {
// self.setStateByBlockNumber(self.defaultBlockAge)
// }
// }
2015-02-24 18:54:18 +00:00
case <-timer.C:
self.logMut.Lock()
self.messagesMut.Lock()
for id, filter := range self.logs {
if time.Since(filter.timeout) > 20*time.Second {
self.filterManager.UninstallFilter(id)
delete(self.logs, id)
}
}
for id, filter := range self.messages {
if time.Since(filter.timeout) > 20*time.Second {
2015-02-26 10:14:54 +00:00
self.xeth().Whisper().Unwatch(id)
2015-02-24 18:54:18 +00:00
delete(self.messages, id)
}
}
self.logMut.Unlock()
self.messagesMut.Unlock()
case <-self.quit:
break done
}
}
}
func (self *EthereumApi) stop() {
close(self.quit)
}
2015-03-06 03:48:03 +00:00
// func (self *EthereumApi) Register(args string, reply *interface{}) error {
// self.regmut.Lock()
// defer self.regmut.Unlock()
2015-02-17 15:54:52 +00:00
2015-03-06 03:48:03 +00:00
// if _, ok := self.register[args]; ok {
// self.register[args] = nil // register with empty
// }
// return nil
// }
2015-02-17 15:54:52 +00:00
2015-03-06 03:48:03 +00:00
// func (self *EthereumApi) Unregister(args string, reply *interface{}) error {
// self.regmut.Lock()
// defer self.regmut.Unlock()
2015-02-17 15:54:52 +00:00
2015-03-06 03:48:03 +00:00
// delete(self.register, args)
2015-02-17 15:54:52 +00:00
2015-03-06 03:48:03 +00:00
// return nil
// }
2015-02-17 15:54:52 +00:00
2015-03-06 03:37:45 +00:00
// func (self *EthereumApi) WatchTx(args string, reply *interface{}) error {
// self.regmut.Lock()
// defer self.regmut.Unlock()
2015-02-17 15:54:52 +00:00
2015-03-06 03:37:45 +00:00
// txs := self.register[args]
// self.register[args] = nil
2015-02-17 15:54:52 +00:00
2015-03-06 03:37:45 +00:00
// *reply = txs
// return nil
// }
2015-02-17 15:54:52 +00:00
func (self *EthereumApi) NewFilter(args *FilterOptions, reply *interface{}) error {
var id int
2015-02-26 10:14:54 +00:00
filter := core.NewFilter(self.xeth().Backend())
filter.SetOptions(toFilterOptions(args))
filter.LogsCallback = func(logs state.Logs) {
self.logMut.Lock()
defer self.logMut.Unlock()
self.logs[id].add(logs...)
}
id = self.filterManager.InstallFilter(filter)
2015-02-20 15:59:08 +00:00
self.logs[id] = &logFilter{timeout: time.Now()}
*reply = i2hex(id)
return nil
}
2015-02-19 12:21:37 +00:00
func (self *EthereumApi) UninstallFilter(id int, reply *interface{}) error {
delete(self.logs, id)
self.filterManager.UninstallFilter(id)
*reply = true
return nil
}
2015-02-05 19:55:03 +00:00
func (self *EthereumApi) NewFilterString(args string, reply *interface{}) error {
var id int
2015-02-26 10:14:54 +00:00
filter := core.NewFilter(self.xeth().Backend())
2015-02-05 19:55:03 +00:00
callback := func(block *types.Block) {
self.logMut.Lock()
defer self.logMut.Unlock()
self.logs[id].add(&state.StateLog{})
2015-02-05 19:55:03 +00:00
}
if args == "pending" {
filter.PendingCallback = callback
} else if args == "chain" {
filter.BlockCallback = callback
}
id = self.filterManager.InstallFilter(filter)
self.logs[id] = &logFilter{timeout: time.Now()}
2015-03-10 19:16:53 +00:00
*reply = i2hex(id)
2015-02-05 19:55:03 +00:00
return nil
}
func (self *EthereumApi) FilterChanged(id int, reply *interface{}) error {
self.logMut.Lock()
defer self.logMut.Unlock()
if self.logs[id] != nil {
*reply = toLogs(self.logs[id].get())
}
return nil
}
func (self *EthereumApi) Logs(id int, reply *interface{}) error {
self.logMut.Lock()
defer self.logMut.Unlock()
filter := self.filterManager.GetFilter(id)
if filter != nil {
*reply = toLogs(filter.Find())
}
return nil
2014-10-21 11:24:48 +00:00
}
func (self *EthereumApi) AllLogs(args *FilterOptions, reply *interface{}) error {
2015-02-26 10:14:54 +00:00
filter := core.NewFilter(self.xeth().Backend())
filter.SetOptions(toFilterOptions(args))
*reply = toLogs(filter.Find())
return nil
}
func (p *EthereumApi) Transact(args *NewTxArgs, reply *interface{}) error {
2015-03-04 14:22:59 +00:00
if args.Gas == ethutil.Big0 {
args.Gas = defaultGas
}
2015-03-04 14:22:59 +00:00
if args.GasPrice == ethutil.Big0 {
args.GasPrice = defaultGasPrice
}
2015-02-17 15:54:52 +00:00
// TODO if no_private_key then
2015-02-26 10:14:54 +00:00
//if _, exists := p.register[args.From]; exists {
// p.register[args.From] = append(p.register[args.From], args)
//} else {
/*
account := accounts.Get(fromHex(args.From))
if account != nil {
if account.Unlocked() {
if !unlockAccount(account) {
return
}
}
result, _ := account.Transact(fromHex(args.To), fromHex(args.Value), fromHex(args.Gas), fromHex(args.GasPrice), fromHex(args.Data))
if len(result) > 0 {
*reply = toHex(result)
}
} else if _, exists := p.register[args.From]; exists {
p.register[ags.From] = append(p.register[args.From], args)
}
*/
2015-03-04 14:22:59 +00:00
result, err := p.xeth().Transact( /* TODO specify account */ args.To, args.Value.String(), args.Gas.String(), args.GasPrice.String(), args.Data)
if err != nil {
return err
}
2015-02-26 10:14:54 +00:00
*reply = result
//}
return nil
}
func (p *EthereumApi) Call(args *NewTxArgs, reply *interface{}) error {
2015-03-04 14:22:59 +00:00
result, err := p.xeth().Call( /* TODO specify account */ args.To, args.Value.String(), args.Gas.String(), args.GasPrice.String(), args.Data)
if err != nil {
return err
}
*reply = result
return nil
2014-10-21 11:24:48 +00:00
}
2015-03-06 03:37:45 +00:00
func (p *EthereumApi) GetBalance(args *GetBalanceArgs, reply *interface{}) error {
if err := args.requirements(); err != nil {
return err
2014-10-21 11:24:48 +00:00
}
2015-03-06 03:37:45 +00:00
state := p.xeth().State().SafeGet(args.Address)
*reply = toHex(state.Balance().Bytes())
return nil
2014-10-21 11:24:48 +00:00
}
2015-03-06 03:37:45 +00:00
func (p *EthereumApi) GetStorage(args *GetStorageArgs, reply *interface{}) error {
if err := args.requirements(); err != nil {
return err
2014-10-21 11:24:48 +00:00
}
2015-03-06 03:37:45 +00:00
*reply = p.xeth().State().SafeGet(args.Address).Storage()
return nil
}
2015-03-06 03:37:45 +00:00
func (p *EthereumApi) GetStorageAt(args *GetStorageAtArgs, reply *interface{}) error {
if err := args.requirements(); err != nil {
return err
}
2015-02-26 10:14:54 +00:00
state := p.xeth().State().SafeGet(args.Address)
value := state.StorageString(args.Key)
var hx string
if strings.Index(args.Key, "0x") == 0 {
hx = string([]byte(args.Key)[2:])
} else {
// Convert the incoming string (which is a bigint) into hex
i, _ := new(big.Int).SetString(args.Key, 10)
hx = ethutil.Bytes2Hex(i.Bytes())
}
rpclogger.Debugf("GetStateAt(%s, %s)\n", args.Address, hx)
*reply = map[string]string{args.Key: value.Str()}
return nil
}
func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
2014-10-21 11:24:48 +00:00
}
2015-02-26 10:14:54 +00:00
*reply = p.xeth().TxCountAt(args.Address)
2014-10-21 11:24:48 +00:00
return nil
}
2015-03-06 03:37:45 +00:00
func (p *EthereumApi) GetData(args *GetDataArgs, reply *interface{}) error {
if err := args.requirements(); err != nil {
2015-01-13 15:27:36 +00:00
return err
}
2015-02-26 10:14:54 +00:00
*reply = p.xeth().CodeAt(args.Address)
2015-01-13 15:27:36 +00:00
return nil
}
2015-02-19 17:41:50 +00:00
func (p *EthereumApi) GetCompilers(reply *interface{}) error {
2015-03-09 15:55:18 +00:00
c := []string{""}
2015-02-19 17:41:50 +00:00
*reply = c
return nil
}
func (p *EthereumApi) DbPut(args *DbArgs, reply *interface{}) error {
2015-03-06 03:37:45 +00:00
if err := args.requirements(); err != nil {
return err
}
p.db.Put([]byte(args.Database+args.Key), []byte(args.Value))
*reply = true
return nil
}
func (p *EthereumApi) DbGet(args *DbArgs, reply *interface{}) error {
2015-03-06 03:37:45 +00:00
if err := args.requirements(); err != nil {
return err
}
res, _ := p.db.Get([]byte(args.Database + args.Key))
*reply = string(res)
return nil
}
func (p *EthereumApi) NewWhisperIdentity(reply *interface{}) error {
2015-02-26 10:14:54 +00:00
*reply = p.xeth().Whisper().NewIdentity()
return nil
}
2015-03-06 03:37:45 +00:00
func (p *EthereumApi) NewWhisperFilter(args *WhisperFilterArgs, reply *interface{}) error {
var id int
2015-03-06 03:37:45 +00:00
opts := new(xeth.Options)
opts.From = args.From
opts.To = args.To
opts.Topics = args.Topics
opts.Fn = func(msg xeth.WhisperMessage) {
p.messagesMut.Lock()
defer p.messagesMut.Unlock()
p.messages[id].add(msg) // = append(p.messages[id], msg)
}
2015-03-06 03:37:45 +00:00
id = p.xeth().Whisper().Watch(opts)
p.messages[id] = &whisperFilter{timeout: time.Now()}
*reply = id
return nil
}
func (self *EthereumApi) MessagesChanged(id int, reply *interface{}) error {
self.messagesMut.Lock()
defer self.messagesMut.Unlock()
if self.messages[id] != nil {
*reply = self.messages[id].get()
}
return nil
}
func (p *EthereumApi) WhisperPost(args *WhisperMessageArgs, reply *interface{}) error {
2015-02-26 10:14:54 +00:00
err := p.xeth().Whisper().Post(args.Payload, args.To, args.From, args.Topic, args.Priority, args.Ttl)
if err != nil {
return err
}
*reply = true
return nil
}
func (p *EthereumApi) HasWhisperIdentity(args string, reply *interface{}) error {
2015-02-26 10:14:54 +00:00
*reply = p.xeth().Whisper().HasIdentity(args)
return nil
}
func (p *EthereumApi) WhisperMessages(id int, reply *interface{}) error {
2015-02-26 10:14:54 +00:00
*reply = p.xeth().Whisper().Messages(id)
return nil
}
2015-03-10 17:52:45 +00:00
func (p *EthereumApi) GetBlockByHash(blockhash string, includetx bool) (*BlockRes, error) {
block := p.xeth().EthBlockByHash(blockhash)
br := NewBlockRes(block)
br.fullTx = includetx
return br, nil
}
func (p *EthereumApi) GetBlockByNumber(blocknum int64, includetx bool) (*BlockRes, error) {
block := p.xeth().EthBlockByNumber(blocknum)
br := NewBlockRes(block)
br.fullTx = includetx
return br, nil
}
func (p *EthereumApi) GetBlockTransactionCountByHash(blockhash string) (int64, error) {
block := p.xeth().EthBlockByHash(blockhash)
br := NewBlockRes(block)
return int64(len(br.Transactions)), nil
}
func (p *EthereumApi) GetBlockTransactionCountByNumber(blocknum int64) (int64, error) {
block := p.xeth().EthBlockByNumber(blocknum)
br := NewBlockRes(block)
return int64(len(br.Transactions)), nil
}
func (p *EthereumApi) GetBlockUncleCountByHash(blockhash string) (int64, error) {
block := p.xeth().EthBlockByHash(blockhash)
br := NewBlockRes(block)
return int64(len(br.Uncles)), nil
}
func (p *EthereumApi) GetBlockUncleCountByNumber(blocknum int64) (int64, error) {
block := p.xeth().EthBlockByNumber(blocknum)
br := NewBlockRes(block)
return int64(len(br.Uncles)), nil
}
func (p *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error {
2015-02-24 18:05:03 +00:00
// Spec at https://github.com/ethereum/wiki/wiki/Generic-JSON-RPC
rpclogger.Infof("%s %s", req.Method, req.Params)
switch req.Method {
case "web3_sha3":
2015-03-06 03:37:45 +00:00
args := new(Sha3Args)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
2015-03-06 03:37:45 +00:00
*reply = toHex(crypto.Sha3(fromHex(args.Data)))
case "net_listening":
2015-03-06 03:37:45 +00:00
*reply = p.xeth().IsListening()
case "net_peerCount":
2015-03-06 03:37:45 +00:00
*reply = toHex(big.NewInt(int64(p.xeth().PeerCount())).Bytes())
case "eth_coinbase":
2015-03-06 03:37:45 +00:00
*reply = p.xeth().Coinbase()
case "eth_mining":
2015-03-06 03:37:45 +00:00
*reply = p.xeth().IsMining()
case "eth_gasPrice":
*reply = toHex(defaultGasPrice.Bytes())
case "eth_accounts":
2015-03-06 03:37:45 +00:00
*reply = p.xeth().Accounts()
case "eth_blockNumber":
2015-03-06 03:37:45 +00:00
*reply = toHex(p.xeth().Backend().ChainManager().CurrentBlock().Number().Bytes())
case "eth_getBalance":
2015-03-06 03:37:45 +00:00
// TODO handle BlockNumber
args := new(GetBalanceArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
2015-03-06 03:37:45 +00:00
return p.GetBalance(args, reply)
case "eth_getStorage", "eth_storageAt":
2015-03-06 03:37:45 +00:00
// TODO handle BlockNumber
args := new(GetStorageArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
2015-03-05 18:26:21 +00:00
return p.GetStorage(args, reply)
case "eth_getStorageAt":
2015-03-06 03:37:45 +00:00
// TODO handle BlockNumber
args := new(GetStorageAtArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
return p.GetStorageAt(args, reply)
case "eth_getTransactionCount":
2015-03-06 03:37:45 +00:00
// TODO handle BlockNumber
args := new(GetTxCountArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
return p.GetTxCountAt(args, reply)
case "eth_getBlockTransactionCountByHash":
2015-03-10 17:52:45 +00:00
args := new(GetBlockByHashArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
v, err := p.GetBlockTransactionCountByHash(args.BlockHash)
if err != nil {
return err
}
*reply = toHex(big.NewInt(v).Bytes())
case "eth_getBlockTransactionCountByNumber":
2015-03-10 17:52:45 +00:00
args := new(GetBlockByNumberArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
v, err := p.GetBlockTransactionCountByNumber(args.BlockNumber)
if err != nil {
return err
}
*reply = toHex(big.NewInt(v).Bytes())
case "eth_getUncleCountByBlockHash":
2015-03-10 17:52:45 +00:00
args := new(GetBlockByHashArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
v, err := p.GetBlockUncleCountByHash(args.BlockHash)
if err != nil {
return err
}
*reply = toHex(big.NewInt(v).Bytes())
case "eth_getUncleCountByBlockNumber":
2015-03-10 17:52:45 +00:00
args := new(GetBlockByNumberArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
v, err := p.GetBlockUncleCountByNumber(args.BlockNumber)
if err != nil {
return err
}
*reply = toHex(big.NewInt(v).Bytes())
case "eth_getData":
2015-03-06 03:37:45 +00:00
// TODO handle BlockNumber
args := new(GetDataArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
2015-03-06 03:37:45 +00:00
return p.GetData(args, reply)
2015-03-10 19:28:20 +00:00
case "eth_sendTransaction", "eth_transact":
2015-03-06 03:37:45 +00:00
args := new(NewTxArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
2015-01-29 11:01:51 +00:00
return err
}
return p.Transact(args, reply)
case "eth_call":
2015-03-06 03:37:45 +00:00
args := new(NewTxArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
return p.Call(args, reply)
case "eth_flush":
return errNotImplemented
2015-03-05 17:07:05 +00:00
case "eth_getBlockByHash":
2015-03-06 03:37:45 +00:00
args := new(GetBlockByHashArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
2015-03-10 17:52:45 +00:00
v, err := p.GetBlockByHash(args.BlockHash, args.Transactions)
if err != nil {
return err
}
*reply = v
2015-03-06 03:37:45 +00:00
case "eth_getBlockByNumber":
args := new(GetBlockByNumberArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
2015-03-10 17:52:45 +00:00
v, err := p.GetBlockByNumber(args.BlockNumber, args.Transactions)
if err != nil {
return err
}
*reply = v
case "eth_getTransactionByHash":
case "eth_getTransactionByBlockHashAndIndex":
case "eth_getTransactionByBlockNumberAndIndex":
case "eth_getUncleByBlockHashAndIndex":
case "eth_getUncleByBlockNumberAndIndex":
return errNotImplemented
case "eth_getCompilers":
return p.GetCompilers(reply)
case "eth_compileSolidity":
case "eth_compileLLL":
case "eth_compileSerpent":
2015-03-09 15:55:18 +00:00
return errNotImplemented
case "eth_newFilter":
2015-03-06 03:37:45 +00:00
args := new(FilterOptions)
if err := json.Unmarshal(req.Params, &args); err != nil {
2015-02-05 19:55:03 +00:00
return err
}
return p.NewFilter(args, reply)
2015-03-05 17:07:05 +00:00
case "eth_newBlockFilter":
2015-03-06 03:37:45 +00:00
args := new(FilterStringArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
2015-03-05 17:07:05 +00:00
return err
}
2015-03-06 03:37:45 +00:00
return p.NewFilterString(args.Word, reply)
2015-02-19 12:21:37 +00:00
case "eth_uninstallFilter":
2015-03-06 03:37:45 +00:00
args := new(FilterIdArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
2015-02-19 12:21:37 +00:00
return err
}
2015-03-06 03:37:45 +00:00
return p.UninstallFilter(args.Id, reply)
case "eth_getFilterChanges":
2015-03-06 03:37:45 +00:00
args := new(FilterIdArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
2015-03-06 03:37:45 +00:00
return p.FilterChanged(args.Id, reply)
case "eth_getFilterLogs":
2015-03-06 03:37:45 +00:00
args := new(FilterIdArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
2015-03-06 03:37:45 +00:00
return p.Logs(args.Id, reply)
case "eth_getLogs":
2015-03-06 03:37:45 +00:00
args := new(FilterOptions)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
return p.AllLogs(args, reply)
case "eth_getWork":
case "eth_submitWork":
return errNotImplemented
case "db_put":
2015-03-06 03:37:45 +00:00
args := new(DbArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
return p.DbPut(args, reply)
case "db_get":
2015-03-06 03:37:45 +00:00
args := new(DbArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
return p.DbGet(args, reply)
case "shh_post":
2015-03-06 03:37:45 +00:00
args := new(WhisperMessageArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
return p.WhisperPost(args, reply)
case "shh_newIdentity":
return p.NewWhisperIdentity(reply)
case "shh_hasIdentity":
2015-03-06 03:37:45 +00:00
args := new(WhisperIdentityArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
2015-03-06 03:37:45 +00:00
return p.HasWhisperIdentity(args.Identity, reply)
case "shh_newGroup":
case "shh_addToGroup":
return errNotImplemented
case "shh_newFilter":
2015-03-06 03:37:45 +00:00
args := new(WhisperFilterArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
return p.NewWhisperFilter(args, reply)
case "shh_uninstallFilter":
return errNotImplemented
2015-03-05 17:07:05 +00:00
case "shh_getFilterChanges":
2015-03-06 03:37:45 +00:00
args := new(FilterIdArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
2015-03-06 03:37:45 +00:00
return p.MessagesChanged(args.Id, reply)
case "shh_getMessages":
2015-03-06 03:37:45 +00:00
args := new(FilterIdArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
2015-03-06 03:37:45 +00:00
return p.WhisperMessages(args.Id, reply)
2015-03-06 03:48:03 +00:00
// case "eth_register":
// args, err := req.ToRegisterArgs()
// if err != nil {
// return err
// }
// return p.Register(args, reply)
// case "eth_unregister":
// args, err := req.ToRegisterArgs()
// if err != nil {
// return err
// }
// return p.Unregister(args, reply)
// case "eth_watchTx":
// args, err := req.ToWatchTxArgs()
// if err != nil {
// return err
// }
// return p.WatchTx(args, reply)
default:
2015-02-24 18:05:03 +00:00
return NewErrorWithMessage(errNotImplemented, req.Method)
}
rpclogger.DebugDetailf("Reply: %T %s", reply, reply)
2015-01-13 15:27:36 +00:00
return nil
}
2015-02-26 10:14:54 +00:00
func (self *EthereumApi) xeth() *xeth.XEth {
self.xethMu.RLock()
defer self.xethMu.RUnlock()
return self.eth
}
func (self *EthereumApi) useState(statedb *state.StateDB) {
self.xethMu.Lock()
defer self.xethMu.Unlock()
2015-02-26 11:06:10 +00:00
self.eth = self.eth.UseState(statedb)
2015-02-26 10:14:54 +00:00
}
2015-03-06 03:48:03 +00:00
func toFilterOptions(options *FilterOptions) core.FilterOptions {
var opts core.FilterOptions
// Convert optional address slice/string to byte slice
if str, ok := options.Address.(string); ok {
opts.Address = [][]byte{fromHex(str)}
} else if slice, ok := options.Address.([]interface{}); ok {
bslice := make([][]byte, len(slice))
for i, addr := range slice {
if saddr, ok := addr.(string); ok {
bslice[i] = fromHex(saddr)
}
}
opts.Address = bslice
}
opts.Earliest = options.Earliest
opts.Latest = options.Latest
2015-03-09 17:19:35 +00:00
topics := make([][][]byte, len(options.Topics))
for i, topicDat := range options.Topics {
if slice, ok := topicDat.([]interface{}); ok {
topics[i] = make([][]byte, len(slice))
for j, topic := range slice {
topics[i][j] = fromHex(topic.(string))
}
} else if str, ok := topicDat.(string); ok {
topics[i] = make([][]byte, 1)
topics[i][0] = fromHex(str)
}
2015-03-06 03:48:03 +00:00
}
2015-03-09 17:19:35 +00:00
opts.Topics = topics
2015-03-06 03:48:03 +00:00
return opts
}