begin conversion to rpc over http

Per specification at
https://github.com/ethereum/wiki/wiki/Generic-JSON-RPC
This commit is contained in:
Taylor Gerring 2015-01-12 23:25:29 -06:00
parent c9985bf563
commit 32bed50ba1
5 changed files with 459 additions and 284 deletions

View File

@ -3,6 +3,7 @@ package rpc
import ( import (
"encoding/json" "encoding/json"
"io" "io"
"net/http"
) )
type jsonWrapper struct{} type jsonWrapper struct{}
@ -11,10 +12,76 @@ func (self jsonWrapper) Send(writer io.Writer, v interface{}) (n int, err error)
var payload []byte var payload []byte
payload, err = json.Marshal(v) payload, err = json.Marshal(v)
if err != nil { if err != nil {
jsonlogger.Fatalln("Error marshalling JSON", err)
return 0, err return 0, err
} }
jsonlogger.Infof("Sending payload: %s", payload)
return writer.Write(payload) return writer.Write(payload)
} }
func (self jsonWrapper) ParseRequestBody(req *http.Request) (RpcRequest, error) {
var reqParsed RpcRequest
// Convert JSON to native types
d := json.NewDecoder(req.Body)
// d.UseNumber()
defer req.Body.Close()
err := d.Decode(&reqParsed)
if err != nil {
jsonlogger.Errorln("Error decoding JSON: ", err)
return reqParsed, err
}
jsonlogger.DebugDetailf("Parsed request: %s", reqParsed)
return reqParsed, nil
}
func (self jsonWrapper) GetRequestReply(xeth *EthereumApi, req *RpcRequest, reply *interface{}) error {
// call function for request method
jsonlogger.DebugDetailf("%T %s", req.Params, req.Params)
switch req.Method {
case "eth_coinbase":
return xeth.GetCoinbase(reply)
case "eth_listening":
return xeth.GetIsListening(reply)
case "eth_mining":
return xeth.GetIsMining(reply)
case "eth_peerCount":
return xeth.GetPeerCount(reply)
case "eth_countAt":
args, err := req.ToGetTxCountArgs()
if err != nil {
return err
}
return xeth.GetTxCountAt(args, reply)
// case "eth_codeAt":
// return nil
case "eth_balanceAt":
args, err := req.ToGetBalanceArgs()
if err != nil {
return err
}
return xeth.GetBalanceAt(args, reply)
case "eth_stateAt":
args, err := req.ToGetStorageArgs()
if err != nil {
return err
}
return xeth.GetStorageAt(args, reply)
case "eth_blockByNumber", "eth_blockByHash":
args, err := req.ToGetBlockArgs()
if err != nil {
return err
}
return xeth.GetBlock(args, reply)
default:
return NewErrorResponse(ErrorNotImplemented)
}
jsonlogger.DebugDetailf("Reply: %T %s", reply, reply)
return nil
}
var JSON jsonWrapper var JSON jsonWrapper

View File

