An example program generated with https://github.com/gregdhill/go-openrpc/

example.go

// Code generated by go-openrpc. DO NOT EDIT.
package main

import (
	"bytes"
	"encoding/json"
	rpct "github.com/gregdhill/go-openrpc/rpc"
	"io/ioutil"
	"log"
	"net/http"
	"reflect"
)

// https://github.com/a8m/reflect-examples#wrap-a-reflectvalue-with-pointer-t--t
func ptr(v reflect.Value) reflect.Value {
	pt := reflect.PtrTo(v.Type())
	pv := reflect.New(pt.Elem())
	pv.Elem().Set(v)
	return pv
}

func ResultToStruct(msg json.RawMessage, res interface{}) error {
	var err error
	val := reflect.ValueOf(res)
	if val.Kind() == reflect.Ptr {
		val = val.Elem()
	}
	// Get first (and only field)
	field := val.Field(0)
	if field.CanSet() {
		pf := ptr(field)
		err = json.Unmarshal(msg, pf.Interface())
		if err != nil {
			return err
		}
		field.Set(pf.Elem())
	}
	return nil
}

var gethClientRPC string

type exampleRPCService struct{}

func (s *exampleRPCService) Web3ClientVersion() (result *rpct.Web3ClientVersionResult, err error) {
	defer log.Println(`web3_clientVersion`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "web3_clientVersion",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.Web3ClientVersionResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) Web3Sha3(params *rpct.Web3Sha3Params) (result *rpct.Web3Sha3Result, err error) {
	defer log.Println("web3_sha3", "params=", params)
	defer log.Println(`web3_sha3`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "web3_sha3",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.Web3Sha3Result)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) NetListening() (result *rpct.NetListeningResult, err error) {
	defer log.Println(`net_listening`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "net_listening",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.NetListeningResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) NetPeerCount() (result *rpct.NetPeerCountResult, err error) {
	defer log.Println(`net_peerCount`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "net_peerCount",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.NetPeerCountResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) NetVersion() (result *rpct.NetVersionResult, err error) {
	defer log.Println(`net_version`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "net_version",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.NetVersionResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthBlockNumber() (result *rpct.EthBlockNumberResult, err error) {
	defer log.Println(`eth_blockNumber`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_blockNumber",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthBlockNumberResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthCall(params *rpct.EthCallParams) (result *rpct.EthCallResult, err error) {
	defer log.Println("eth_call", "params=", params)
	defer log.Println(`eth_call`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_call",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthCallResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthChainId() (result *rpct.EthChainIdResult, err error) {
	defer log.Println(`eth_chainId`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_chainId",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthChainIdResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthCoinbase() (result *rpct.EthCoinbaseResult, err error) {
	defer log.Println(`eth_coinbase`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_coinbase",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthCoinbaseResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthEstimateGas(params *rpct.EthEstimateGasParams) (result *rpct.EthEstimateGasResult, err error) {
	defer log.Println("eth_estimateGas", "params=", params)
	defer log.Println(`eth_estimateGas`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_estimateGas",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthEstimateGasResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGasPrice() (result *rpct.EthGasPriceResult, err error) {
	defer log.Println(`eth_gasPrice`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_gasPrice",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGasPriceResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetBalance(params *rpct.EthGetBalanceParams) (result *rpct.EthGetBalanceResult, err error) {
	defer log.Println("eth_getBalance", "params=", params)
	defer log.Println(`eth_getBalance`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getBalance",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetBalanceResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetBlockByHash(params *rpct.EthGetBlockByHashParams) (result *rpct.EthGetBlockByHashResult, err error) {
	defer log.Println("eth_getBlockByHash", "params=", params)
	defer log.Println(`eth_getBlockByHash`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getBlockByHash",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetBlockByHashResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetBlockByNumber(params *rpct.EthGetBlockByNumberParams) (result *rpct.EthGetBlockByNumberResult, err error) {
	defer log.Println("eth_getBlockByNumber", "params=", params)
	defer log.Println(`eth_getBlockByNumber`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getBlockByNumber",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetBlockByNumberResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetBlockTransactionCountByHash(params *rpct.EthGetBlockTransactionCountByHashParams) (result *rpct.EthGetBlockTransactionCountByHashResult, err error) {
	defer log.Println("eth_getBlockTransactionCountByHash", "params=", params)
	defer log.Println(`eth_getBlockTransactionCountByHash`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getBlockTransactionCountByHash",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetBlockTransactionCountByHashResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetBlockTransactionCountByNumber(params *rpct.EthGetBlockTransactionCountByNumberParams) (result *rpct.EthGetBlockTransactionCountByNumberResult, err error) {
	defer log.Println("eth_getBlockTransactionCountByNumber", "params=", params)
	defer log.Println(`eth_getBlockTransactionCountByNumber`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getBlockTransactionCountByNumber",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetBlockTransactionCountByNumberResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetCode(params *rpct.EthGetCodeParams) (result *rpct.EthGetCodeResult, err error) {
	defer log.Println("eth_getCode", "params=", params)
	defer log.Println(`eth_getCode`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getCode",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetCodeResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetFilterChanges(params *rpct.EthGetFilterChangesParams) (result *rpct.EthGetFilterChangesResult, err error) {
	defer log.Println("eth_getFilterChanges", "params=", params)
	defer log.Println(`eth_getFilterChanges`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getFilterChanges",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetFilterChangesResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetFilterLogs(params *rpct.EthGetFilterLogsParams) (result *rpct.EthGetFilterLogsResult, err error) {
	defer log.Println("eth_getFilterLogs", "params=", params)
	defer log.Println(`eth_getFilterLogs`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getFilterLogs",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetFilterLogsResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetRawTransactionByHash(params *rpct.EthGetRawTransactionByHashParams) (result *rpct.EthGetRawTransactionByHashResult, err error) {
	defer log.Println("eth_getRawTransactionByHash", "params=", params)
	defer log.Println(`eth_getRawTransactionByHash`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getRawTransactionByHash",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetRawTransactionByHashResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetRawTransactionByBlockHashAndIndex(params *rpct.EthGetRawTransactionByBlockHashAndIndexParams) (result *rpct.EthGetRawTransactionByBlockHashAndIndexResult, err error) {
	defer log.Println("eth_getRawTransactionByBlockHashAndIndex", "params=", params)
	defer log.Println(`eth_getRawTransactionByBlockHashAndIndex`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getRawTransactionByBlockHashAndIndex",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetRawTransactionByBlockHashAndIndexResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetRawTransactionByBlockNumberAndIndex(params *rpct.EthGetRawTransactionByBlockNumberAndIndexParams) (result *rpct.EthGetRawTransactionByBlockNumberAndIndexResult, err error) {
	defer log.Println("eth_getRawTransactionByBlockNumberAndIndex", "params=", params)
	defer log.Println(`eth_getRawTransactionByBlockNumberAndIndex`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getRawTransactionByBlockNumberAndIndex",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetRawTransactionByBlockNumberAndIndexResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetLogs(params *rpct.EthGetLogsParams) (result *rpct.EthGetLogsResult, err error) {
	defer log.Println("eth_getLogs", "params=", params)
	defer log.Println(`eth_getLogs`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getLogs",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetLogsResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetStorageAt(params *rpct.EthGetStorageAtParams) (result *rpct.EthGetStorageAtResult, err error) {
	defer log.Println("eth_getStorageAt", "params=", params)
	defer log.Println(`eth_getStorageAt`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getStorageAt",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetStorageAtResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetTransactionByBlockHashAndIndex(params *rpct.EthGetTransactionByBlockHashAndIndexParams) (result *rpct.EthGetTransactionByBlockHashAndIndexResult, err error) {
	defer log.Println("eth_getTransactionByBlockHashAndIndex", "params=", params)
	defer log.Println(`eth_getTransactionByBlockHashAndIndex`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getTransactionByBlockHashAndIndex",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetTransactionByBlockHashAndIndexResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetTransactionByBlockNumberAndIndex(params *rpct.EthGetTransactionByBlockNumberAndIndexParams) (result *rpct.EthGetTransactionByBlockNumberAndIndexResult, err error) {
	defer log.Println("eth_getTransactionByBlockNumberAndIndex", "params=", params)
	defer log.Println(`eth_getTransactionByBlockNumberAndIndex`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getTransactionByBlockNumberAndIndex",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetTransactionByBlockNumberAndIndexResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetTransactionByHash(params *rpct.EthGetTransactionByHashParams) (result *rpct.EthGetTransactionByHashResult, err error) {
	defer log.Println("eth_getTransactionByHash", "params=", params)
	defer log.Println(`eth_getTransactionByHash`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getTransactionByHash",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetTransactionByHashResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetTransactionCount(params *rpct.EthGetTransactionCountParams) (result *rpct.EthGetTransactionCountResult, err error) {
	defer log.Println("eth_getTransactionCount", "params=", params)
	defer log.Println(`eth_getTransactionCount`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getTransactionCount",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetTransactionCountResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetTransactionReceipt(params *rpct.EthGetTransactionReceiptParams) (result *rpct.EthGetTransactionReceiptResult, err error) {
	defer log.Println("eth_getTransactionReceipt", "params=", params)
	defer log.Println(`eth_getTransactionReceipt`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getTransactionReceipt",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetTransactionReceiptResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetUncleByBlockHashAndIndex(params *rpct.EthGetUncleByBlockHashAndIndexParams) (result *rpct.EthGetUncleByBlockHashAndIndexResult, err error) {
	defer log.Println("eth_getUncleByBlockHashAndIndex", "params=", params)
	defer log.Println(`eth_getUncleByBlockHashAndIndex`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getUncleByBlockHashAndIndex",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetUncleByBlockHashAndIndexResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetUncleByBlockNumberAndIndex(params *rpct.EthGetUncleByBlockNumberAndIndexParams) (result *rpct.EthGetUncleByBlockNumberAndIndexResult, err error) {
	defer log.Println("eth_getUncleByBlockNumberAndIndex", "params=", params)
	defer log.Println(`eth_getUncleByBlockNumberAndIndex`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getUncleByBlockNumberAndIndex",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetUncleByBlockNumberAndIndexResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetUncleCountByBlockHash(params *rpct.EthGetUncleCountByBlockHashParams) (result *rpct.EthGetUncleCountByBlockHashResult, err error) {
	defer log.Println("eth_getUncleCountByBlockHash", "params=", params)
	defer log.Println(`eth_getUncleCountByBlockHash`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getUncleCountByBlockHash",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetUncleCountByBlockHashResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetUncleCountByBlockNumber(params *rpct.EthGetUncleCountByBlockNumberParams) (result *rpct.EthGetUncleCountByBlockNumberResult, err error) {
	defer log.Println("eth_getUncleCountByBlockNumber", "params=", params)
	defer log.Println(`eth_getUncleCountByBlockNumber`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getUncleCountByBlockNumber",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetUncleCountByBlockNumberResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetProof(params *rpct.EthGetProofParams) (result *rpct.EthGetProofResult, err error) {
	defer log.Println("eth_getProof", "params=", params)
	defer log.Println(`eth_getProof`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getProof",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetProofResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthGetWork() (result *rpct.EthGetWorkResult, err error) {
	defer log.Println(`eth_getWork`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_getWork",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthGetWorkResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthHashrate() (result *rpct.EthHashrateResult, err error) {
	defer log.Println(`eth_hashrate`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_hashrate",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthHashrateResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthMining() (result *rpct.EthMiningResult, err error) {
	defer log.Println(`eth_mining`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_mining",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthMiningResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthNewBlockFilter() (result *rpct.EthNewBlockFilterResult, err error) {
	defer log.Println(`eth_newBlockFilter`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_newBlockFilter",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthNewBlockFilterResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthNewFilter(params *rpct.EthNewFilterParams) (result *rpct.EthNewFilterResult, err error) {
	defer log.Println("eth_newFilter", "params=", params)
	defer log.Println(`eth_newFilter`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_newFilter",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthNewFilterResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthNewPendingTransactionFilter() (result *rpct.EthNewPendingTransactionFilterResult, err error) {
	defer log.Println(`eth_newPendingTransactionFilter`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_newPendingTransactionFilter",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthNewPendingTransactionFilterResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthPendingTransactions() (result *rpct.EthPendingTransactionsResult, err error) {
	defer log.Println(`eth_pendingTransactions`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_pendingTransactions",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthPendingTransactionsResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthProtocolVersion() (result *rpct.EthProtocolVersionResult, err error) {
	defer log.Println(`eth_protocolVersion`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_protocolVersion",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthProtocolVersionResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthSign(params *rpct.EthSignParams) (result *rpct.EthSignResult, err error) {
	defer log.Println("eth_sign", "params=", params)
	defer log.Println(`eth_sign`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_sign",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthSignResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthAccounts() (result *rpct.EthAccountsResult, err error) {
	defer log.Println(`eth_accounts`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_accounts",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthAccountsResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthSendTransaction(params *rpct.EthSendTransactionParams) (result *rpct.EthSendTransactionResult, err error) {
	defer log.Println("eth_sendTransaction", "params=", params)
	defer log.Println(`eth_sendTransaction`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_sendTransaction",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthSendTransactionResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthSendRawTransaction(params *rpct.EthSendRawTransactionParams) (result *rpct.EthSendRawTransactionResult, err error) {
	defer log.Println("eth_sendRawTransaction", "params=", params)
	defer log.Println(`eth_sendRawTransaction`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_sendRawTransaction",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthSendRawTransactionResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthSubmitHashrate(params *rpct.EthSubmitHashrateParams) (result *rpct.EthSubmitHashrateResult, err error) {
	defer log.Println("eth_submitHashrate", "params=", params)
	defer log.Println(`eth_submitHashrate`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_submitHashrate",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthSubmitHashrateResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthSubmitWork(params *rpct.EthSubmitWorkParams) (result *rpct.EthSubmitWorkResult, err error) {
	defer log.Println("eth_submitWork", "params=", params)
	defer log.Println(`eth_submitWork`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_submitWork",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthSubmitWorkResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthSyncing() (result *rpct.EthSyncingResult, err error) {
	defer log.Println(`eth_syncing`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_syncing",
		Params:  []byte("[]"),
		ID:      1,
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthSyncingResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}
func (s *exampleRPCService) EthUninstallFilter(params *rpct.EthUninstallFilterParams) (result *rpct.EthUninstallFilterResult, err error) {
	defer log.Println("eth_uninstallFilter", "params=", params)
	defer log.Println(`eth_uninstallFilter`)

	req := rpct.RPCRequest{
		JSONRPC: "2.0",
		Method:  "eth_uninstallFilter",
		Params:  []byte("[]"),
		ID:      1,
	}
	if params != nil {
		set := []interface{}{}
		val := reflect.ValueOf(params).Elem()

		for i := 0; i < val.NumField(); i++ {
			valField := val.Field(i)
			set = append(set, valField.Interface())
		}

		b, err := json.Marshal(set)
		if err != nil {
			return nil, err
		}

		req.Params = b
	}

	reqB, err := json.Marshal(&req)
	if err != nil {
		return nil, err
	}
	log.Println("posting", string(reqB))
	buf := bytes.NewBuffer(reqB)
	res, err := http.Post(gethClientRPC, "application/json", buf)
	if err != nil {
		log.Println("POST error:", err)
		return nil, err
	}

	gotB, err := ioutil.ReadAll(res.Body)
	if err != nil {
		log.Println("read body error:", err)
		return nil, err
	}

	// TODO: handle server error response

	gotRes := &struct {
		JSONRPC string          `json:"jsonrpc"`
		Result  json.RawMessage `json:"result"`
		ID      interface{}     `json:"id"`
	}{}

	err = json.Unmarshal(gotB, gotRes)
	if err != nil {
		log.Println("json unmarshal error:", err, "data", string(gotB))
		return nil, err
	}
	log.Println("received OK response:", string(gotB))

	wantRes := new(rpct.EthUninstallFilterResult)
	err = ResultToStruct(gotRes.Result, wantRes)
	if err != nil {
		log.Println("result to struct error:", err, "result", gotRes.Result)
		return nil, err
	}

	return wantRes, nil

}

func main() {
	gethClientRPC = "http://localhost:8545"
	service := new(exampleRPCService)
	server := rpct.NewServer(service)

	s := http.Server{
		Addr:    ":3000",
		Handler: server,
	}
	log.Println("Expecting upstream eth RPC endpoint at", gethClientRPC)
	log.Println("Serving on http://localhost:3000 ...")
	log.Fatal(s.ListenAndServe())
}