diff --git a/erisdb/serve.go b/erisdb/serve.go
index 6379432609cad8ab25318f949f34248e03311224..0aa849a0a39dd8628717fa7175b2d3018990676e 100644
--- a/erisdb/serve.go
+++ b/erisdb/serve.go
@@ -6,26 +6,34 @@ import (
 	"bytes"
 	"fmt"
 	"io/ioutil"
+	"net"
+	"net/http"
 	"path"
 	"strings"
 	"sync"
 
+	// tendermint support libs
 	. "github.com/tendermint/go-common"
 	cfg "github.com/tendermint/go-config"
 	dbm "github.com/tendermint/go-db"
 	"github.com/tendermint/go-events"
-	"github.com/tendermint/go-p2p"
+	rpcserver "github.com/tendermint/go-rpc/server"
 	"github.com/tendermint/go-wire"
 	"github.com/tendermint/log15"
 
+	// for inproc tendermint
+	"github.com/tendermint/go-p2p"
 	"github.com/tendermint/tendermint/node"
 	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 	tmspcli "github.com/tendermint/tmsp/client"
+
+	// tmsp server
 	tmsp "github.com/tendermint/tmsp/server"
 
 	edbcfg "github.com/eris-ltd/eris-db/config"
 	ep "github.com/eris-ltd/eris-db/erisdb/pipe"
+	rpccore "github.com/eris-ltd/eris-db/rpc/core"
 	"github.com/eris-ltd/eris-db/server"
 	sm "github.com/eris-ltd/eris-db/state"
 	stypes "github.com/eris-ltd/eris-db/state/types"
@@ -126,7 +134,8 @@ func ServeErisDB(workDir string, inProc bool) (*server.ServeProcess, error) {
 	app.SetHostAddress(edbConf.Tendermint.Host)
 	if inProc {
 		fmt.Println("Starting tm node in proc")
-		startTMNode(app)
+		// will also start the go-rpc server (46657 api)
+		startTMNode(app, workDir)
 	} else {
 		fmt.Println("Starting tmsp listener")
 		// Start the tmsp listener for state update commands
@@ -161,7 +170,7 @@ func ServeErisDB(workDir string, inProc bool) (*server.ServeProcess, error) {
 }
 
 // start an inproc tendermint node
-func startTMNode(app *edbapp.ErisDBApp) {
+func startTMNode(app *edbapp.ErisDBApp, workDir string) {
 	// get the genesis
 	genDocFile := config.GetString("tm.genesis_file")
 	jsonBlob, err := ioutil.ReadFile(genDocFile)
@@ -199,9 +208,46 @@ func startTMNode(app *edbapp.ErisDBApp) {
 
 	// Run the RPC server.
 	if config.GetString("tm.rpc_laddr") != "" {
-		_, err := nd.StartRPC()
+		_, err := StartRPC(nd, app)
 		if err != nil {
 			PanicCrisis(err)
 		}
 	}
 }
+
+func StartRPC(n *node.Node, edbApp *edbapp.ErisDBApp) ([]net.Listener, error) {
+	rpccore.SetErisDBApp(edbApp)
+	rpccore.SetBlockStore(n.BlockStore())
+	rpccore.SetConsensusState(n.ConsensusState())
+	rpccore.SetConsensusReactor(n.ConsensusReactor())
+	rpccore.SetMempoolReactor(n.MempoolReactor())
+	rpccore.SetSwitch(n.Switch())
+	rpccore.SetPrivValidator(n.PrivValidator())
+	rpccore.SetGenDoc(LoadGenDoc())
+
+	listenAddrs := strings.Split(config.GetString("tm.rpc_laddr"), ",")
+
+	// we may expose the rpc over both a unix and tcp socket
+	listeners := make([]net.Listener, len(listenAddrs))
+	for i, listenAddr := range listenAddrs {
+		mux := http.NewServeMux()
+		wm := rpcserver.NewWebsocketManager(rpccore.Routes, n.EventSwitch())
+		mux.HandleFunc("/websocket", wm.WebsocketHandler)
+		rpcserver.RegisterRPCFuncs(mux, rpccore.Routes)
+		listener, err := rpcserver.StartHTTPServer(listenAddr, mux)
+		if err != nil {
+			return nil, err
+		}
+		listeners[i] = listener
+	}
+	return listeners, nil
+}
+
+func LoadGenDoc() *stypes.GenesisDoc {
+	genDocFile := config.GetString("tm.genesis_file")
+	jsonBlob, err := ioutil.ReadFile(genDocFile)
+	if err != nil {
+		Exit(Fmt("Couldn't read GenesisDoc file: %v", err))
+	}
+	return stypes.GenesisDocFromJSON(jsonBlob)
+}
diff --git a/rpc/client/client.go b/rpc/client/client.go
new file mode 100644
index 0000000000000000000000000000000000000000..ac3cd2707f92abeb2acd229dbbac870a01c5d006
--- /dev/null
+++ b/rpc/client/client.go
@@ -0,0 +1,171 @@
+package client
+
+import (
+	rpcclient "github.com/tendermint/go-rpc/client"
+
+	acm "github.com/eris-ltd/eris-db/account"
+	ctypes "github.com/eris-ltd/eris-db/rpc/core/types"
+	"github.com/eris-ltd/eris-db/txs"
+)
+
+func Status(client rpcclient.Client) (*ctypes.ResultStatus, error) {
+	var res ctypes.ErisDBResult //ResultStatus)
+	var err error
+	switch cli := client.(type) {
+	case *rpcclient.ClientJSONRPC:
+		_, err = cli.Call("status", []interface{}{}, &res)
+	case *rpcclient.ClientURI:
+		_, err = cli.Call("status", map[string]interface{}{}, &res)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return res.(*ctypes.ResultStatus), nil
+}
+
+func GenPrivAccount(client rpcclient.Client) (*acm.PrivAccount, error) {
+	var res ctypes.ErisDBResult
+	var err error
+	switch cli := client.(type) {
+	case *rpcclient.ClientJSONRPC:
+		_, err = cli.Call("unsafe/gen_priv_account", []interface{}{}, &res)
+	case *rpcclient.ClientURI:
+		_, err = cli.Call("unsafe/gen_priv_account", map[string]interface{}{}, &res)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return res.(*ctypes.ResultGenPrivAccount).PrivAccount, nil
+}
+
+func GetAccount(client rpcclient.Client, addr []byte) (*acm.Account, error) {
+	var res ctypes.ErisDBResult
+	var err error
+	switch cli := client.(type) {
+	case *rpcclient.ClientJSONRPC:
+		_, err = cli.Call("get_account", []interface{}{addr}, &res)
+	case *rpcclient.ClientURI:
+		_, err = cli.Call("get_account", map[string]interface{}{"address": addr}, &res)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return res.(*ctypes.ResultGetAccount).Account, nil
+}
+
+func SignTx(client rpcclient.Client, tx types.Tx, privAccs []*acm.PrivAccount) (types.Tx, error) {
+	wrapTx := struct {
+		types.Tx `json:"unwrap"`
+	}{tx}
+	var res ctypes.ErisDBResult
+	var err error
+	switch cli := client.(type) {
+	case *rpcclient.ClientJSONRPC:
+		_, err = cli.Call("unsafe/sign_tx", []interface{}{wrapTx, privAccs}, &res)
+	case *rpcclient.ClientURI:
+		_, err = cli.Call("unsafe/sign_tx", map[string]interface{}{"tx": wrapTx, "privAccounts": privAccs}, &res)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return res.(*ctypes.ResultSignTx).Tx, nil
+}
+
+func BroadcastTx(client rpcclient.Client, tx types.Tx) (ctypes.Receipt, error) {
+	wrapTx := struct {
+		types.Tx `json:"unwrap"`
+	}{tx}
+	var res ctypes.ErisDBResult
+	var err error
+	switch cli := client.(type) {
+	case *rpcclient.ClientJSONRPC:
+		_, err = cli.Call("broadcast_tx", []interface{}{wrapTx}, &res)
+	case *rpcclient.ClientURI:
+		_, err = cli.Call("broadcast_tx", map[string]interface{}{"tx": wrapTx}, &res)
+	}
+	if err != nil {
+		return ctypes.Receipt{}, err
+	}
+	data := res.(*ctypes.ResultBroadcastTx).Data
+	// TODO: unmarshal data to receuipt
+	_ = data
+	return ctypes.Receipt{}, err
+
+}
+
+func DumpStorage(client rpcclient.Client, addr []byte) (*ctypes.ResultDumpStorage, error) {
+	var res ctypes.ErisDBResult
+	var err error
+	switch cli := client.(type) {
+	case *rpcclient.ClientJSONRPC:
+		_, err = cli.Call("dump_storage", []interface{}{addr}, &res)
+	case *rpcclient.ClientURI:
+		_, err = cli.Call("dump_storage", map[string]interface{}{"address": addr}, &res)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return res.(*ctypes.ResultDumpStorage), err
+}
+
+func GetStorage(client rpcclient.Client, addr, key []byte) ([]byte, error) {
+	var res ctypes.ErisDBResult
+	var err error
+	switch cli := client.(type) {
+	case *rpcclient.ClientJSONRPC:
+		_, err = cli.Call("get_storage", []interface{}{addr, key}, &res)
+	case *rpcclient.ClientURI:
+		_, err = cli.Call("get_storage", map[string]interface{}{"address": addr, "key": key}, &res)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return res.(*ctypes.ResultGetStorage).Value, nil
+}
+
+func CallCode(client rpcclient.Client, fromAddress, code, data []byte) (*ctypes.ResultCall, error) {
+	var res ctypes.ErisDBResult
+	var err error
+	switch cli := client.(type) {
+	case *rpcclient.ClientJSONRPC:
+		_, err = cli.Call("call_code", []interface{}{fromAddress, code, data}, &res)
+	case *rpcclient.ClientURI:
+		_, err = cli.Call("call_code", map[string]interface{}{"fromAddress": fromAddress, "code": code, "data": data}, &res)
+
+	}
+	if err != nil {
+		return nil, err
+	}
+	return res.(*ctypes.ResultCall), err
+}
+
+func Call(client rpcclient.Client, fromAddress, toAddress, data []byte) (*ctypes.ResultCall, error) {
+	var res ctypes.ErisDBResult
+	var err error
+	switch cli := client.(type) {
+	case *rpcclient.ClientJSONRPC:
+		_, err = cli.Call("call", []interface{}{fromAddress, toAddress, data}, &res)
+	case *rpcclient.ClientURI:
+		_, err = cli.Call("call", map[string]interface{}{"fromAddress": fromAddress, "toAddress": toAddress, "data": data}, &res)
+
+	}
+	if err != nil {
+		return nil, err
+	}
+	return res.(*ctypes.ResultCall), err
+}
+
+func GetName(client rpcclient.Client, name string) (*types.NameRegEntry, error) {
+	var res ctypes.ErisDBResult
+	var err error
+	switch cli := client.(type) {
+	case *rpcclient.ClientJSONRPC:
+		_, err = cli.Call("get_name", []interface{}{name}, &res)
+	case *rpcclient.ClientURI:
+		_, err = cli.Call("get_name", map[string]interface{}{"name": name}, &res)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return res.(*ctypes.ResultGetName).Entry, nil
+}
diff --git a/rpc/core/accounts.go b/rpc/core/accounts.go
index 161a14af67a8e19f392ed1e191f4e4d113cdebe3..ca236cfb9bbe977e78dddf9a3b1c1650961c9632 100644
--- a/rpc/core/accounts.go
+++ b/rpc/core/accounts.go
@@ -17,7 +17,8 @@ func GetAccount(address []byte) (*ctypes.ResultGetAccount, error) {
 	// cache := mempoolReactor.Mempool.GetCache()
 	account := cache.GetAccount(address)
 	if account == nil {
-		return nil, nil
+		log.Warn("Nil Account")
+		return &ctypes.ResultGetAccount{nil}, nil
 	}
 	return &ctypes.ResultGetAccount{account}, nil
 }
diff --git a/rpc/core/mempool.go b/rpc/core/mempool.go
new file mode 100644
index 0000000000000000000000000000000000000000..47025a085cac7505661b8da16d14e31ce0262881
--- /dev/null
+++ b/rpc/core/mempool.go
@@ -0,0 +1,38 @@
+package core
+
+import (
+	"fmt"
+	ctypes "github.com/eris-ltd/eris-db/rpc/core/types"
+	txs "github.com/eris-ltd/eris-db/txs"
+	"github.com/tendermint/tendermint/types"
+	tmsp "github.com/tendermint/tmsp/types"
+)
+
+//-----------------------------------------------------------------------------
+
+// NOTE: tx must be signed
+func BroadcastTxAsync(tx types.Tx) (*ctypes.ResultBroadcastTx, error) {
+	err := mempoolReactor.BroadcastTx(tx, nil)
+	if err != nil {
+		return nil, fmt.Errorf("Error broadcasting transaction: %v", err)
+	}
+	return &ctypes.ResultBroadcastTx{}, nil
+}
+
+// Note: tx must be signed
+func BroadcastTxSync(tx txs.Tx) (*ctypes.ResultBroadcastTx, error) {
+	fmt.Println("BROADCAST!", tx)
+	resCh := make(chan *tmsp.Response, 1)
+	err := mempoolReactor.BroadcastTx(txs.EncodeTx(tx), func(res *tmsp.Response) {
+		resCh <- res
+	})
+	if err != nil {
+		return nil, fmt.Errorf("Error broadcasting transaction: %v", err)
+	}
+	res := <-resCh
+	return &ctypes.ResultBroadcastTx{
+		Code: res.Code,
+		Data: res.Data,
+		Log:  res.Log,
+	}, nil
+}
diff --git a/rpc/core/routes.go b/rpc/core/routes.go
index 9d8bf8f556d78a7deb73b28c04812380b5454861..80eee8a24f66a2f472e8a4b951d0ca7b9efd6741 100644
--- a/rpc/core/routes.go
+++ b/rpc/core/routes.go
@@ -1,29 +1,146 @@
 package core
 
 import (
+	acm "github.com/eris-ltd/eris-db/account"
+	ctypes "github.com/eris-ltd/eris-db/rpc/core/types"
+	"github.com/eris-ltd/eris-db/txs"
 	rpc "github.com/tendermint/go-rpc/server"
 )
 
 // TODO: eliminate redundancy between here and reading code from core/
 var Routes = map[string]*rpc.RPCFunc{
-	"status":   rpc.NewRPCFunc(Status, ""),
-	"net_info": rpc.NewRPCFunc(NetInfo, ""),
+	"status":                  rpc.NewRPCFunc(StatusResult, ""),
+	"net_info":                rpc.NewRPCFunc(NetInfoResult, ""),
+	"genesis":                 rpc.NewRPCFunc(GenesisResult, ""),
+	"get_account":             rpc.NewRPCFunc(GetAccountResult, "address"),
+	"get_storage":             rpc.NewRPCFunc(GetStorageResult, "address,key"),
+	"call":                    rpc.NewRPCFunc(CallResult, "fromAddress,toAddress,data"),
+	"call_code":               rpc.NewRPCFunc(CallCodeResult, "fromAddress,code,data"),
+	"dump_storage":            rpc.NewRPCFunc(DumpStorageResult, "address"),
+	"list_accounts":           rpc.NewRPCFunc(ListAccountsResult, ""),
+	"get_name":                rpc.NewRPCFunc(GetNameResult, "name"),
+	"list_names":              rpc.NewRPCFunc(ListNamesResult, ""),
+	"broadcast_tx":            rpc.NewRPCFunc(BroadcastTxResult, "tx"),
+	"unsafe/gen_priv_account": rpc.NewRPCFunc(GenPrivAccountResult, ""),
+	"unsafe/sign_tx":          rpc.NewRPCFunc(SignTxResult, "tx,privAccounts"),
+
+	// TODO: hookup
 	//	"blockchain":              rpc.NewRPCFunc(BlockchainInfo, "minHeight,maxHeight"),
-	"genesis": rpc.NewRPCFunc(Genesis, ""),
 	//	"get_block":               rpc.NewRPCFunc(GetBlock, "height"),
-	"get_account": rpc.NewRPCFunc(GetAccount, "address"),
-	"get_storage": rpc.NewRPCFunc(GetStorage, "address,key"),
-	"call":        rpc.NewRPCFunc(Call, "fromAddress,toAddress,data"),
-	"call_code":   rpc.NewRPCFunc(CallCode, "fromAddress,code,data"),
 	//"list_validators":         rpc.NewRPCFunc(ListValidators, ""),
 	// "dump_consensus_state":    rpc.NewRPCFunc(DumpConsensusState, ""),
-	"dump_storage": rpc.NewRPCFunc(DumpStorage, "address"),
-	// "broadcast_tx":            rpc.NewRPCFunc(BroadcastTx, "tx"),
 	// "list_unconfirmed_txs":    rpc.NewRPCFunc(ListUnconfirmedTxs, ""),
-	"list_accounts":           rpc.NewRPCFunc(ListAccounts, ""),
-	"get_name":                rpc.NewRPCFunc(GetName, "name"),
-	"list_names":              rpc.NewRPCFunc(ListNames, ""),
-	"unsafe/gen_priv_account": rpc.NewRPCFunc(GenPrivAccount, ""),
-	"unsafe/sign_tx":          rpc.NewRPCFunc(SignTx, "tx,privAccounts"),
 	// subscribe/unsubscribe are reserved for websocket events.
 }
+
+func StatusResult() (ctypes.ErisDBResult, error) {
+	if r, err := Status(); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func NetInfoResult() (ctypes.ErisDBResult, error) {
+	if r, err := NetInfo(); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func GenesisResult() (ctypes.ErisDBResult, error) {
+	if r, err := Genesis(); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func GetAccountResult(address []byte) (ctypes.ErisDBResult, error) {
+	if r, err := GetAccount(address); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func GetStorageResult(address, key []byte) (ctypes.ErisDBResult, error) {
+	if r, err := GetStorage(address, key); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func CallResult(fromAddress, toAddress, data []byte) (ctypes.ErisDBResult, error) {
+	if r, err := Call(fromAddress, toAddress, data); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func CallCodeResult(fromAddress, code, data []byte) (ctypes.ErisDBResult, error) {
+	if r, err := CallCode(fromAddress, code, data); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func DumpStorageResult(address []byte) (ctypes.ErisDBResult, error) {
+	if r, err := DumpStorage(address); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func ListAccountsResult() (ctypes.ErisDBResult, error) {
+	if r, err := ListAccounts(); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func GetNameResult(name string) (ctypes.ErisDBResult, error) {
+	if r, err := GetName(name); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func ListNamesResult() (ctypes.ErisDBResult, error) {
+	if r, err := ListNames(); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func GenPrivAccountResult() (ctypes.ErisDBResult, error) {
+	if r, err := GenPrivAccount(); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func SignTxResult(tx types.Tx, privAccounts []*acm.PrivAccount) (ctypes.ErisDBResult, error) {
+	if r, err := SignTx(tx, privAccounts); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func BroadcastTxResult(tx types.Tx) (ctypes.ErisDBResult, error) {
+	if r, err := BroadcastTxSync(tx); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
diff --git a/rpc/core/types/responses.go b/rpc/core/types/responses.go
index c1718dbee8d0012463b7fa8b0637929dab816dfe..d8a9a61b043b66cad9c0fbbbff06cfb791bdc24e 100644
--- a/rpc/core/types/responses.go
+++ b/rpc/core/types/responses.go
@@ -8,7 +8,9 @@ import (
 
 	"github.com/tendermint/go-crypto"
 	"github.com/tendermint/go-p2p"
+	"github.com/tendermint/go-rpc/types"
 	"github.com/tendermint/go-wire"
+	tmsptypes "github.com/tendermint/tmsp/types"
 )
 
 type ResultGetStorage struct {
@@ -92,7 +94,9 @@ type ResultGetAccount struct {
 }
 
 type ResultBroadcastTx struct {
-	Receipt Receipt `json:"receipt"`
+	Code tmsptypes.CodeType `json:"code"`
+	Data []byte             `json:"data"`
+	Log  string             `json:"log"`
 }
 
 type Receipt struct {
@@ -124,14 +128,7 @@ type ResultEvent struct {
 }
 
 //----------------------------------------
-// response & result types
-
-type Response struct {
-	JSONRPC string `json:"jsonrpc"`
-	ID      string `json:"id"`
-	Result  Result `json:"result"`
-	Error   string `json:"error"`
-}
+// result types
 
 const (
 	ResultTypeGetStorage         = byte(0x01)
@@ -155,11 +152,13 @@ const (
 	ResultTypeEvent              = byte(0x13) // so websockets can respond to rpc functions
 )
 
-type Result interface{}
+type ErisDBResult interface {
+	rpctypes.Result
+}
 
 // for wire.readReflect
 var _ = wire.RegisterInterface(
-	struct{ Result }{},
+	struct{ ErisDBResult }{},
 	wire.ConcreteType{&ResultGetStorage{}, ResultTypeGetStorage},
 	wire.ConcreteType{&ResultCall{}, ResultTypeCall},
 	wire.ConcreteType{&ResultListAccounts{}, ResultTypeListAccounts},
diff --git a/rpc/core_client/client.go b/rpc/core_client/client.go
deleted file mode 100644
index f95eadfb6335d126ccdcbbec7dbc8f1c632d31a3..0000000000000000000000000000000000000000
--- a/rpc/core_client/client.go
+++ /dev/null
@@ -1,236 +0,0 @@
-package core_client
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-
-	ctypes "github.com/eris-ltd/eris-db/rpc/core/types"
-	rpctypes "github.com/tendermint/go-rpc/types"
-	"github.com/tendermint/go-wire"
-	//"reflect"
-	// Uncomment to use go:generate
-	// _ "github.com/tendermint/go-rpc-gen"
-)
-
-// maps camel-case function names to lower case rpc version
-var reverseFuncMap = map[string]string{
-	"Status":             "status",
-	"NetInfo":            "net_info",
-	"BlockchainInfo":     "blockchain",
-	"Genesis":            "genesis",
-	"GetBlock":           "get_block",
-	"GetAccount":         "get_account",
-	"GetStorage":         "get_storage",
-	"Call":               "call",
-	"CallCode":           "call_code",
-	"ListValidators":     "list_validators",
-	"DumpConsensusState": "dump_consensus_state",
-	"DumpStorage":        "dump_storage",
-	"BroadcastTx":        "broadcast_tx",
-	"ListUnconfirmedTxs": "list_unconfirmed_txs",
-	"ListAccounts":       "list_accounts",
-	"GetName":            "get_name",
-	"ListNames":          "list_names",
-	"GenPrivAccount":     "unsafe/gen_priv_account",
-	"SignTx":             "unsafe/sign_tx",
-}
-
-/*
-// fill the map from camelcase to lowercase
-func fillReverseFuncMap() map[string]string {
-	fMap := make(map[string]string)
-	for name, f := range core.Routes {
-		camelName := runtime.FuncForPC(f.f.Pointer()).Name()
-		spl := strings.Split(camelName, ".")
-		if len(spl) > 1 {
-			camelName = spl[len(spl)-1]
-		}
-		fMap[camelName] = name
-	}
-	return fMap
-}
-*/
-
-type Response struct {
-	Status string
-	Data   interface{}
-	Error  string
-}
-
-//go:generate go-rpc-gen -interface Client -dir ../core -pkg core -type *ClientHTTP,*ClientJSON -exclude pipe.go -out-pkg core_client
-
-type ClientJSON struct {
-	addr string
-}
-
-type ClientHTTP struct {
-	addr string
-}
-
-func NewClient(addr, typ string) Client {
-	switch typ {
-	case "HTTP":
-		return &ClientHTTP{addr}
-	case "JSONRPC":
-		return &ClientJSON{addr}
-	default:
-		panic("Unknown client type " + typ + ". Select HTTP or JSONRPC")
-	}
-	return nil
-}
-
-func argsToJson(args ...interface{}) ([]string, error) {
-	l := len(args)
-	jsons := make([]string, l)
-	n, err := new(int), new(error)
-	for i, a := range args {
-		buf := new(bytes.Buffer)
-		wire.WriteJSON(a, buf, n, err)
-		if *err != nil {
-			return nil, *err
-		}
-		jsons[i] = string(buf.Bytes())
-	}
-	return jsons, nil
-}
-
-func (c *ClientJSON) RequestResponse(s rpctypes.RPCRequest) (b []byte, err error) {
-	b = wire.JSONBytes(s)
-	buf := bytes.NewBuffer(b)
-	resp, err := http.Post(c.addr, "text/json", buf)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	return ioutil.ReadAll(resp.Body)
-}
-
-/*
-	What follows is used by `rpc-gen` when `go generate` is called
-	to populate the rpc client methods
-*/
-
-// first we define the base interface, which rpc-gen will further populate with generated methods
-
-/*rpc-gen:define-interface Client
-type Client interface {
-	Address() string // returns the remote address
-}
-*/
-
-// encoding functions
-
-func binaryWriter(args ...interface{}) ([]interface{}, error) {
-	list := []interface{}{}
-	for _, a := range args {
-		buf, n, err := new(bytes.Buffer), new(int), new(error)
-		wire.WriteJSON(a, buf, n, err)
-		if *err != nil {
-			return nil, *err
-		}
-		list = append(list, buf.Bytes())
-
-	}
-	return list, nil
-}
-
-func argsToURLValues(argNames []string, args ...interface{}) (url.Values, error) {
-	values := make(url.Values)
-	if len(argNames) == 0 {
-		return values, nil
-	}
-	if len(argNames) != len(args) {
-		return nil, fmt.Errorf("argNames and args have different lengths: %d, %d", len(argNames), len(args))
-	}
-	slice, err := argsToJson(args...)
-	if err != nil {
-		return nil, err
-	}
-	for i, name := range argNames {
-		s := slice[i]
-		values.Set(name, s) // s[0]
-		/*for j := 1; j < len(s); j++ {
-			values.Add(name, s[j])
-		}*/
-	}
-	return values, nil
-}
-
-func unmarshalCheckResponse(body []byte) (response *ctypes.Response, err error) {
-	response = new(ctypes.Response)
-	wire.ReadJSON(response, body, &err)
-	if err != nil {
-		return nil, err
-	}
-	if response.Error != "" {
-		return nil, fmt.Errorf(response.Error)
-	}
-	return response, nil
-}
-
-// import statements we will need for the templates
-
-/*rpc-gen:imports:
-rpctypes github.com/tendermint/tendermint/rpc/types
-net/http
-io/ioutil
-fmt
-*/
-
-// Template functions to be filled in
-
-/*rpc-gen:template:*ClientJSON func (c *ClientJSON) {{name}}({{args.def}}) ({{response}}) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["{{name}}"],
-		Params:  []interface{}{ {{args.ident}} },
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil{
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil{
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.({{response.0}})
-	if !ok{
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}*/
-
-/*rpc-gen:template:*ClientHTTP func (c *ClientHTTP) {{name}}({{args.def}}) ({{response}}){
-	values, err := argsToURLValues({{args.name}}, {{args.ident}})
-	if err != nil{
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["{{name}}"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil{
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.({{response.0}})
-	if !ok{
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}*/
diff --git a/rpc/core_client/client_methods.go b/rpc/core_client/client_methods.go
deleted file mode 100644
index dd1848c4b7df25373f2f2818f32dc1170e128502..0000000000000000000000000000000000000000
--- a/rpc/core_client/client_methods.go
+++ /dev/null
@@ -1,1042 +0,0 @@
-// File generated by github.com/ebuchman/rpc-gen
-
-package core_client
-
-import (
-	"fmt"
-	acm "github.com/eris-ltd/eris-db/account"
-	ctypes "github.com/eris-ltd/eris-db/rpc/core/types"
-	"github.com/eris-ltd/eris-db/txs"
-	rpctypes "github.com/tendermint/go-rpc/types"
-	"io/ioutil"
-	"net/http"
-)
-
-type Client interface {
-	BlockchainInfo(minHeight int, maxHeight int) (*ctypes.ResultBlockchainInfo, error)
-	BroadcastTx(tx types.Tx) (*ctypes.ResultBroadcastTx, error)
-	Call(fromAddress []byte, toAddress []byte, data []byte) (*ctypes.ResultCall, error)
-	CallCode(fromAddress []byte, code []byte, data []byte) (*ctypes.ResultCall, error)
-	DumpConsensusState() (*ctypes.ResultDumpConsensusState, error)
-	DumpStorage(address []byte) (*ctypes.ResultDumpStorage, error)
-	GenPrivAccount() (*ctypes.ResultGenPrivAccount, error)
-	Genesis() (*ctypes.ResultGenesis, error)
-	GetAccount(address []byte) (*ctypes.ResultGetAccount, error)
-	GetBlock(height int) (*ctypes.ResultGetBlock, error)
-	GetName(name string) (*ctypes.ResultGetName, error)
-	GetStorage(address []byte, key []byte) (*ctypes.ResultGetStorage, error)
-	ListAccounts() (*ctypes.ResultListAccounts, error)
-	ListNames() (*ctypes.ResultListNames, error)
-	ListUnconfirmedTxs() (*ctypes.ResultListUnconfirmedTxs, error)
-	ListValidators() (*ctypes.ResultListValidators, error)
-	NetInfo() (*ctypes.ResultNetInfo, error)
-	SignTx(tx types.Tx, privAccounts []*acm.PrivAccount) (*ctypes.ResultSignTx, error)
-	Status() (*ctypes.ResultStatus, error)
-}
-
-func (c *ClientHTTP) BlockchainInfo(minHeight int, maxHeight int) (*ctypes.ResultBlockchainInfo, error) {
-	values, err := argsToURLValues([]string{"minHeight", "maxHeight"}, minHeight, maxHeight)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["BlockchainInfo"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultBlockchainInfo)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) BroadcastTx(tx types.Tx) (*ctypes.ResultBroadcastTx, error) {
-	values, err := argsToURLValues([]string{"tx"}, tx)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["BroadcastTx"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultBroadcastTx)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) Call(fromAddress []byte, toAddress []byte, data []byte) (*ctypes.ResultCall, error) {
-	values, err := argsToURLValues([]string{"fromAddress", "toAddress", "data"}, fromAddress, toAddress, data)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["Call"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultCall)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) CallCode(fromAddress []byte, code []byte, data []byte) (*ctypes.ResultCall, error) {
-	values, err := argsToURLValues([]string{"fromAddress", "code", "data"}, fromAddress, code, data)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["CallCode"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultCall)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) DumpConsensusState() (*ctypes.ResultDumpConsensusState, error) {
-	values, err := argsToURLValues(nil)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["DumpConsensusState"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultDumpConsensusState)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) DumpStorage(address []byte) (*ctypes.ResultDumpStorage, error) {
-	values, err := argsToURLValues([]string{"address"}, address)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["DumpStorage"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultDumpStorage)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) GenPrivAccount() (*ctypes.ResultGenPrivAccount, error) {
-	values, err := argsToURLValues(nil)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["GenPrivAccount"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultGenPrivAccount)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) Genesis() (*ctypes.ResultGenesis, error) {
-	values, err := argsToURLValues(nil)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["Genesis"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultGenesis)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) GetAccount(address []byte) (*ctypes.ResultGetAccount, error) {
-	values, err := argsToURLValues([]string{"address"}, address)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["GetAccount"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultGetAccount)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) GetBlock(height int) (*ctypes.ResultGetBlock, error) {
-	values, err := argsToURLValues([]string{"height"}, height)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["GetBlock"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultGetBlock)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) GetName(name string) (*ctypes.ResultGetName, error) {
-	values, err := argsToURLValues([]string{"name"}, name)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["GetName"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultGetName)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) GetStorage(address []byte, key []byte) (*ctypes.ResultGetStorage, error) {
-	values, err := argsToURLValues([]string{"address", "key"}, address, key)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["GetStorage"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultGetStorage)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) ListAccounts() (*ctypes.ResultListAccounts, error) {
-	values, err := argsToURLValues(nil)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["ListAccounts"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultListAccounts)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) ListNames() (*ctypes.ResultListNames, error) {
-	values, err := argsToURLValues(nil)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["ListNames"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultListNames)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) ListUnconfirmedTxs() (*ctypes.ResultListUnconfirmedTxs, error) {
-	values, err := argsToURLValues(nil)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["ListUnconfirmedTxs"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultListUnconfirmedTxs)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) ListValidators() (*ctypes.ResultListValidators, error) {
-	values, err := argsToURLValues(nil)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["ListValidators"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultListValidators)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) NetInfo() (*ctypes.ResultNetInfo, error) {
-	values, err := argsToURLValues(nil)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["NetInfo"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultNetInfo)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) SignTx(tx types.Tx, privAccounts []*acm.PrivAccount) (*ctypes.ResultSignTx, error) {
-	values, err := argsToURLValues([]string{"tx", "privAccounts"}, tx, privAccounts)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["SignTx"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultSignTx)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientHTTP) Status() (*ctypes.ResultStatus, error) {
-	values, err := argsToURLValues(nil)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := http.PostForm(c.addr+reverseFuncMap["Status"], values)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultStatus)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) BlockchainInfo(minHeight int, maxHeight int) (*ctypes.ResultBlockchainInfo, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["BlockchainInfo"],
-		Params:  []interface{}{minHeight, maxHeight},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultBlockchainInfo)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) BroadcastTx(tx types.Tx) (*ctypes.ResultBroadcastTx, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["BroadcastTx"],
-		Params:  []interface{}{tx},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultBroadcastTx)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) Call(fromAddress []byte, toAddress []byte, data []byte) (*ctypes.ResultCall, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["Call"],
-		Params:  []interface{}{fromAddress, toAddress, data},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultCall)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) CallCode(fromAddress []byte, code []byte, data []byte) (*ctypes.ResultCall, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["CallCode"],
-		Params:  []interface{}{fromAddress, code, data},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultCall)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) DumpConsensusState() (*ctypes.ResultDumpConsensusState, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["DumpConsensusState"],
-		Params:  []interface{}{},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultDumpConsensusState)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) DumpStorage(address []byte) (*ctypes.ResultDumpStorage, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["DumpStorage"],
-		Params:  []interface{}{address},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultDumpStorage)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) GenPrivAccount() (*ctypes.ResultGenPrivAccount, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["GenPrivAccount"],
-		Params:  []interface{}{},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultGenPrivAccount)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) Genesis() (*ctypes.ResultGenesis, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["Genesis"],
-		Params:  []interface{}{},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultGenesis)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) GetAccount(address []byte) (*ctypes.ResultGetAccount, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["GetAccount"],
-		Params:  []interface{}{address},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultGetAccount)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) GetBlock(height int) (*ctypes.ResultGetBlock, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["GetBlock"],
-		Params:  []interface{}{height},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultGetBlock)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) GetName(name string) (*ctypes.ResultGetName, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["GetName"],
-		Params:  []interface{}{name},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultGetName)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) GetStorage(address []byte, key []byte) (*ctypes.ResultGetStorage, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["GetStorage"],
-		Params:  []interface{}{address, key},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultGetStorage)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) ListAccounts() (*ctypes.ResultListAccounts, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["ListAccounts"],
-		Params:  []interface{}{},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultListAccounts)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) ListNames() (*ctypes.ResultListNames, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["ListNames"],
-		Params:  []interface{}{},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultListNames)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) ListUnconfirmedTxs() (*ctypes.ResultListUnconfirmedTxs, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["ListUnconfirmedTxs"],
-		Params:  []interface{}{},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultListUnconfirmedTxs)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) ListValidators() (*ctypes.ResultListValidators, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["ListValidators"],
-		Params:  []interface{}{},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultListValidators)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) NetInfo() (*ctypes.ResultNetInfo, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["NetInfo"],
-		Params:  []interface{}{},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultNetInfo)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) SignTx(tx types.Tx, privAccounts []*acm.PrivAccount) (*ctypes.ResultSignTx, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["SignTx"],
-		Params:  []interface{}{tx, privAccounts},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultSignTx)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
-
-func (c *ClientJSON) Status() (*ctypes.ResultStatus, error) {
-	request := rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		Method:  reverseFuncMap["Status"],
-		Params:  []interface{}{},
-		ID:      "",
-	}
-	body, err := c.RequestResponse(request)
-	if err != nil {
-		return nil, err
-	}
-	response, err := unmarshalCheckResponse(body)
-	if err != nil {
-		return nil, err
-	}
-	if response.Result == nil {
-		return nil, nil
-	}
-	result, ok := response.Result.(*ctypes.ResultStatus)
-	if !ok {
-		return nil, fmt.Errorf("response result was wrong type")
-	}
-	return result, nil
-}
diff --git a/rpc/core_client/log.go b/rpc/core_client/log.go
deleted file mode 100644
index 54b638dc1eafc6095f18e05e47ee64dc6bbd9fd8..0000000000000000000000000000000000000000
--- a/rpc/core_client/log.go
+++ /dev/null
@@ -1,7 +0,0 @@
-package core_client
-
-import (
-	"github.com/tendermint/log15"
-)
-
-var log = log15.New("module", "core_client")
diff --git a/rpc/core_client/ws_client.go b/rpc/core_client/ws_client.go
deleted file mode 100644
index fbd3619b402910d856a7b038f0610302b662b517..0000000000000000000000000000000000000000
--- a/rpc/core_client/ws_client.go
+++ /dev/null
@@ -1,119 +0,0 @@
-package core_client
-
-import (
-	"net/http"
-	"strings"
-	"time"
-
-	ctypes "github.com/eris-ltd/eris-db/rpc/core/types"
-	"github.com/gorilla/websocket"
-	. "github.com/tendermint/go-common"
-	"github.com/tendermint/go-rpc/types"
-	"github.com/tendermint/go-wire"
-)
-
-const (
-	wsEventsChannelCapacity  = 10
-	wsResultsChannelCapacity = 10
-	wsWriteTimeoutSeconds    = 10
-)
-
-type WSClient struct {
-	QuitService
-	Address string
-	*websocket.Conn
-	EventsCh  chan ctypes.ResultEvent
-	ResultsCh chan ctypes.Result
-}
-
-// create a new connection
-func NewWSClient(addr string) *WSClient {
-	wsClient := &WSClient{
-		Address:   addr,
-		Conn:      nil,
-		EventsCh:  make(chan ctypes.ResultEvent, wsEventsChannelCapacity),
-		ResultsCh: make(chan ctypes.Result, wsResultsChannelCapacity),
-	}
-	wsClient.QuitService = *NewQuitService(log, "WSClient", wsClient)
-	return wsClient
-}
-
-func (wsc *WSClient) OnStart() error {
-	wsc.QuitService.OnStart()
-	err := wsc.dial()
-	if err != nil {
-		return err
-	}
-	go wsc.receiveEventsRoutine()
-	return nil
-}
-
-func (wsc *WSClient) dial() error {
-	// Dial
-	dialer := websocket.DefaultDialer
-	rHeader := http.Header{}
-	con, _, err := dialer.Dial(wsc.Address, rHeader)
-	if err != nil {
-		return err
-	}
-	// Set the ping/pong handlers
-	con.SetPingHandler(func(m string) error {
-		con.WriteControl(websocket.PongMessage, []byte(m), time.Now().Add(time.Second*wsWriteTimeoutSeconds))
-		return nil
-	})
-	con.SetPongHandler(func(m string) error {
-		return nil
-	})
-	wsc.Conn = con
-	return nil
-}
-
-func (wsc *WSClient) OnStop() {
-	wsc.QuitService.OnStop()
-}
-
-func (wsc *WSClient) receiveEventsRoutine() {
-	for {
-		_, data, err := wsc.ReadMessage()
-		if err != nil {
-			log.Info("WSClient failed to read message", "error", err, "data", string(data))
-			wsc.Stop()
-			break
-		} else {
-			var response ctypes.Response
-			wire.ReadJSON(&response, data, &err)
-			if err != nil {
-				log.Info("WSClient failed to parse message", "error", err)
-				wsc.Stop()
-				break
-			}
-			if strings.HasSuffix(response.ID, "#event") {
-				wsc.EventsCh <- *response.Result.(*ctypes.ResultEvent)
-			} else {
-				wsc.ResultsCh <- response.Result
-			}
-		}
-	}
-}
-
-// subscribe to an event
-func (wsc *WSClient) Subscribe(eventid string) error {
-	err := wsc.WriteJSON(rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		ID:      "",
-		Method:  "subscribe",
-		Params:  []interface{}{eventid},
-	})
-	return err
-}
-
-// unsubscribe from an event
-func (wsc *WSClient) Unsubscribe(eventid string) error {
-	err := wsc.WriteJSON(rpctypes.RPCRequest{
-		JSONRPC: "2.0",
-		ID:      "",
-		Method:  "unsubscribe",
-		Params:  []interface{}{eventid},
-	})
-	return err
-}
diff --git a/state/types/genesis.go b/state/types/genesis.go
index 8886da405c2b3b294fbfa6586b0be9d15f74a7b8..806d701b29b2ce0daf3e9f5d99862917e7f8b5db 100644
--- a/state/types/genesis.go
+++ b/state/types/genesis.go
@@ -3,10 +3,10 @@ package types
 import (
 	"time"
 
+	ptypes "github.com/eris-ltd/eris-db/permission/types"
 	. "github.com/tendermint/go-common"
 	"github.com/tendermint/go-crypto"
 	"github.com/tendermint/go-wire"
-	ptypes "github.com/eris-ltd/eris-db/permission/types"
 )
 
 //------------------------------------------------------------
@@ -30,10 +30,10 @@ type GenesisAccount struct {
 }
 
 type GenesisValidator struct {
-	PubKey   crypto.PubKeyEd25519 `json:"pub_key"`
-	Amount   int64                `json:"amount"`
-	Name     string               `json:"name"`
-	UnbondTo []BasicAccount       `json:"unbond_to"`
+	PubKey   crypto.PubKey  `json:"pub_key"`
+	Amount   int64          `json:"amount"`
+	Name     string         `json:"name"`
+	UnbondTo []BasicAccount `json:"unbond_to"`
 }
 
 type GenesisParams struct {
diff --git a/tmsp/erisdb.go b/tmsp/erisdb.go
index 514f219806b8e8101aa56f8b754870626cff7b87..ae31612fee7c57cc9a0f42f8be45d922986b5b00 100644
--- a/tmsp/erisdb.go
+++ b/tmsp/erisdb.go
@@ -60,7 +60,6 @@ func (app *ErisDBApp) SetHostAddress(host string) {
 // Broadcast a tx to the tendermint core
 // NOTE: this assumes we know the address of core
 func (app *ErisDBApp) BroadcastTx(tx types.Tx) error {
-	var result ctypes.TMResult
 	buf := new(bytes.Buffer)
 	var n int
 	var err error
@@ -72,6 +71,8 @@ func (app *ErisDBApp) BroadcastTx(tx types.Tx) error {
 	params := map[string]interface{}{
 		"tx": hex.EncodeToString(buf.Bytes()),
 	}
+
+	var result ctypes.TMResult
 	_, err = app.client.Call("broadcast_tx_sync", params, &result)
 	return err
 }
@@ -117,6 +118,7 @@ func (app *ErisDBApp) AppendTx(txBytes []byte) (res tmsp.Result) {
 	if err != nil {
 		return tmsp.NewError(tmsp.CodeType_InternalError, fmt.Sprintf("Internal error: %v", err))
 	}
+	// TODO: need to return receipt so rpc.ResultBroadcastTx.Data (or Log) is the receipt
 	return tmsp.NewResultOK(nil, "Success")
 }
 
@@ -139,6 +141,7 @@ func (app *ErisDBApp) CheckTx(txBytes []byte) (res tmsp.Result) {
 		return tmsp.NewError(tmsp.CodeType_InternalError, fmt.Sprintf("Internal error: %v", err))
 	}
 
+	// TODO: need to return receipt so rpc.ResultBroadcastTx.Data (or Log) is the receipt
 	return tmsp.NewResultOK(nil, "Success")
 }
 
diff --git a/txs/tx.go b/txs/tx.go
index 37805cfc5a30fbd635ffc6886497b7dc91d10e54..d84807edae5bd7afae690bd332393f100ae64dae 100644
--- a/txs/tx.go
+++ b/txs/tx.go
@@ -369,6 +369,13 @@ func TxID(chainID string, tx Tx) []byte {
 
 //-----------------------------------------------------------------------------
 
+func EncodeTx(tx Tx) []byte {
+	wrapTx := struct {
+		Tx Tx `json:"unwrap"`
+	}{tx}
+	return wire.JSONBytes(wrapTx)
+}
+
 // panic on err
 func DecodeTx(txBytes []byte) Tx {
 	var n int