@ -1,14 +1,169 @@
package rpc package rpc
import "github.com/ethereum/go-ethereum/ethutil" import (
"bytes"
"encoding/json"
"errors"
type Message struct { // "github.com/ethereum/go-ethereum/ethutil"
Call string `json:"call"` )
Args []interface{} `json:"args"`
Id int `json:"_id"` const (
Data interface{} `json:"data"` ErrorArguments = "Error: Insufficient arguments"
ErrorNotImplemented = "Error: Method not implemented"
ErrorUnknown = "Error: Unknown error"
ErrorParseRequest = "Error: Could not parse request"
ErrorDecodeArgs = "Error: Could not decode arguments"
)
// type JsonResponse interface {
// }
type ErrorResponse struct {
Error bool `json:"error"`
ErrorText string `json:"errorText"`
} }
func (self *Message) Arguments() *ethutil.Value { // type SuccessRes struct {
return ethutil.NewValue(self.Args) // Error bool `json:"error"`
// Result JsonResponse `json:"result"`
// }
// type Message struct {
// Call string `json:"call"`
// Args []interface{} `json:"args"`
// Id int `json:"_id"`
// Data interface{} `json:"data"`
// }
// func (self *Message) Arguments() *ethutil.Value {
// return ethutil.NewValue(self.Args)
// }
type RpcSuccessResponse struct {
ID int `json:"id"`
JsonRpc string `json:"jsonrpc"`
Error bool `json:"error"`
Result interface{} `json:"result"`
}
type RpcErrorResponse struct {
ID int `json:"id"`
JsonRpc string `json:"jsonrpc"`
Error bool `json:"error"`
ErrorText string `json:"errortext"`
}
type RpcRequest struct {
JsonRpc string `json:"jsonrpc"`
ID int `json:"id"`
Method string `json:"method"`
Params []json.RawMessage `json:"params"`
}
func (req *RpcRequest) ToGetBlockArgs() (*GetBlockArgs, error) {
if len(req.Params) < 1 {
return nil, NewErrorResponse(ErrorArguments)
}
args := new(GetBlockArgs)
r := bytes.NewReader(req.Params[0])
err := json.NewDecoder(r).Decode(args)
if err != nil {
return nil, NewErrorResponse(ErrorDecodeArgs)
}
jsonlogger.DebugDetailf("%T %v", args, args)
return args, nil
}
func (req *RpcRequest) ToNewTxArgs() (*NewTxArgs, error) {
if len(req.Params) < 7 {
return nil, NewErrorResponse(ErrorArguments)
}
args := new(NewTxArgs)
r := bytes.NewReader(req.Params[0])
err := json.NewDecoder(r).Decode(args)
if err != nil {
return nil, NewErrorResponse(ErrorDecodeArgs)
}
jsonlogger.DebugDetailf("%T %v", args, args)
return args, nil
}
func (req *RpcRequest) ToPushTxArgs() (*PushTxArgs, error) {
if len(req.Params) < 1 {
return nil, NewErrorResponse(ErrorArguments)
}
args := new(PushTxArgs)
r := bytes.NewReader(req.Params[0])
err := json.NewDecoder(r).Decode(args)
if err != nil {
return nil, NewErrorResponse(ErrorDecodeArgs)
}
jsonlogger.DebugDetailf("%T %v", args, args)
return args, nil
}
func (req *RpcRequest) ToGetStorageArgs() (*GetStorageArgs, error) {
if len(req.Params) < 2 {
return nil, NewErrorResponse(ErrorArguments)
}
args := new(GetStorageArgs)
// TODO need to pass both arguments
r := bytes.NewReader(req.Params[0])
err := json.NewDecoder(r).Decode(args)
if err != nil {
return nil, NewErrorResponse(ErrorDecodeArgs)
}
jsonlogger.DebugDetailf("%T %v", args, args)
return args, nil
}
func (req *RpcRequest) ToGetTxCountArgs() (*GetTxCountArgs, error) {
if len(req.Params) < 1 {
return nil, NewErrorResponse(ErrorArguments)
}
args := new(GetTxCountArgs)
r := bytes.NewReader(req.Params[0])
err := json.NewDecoder(r).Decode(args)
if err != nil {
return nil, NewErrorResponse(ErrorDecodeArgs)
}
jsonlogger.DebugDetailf("%T %v", args, args)
return args, nil
}
func (req *RpcRequest) ToGetBalanceArgs() (*GetBalanceArgs, error) {
if len(req.Params) < 1 {
return nil, NewErrorResponse(ErrorArguments)
}
args := new(GetBalanceArgs)
r := bytes.NewReader(req.Params[0])
err := json.NewDecoder(r).Decode(args)
if err != nil {
return nil, NewErrorResponse(ErrorDecodeArgs)
}
jsonlogger.DebugDetailf("%T %v", args, args)
return args, nil
}
// 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
// // return res
// }
func NewErrorResponse(msg string) error {
return errors.New(msg)
} }

View File

