aboutsummaryrefslogtreecommitdiffstats
path: root/rpc/api.go
diff options
context:
space:
mode:
Diffstat (limited to 'rpc/api.go')
-rw-r--r--rpc/api.go1019
1 files changed, 410 insertions, 609 deletions
diff --git a/rpc/api.go b/rpc/api.go
index 28024c206..d1f984144 100644
--- a/rpc/api.go
+++ b/rpc/api.go
@@ -1,734 +1,535 @@
-/*
-For each request type, define the following:
-
-1. RpcRequest "To" method [message.go], which does basic validation and conversion to "Args" type via json.Decoder()
-2. json.Decoder() calls "UnmarshalON" defined on each "Args" struct
-3. EthereumApi method, taking the "Args" type and replying with an interface to be marshalled to ON
-
-*/
package rpc
import (
- "fmt"
+ "encoding/json"
"math/big"
- "strings"
+ "path"
"sync"
- "time"
+ "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core"
- "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"
- "github.com/ethereum/go-ethereum/event"
- "github.com/ethereum/go-ethereum/event/filter"
- "github.com/ethereum/go-ethereum/state"
- "github.com/ethereum/go-ethereum/ui"
"github.com/ethereum/go-ethereum/xeth"
)
-var (
- defaultGasPrice = big.NewInt(10000000000000)
- defaultGas = big.NewInt(10000)
- filterTickerTime = 15 * time.Second
-)
-
type EthereumApi struct {
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
- // Register keeps a list of accounts and transaction data
- regmut sync.Mutex
- register map[string][]*NewTxArgs
-
- db ethutil.Database
-
- defaultBlockAge int64
+ db common.Database
}
-func NewEthereumApi(eth *xeth.XEth) *EthereumApi {
- db, _ := ethdb.NewLDBDatabase("dapps")
+func NewEthereumApi(xeth *xeth.XEth, dataDir string) *EthereumApi {
+ // What about when dataDir is empty?
+ db, err := ethdb.NewLDBDatabase(path.Join(dataDir, "dapps"))
+ if err != nil {
+ panic(err)
+ }
api := &EthereumApi{
- 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,
+ eth: xeth,
+ db: db,
}
- go api.filterManager.Start()
- go api.start()
return api
}
-func (self *EthereumApi) setStateByBlockNumber(num int64) {
- chain := self.xeth().Backend().ChainManager()
- var block *types.Block
-
- if self.defaultBlockAge < 0 {
- num = chain.CurrentBlock().Number().Int64() + num + 1
- }
- block = chain.GetBlockByNumber(uint64(num))
-
- if block != nil {
- self.useState(state.New(block.Root(), self.xeth().Backend().Db()))
- } else {
- self.useState(chain.State())
- }
-}
-
-func (self *EthereumApi) start() {
- timer := time.NewTicker(filterTickerTime)
- events := self.mux.Subscribe(core.ChainEvent{})
-
-done:
- for {
- select {
- case ev := <-events.Chan():
- switch ev.(type) {
- case core.ChainEvent:
- if self.defaultBlockAge < 0 {
- self.setStateByBlockNumber(self.defaultBlockAge)
- }
- }
- 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 {
- self.xeth().Whisper().Unwatch(id)
- delete(self.messages, id)
- }
- }
- self.logMut.Unlock()
- self.messagesMut.Unlock()
- case <-self.quit:
- break done
- }
- }
-}
-
-func (self *EthereumApi) stop() {
- close(self.quit)
-}
-
-func (self *EthereumApi) Register(args string, reply *interface{}) error {
- self.regmut.Lock()
- defer self.regmut.Unlock()
-
- if _, ok := self.register[args]; ok {
- self.register[args] = nil // register with empty
- }
- return nil
-}
-
-func (self *EthereumApi) Unregister(args string, reply *interface{}) error {
- self.regmut.Lock()
- defer self.regmut.Unlock()
-
- delete(self.register, args)
-
- return nil
-}
-
-func (self *EthereumApi) WatchTx(args string, reply *interface{}) error {
- self.regmut.Lock()
- defer self.regmut.Unlock()
-
- txs := self.register[args]
- self.register[args] = nil
-
- *reply = txs
- return nil
-}
-
-func (self *EthereumApi) NewFilter(args *FilterOptions, reply *interface{}) error {
- var id int
- 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)
- self.logs[id] = &logFilter{timeout: time.Now()}
-
- *reply = id
-
- return nil
-}
-
-func (self *EthereumApi) UninstallFilter(id int, reply *interface{}) error {
- delete(self.logs, id)
- self.filterManager.UninstallFilter(id)
- *reply = true
- return nil
-}
-
-func (self *EthereumApi) NewFilterString(args string, reply *interface{}) error {
- var id int
- filter := core.NewFilter(self.xeth().Backend())
-
- callback := func(block *types.Block) {
- self.logMut.Lock()
- defer self.logMut.Unlock()
-
- self.logs[id].add(&state.StateLog{})
- }
- 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()}
- *reply = id
-
- 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())
- }
+func (api *EthereumApi) xeth() *xeth.XEth {
+ api.xethMu.RLock()
+ defer api.xethMu.RUnlock()
- return nil
+ return api.eth
}
-func (self *EthereumApi) AllLogs(args *FilterOptions, reply *interface{}) error {
- filter := core.NewFilter(self.xeth().Backend())
- filter.SetOptions(toFilterOptions(args))
-
- *reply = toLogs(filter.Find())
-
- return nil
+func (api *EthereumApi) xethAtStateNum(num int64) *xeth.XEth {
+ return api.xeth().AtStateNum(num)
}
-func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *interface{}) error {
- // This seems a bit precarious Maybe worth splitting to discrete functions
- if len(args.Hash) > 0 {
- *reply = p.xeth().BlockByHash(args.Hash)
- } else {
- *reply = p.xeth().BlockByNumber(args.BlockNumber)
- }
- return nil
+func (api *EthereumApi) Close() {
+ api.db.Close()
}
-func (p *EthereumApi) Transact(args *NewTxArgs, reply *interface{}) error {
- if len(args.Gas) == 0 {
- args.Gas = defaultGas.String()
- }
-
- if len(args.GasPrice) == 0 {
- args.GasPrice = defaultGasPrice.String()
- }
-
- // TODO if no_private_key then
- //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
- }
- }
+func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error {
+ // Spec at https://github.com/ethereum/wiki/wiki/Generic-JSON-RPC
+ rpclogger.Infof("%s %s", req.Method, req.Params)
- 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)
+ switch req.Method {
+ case "web3_sha3":
+ args := new(Sha3Args)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
+ *reply = common.ToHex(crypto.Sha3(common.FromHex(args.Data)))
+ case "web3_clientVersion":
+ *reply = api.xeth().Backend().Version()
+ case "net_version":
+ *reply = string(api.xeth().Backend().ProtocolVersion())
+ case "net_listening":
+ *reply = api.xeth().IsListening()
+ case "net_peerCount":
+ v := api.xeth().PeerCount()
+ *reply = common.ToHex(big.NewInt(int64(v)).Bytes())
+ case "eth_coinbase":
+ // TODO handling of empty coinbase due to lack of accounts
+ res := api.xeth().Coinbase()
+ if res == "0x" || res == "0x0" {
+ *reply = nil
+ } else {
+ *reply = res
+ }
+ case "eth_mining":
+ *reply = api.xeth().IsMining()
+ case "eth_gasPrice":
+ v := api.xeth().DefaultGas()
+ *reply = common.ToHex(v.Bytes())
+ case "eth_accounts":
+ *reply = api.xeth().Accounts()
+ case "eth_blockNumber":
+ v := api.xeth().Backend().ChainManager().CurrentBlock().Number()
+ *reply = common.ToHex(v.Bytes())
+ case "eth_getBalance":
+ args := new(GetBalanceArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
}
- */
- result, _ := p.xeth().Transact( /* TODO specify account */ args.To, args.Value, args.Gas, args.GasPrice, args.Data)
- *reply = result
- //}
-
- return nil
-}
-
-func (p *EthereumApi) Call(args *NewTxArgs, reply *interface{}) error {
- result, err := p.xeth().Call( /* TODO specify account */ args.To, args.Value, args.Gas, args.GasPrice, args.Data)
- if err != nil {
- return err
- }
-
- *reply = result
- return nil
-}
-
-func (p *EthereumApi) PushTx(args *PushTxArgs, reply *interface{}) error {
- err := args.requirementsPushTx()
- if err != nil {
- return err
- }
- result, _ := p.xeth().PushTx(args.Tx)
- *reply = result
- return nil
-}
-
-func (p *EthereumApi) GetStateAt(args *GetStateArgs, reply *interface{}) error {
- err := args.requirements()
- if err != nil {
- return err
- }
-
- 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) GetStorageAt(args *GetStorageArgs, reply *interface{}) error {
- err := args.requirements()
- if err != nil {
- return err
- }
+ if err := args.requirements(); err != nil {
+ return err
+ }
- *reply = p.xeth().State().SafeGet(args.Address).Storage()
- return nil
-}
+ v := api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address).Balance()
+ *reply = common.ToHex(v.Bytes())
+ case "eth_getStorage", "eth_storageAt":
+ args := new(GetStorageArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
-func (p *EthereumApi) GetPeerCount(reply *interface{}) error {
- *reply = p.xeth().PeerCount()
- return nil
-}
+ if err := args.requirements(); err != nil {
+ return err
+ }
-func (p *EthereumApi) GetIsListening(reply *interface{}) error {
- *reply = p.xeth().IsListening()
- return nil
-}
+ *reply = api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address).Storage()
+ case "eth_getStorageAt":
+ args := new(GetStorageAtArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
+ if err := args.requirements(); err != nil {
+ return err
+ }
-func (p *EthereumApi) GetCoinbase(reply *interface{}) error {
- *reply = p.xeth().Coinbase()
- return nil
-}
+ state := api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address)
+ value := state.StorageString(args.Key)
-func (p *EthereumApi) Accounts(reply *interface{}) error {
- *reply = p.xeth().Accounts()
- return nil
-}
+ *reply = common.Bytes2Hex(value.Bytes())
+ case "eth_getTransactionCount":
+ args := new(GetTxCountArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
-func (p *EthereumApi) GetIsMining(reply *interface{}) error {
- *reply = p.xeth().IsMining()
- return nil
-}
+ err := args.requirements()
+ if err != nil {
+ return err
+ }
-func (p *EthereumApi) SetMining(shouldmine bool, reply *interface{}) error {
- *reply = p.xeth().SetMining(shouldmine)
- return nil
-}
+ *reply = api.xethAtStateNum(args.BlockNumber).TxCountAt(args.Address)
+ case "eth_getBlockTransactionCountByHash":
+ args := new(GetBlockByHashArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
-func (p *EthereumApi) GetDefaultBlockAge(reply *interface{}) error {
- *reply = p.defaultBlockAge
- return nil
-}
+ block := NewBlockRes(api.xeth().EthBlockByHash(args.BlockHash))
+ *reply = common.ToHex(big.NewInt(int64(len(block.Transactions))).Bytes())
+ case "eth_getBlockTransactionCountByNumber":
+ args := new(GetBlockByNumberArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
-func (p *EthereumApi) SetDefaultBlockAge(defaultBlockAge int64, reply *interface{}) error {
- p.defaultBlockAge = defaultBlockAge
- p.setStateByBlockNumber(p.defaultBlockAge)
+ block := NewBlockRes(api.xeth().EthBlockByNumber(args.BlockNumber))
+ *reply = common.ToHex(big.NewInt(int64(len(block.Transactions))).Bytes())
+ case "eth_getUncleCountByBlockHash":
+ args := new(GetBlockByHashArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
- *reply = true
- return nil
-}
+ block := api.xeth().EthBlockByHash(args.BlockHash)
+ br := NewBlockRes(block)
+ *reply = common.ToHex(big.NewInt(int64(len(br.Uncles))).Bytes())
+ case "eth_getUncleCountByBlockNumber":
+ args := new(GetBlockByNumberArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
-func (p *EthereumApi) BlockNumber(reply *interface{}) error {
- *reply = p.xeth().Backend().ChainManager().CurrentBlock().Number()
- return nil
-}
+ block := api.xeth().EthBlockByNumber(args.BlockNumber)
+ br := NewBlockRes(block)
+ *reply = common.ToHex(big.NewInt(int64(len(br.Uncles))).Bytes())
+ case "eth_getData", "eth_getCode":
+ args := new(GetDataArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
+ if err := args.requirements(); err != nil {
+ return err
+ }
+ *reply = api.xethAtStateNum(args.BlockNumber).CodeAt(args.Address)
+ case "eth_sendTransaction", "eth_transact":
+ args := new(NewTxArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
-func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *interface{}) error {
- err := args.requirements()
- if err != nil {
- return err
- }
- *reply = p.xeth().TxCountAt(args.Address)
- return nil
-}
+ if err := args.requirements(); err != nil {
+ return err
+ }
-func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *interface{}) error {
- err := args.requirements()
- if err != nil {
- return err
- }
- state := p.xeth().State().SafeGet(args.Address)
- *reply = toHex(state.Balance().Bytes())
- return nil
-}
+ v, err := api.xeth().Transact(args.From, args.To, args.Value.String(), args.Gas.String(), args.GasPrice.String(), args.Data)
+ if err != nil {
+ return err
+ }
+ *reply = v
+ case "eth_call":
+ args := new(NewTxArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
-func (p *EthereumApi) GetCodeAt(args *GetCodeAtArgs, reply *interface{}) error {
- err := args.requirements()
- if err != nil {
- return err
- }
- *reply = p.xeth().CodeAt(args.Address)
- return nil
-}
+ v, err := api.xethAtStateNum(args.BlockNumber).Call(args.From, args.To, args.Value.String(), args.Gas.String(), args.GasPrice.String(), args.Data)
+ if err != nil {
+ return err
+ }
-func (p *EthereumApi) GetCompilers(reply *interface{}) error {
- c := []string{"serpent"}
- *reply = c
- return nil
-}
+ *reply = v
+ case "eth_flush":
+ return NewNotImplementedError(req.Method)
+ case "eth_getBlockByHash":
+ args := new(GetBlockByHashArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
-func (p *EthereumApi) CompileSerpent(script string, reply *interface{}) error {
- res, err := ethutil.Compile(script, false)
- if err != nil {
- return err
- }
- *reply = res
- return nil
-}
+ block := api.xeth().EthBlockByHash(args.BlockHash)
+ br := NewBlockRes(block)
+ br.fullTx = args.IncludeTxs
-func (p *EthereumApi) Sha3(args *Sha3Args, reply *interface{}) error {
- *reply = toHex(crypto.Sha3(fromHex(args.Data)))
- return nil
-}
+ *reply = br
+ case "eth_getBlockByNumber":
+ args := new(GetBlockByNumberArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
-func (p *EthereumApi) DbPut(args *DbArgs, reply *interface{}) error {
- err := args.requirements()
- if err != nil {
- return err
- }
+ block := api.xeth().EthBlockByNumber(args.BlockNumber)
+ br := NewBlockRes(block)
+ br.fullTx = args.IncludeTxs
- p.db.Put([]byte(args.Database+args.Key), []byte(args.Value))
- *reply = true
- return nil
-}
+ *reply = br
+ case "eth_getTransactionByHash":
+ // HashIndexArgs used, but only the "Hash" part we need.
+ args := new(HashIndexArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ }
+ tx := api.xeth().EthTransactionByHash(args.Hash)
+ if tx != nil {
+ *reply = NewTransactionRes(tx)
+ }
+ case "eth_getTransactionByBlockHashAndIndex":
+ args := new(HashIndexArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
-func (p *EthereumApi) DbGet(args *DbArgs, reply *interface{}) error {
- err := args.requirements()
- if err != nil {
- return err
- }
+ block := api.xeth().EthBlockByHash(args.Hash)
+ br := NewBlockRes(block)
+ br.fullTx = true
- res, _ := p.db.Get([]byte(args.Database + args.Key))
- *reply = string(res)
- return nil
-}
+ if args.Index > int64(len(br.Transactions)) || args.Index < 0 {
+ return NewValidationError("Index", "does not exist")
+ }
+ *reply = br.Transactions[args.Index]
+ case "eth_getTransactionByBlockNumberAndIndex":
+ args := new(BlockNumIndexArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
-func (p *EthereumApi) NewWhisperIdentity(reply *interface{}) error {
- *reply = p.xeth().Whisper().NewIdentity()
- return nil
-}
+ block := api.xeth().EthBlockByNumber(args.BlockNumber)
+ v := NewBlockRes(block)
+ v.fullTx = true
-func (p *EthereumApi) NewWhisperFilter(args *xeth.Options, reply *interface{}) error {
- var id int
- args.Fn = func(msg xeth.WhisperMessage) {
- p.messagesMut.Lock()
- defer p.messagesMut.Unlock()
- p.messages[id].add(msg) // = append(p.messages[id], msg)
- }
- id = p.xeth().Whisper().Watch(args)
- p.messages[id] = &whisperFilter{timeout: time.Now()}
- *reply = id
- return nil
-}
+ if args.Index > int64(len(v.Transactions)) || args.Index < 0 {
+ return NewValidationError("Index", "does not exist")
+ }
+ *reply = v.Transactions[args.Index]
+ case "eth_getUncleByBlockHashAndIndex":
+ args := new(HashIndexArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
-func (self *EthereumApi) MessagesChanged(id int, reply *interface{}) error {
- self.messagesMut.Lock()
- defer self.messagesMut.Unlock()
+ br := NewBlockRes(api.xeth().EthBlockByHash(args.Hash))
- if self.messages[id] != nil {
- *reply = self.messages[id].get()
- }
+ if args.Index > int64(len(br.Uncles)) || args.Index < 0 {
+ return NewValidationError("Index", "does not exist")
+ }
- return nil
-}
+ uhash := br.Uncles[args.Index].Hex()
+ uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash))
-func (p *EthereumApi) WhisperPost(args *WhisperMessageArgs, reply *interface{}) error {
- err := p.xeth().Whisper().Post(args.Payload, args.To, args.From, args.Topic, args.Priority, args.Ttl)
- if err != nil {
- return err
- }
+ *reply = uncle
+ case "eth_getUncleByBlockNumberAndIndex":
+ args := new(BlockNumIndexArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
+ return err
+ }
- *reply = true
- return nil
-}
+ block := api.xeth().EthBlockByNumber(args.BlockNumber)
+ v := NewBlockRes(block)
+ v.fullTx = true
-func (p *EthereumApi) HasWhisperIdentity(args string, reply *interface{}) error {
- *reply = p.xeth().Whisper().HasIdentity(args)
- return nil
-}
+ if args.Index > int64(len(v.Uncles)) || args.Index < 0 {
+ return NewValidationError("Index", "does not exist")
+ }
-func (p *EthereumApi) WhisperMessages(id int, reply *interface{}) error {
- *reply = p.xeth().Whisper().Messages(id)
- return nil
-}
+ uhash := v.Uncles[args.Index].Hex()
+ uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash))
-func (p *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error {
- // Spec at https://github.com/ethereum/wiki/wiki/Generic-JSON-RPC
- rpclogger.DebugDetailf("%T %s", req.Params, req.Params)
- switch req.Method {
- case "eth_coinbase":
- return p.GetCoinbase(reply)
- case "eth_listening":
- return p.GetIsListening(reply)
- case "eth_mining":
- return p.GetIsMining(reply)
- case "eth_setMining":
- args, err := req.ToBoolArgs()
- if err != nil {
- return err
- }
- return p.SetMining(args, reply)
- case "eth_defaultBlock":
- return p.GetDefaultBlockAge(reply)
- case "eth_setDefaultBlock":
- args, err := req.ToIntArgs()
- if err != nil {
- return err
- }
- return p.SetDefaultBlockAge(int64(args), reply)
- case "eth_peerCount":
- return p.GetPeerCount(reply)
- case "eth_number":
- return p.BlockNumber(reply)
- case "eth_accounts":
- return p.Accounts(reply)
- case "eth_countAt":
- args, err := req.ToGetTxCountArgs()
- if err != nil {
- return err
- }
- return p.GetTxCountAt(args, reply)
- case "eth_codeAt":
- args, err := req.ToGetCodeAtArgs()
- if err != nil {
- return err
- }
- return p.GetCodeAt(args, reply)
- case "eth_balanceAt":
- args, err := req.ToGetBalanceArgs()
- if err != nil {
- return err
- }
- return p.GetBalanceAt(args, reply)
- case "eth_stateAt":
- args, err := req.ToGetStateArgs()
- if err != nil {
+ *reply = uncle
+ case "eth_getCompilers":
+ c := []string{""}
+ *reply = c
+ case "eth_compileSolidity", "eth_compileLLL", "eth_compileSerpent":
+ return NewNotImplementedError(req.Method)
+ case "eth_newFilter":
+ args := new(BlockFilterArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.GetStateAt(args, reply)
- case "eth_storageAt":
- args, err := req.ToStorageAtArgs()
- if err != nil {
+
+ opts := toFilterOptions(args)
+ id := api.xeth().RegisterFilter(opts)
+ *reply = common.ToHex(big.NewInt(int64(id)).Bytes())
+ case "eth_newBlockFilter":
+ args := new(FilterStringArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.GetStorageAt(args, reply)
- case "eth_blockByNumber", "eth_blockByHash":
- args, err := req.ToGetBlockArgs()
- if err != nil {
+ if err := args.requirements(); err != nil {
return err
}
- return p.GetBlock(args, reply)
- case "eth_transact":
- args, err := req.ToNewTxArgs()
- if err != nil {
+
+ id := api.xeth().NewFilterString(args.Word)
+ *reply = common.ToHex(big.NewInt(int64(id)).Bytes())
+ case "eth_uninstallFilter":
+ args := new(FilterIdArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.Transact(args, reply)
- case "eth_call":
- args, err := req.ToNewTxArgs()
- if err != nil {
+ *reply = api.xeth().UninstallFilter(args.Id)
+ case "eth_getFilterChanges":
+ args := new(FilterIdArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.Call(args, reply)
- case "eth_newFilter":
- args, err := req.ToFilterArgs()
- if err != nil {
+ *reply = NewLogsRes(api.xeth().FilterChanged(args.Id))
+ case "eth_getFilterLogs":
+ args := new(FilterIdArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.NewFilter(args, reply)
- case "eth_newFilterString":
- args, err := req.ToFilterStringArgs()
- if err != nil {
+ *reply = NewLogsRes(api.xeth().Logs(args.Id))
+ case "eth_getLogs":
+ args := new(BlockFilterArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.NewFilterString(args, reply)
- case "eth_uninstallFilter":
- args, err := req.ToUninstallFilterArgs()
- if err != nil {
+ opts := toFilterOptions(args)
+ *reply = NewLogsRes(api.xeth().AllLogs(opts))
+ case "eth_getWork":
+ api.xeth().SetMining(true)
+ *reply = api.xeth().RemoteMining().GetWork()
+ case "eth_submitWork":
+ args := new(SubmitWorkArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.UninstallFilter(args, reply)
- case "eth_changed":
- args, err := req.ToIdArgs()
- if err != nil {
+ *reply = api.xeth().RemoteMining().SubmitWork(args.Nonce, args.Digest, args.Header)
+ case "db_putString":
+ args := new(DbArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.FilterChanged(args, reply)
- case "eth_filterLogs":
- args, err := req.ToIdArgs()
- if err != nil {
+
+ if err := args.requirements(); err != nil {
return err
}
- return p.Logs(args, reply)
- case "eth_logs":
- args, err := req.ToFilterArgs()
- if err != nil {
+
+ api.db.Put([]byte(args.Database+args.Key), args.Value)
+ *reply = true
+ case "db_getString":
+ args := new(DbArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.AllLogs(args, reply)
- case "eth_gasPrice":
- *reply = toHex(defaultGasPrice.Bytes())
- return nil
- case "eth_register":
- args, err := req.ToRegisterArgs()
- if err != nil {
+
+ if err := args.requirements(); err != nil {
return err
}
- return p.Register(args, reply)
- case "eth_unregister":
- args, err := req.ToRegisterArgs()
- if err != nil {
+
+ res, _ := api.db.Get([]byte(args.Database + args.Key))
+ *reply = string(res)
+ case "db_putHex":
+ args := new(DbHexArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.Unregister(args, reply)
- case "eth_watchTx":
- args, err := req.ToWatchTxArgs()
- if err != nil {
+
+ if err := args.requirements(); err != nil {
return err
}
- return p.WatchTx(args, reply)
- case "eth_compilers":
- return p.GetCompilers(reply)
- case "eth_serpent":
- args, err := req.ToCompileArgs()
- if err != nil {
+
+ api.db.Put([]byte(args.Database+args.Key), args.Value)
+ *reply = true
+ case "db_getHex":
+ args := new(DbHexArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.CompileSerpent(args, reply)
- case "web3_sha3":
- args, err := req.ToSha3Args()
- if err != nil {
+
+ if err := args.requirements(); err != nil {
return err
}
- return p.Sha3(args, reply)
- case "db_put":
- args, err := req.ToDbPutArgs()
- if err != nil {
+
+ res, _ := api.db.Get([]byte(args.Database + args.Key))
+ *reply = common.ToHex(res)
+ case "shh_post":
+ args := new(WhisperMessageArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.DbPut(args, reply)
- case "db_get":
- args, err := req.ToDbGetArgs()
+
+ err := api.xeth().Whisper().Post(args.Payload, args.To, args.From, args.Topics, args.Priority, args.Ttl)
if err != nil {
return err
}
- return p.DbGet(args, reply)
+
+ *reply = true
case "shh_newIdentity":
- return p.NewWhisperIdentity(reply)
- case "shh_newFilter":
- args, err := req.ToWhisperFilterArgs()
- if err != nil {
+ *reply = api.xeth().Whisper().NewIdentity()
+ // case "shh_removeIdentity":
+ // args := new(WhisperIdentityArgs)
+ // if err := json.Unmarshal(req.Params, &args); err != nil {
+ // return err
+ // }
+ // *reply = api.xeth().Whisper().RemoveIdentity(args.Identity)
+ case "shh_hasIdentity":
+ args := new(WhisperIdentityArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.NewWhisperFilter(args, reply)
- case "shh_changed":
- args, err := req.ToIdArgs()
- if err != nil {
+ *reply = api.xeth().Whisper().HasIdentity(args.Identity)
+ case "shh_newGroup", "shh_addToGroup":
+ return NewNotImplementedError(req.Method)
+ case "shh_newFilter":
+ args := new(WhisperFilterArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.MessagesChanged(args, reply)
- case "shh_post":
- args, err := req.ToWhisperPostArgs()
- if err != nil {
+ opts := new(xeth.Options)
+ opts.From = args.From
+ opts.To = args.To
+ opts.Topics = args.Topics
+ id := api.xeth().NewWhisperFilter(opts)
+ *reply = common.ToHex(big.NewInt(int64(id)).Bytes())
+ case "shh_uninstallFilter":
+ args := new(FilterIdArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.WhisperPost(args, reply)
- case "shh_haveIdentity":
- args, err := req.ToWhisperHasIdentityArgs()
- if err != nil {
+ *reply = api.xeth().UninstallWhisperFilter(args.Id)
+ case "shh_getFilterChanges":
+ args := new(FilterIdArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.HasWhisperIdentity(args, reply)
+ *reply = api.xeth().MessagesChanged(args.Id)
case "shh_getMessages":
- args, err := req.ToIdArgs()
- if err != nil {
+ args := new(FilterIdArgs)
+ if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- return p.WhisperMessages(args, reply)
+ *reply = api.xeth().Whisper().Messages(args.Id)
+
+ // case "eth_register":
+ // // Placeholder for actual type
+ // args := new(HashIndexArgs)
+ // if err := json.Unmarshal(req.Params, &args); err != nil {
+ // return err
+ // }
+ // *reply = api.xeth().Register(args.Hash)
+ // case "eth_unregister":
+ // args := new(HashIndexArgs)
+ // if err := json.Unmarshal(req.Params, &args); err != nil {
+ // return err
+ // }
+ // *reply = api.xeth().Unregister(args.Hash)
+ // case "eth_watchTx":
+ // args := new(HashIndexArgs)
+ // if err := json.Unmarshal(req.Params, &args); err != nil {
+ // return err
+ // }
+ // *reply = api.xeth().PullWatchTx(args.Hash)
default:
- return NewErrorWithMessage(errNotImplemented, req.Method)
+ return NewNotImplementedError(req.Method)
}
rpclogger.DebugDetailf("Reply: %T %s", reply, reply)
return nil
}
-func (self *EthereumApi) xeth() *xeth.XEth {
- self.xethMu.RLock()
- defer self.xethMu.RUnlock()
-
- return self.eth
-}
+func toFilterOptions(options *BlockFilterArgs) *core.FilterOptions {
+ var opts core.FilterOptions
-func (self *EthereumApi) useState(statedb *state.StateDB) {
- self.xethMu.Lock()
- defer self.xethMu.Unlock()
+ // Convert optional address slice/string to byte slice
+ if str, ok := options.Address.(string); ok {
+ opts.Address = []common.Address{common.HexToAddress(str)}
+ } else if slice, ok := options.Address.([]interface{}); ok {
+ bslice := make([]common.Address, len(slice))
+ for i, addr := range slice {
+ if saddr, ok := addr.(string); ok {
+ bslice[i] = common.HexToAddress(saddr)
+ }
+ }
+ opts.Address = bslice
+ }
- self.eth = self.eth.UseState(statedb)
-}
+ opts.Earliest = options.Earliest
+ opts.Latest = options.Latest
-func t(f ui.Frontend) {
- // Call the password dialog
- ret, err := f.Call("PasswordDialog")
- if err != nil {
- fmt.Println(err)
+ topics := make([][]common.Hash, len(options.Topics))
+ for i, topicDat := range options.Topics {
+ if slice, ok := topicDat.([]interface{}); ok {
+ topics[i] = make([]common.Hash, len(slice))
+ for j, topic := range slice {
+ topics[i][j] = common.HexToHash(topic.(string))
+ }
+ } else if str, ok := topicDat.(string); ok {
+ topics[i] = []common.Hash{common.HexToHash(str)}
+ }
}
- // Get the first argument
- t, _ := ret.Get(0)
- fmt.Println("return:", t)
+ opts.Topics = topics
+
+ return &opts
}
+
+/*
+ Work() chan<- *types.Block
+ SetWorkCh(chan<- Work)
+ Stop()
+ Start()
+ Rate() uint64
+*/
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-26 18:32:22 +0800