aboutsummaryrefslogtreecommitdiffstats
path: root/rpc/packages.go
diff options
context:
space:
mode:
Diffstat (limited to 'rpc/packages.go')
-rw-r--r--rpc/packages.go534
1 files changed, 353 insertions, 181 deletions
diff --git a/rpc/packages.go b/rpc/packages.go
index 5535e6e79..ac3127356 100644
--- a/rpc/packages.go
+++ b/rpc/packages.go
@@ -1,205 +1,188 @@
+/*
+ This file is part of go-ethereum
+
+ go-ethereum is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ go-ethereum is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+*/
+/*
+
+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 (
- "encoding/json"
- "errors"
+ "fmt"
"math/big"
"strings"
+ "sync"
+ "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/filter"
+ "github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/xeth"
)
+const (
+ defaultGasPrice = "10000000000000"
+ defaultGas = "10000"
+)
+
type EthereumApi struct {
- pipe *xeth.JSXEth
-}
+ xeth *xeth.XEth
+ filterManager *filter.FilterManager
-type JsonArgs interface {
- requirements() error
-}
+ logMut sync.RWMutex
+ logs map[int]state.Logs
-type BlockResponse struct {
- JsonResponse
-}
-type GetBlockArgs struct {
- BlockNumber int
- Hash string
-}
+ messagesMut sync.RWMutex
+ messages map[int][]xeth.WhisperMessage
-type ErrorResponse struct {
- Error bool `json:"error"`
- ErrorText string `json:"errorText"`
+ db ethutil.Database
}
-type JsonResponse interface {
-}
+func NewEthereumApi(eth *xeth.XEth) *EthereumApi {
+ db, _ := ethdb.NewLDBDatabase("dapps")
+ api := &EthereumApi{
+ xeth: eth,
+ filterManager: filter.NewFilterManager(eth.Backend().EventMux()),
+ logs: make(map[int]state.Logs),
+ messages: make(map[int][]xeth.WhisperMessage),
+ db: db,
+ }
+ go api.filterManager.Start()
-type SuccessRes struct {
- Error bool `json:"error"`
- Result JsonResponse `json:"result"`
+ return api
}
-func NewSuccessRes(object JsonResponse) string {
- e := SuccessRes{Error: false, Result: object}
- res, err := json.Marshal(e)
- if err != nil {
- // This should never happen
- panic("Creating json error response failed, help")
- }
- success := string(res)
- return success
-}
+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()
-func NewErrorResponse(msg string) error {
- e := ErrorResponse{Error: true, ErrorText: msg}
- res, err := json.Marshal(e)
- if err != nil {
- // This should never happen
- panic("Creating json error response failed, help")
+ self.logs[id] = append(self.logs[id], logs...)
}
- newErr := errors.New(string(res))
- return newErr
-}
+ id = self.filterManager.InstallFilter(filter)
+ *reply = id
-func (b *GetBlockArgs) requirements() error {
- if b.BlockNumber == 0 && b.Hash == "" {
- return NewErrorResponse("GetBlock requires either a block 'number' or a block 'hash' as argument")
- }
return nil
}
-func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *string) error {
- err := args.requirements()
- if err != nil {
- return err
+func (self *EthereumApi) NewFilterString(args string, reply *interface{}) error {
+ var id int
+ filter := core.NewFilter(self.xeth.Backend())
+
+ callback := func(block *types.Block) {
+ self.logs[id] = append(self.logs[id], &state.StateLog{})
}
+ if args == "pending" {
+ filter.PendingCallback = callback
+ } else if args == "chain" {
+ filter.BlockCallback = callback
+ }
+
+ id = self.filterManager.InstallFilter(filter)
+ *reply = id
- block := p.pipe.BlockByHash(args.Hash)
- *reply = NewSuccessRes(block)
return nil
}
-type NewTxArgs struct {
- Sec string
- Recipient string
- Value string
- Gas string
- GasPrice string
- Init string
- Body string
-}
-type TxResponse struct {
- Hash string
-}
+func (self *EthereumApi) FilterChanged(id int, reply *interface{}) error {
+ self.logMut.RLock()
+ defer self.logMut.RUnlock()
+
+ *reply = toLogs(self.logs[id])
+
+ self.logs[id] = nil // empty the logs
-func (a *NewTxArgs) requirements() error {
- if a.Recipient == "" {
- return NewErrorResponse("Transact requires a 'recipient' address as argument")
- }
- if a.Value == "" {
- return NewErrorResponse("Transact requires a 'value' as argument")
- }
- if a.Gas == "" {
- return NewErrorResponse("Transact requires a 'gas' value as argument")
- }
- if a.GasPrice == "" {
- return NewErrorResponse("Transact requires a 'gasprice' value as argument")
- }
return nil
}
-func (a *NewTxArgs) requirementsContract() error {
- if a.Value == "" {
- return NewErrorResponse("Create requires a 'value' as argument")
- }
- if a.Gas == "" {
- return NewErrorResponse("Create requires a 'gas' value as argument")
- }
- if a.GasPrice == "" {
- return NewErrorResponse("Create requires a 'gasprice' value as argument")
- }
- if a.Body == "" {
- return NewErrorResponse("Create requires a 'body' value as argument")
- }
+func (self *EthereumApi) Logs(id int, reply *interface{}) error {
+ filter := self.filterManager.GetFilter(id)
+ *reply = toLogs(filter.Find())
+
return nil
}
-func (p *EthereumApi) Transact(args *NewTxArgs, reply *string) error {
+func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
}
- result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, args.Recipient, args.Value, args.Gas, args.GasPrice, args.Body)
- *reply = NewSuccessRes(result)
- return nil
-}
-func (p *EthereumApi) Create(args *NewTxArgs, reply *string) error {
- err := args.requirementsContract()
- if err != nil {
- return err
+ if args.BlockNumber > 0 {
+ *reply = p.xeth.BlockByNumber(args.BlockNumber)
+ } else {
+ *reply = p.xeth.BlockByHash(args.Hash)
}
-
- result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, "", args.Value, args.Gas, args.GasPrice, args.Body)
- *reply = NewSuccessRes(result)
return nil
}
-type PushTxArgs struct {
- Tx string
-}
+func (p *EthereumApi) Transact(args *NewTxArgs, reply *interface{}) error {
+ if len(args.Gas) == 0 {
+ args.Gas = defaultGas
+ }
-func (a *PushTxArgs) requirementsPushTx() error {
- if a.Tx == "" {
- return NewErrorResponse("PushTx requires a 'tx' as argument")
+ if len(args.GasPrice) == 0 {
+ args.GasPrice = defaultGasPrice
}
+
+ result, _ := p.xeth.Transact( /* TODO specify account */ args.To, args.Value, args.Gas, args.GasPrice, args.Data)
+ *reply = result
return nil
}
-func (p *EthereumApi) PushTx(args *PushTxArgs, reply *string) error {
- err := args.requirementsPushTx()
+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
}
- result, _ := p.pipe.PushTx(args.Tx)
- *reply = NewSuccessRes(result)
- return nil
-}
-func (p *EthereumApi) GetKey(args interface{}, reply *string) error {
- *reply = NewSuccessRes(p.pipe.Key())
+ *reply = result
return nil
}
-type GetStorageArgs struct {
- Address string
- Key string
-}
-
-func (a *GetStorageArgs) requirements() error {
- if a.Address == "" {
- return NewErrorResponse("GetStorageAt requires an 'address' value as argument")
- }
- if a.Key == "" {
- return NewErrorResponse("GetStorageAt requires an 'key' value as argument")
+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
}
-type GetStorageAtRes struct {
- Key string `json:"key"`
- Value string `json:"value"`
- Address string `json:"address"`
-}
-
-func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *string) error {
+func (p *EthereumApi) GetStateAt(args *GetStateArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
}
- state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
+ 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:])
@@ -208,104 +191,293 @@ func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *string) error {
i, _ := new(big.Int).SetString(args.Key, 10)
hx = ethutil.Bytes2Hex(i.Bytes())
}
- jsonlogger.Debugf("GetStorageAt(%s, %s)\n", args.Address, hx)
- value := state.Storage(ethutil.Hex2Bytes(hx))
- *reply = NewSuccessRes(GetStorageAtRes{Address: args.Address, Key: args.Key, Value: value.Str()})
+ rpclogger.Debugf("GetStateAt(%s, %s)\n", args.Address, hx)
+ *reply = map[string]string{args.Key: value.Str()}
return nil
}
-type GetTxCountArgs struct {
- Address string `json:"address"`
+func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *interface{}) error {
+ err := args.requirements()
+ if err != nil {
+ return err
+ }
+
+ *reply = p.xeth.State().SafeGet(args.Address).Storage()
+ return nil
}
-type GetTxCountRes struct {
- Nonce int `json:"nonce"`
+
+func (p *EthereumApi) GetPeerCount(reply *interface{}) error {
+ *reply = p.xeth.PeerCount()
+ return nil
}
-func (a *GetTxCountArgs) requirements() error {
- if a.Address == "" {
- return NewErrorResponse("GetTxCountAt requires an 'address' value as argument")
- }
+func (p *EthereumApi) GetIsListening(reply *interface{}) error {
+ *reply = p.xeth.IsListening()
return nil
}
-type GetPeerCountRes struct {
- PeerCount int `json:"peerCount"`
+func (p *EthereumApi) GetCoinbase(reply *interface{}) error {
+ *reply = p.xeth.Coinbase()
+ return nil
}
-func (p *EthereumApi) GetPeerCount(args *interface{}, reply *string) error {
- *reply = NewSuccessRes(GetPeerCountRes{PeerCount: p.pipe.PeerCount()})
+func (p *EthereumApi) Accounts(reply *interface{}) error {
+ *reply = p.xeth.Accounts()
return nil
}
-type GetListeningRes struct {
- IsListening bool `json:"isListening"`
+func (p *EthereumApi) GetIsMining(reply *interface{}) error {
+ *reply = p.xeth.IsMining()
+ return nil
}
-func (p *EthereumApi) GetIsListening(args *interface{}, reply *string) error {
- *reply = NewSuccessRes(GetListeningRes{IsListening: p.pipe.IsListening()})
+func (p *EthereumApi) BlockNumber(reply *interface{}) error {
+ *reply = p.xeth.Backend().ChainManager().CurrentBlock().Number()
return nil
}
-type GetCoinbaseRes struct {
- Coinbase string `json:"coinbase"`
+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
}
-func (p *EthereumApi) GetCoinbase(args *interface{}, reply *string) error {
- *reply = NewSuccessRes(GetCoinbaseRes{Coinbase: p.pipe.CoinBase()})
+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
}
-type GetMiningRes struct {
- IsMining bool `json:"isMining"`
+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
}
-func (p *EthereumApi) GetIsMining(args *interface{}, reply *string) error {
- *reply = NewSuccessRes(GetMiningRes{IsMining: p.pipe.IsMining()})
+func (p *EthereumApi) Sha3(args *Sha3Args, reply *interface{}) error {
+ *reply = toHex(crypto.Sha3(fromHex(args.Data)))
return nil
}
-func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *string) error {
+func (p *EthereumApi) DbPut(args *DbArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
}
- state := p.pipe.TxCountAt(args.Address)
- *reply = NewSuccessRes(GetTxCountRes{Nonce: state})
+
+ p.db.Put([]byte(args.Database+args.Key), []byte(args.Value))
+ *reply = true
+ return nil
+}
+
+func (p *EthereumApi) DbGet(args *DbArgs, reply *interface{}) error {
+ err := args.requirements()
+ if err != nil {
+ return err
+ }
+
+ res, _ := p.db.Get([]byte(args.Database + args.Key))
+ *reply = string(res)
return nil
}
-type GetBalanceArgs struct {
- Address string
+func (p *EthereumApi) NewWhisperIdentity(reply *interface{}) error {
+ *reply = p.xeth.Whisper().NewIdentity()
+ return nil
}
-func (a *GetBalanceArgs) requirements() error {
- if a.Address == "" {
- return NewErrorResponse("GetBalanceAt requires an 'address' value as argument")
+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] = append(p.messages[id], msg)
}
+ id = p.xeth.Whisper().Watch(args)
+ *reply = id
return nil
}
-type BalanceRes struct {
- Balance string `json:"balance"`
- Address string `json:"address"`
+func (self *EthereumApi) MessagesChanged(id int, reply *interface{}) error {
+ self.messagesMut.RLock()
+ defer self.messagesMut.RUnlock()
+
+ *reply = self.messages[id]
+
+ self.messages[id] = nil // empty the messages
+
+ return nil
}
-func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *string) error {
- err := args.requirements()
+func (p *EthereumApi) WhisperPost(args *WhisperMessageArgs, reply *interface{}) error {
+ err := p.xeth.Whisper().Post(args.Payload, args.To, args.From, args.Topics, args.Priority, args.Ttl)
if err != nil {
return err
}
- state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
- *reply = NewSuccessRes(BalanceRes{Balance: state.Balance().String(), Address: args.Address})
+
+ *reply = true
return nil
}
-type TestRes struct {
- JsonResponse `json:"-"`
- Answer int `json:"answer"`
+func (p *EthereumApi) HasWhisperIdentity(args string, reply *interface{}) error {
+ *reply = p.xeth.Whisper().HasIdentity(args)
+ return nil
+}
+
+func (p *EthereumApi) WhisperMessages(id int, reply *interface{}) error {
+ *reply = p.xeth.Whisper().Messages(id)
+ return nil
}
-func (p *EthereumApi) Test(args *GetBlockArgs, reply *string) error {
- *reply = NewSuccessRes(TestRes{Answer: 15})
+func (p *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error {
+ // Spec at https://github.com/ethereum/wiki/wiki/Generic-ON-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_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 {
+ return err
+ }
+ return p.GetStateAt(args, reply)
+ case "eth_storageAt":
+ args, err := req.ToStorageAtArgs()
+ if err != nil {
+ return err
+ }
+ return p.GetStorageAt(args, reply)
+ case "eth_blockByNumber", "eth_blockByHash":
+ args, err := req.ToGetBlockArgs()
+ if err != nil {
+ return err
+ }
+ return p.GetBlock(args, reply)
+ case "eth_transact":
+ args, err := req.ToNewTxArgs()
+ if err != nil {
+ return err
+ }
+ return p.Transact(args, reply)
+ case "eth_call":
+ args, err := req.ToNewTxArgs()
+ if err != nil {
+ return err
+ }
+ return p.Call(args, reply)
+ case "eth_newFilter":
+ args, err := req.ToFilterArgs()
+ if err != nil {
+ return err
+ }
+ return p.NewFilter(args, reply)
+ case "eth_newFilterString":
+ args, err := req.ToFilterStringArgs()
+ if err != nil {
+ return err
+ }
+ return p.NewFilterString(args, reply)
+ case "eth_changed":
+ args, err := req.ToFilterChangedArgs()
+ if err != nil {
+ return err
+ }
+ return p.FilterChanged(args, reply)
+ case "eth_gasPrice":
+ *reply = defaultGasPrice
+ return nil
+ case "web3_sha3":
+ args, err := req.ToSha3Args()
+ if err != nil {
+ return err
+ }
+ return p.Sha3(args, reply)
+ case "db_put":
+ args, err := req.ToDbPutArgs()
+ if err != nil {
+ return err
+ }
+ return p.DbPut(args, reply)
+ case "db_get":
+ args, err := req.ToDbGetArgs()
+ if err != nil {
+ return err
+ }
+ return p.DbGet(args, reply)
+ case "shh_newIdentity":
+ return p.NewWhisperIdentity(reply)
+ case "shh_newFilter":
+ args, err := req.ToWhisperFilterArgs()
+ if err != nil {
+ return err
+ }
+ return p.NewWhisperFilter(args, reply)
+ case "shh_changed":
+ args, err := req.ToWhisperIdArgs()
+ if err != nil {
+ return err
+ }
+ return p.MessagesChanged(args, reply)
+ case "shh_post":
+ args, err := req.ToWhisperPostArgs()
+ if err != nil {
+ return err
+ }
+ return p.WhisperPost(args, reply)
+ case "shh_haveIdentity":
+ args, err := req.ToWhisperHasIdentityArgs()
+ if err != nil {
+ return err
+ }
+ return p.HasWhisperIdentity(args, reply)
+ case "shh_getMessages":
+ args, err := req.ToWhisperIdArgs()
+ if err != nil {
+ return err
+ }
+ return p.WhisperMessages(args, reply)
+ default:
+ return NewErrorResponse(fmt.Sprintf("%v %s", ErrorNotImplemented, req.Method))
+ }
+
+ rpclogger.DebugDetailf("Reply: %T %s", reply, reply)
return nil
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-01-08 01:56:11 +0800