@ -1,11 +1,12 @@
package rpc package rpc
import ( import (
// "bytes"
"encoding/json" "encoding/json"
"errors"
"math/big" "math/big"
"strings" "strings"
// "errors"
"github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/xeth" "github.com/ethereum/go-ethereum/xeth"
) )
@ -14,84 +15,169 @@ type EthereumApi struct {
pipe *xeth.JSXEth pipe *xeth.JSXEth
} }
type JsonArgs interface { func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *interface{}) error {
requirements() error
}
type BlockResponse struct {
JsonResponse
}
type GetBlockArgs struct {
BlockNumber int
Hash string
}
type ErrorResponse struct {
Error bool `json:"error"`
ErrorText string `json:"errorText"`
}
type JsonResponse interface {
}
type SuccessRes struct {
Error bool `json:"error"`
Result JsonResponse `json:"result"`
}
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 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")
}
newErr := errors.New(string(res))
return newErr
}
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() err := args.requirements()
if err != nil { if err != nil {
return err return err
} }
block := p.pipe.BlockByHash(args.Hash) // var block xeth.JSBlock
*reply = NewSuccessRes(block) if args.BlockNumber > 0 {
// block := p.pipe.BlockByNumber(int32(args.BlockNumber))
*reply = p.pipe.BlockByNumber(args.BlockNumber)
} else {
// block := p.pipe.BlockByHash(args.Hash)
*reply = p.pipe.BlockByHash(args.Hash)
}
return nil
}
func (p *EthereumApi) Transact(args *NewTxArgs, 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 = result
return nil
}
func (p *EthereumApi) Create(args *NewTxArgs, reply *interface{}) error {
err := args.requirementsContract()
if err != nil {
return err
}
result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, "", args.Value, args.Gas, args.GasPrice, args.Body)
*reply = result
return nil
}
func (p *EthereumApi) PushTx(args *PushTxArgs, reply *interface{}) error {
err := args.requirementsPushTx()
if err != nil {
return err
}
result, _ := p.pipe.PushTx(args.Tx)
*reply = result
return nil
}
func (p *EthereumApi) GetKey(args interface{}, reply *interface{}) error {
*reply = p.pipe.Key()
return nil
}
func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
}
state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
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())
}
jsonlogger.Debugf("GetStorageAt(%s, %s)\n", args.Address, hx)
value := state.Storage(ethutil.Hex2Bytes(hx))
*reply = GetStorageAtRes{Address: args.Address, Key: args.Key, Value: value.Str()}
return nil
}
func (p *EthereumApi) GetPeerCount(reply *interface{}) error {
*reply = p.pipe.PeerCount()
return nil
}
func (p *EthereumApi) GetIsListening(reply *interface{}) error {
*reply = p.pipe.IsListening()
// *reply = NewSuccessRes(GetListeningRes{IsListening: p.pipe.IsListening()})
return nil
}
func (p *EthereumApi) GetCoinbase(reply *interface{}) error {
*reply = p.pipe.CoinBase()
// *reply = p.pipe.CoinBase()
return nil
}
func (p *EthereumApi) GetIsMining(reply *interface{}) error {
*reply = p.pipe.IsMining()
return nil
}
func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
}
*reply = p.pipe.TxCountAt(args.Address)
return nil
}
func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
}
state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
*reply = BalanceRes{Balance: state.Balance().String(), Address: args.Address}
return nil
}
// type JsonArgs interface {
// requirements() error
// }
// type BlockResponse struct {
// JsonResponse
// }
type GetBlockArgs struct {
BlockNumber int32
Hash string
}
func (obj *GetBlockArgs) UnmarshalJSON(b []byte) (err error) {
argint, argstr := int32(0), ""
if err = json.Unmarshal(b, &argint); err == nil {
obj.BlockNumber = argint
return
}
if err = json.Unmarshal(b, &argstr); err == nil {
obj.Hash = argstr
return
}
return NewErrorResponse("Could not determine JSON parameters")
}
func (obj *GetBlockArgs) requirements() error {
if obj.BlockNumber == 0 && obj.Hash == "" {
return NewErrorResponse("GetBlock requires either a block 'number' or a block 'hash' as argument")
}
return nil return nil
} }
type NewTxArgs struct { type NewTxArgs struct {
Sec string Sec string `json:"sec"`
Recipient string Recipient string `json:"recipient"`
Value string Value string `json:"value"`
Gas string Gas string `json:"gas"`
GasPrice string GasPrice string `json:"gasprice"`
Init string Init string `json:"init"`
Body string Body string `json:"body"`
}
type TxResponse struct {
Hash string
} }
// type TxResponse struct {
// Hash string
// }
func (a *NewTxArgs) requirements() error { func (a *NewTxArgs) requirements() error {
if a.Recipient == "" { if a.Recipient == "" {
return NewErrorResponse("Transact requires a 'recipient' address as argument") return NewErrorResponse("Transact requires a 'recipient' address as argument")
@ -124,29 +210,8 @@ func (a *NewTxArgs) requirementsContract() error {
return nil return nil
} }
func (p *EthereumApi) Transact(args *NewTxArgs, reply *string) 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
}
result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, "", args.Value, args.Gas, args.GasPrice, args.Body)
*reply = NewSuccessRes(result)
return nil
}
type PushTxArgs struct { type PushTxArgs struct {
Tx string Tx string `json:"tx"`
} }
func (a *PushTxArgs) requirementsPushTx() error { func (a *PushTxArgs) requirementsPushTx() error {
@ -156,21 +221,6 @@ func (a *PushTxArgs) requirementsPushTx() error {
return nil return nil
} }
func (p *EthereumApi) PushTx(args *PushTxArgs, reply *string) error {
err := args.requirementsPushTx()
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())
return nil
}
type GetStorageArgs struct { type GetStorageArgs struct {
Address string Address string
Key string Key string
@ -192,33 +242,21 @@ type GetStorageAtRes struct {
Address string `json:"address"` Address string `json:"address"`
} }
func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *string) error {
err := args.requirements()
if err != nil {
return err
}
state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
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())
}
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()})
return nil
}
type GetTxCountArgs struct { type GetTxCountArgs struct {
Address string `json:"address"` Address string `json:"address"`
} }
type GetTxCountRes struct {
Nonce int `json:"nonce"` // type GetTxCountRes struct {
// Nonce int `json:"nonce"`
// }
func (obj *GetTxCountArgs) UnmarshalJSON(b []byte) (err error) {
arg0 := ""
if err = json.Unmarshal(b, arg0); err == nil {
obj.Address = arg0
return
}
return NewErrorResponse("Could not determine JSON parameters")
} }
func (a *GetTxCountArgs) requirements() error { func (a *GetTxCountArgs) requirements() error {
@ -228,56 +266,35 @@ func (a *GetTxCountArgs) requirements() error {
return nil return nil
} }
type GetPeerCountRes struct { // type GetPeerCountRes struct {
PeerCount int `json:"peerCount"` // PeerCount int `json:"peerCount"`
} // }
func (p *EthereumApi) GetPeerCount(args *interface{}, reply *string) error { // type GetListeningRes struct {
*reply = NewSuccessRes(GetPeerCountRes{PeerCount: p.pipe.PeerCount()}) // IsListening bool `json:"isListening"`
return nil // }
}
type GetListeningRes struct { // type GetCoinbaseRes struct {
IsListening bool `json:"isListening"` // Coinbase string `json:"coinbase"`
} // }
func (p *EthereumApi) GetIsListening(args *interface{}, reply *string) error { // type GetMiningRes struct {
*reply = NewSuccessRes(GetListeningRes{IsListening: p.pipe.IsListening()}) // IsMining bool `json:"isMining"`
return nil // }
}
type GetCoinbaseRes struct {
Coinbase string `json:"coinbase"`
}
func (p *EthereumApi) GetCoinbase(args *interface{}, reply *string) error {
*reply = NewSuccessRes(GetCoinbaseRes{Coinbase: p.pipe.CoinBase()})
return nil
}
type GetMiningRes struct {
IsMining bool `json:"isMining"`
}
func (p *EthereumApi) GetIsMining(args *interface{}, reply *string) error {
*reply = NewSuccessRes(GetMiningRes{IsMining: p.pipe.IsMining()})
return nil
}
func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *string) error {
err := args.requirements()
if err != nil {
return err
}
state := p.pipe.TxCountAt(args.Address)
*reply = NewSuccessRes(GetTxCountRes{Nonce: state})
return nil
}
type GetBalanceArgs struct { type GetBalanceArgs struct {
Address string Address string
} }
func (obj *GetBalanceArgs) UnmarshalJSON(b []byte) (err error) {
arg0 := ""
if err = json.Unmarshal(b, &arg0); err == nil {
obj.Address = arg0
return
}
return NewErrorResponse("Could not determine JSON parameters")
}
func (a *GetBalanceArgs) requirements() error { func (a *GetBalanceArgs) requirements() error {
if a.Address == "" { if a.Address == "" {
return NewErrorResponse("GetBalanceAt requires an 'address' value as argument") return NewErrorResponse("GetBalanceAt requires an 'address' value as argument")
@ -290,22 +307,12 @@ type BalanceRes struct {
Address string `json:"address"` Address string `json:"address"`
} }
func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *string) error { // type TestRes struct {
err := args.requirements() // JsonResponse `json:"-"`
if err != nil { // Answer int `json:"answer"`
return err // }
}
state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
*reply = NewSuccessRes(BalanceRes{Balance: state.Balance().String(), Address: args.Address})
return nil
}
type TestRes struct { // func (p *EthereumApi) Test(args *GetBlockArgs, reply *interface{}) error {
JsonResponse `json:"-"` // *reply = NewSuccessRes(TestRes{Answer: 15})
Answer int `json:"answer"` // return nil
} // }
func (p *EthereumApi) Test(args *GetBlockArgs, reply *string) error {
*reply = NewSuccessRes(TestRes{Answer: 15})
return nil
}

View File

@ -3,8 +3,7 @@ package rpc
import ( import (
"fmt" "fmt"
"net" "net"
"net/rpc" "net/http"
"net/rpc/jsonrpc"
"github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/xeth" "github.com/ethereum/go-ethereum/xeth"
@ -38,17 +37,14 @@ func (s *JsonRpcServer) Stop() {
func (s *JsonRpcServer) Start() { func (s *JsonRpcServer) Start() {
jsonlogger.Infoln("Starting JSON-RPC server") jsonlogger.Infoln("Starting JSON-RPC server")
go s.exitHandler() go s.exitHandler()
rpc.Register(&EthereumApi{pipe: s.pipe})
rpc.HandleHTTP()
for { h := apiHandler(&EthereumApi{pipe: s.pipe})
conn, err := s.listener.Accept() http.Handle("/", h)
if err != nil {
jsonlogger.Infoln("Error starting JSON-RPC:", err) err := http.Serve(s.listener, nil)
break // TODO Complains on shutdown due to listner already being closed
} if err != nil {
jsonlogger.Debugln("Incoming request.") jsonlogger.Errorln("Error on JSON-RPC interface:", err)
go jsonrpc.ServeConn(conn)
} }
} }
@ -65,3 +61,28 @@ func NewJsonRpcServer(pipe *xeth.JSXEth, port int) (*JsonRpcServer, error) {
pipe: pipe, pipe: pipe,
}, nil }, nil
} }
func apiHandler(xeth *EthereumApi) http.Handler {
fn := func(w http.ResponseWriter, req *http.Request) {
jsonlogger.Debugln("Handling request")
reqParsed, reqerr := JSON.ParseRequestBody(req)
if reqerr != nil {
JSON.Send(w, &RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: ErrorParseRequest})
return
}
var response interface{}
reserr := JSON.GetRequestReply(xeth, &reqParsed, &response)
if reserr != nil {
jsonlogger.Errorln(reserr)
JSON.Send(w, &RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: reserr.Error()})
return
}
jsonlogger.Debugf("Generated response: %T %s", response, response)
JSON.Send(w, &RpcSuccessResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: false, Result: response})
}
return http.HandlerFunc(fn)
}

