diff --git a/rpc/tendermint/jsonrpc.go b/rpc/jsonrpc.go
similarity index 98%
rename from rpc/tendermint/jsonrpc.go
rename to rpc/jsonrpc.go
index f0be57ee3633a085373aa117d7eb56d3aec3e37a..72115138ad53350c8619c1fdce1ba67720e78a17 100644
--- a/rpc/tendermint/jsonrpc.go
+++ b/rpc/jsonrpc.go
@@ -1,4 +1,4 @@
-package rpc_tendermint
+package rpc
 
 import (
 	"encoding/json"
diff --git a/rpc/tendermint/rpc_test.go b/rpc/rpc_test.go
similarity index 96%
rename from rpc/tendermint/rpc_test.go
rename to rpc/rpc_test.go
index 5764ef6407f0b16c1af89bc955d31f8b1701001e..bfafa4c2f9861f01192de0ad9b9aba05897d304d 100644
--- a/rpc/tendermint/rpc_test.go
+++ b/rpc/rpc_test.go
@@ -1,4 +1,4 @@
-package rpc_tendermint
+package rpc
 
 import (
 	"github.com/stretchr/testify/assert"
diff --git a/rpc/v0/json_service.go b/rpc/v0/json_service.go
index adce33f211aec98d9c5eb9c339596ec2fc8424d5..822c5e7efc8c45717eced3728aac697b0d98c2e4 100644
--- a/rpc/v0/json_service.go
+++ b/rpc/v0/json_service.go
@@ -11,7 +11,6 @@ import (
 	definitions "github.com/eris-ltd/eris-db/definitions"
 	event "github.com/eris-ltd/eris-db/event"
 	rpc "github.com/eris-ltd/eris-db/rpc"
-	rpc_tendermint "github.com/eris-ltd/eris-db/rpc/tendermint"
 	server "github.com/eris-ltd/eris-db/server"
 )
 
@@ -80,21 +79,21 @@ func NewErisDbJsonService(codec rpc.Codec, pipe definitions.Pipe,
 func (this *ErisDbJsonService) Process(r *http.Request, w http.ResponseWriter) {
 
 	// Create new request object and unmarshal.
-	req := &rpc_tendermint.RPCRequest{}
+	req := &rpc.RPCRequest{}
 	decoder := json.NewDecoder(r.Body)
 	errU := decoder.Decode(req)
 
 	// Error when decoding.
 	if errU != nil {
 		this.writeError("Failed to parse request: "+errU.Error(), "",
-			rpc_tendermint.PARSE_ERROR, w)
+			rpc.PARSE_ERROR, w)
 		return
 	}
 
 	// Wrong protocol version.
 	if req.JSONRPC != "2.0" {
 		this.writeError("Wrong protocol version: "+req.JSONRPC, req.Id,
-			rpc_tendermint.INVALID_REQUEST, w)
+			rpc.INVALID_REQUEST, w)
 		return
 	}
 
@@ -108,13 +107,13 @@ func (this *ErisDbJsonService) Process(r *http.Request, w http.ResponseWriter) {
 			this.writeResponse(req.Id, resp, w)
 		}
 	} else {
-		this.writeError("Method not found: "+mName, req.Id, rpc_tendermint.METHOD_NOT_FOUND, w)
+		this.writeError("Method not found: "+mName, req.Id, rpc.METHOD_NOT_FOUND, w)
 	}
 }
 
 // Helper for writing error responses.
 func (this *ErisDbJsonService) writeError(msg, id string, code int, w http.ResponseWriter) {
-	response := rpc_tendermint.NewRPCErrorResponse(id, code, msg)
+	response := rpc.NewRPCErrorResponse(id, code, msg)
 	err := this.codec.Encode(response, w)
 	// If there's an error here all bets are off.
 	if err != nil {
@@ -127,11 +126,11 @@ func (this *ErisDbJsonService) writeError(msg, id string, code int, w http.Respo
 // Helper for writing responses.
 func (this *ErisDbJsonService) writeResponse(id string, result interface{}, w http.ResponseWriter) {
 	log.Debug("Result: %v\n", result)
-	response := rpc_tendermint.NewRPCResponse(id, result)
+	response := rpc.NewRPCResponse(id, result)
 	err := this.codec.Encode(response, w)
 	log.Debug("Response: %v\n", response)
 	if err != nil {
-		this.writeError("Internal error: "+err.Error(), id, rpc_tendermint.INTERNAL_ERROR, w)
+		this.writeError("Internal error: "+err.Error(), id, rpc.INTERNAL_ERROR, w)
 		return
 	}
 	w.WriteHeader(200)
@@ -140,51 +139,51 @@ func (this *ErisDbJsonService) writeResponse(id string, result interface{}, w ht
 // *************************************** Events ************************************
 
 // Subscribe to an event.
-func (this *ErisDbJsonService) EventSubscribe(request *rpc_tendermint.RPCRequest,
+func (this *ErisDbJsonService) EventSubscribe(request *rpc.RPCRequest,
 	requester interface{}) (interface{}, int, error) {
 	param := &EventIdParam{}
 	err := json.Unmarshal(request.Params, param)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	eventId := param.EventId
 	subId, errC := this.eventSubs.Add(eventId)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return &event.EventSub{subId}, 0, nil
 }
 
 // Un-subscribe from an event.
-func (this *ErisDbJsonService) EventUnsubscribe(request *rpc_tendermint.RPCRequest,
+func (this *ErisDbJsonService) EventUnsubscribe(request *rpc.RPCRequest,
 	requester interface{}) (interface{}, int, error) {
 	param := &SubIdParam{}
 	err := json.Unmarshal(request.Params, param)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	subId := param.SubId
 
 	result, errC := this.pipe.Events().Unsubscribe(subId)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return &event.EventUnsub{result}, 0, nil
 }
 
 // Check subscription event cache for new data.
-func (this *ErisDbJsonService) EventPoll(request *rpc_tendermint.RPCRequest,
+func (this *ErisDbJsonService) EventPoll(request *rpc.RPCRequest,
 	requester interface{}) (interface{}, int, error) {
 	param := &SubIdParam{}
 	err := json.Unmarshal(request.Params, param)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	subId := param.SubId
 
 	result, errC := this.eventSubs.Poll(subId)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return &event.PollResponse{result}, 0, nil
 }
diff --git a/rpc/v0/methods.go b/rpc/v0/methods.go
index be89ebbe103e6e1a2652b185c7436633c7de703d..f5f5540902711ac6a4dd667757e6c4385291ced1 100644
--- a/rpc/v0/methods.go
+++ b/rpc/v0/methods.go
@@ -4,7 +4,6 @@ import (
 	core_types "github.com/eris-ltd/eris-db/core/types"
 	definitions "github.com/eris-ltd/eris-db/definitions"
 	rpc "github.com/eris-ltd/eris-db/rpc"
-	rpc_tendermint "github.com/eris-ltd/eris-db/rpc/tendermint"
 	"github.com/eris-ltd/eris-db/txs"
 )
 
@@ -56,7 +55,7 @@ type ErisDbMethods struct {
 }
 
 // Used to handle requests. interface{} param is a wildcard used for example with socket events.
-type RequestHandlerFunc func(*rpc_tendermint.RPCRequest, interface{}) (interface{}, int, error)
+type RequestHandlerFunc func(*rpc.RPCRequest, interface{}) (interface{}, int, error)
 
 // Private. Create a method name -> method handler map.
 func (this *ErisDbMethods) getMethods() map[string]RequestHandlerFunc {
@@ -108,374 +107,374 @@ func (this *ErisDbMethods) getMethods() map[string]RequestHandlerFunc {
 
 // *************************************** Accounts ***************************************
 
-func (this *ErisDbMethods) GenPrivAccount(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) GenPrivAccount(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	pac, errC := this.pipe.Accounts().GenPrivAccount()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return pac, 0, nil
 }
 
-func (this *ErisDbMethods) GenPrivAccountFromKey(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) GenPrivAccountFromKey(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 
 	param := &PrivKeyParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 
 	privKey := param.PrivKey
 	pac, errC := this.pipe.Accounts().GenPrivAccountFromKey(privKey)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return pac, 0, nil
 }
 
-func (this *ErisDbMethods) Account(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Account(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &AddressParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	address := param.Address
 	// TODO is address check?
 	account, errC := this.pipe.Accounts().Account(address)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return account, 0, nil
 }
 
-func (this *ErisDbMethods) Accounts(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Accounts(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &AccountsParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	list, errC := this.pipe.Accounts().Accounts(param.Filters)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return list, 0, nil
 }
 
-func (this *ErisDbMethods) AccountStorage(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) AccountStorage(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &AddressParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	address := param.Address
 	storage, errC := this.pipe.Accounts().Storage(address)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return storage, 0, nil
 }
 
-func (this *ErisDbMethods) AccountStorageAt(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) AccountStorageAt(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &StorageAtParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	address := param.Address
 	key := param.Key
 	storageItem, errC := this.pipe.Accounts().StorageAt(address, key)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return storageItem, 0, nil
 }
 
 // *************************************** Blockchain ************************************
 
-func (this *ErisDbMethods) BlockchainInfo(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) BlockchainInfo(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	status, errC := this.pipe.Blockchain().Info()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return status, 0, nil
 }
 
-func (this *ErisDbMethods) ChainId(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) ChainId(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	chainId, errC := this.pipe.Blockchain().ChainId()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return &core_types.ChainId{chainId}, 0, nil
 }
 
-func (this *ErisDbMethods) GenesisHash(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) GenesisHash(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	hash, errC := this.pipe.Blockchain().GenesisHash()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return &core_types.GenesisHash{hash}, 0, nil
 }
 
-func (this *ErisDbMethods) LatestBlockHeight(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) LatestBlockHeight(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	height, errC := this.pipe.Blockchain().LatestBlockHeight()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return &core_types.LatestBlockHeight{height}, 0, nil
 }
 
-func (this *ErisDbMethods) LatestBlock(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) LatestBlock(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 
 	block, errC := this.pipe.Blockchain().LatestBlock()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return block, 0, nil
 }
 
-func (this *ErisDbMethods) Blocks(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Blocks(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &BlocksParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	blocks, errC := this.pipe.Blockchain().Blocks(param.Filters)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return blocks, 0, nil
 }
 
-func (this *ErisDbMethods) Block(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Block(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &HeightParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	height := param.Height
 	block, errC := this.pipe.Blockchain().Block(height)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return block, 0, nil
 }
 
 // *************************************** Consensus ************************************
 
-func (this *ErisDbMethods) ConsensusState(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) ConsensusState(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	state, errC := this.pipe.Consensus().State()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return state, 0, nil
 }
 
-func (this *ErisDbMethods) Validators(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Validators(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	validators, errC := this.pipe.Consensus().Validators()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return validators, 0, nil
 }
 
 // *************************************** Net ************************************
 
-func (this *ErisDbMethods) NetworkInfo(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) NetworkInfo(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	info, errC := this.pipe.Net().Info()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return info, 0, nil
 }
 
-func (this *ErisDbMethods) ClientVersion(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) ClientVersion(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	version, errC := this.pipe.Net().ClientVersion()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return &core_types.ClientVersion{version}, 0, nil
 }
 
-func (this *ErisDbMethods) Moniker(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Moniker(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	moniker, errC := this.pipe.Net().Moniker()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return &core_types.Moniker{moniker}, 0, nil
 }
 
-func (this *ErisDbMethods) Listening(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Listening(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	listening, errC := this.pipe.Net().Listening()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return &core_types.Listening{listening}, 0, nil
 }
 
-func (this *ErisDbMethods) Listeners(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Listeners(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	listeners, errC := this.pipe.Net().Listeners()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return &core_types.Listeners{listeners}, 0, nil
 }
 
-func (this *ErisDbMethods) Peers(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Peers(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	peers, errC := this.pipe.Net().Peers()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return peers, 0, nil
 }
 
-func (this *ErisDbMethods) Peer(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Peer(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &PeerParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	address := param.Address
 	peer, errC := this.pipe.Net().Peer(address)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return peer, 0, nil
 }
 
 // *************************************** Txs ************************************
 
-func (this *ErisDbMethods) Call(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Call(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &CallParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	from := param.From
 	to := param.Address
 	data := param.Data
 	call, errC := this.pipe.Transactor().Call(from, to, data)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return call, 0, nil
 }
 
-func (this *ErisDbMethods) CallCode(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) CallCode(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &CallCodeParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	from := param.From
 	code := param.Code
 	data := param.Data
 	call, errC := this.pipe.Transactor().CallCode(from, code, data)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return call, 0, nil
 }
 
-func (this *ErisDbMethods) BroadcastTx(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) BroadcastTx(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &txs.CallTx{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	receipt, errC := this.pipe.Transactor().BroadcastTx(param)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return receipt, 0, nil
 }
 
-func (this *ErisDbMethods) Transact(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Transact(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &TransactParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	receipt, errC := this.pipe.Transactor().Transact(param.PrivKey, param.Address, param.Data, param.GasLimit, param.Fee)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return receipt, 0, nil
 }
 
-func (this *ErisDbMethods) TransactAndHold(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) TransactAndHold(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &TransactParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	ce, errC := this.pipe.Transactor().TransactAndHold(param.PrivKey, param.Address, param.Data, param.GasLimit, param.Fee)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return ce, 0, nil
 }
 
-func (this *ErisDbMethods) TransactNameReg(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) TransactNameReg(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &TransactNameRegParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	receipt, errC := this.pipe.Transactor().TransactNameReg(param.PrivKey, param.Name, param.Data, param.Amount, param.Fee)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return receipt, 0, nil
 }
 
-func (this *ErisDbMethods) UnconfirmedTxs(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) UnconfirmedTxs(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	txs, errC := this.pipe.Transactor().UnconfirmedTxs()
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return txs, 0, nil
 }
 
-func (this *ErisDbMethods) SignTx(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) SignTx(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &SignTxParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	tx := param.Tx
 	pAccs := param.PrivAccounts
 	txRet, errC := this.pipe.Transactor().SignTx(tx, pAccs)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return txRet, 0, nil
 }
 
 // *************************************** Name Registry ***************************************
 
-func (this *ErisDbMethods) NameRegEntry(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) NameRegEntry(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &NameRegEntryParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	name := param.Name
 	// TODO is address check?
 	entry, errC := this.pipe.NameReg().Entry(name)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return entry, 0, nil
 }
 
-func (this *ErisDbMethods) NameRegEntries(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) NameRegEntries(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &FilterListParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	list, errC := this.pipe.NameReg().Entries(param.Filters)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return list, 0, nil
 }
diff --git a/rpc/v0/wsService.go b/rpc/v0/wsService.go
index 73f396e856bed1d7a32b57634c10b8d79648418f..a95262bd7c5a80844c58cb96c11457c11bb5d884 100644
--- a/rpc/v0/wsService.go
+++ b/rpc/v0/wsService.go
@@ -11,7 +11,6 @@ import (
 	definitions "github.com/eris-ltd/eris-db/definitions"
 	event "github.com/eris-ltd/eris-db/event"
 	rpc "github.com/eris-ltd/eris-db/rpc"
-	rpc_tendermint "github.com/eris-ltd/eris-db/rpc/tendermint"
 	server "github.com/eris-ltd/eris-db/server"
 )
 
@@ -40,18 +39,18 @@ func NewErisDbWsService(codec rpc.Codec,
 func (this *ErisDbWsService) Process(msg []byte, session *server.WSSession) {
 	log.Debug("REQUEST: %s\n", string(msg))
 	// Create new request object and unmarshal.
-	req := &rpc_tendermint.RPCRequest{}
+	req := &rpc.RPCRequest{}
 	errU := json.Unmarshal(msg, req)
 
 	// Error when unmarshaling.
 	if errU != nil {
-		this.writeError("Failed to parse request: "+errU.Error()+" . Raw: "+string(msg), "", rpc_tendermint.PARSE_ERROR, session)
+		this.writeError("Failed to parse request: "+errU.Error()+" . Raw: "+string(msg), "", rpc.PARSE_ERROR, session)
 		return
 	}
 
 	// Wrong protocol version.
 	if req.JSONRPC != "2.0" {
-		this.writeError("Wrong protocol version: "+req.JSONRPC, req.Id, rpc_tendermint.INVALID_REQUEST, session)
+		this.writeError("Wrong protocol version: "+req.JSONRPC, req.Id, rpc.INVALID_REQUEST, session)
 		return
 	}
 
@@ -65,13 +64,13 @@ func (this *ErisDbWsService) Process(msg []byte, session *server.WSSession) {
 			this.writeResponse(req.Id, resp, session)
 		}
 	} else {
-		this.writeError("Method not found: "+mName, req.Id, rpc_tendermint.METHOD_NOT_FOUND, session)
+		this.writeError("Method not found: "+mName, req.Id, rpc.METHOD_NOT_FOUND, session)
 	}
 }
 
 // Convenience method for writing error responses.
 func (this *ErisDbWsService) writeError(msg, id string, code int, session *server.WSSession) {
-	response := rpc_tendermint.NewRPCErrorResponse(id, code, msg)
+	response := rpc.NewRPCErrorResponse(id, code, msg)
 	bts, err := this.codec.EncodeBytes(response)
 	// If there's an error here all bets are off.
 	if err != nil {
@@ -82,11 +81,11 @@ func (this *ErisDbWsService) writeError(msg, id string, code int, session *serve
 
 // Convenience method for writing responses.
 func (this *ErisDbWsService) writeResponse(id string, result interface{}, session *server.WSSession) error {
-	response := rpc_tendermint.NewRPCResponse(id, result)
+	response := rpc.NewRPCResponse(id, result)
 	bts, err := this.codec.EncodeBytes(response)
 	log.Debug("RESPONSE: %v\n", response)
 	if err != nil {
-		this.writeError("Internal error: "+err.Error(), id, rpc_tendermint.INTERNAL_ERROR, session)
+		this.writeError("Internal error: "+err.Error(), id, rpc.INTERNAL_ERROR, session)
 		return err
 	}
 	return session.Write(bts)
@@ -94,20 +93,20 @@ func (this *ErisDbWsService) writeResponse(id string, result interface{}, sessio
 
 // *************************************** Events ************************************
 
-func (this *ErisDbWsService) EventSubscribe(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbWsService) EventSubscribe(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	session, ok := requester.(*server.WSSession)
 	if !ok {
-		return 0, rpc_tendermint.INTERNAL_ERROR, fmt.Errorf("Passing wrong object to websocket events")
+		return 0, rpc.INTERNAL_ERROR, fmt.Errorf("Passing wrong object to websocket events")
 	}
 	param := &EventIdParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	eventId := param.EventId
 	subId, errSID := event.GenerateSubId()
 	if errSID != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errSID
+		return nil, rpc.INTERNAL_ERROR, errSID
 	}
 
 	callback := func(ret events.EventData) {
@@ -115,26 +114,26 @@ func (this *ErisDbWsService) EventSubscribe(request *rpc_tendermint.RPCRequest,
 	}
 	_, errC := this.pipe.Events().Subscribe(subId, eventId, callback)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return &event.EventSub{subId}, 0, nil
 }
 
-func (this *ErisDbWsService) EventUnsubscribe(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbWsService) EventUnsubscribe(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
 	param := &EventIdParam{}
 	err := this.codec.DecodeBytes(param, request.Params)
 	if err != nil {
-		return nil, rpc_tendermint.INVALID_PARAMS, err
+		return nil, rpc.INVALID_PARAMS, err
 	}
 	eventId := param.EventId
 
 	result, errC := this.pipe.Events().Unsubscribe(eventId)
 	if errC != nil {
-		return nil, rpc_tendermint.INTERNAL_ERROR, errC
+		return nil, rpc.INTERNAL_ERROR, errC
 	}
 	return &event.EventUnsub{result}, 0, nil
 }
 
-func (this *ErisDbWsService) EventPoll(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
-	return nil, rpc_tendermint.INTERNAL_ERROR, fmt.Errorf("Cannot poll with websockets")
+func (this *ErisDbWsService) EventPoll(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+	return nil, rpc.INTERNAL_ERROR, fmt.Errorf("Cannot poll with websockets")
 }
diff --git a/test/mock/mock_web_api_test.g_ b/test/mock/mock_web_api_test.go
similarity index 98%
rename from test/mock/mock_web_api_test.g_
rename to test/mock/mock_web_api_test.go
index 68abad450be936403d864210783d63731c603fe6..3435935b62f58c68dec49059700af1ca20c77ad1 100644
--- a/test/mock/mock_web_api_test.g_
+++ b/test/mock/mock_web_api_test.go
@@ -252,7 +252,7 @@ func (this *MockSuite) TestGetPeer() {
 
 func (this *MockSuite) TestTransactCreate() {
 	resp := this.postJson("/unsafe/txpool", this.testData.TransactCreate.Input)
-	ret := &core_types.Receipt{}
+	ret := &txs.Receipt{}
 	errD := this.codec.Decode(ret, resp.Body)
 	this.NoError(errD)
 	this.Equal(ret, this.testData.TransactCreate.Output)
@@ -260,7 +260,7 @@ func (this *MockSuite) TestTransactCreate() {
 
 func (this *MockSuite) TestTransact() {
 	resp := this.postJson("/unsafe/txpool", this.testData.Transact.Input)
-	ret := &core_types.Receipt{}
+	ret := &txs.Receipt{}
 	errD := this.codec.Decode(ret, resp.Body)
 	this.NoError(errD)
 	this.Equal(ret, this.testData.Transact.Output)
@@ -268,7 +268,7 @@ func (this *MockSuite) TestTransact() {
 
 func (this *MockSuite) TestTransactNameReg() {
 	resp := this.postJson("/unsafe/namereg/txpool", this.testData.TransactNameReg.Input)
-	ret := &core_types.Receipt{}
+	ret := &txs.Receipt{}
 	errD := this.codec.Decode(ret, resp.Body)
 	this.NoError(errD)
 	this.Equal(ret, this.testData.TransactNameReg.Output)
@@ -276,7 +276,7 @@ func (this *MockSuite) TestTransactNameReg() {
 
 func (this *MockSuite) TestGetUnconfirmedTxs() {
 	resp := this.get("/txpool")
-	ret := &core_types.UnconfirmedTxs{}
+	ret := &txs.UnconfirmedTxs{}
 	errD := this.codec.Decode(ret, resp.Body)
 	this.NoError(errD)
 	this.Equal(ret, this.testData.GetUnconfirmedTxs.Output)
diff --git a/test/mock/pipe.g_ b/test/mock/pipe.go
similarity index 93%
rename from test/mock/pipe.g_
rename to test/mock/pipe.go
index 61fc0398cfe6c358553d2b129f15e90c878cca2b..1eb3b84e850d1bba591a42ccb22bcad61f78658e 100644
--- a/test/mock/pipe.g_
+++ b/test/mock/pipe.go
@@ -92,6 +92,10 @@ func (this *MockPipe) SetConsensusEngine(_ definitions.ConsensusEngine) error {
 	return nil
 }
 
+func (this *MockPipe) GetConsensusEngine() definitions.ConsensusEngine {
+	return nil
+}
+
 func (this *MockPipe) GetTendermintPipe() (definitions.TendermintPipe, error) {
 	return nil, fmt.Errorf("Tendermint pipe is not supported by mocked pipe.")
 }
@@ -191,7 +195,7 @@ type namereg struct {
 	testData *td.TestData
 }
 
-func (this *namereg) Entry(key string) (*types.NameRegEntry, error) {
+func (this *namereg) Entry(key string) (*core_types.NameRegEntry, error) {
 	return this.testData.GetNameRegEntry.Output, nil
 }
 
@@ -246,15 +250,15 @@ func (this *transactor) CallCode(from, code, data []byte) (*core_types.Call, err
 	return this.testData.CallCode.Output, nil
 }
 
-func (this *transactor) BroadcastTx(tx types.Tx) (*core_types.Receipt, error) {
+func (this *transactor) BroadcastTx(tx types.Tx) (*types.Receipt, error) {
 	return nil, nil
 }
 
-func (this *transactor) UnconfirmedTxs() (*core_types.UnconfirmedTxs, error) {
+func (this *transactor) UnconfirmedTxs() (*types.UnconfirmedTxs, error) {
 	return this.testData.GetUnconfirmedTxs.Output, nil
 }
 
-func (this *transactor) Transact(privKey, address, data []byte, gasLimit, fee int64) (*core_types.Receipt, error) {
+func (this *transactor) Transact(privKey, address, data []byte, gasLimit, fee int64) (*types.Receipt, error) {
 	if address == nil || len(address) == 0 {
 		return this.testData.TransactCreate.Output, nil
 	}
@@ -265,15 +269,15 @@ func (this *transactor) TransactAndHold(privKey, address, data []byte, gasLimit,
 	return nil, nil
 }
 
-func (this *transactor) Send(privKey, toAddress []byte, amount int64) (*core_types.Receipt, error) {
+func (this *transactor) Send(privKey, toAddress []byte, amount int64) (*types.Receipt, error) {
 	return nil, nil
 }
 
-func (this *transactor) SendAndHold(privKey, toAddress []byte, amount int64) (*core_types.Receipt, error) {
+func (this *transactor) SendAndHold(privKey, toAddress []byte, amount int64) (*types.Receipt, error) {
 	return nil, nil
 }
 
-func (this *transactor) TransactNameReg(privKey []byte, name, data string, amount, fee int64) (*core_types.Receipt, error) {
+func (this *transactor) TransactNameReg(privKey []byte, name, data string, amount, fee int64) (*types.Receipt, error) {
 	return this.testData.TransactNameReg.Output, nil
 }
 
diff --git a/test/server/scumbag.go b/test/server/scumbag.go
index 907e198fa00c81bb0f822f60ecca75548695f656..71eaddc61d10affad17ad6f9548d42b461b7f172 100644
--- a/test/server/scumbag.go
+++ b/test/server/scumbag.go
@@ -5,7 +5,7 @@ import (
 	"os"
 	"runtime"
 
-	rpc_tendermint "github.com/eris-ltd/eris-db/rpc/tendermint"
+	rpc "github.com/eris-ltd/eris-db/rpc"
 	"github.com/eris-ltd/eris-db/server"
 	"github.com/gin-gonic/gin"
 	"github.com/tendermint/log15"
@@ -46,7 +46,7 @@ func (this *ScumbagServer) ShutDown() {
 type ScumSocketService struct{}
 
 func (this *ScumSocketService) Process(data []byte, session *server.WSSession) {
-	resp := rpc_tendermint.NewRPCResponse("1", "Scumbag")
+	resp := rpc.NewRPCResponse("1", "Scumbag")
 	bts, _ := json.Marshal(resp)
 	session.Write(bts)
 }
diff --git a/test/testdata/helpers.g_ b/test/testdata/helpers.go
similarity index 100%
rename from test/testdata/helpers.g_
rename to test/testdata/helpers.go
diff --git a/test/testdata/testdata/testdata.g_ b/test/testdata/testdata/testdata.go
similarity index 97%
rename from test/testdata/testdata/testdata.g_
rename to test/testdata/testdata/testdata.go
index d780d80a3bbf75285e298803d9d2e2eb79c52d99..34c7c895bf9e32d94d066fdedbca54c2b21c6ddb 100644
--- a/test/testdata/testdata/testdata.g_
+++ b/test/testdata/testdata/testdata.go
@@ -1,13 +1,12 @@
 package testdata
 
 import (
-
-	account    "github.com/eris-ltd/eris-db/account"
-	core_types "github.com/eris-ltd/eris-db/core/types"
-	event      "github.com/eris-ltd/eris-db/event"
-	rpc_v0     "github.com/eris-ltd/eris-db/rpc/v0"
-	stypes     "github.com/eris-ltd/eris-db/manager/eris-mint/state/types"
-	types      "github.com/eris-ltd/eris-db/txs"
+	account     "github.com/eris-ltd/eris-db/account"
+	core_types  "github.com/eris-ltd/eris-db/core/types"
+	event       "github.com/eris-ltd/eris-db/event"
+	rpc_v0      "github.com/eris-ltd/eris-db/rpc/v0"
+	stypes      "github.com/eris-ltd/eris-db/manager/eris-mint/state/types"
+	transaction "github.com/eris-ltd/eris-db/txs"
 
 	mintTypes "github.com/tendermint/tendermint/types"
 )
@@ -54,7 +53,7 @@ var testDataJson = `{
       ],
       "validators": [
         {
-          "pub_key": "CB3688B7561D488A2A4834E1AEE9398BEF94844D8BDBBCA980C11E3654A45906",
+          "pub_key": [1, "CB3688B7561D488A2A4834E1AEE9398BEF94844D8BDBBCA980C11E3654A45906"],
           "amount": 5000000000,
           "unbond_to": [
             {
@@ -604,16 +603,16 @@ type (
 
 	TransactData struct {
 		Input  *rpc_v0.TransactParam `json:"input"`
-		Output *core_types.Receipt `json:"output"`
+		Output *transaction.Receipt `json:"output"`
 	}
 
 	TransactCreateData struct {
 		Input  *rpc_v0.TransactParam `json:"input"`
-		Output *core_types.Receipt `json:"output"`
+		Output *transaction.Receipt `json:"output"`
 	}
 
 	GetUnconfirmedTxsData struct {
-		Output *core_types.UnconfirmedTxs `json:"output"`
+		Output *transaction.UnconfirmedTxs `json:"output"`
 	}
 
 	CallCodeData struct {
@@ -638,12 +637,12 @@ type (
 
 	TransactNameRegData struct {
 		Input  *rpc_v0.TransactNameRegParam `json:"input"`
-		Output *core_types.Receipt        `json:"output"`
+		Output *transaction.Receipt        `json:"output"`
 	}
 
 	GetNameRegEntryData struct {
 		Input  *rpc_v0.NameRegEntryParam `json:"input"`
-		Output *types.NameRegEntry     `json:"output"`
+		Output *core_types.NameRegEntry     `json:"output"`
 	}
 
 	GetNameRegEntriesData struct {