View File

@ -1,75 +0,0 @@
package rpc
/*
func pack(id int, v ...interface{}) Message {
return Message{Data: v, Id: id}
}
func WriteOn(msg *Message, writer io.Writer) {
//msg := &Message{Seed: seed, Data: data}
switch msg.Call {
case "compile":
data := ethutil.NewValue(msg.Args)
bcode, err := ethutil.Compile(data.Get(0).Str(), false)
if err != nil {
JSON.Send(writer, pack(msg.Id, err.Error()))
}
code := ethutil.Bytes2Hex(bcode)
JSON.Send(writer, pack(msg.Id, code, nil))
case "block":
args := msg.Arguments()
block := pipe.BlockByNumber(int32(args.Get(0).Uint()))
JSON.Send(writer, pack(msg.Id, block))
case "transact":
if mp, ok := msg.Args[0].(map[string]interface{}); ok {
object := mapToTxParams(mp)
JSON.Send(
writer,
pack(msg.Id, args(pipe.Transact(object["from"], object["to"], object["value"], object["gas"], object["gasPrice"], object["data"]))),
)
}
case "coinbase":
JSON.Send(writer, pack(msg.Id, pipe.CoinBase(), msg.Seed))
case "listening":
JSON.Send(writer, pack(msg.Id, pipe.IsListening()))
case "mining":
JSON.Send(writer, pack(msg.Id, pipe.IsMining()))
case "peerCoint":
JSON.Send(writer, pack(msg.Id, pipe.PeerCount()))
case "countAt":
args := msg.Arguments()
JSON.Send(writer, pack(msg.Id, pipe.TxCountAt(args.Get(0).Str())))
case "codeAt":
args := msg.Arguments()
JSON.Send(writer, pack(msg.Id, len(pipe.CodeAt(args.Get(0).Str()))))
case "stateAt":
args := msg.Arguments()
JSON.Send(writer, pack(msg.Id, pipe.StorageAt(args.Get(0).Str(), args.Get(1).Str())))
case "balanceAt":
args := msg.Arguments()
JSON.Send(writer, pack(msg.Id, pipe.BalanceAt(args.Get(0).Str())))
case "newFilter":
case "newFilterString":
case "messages":
// TODO
}
}
*/