diff --git a/cmd/counter/main.go b/cmd/counter/main.go
index fc003fb8..07bf4403 100644
--- a/cmd/counter/main.go
+++ b/cmd/counter/main.go
@@ -6,19 +6,31 @@ import (
 	. "github.com/tendermint/go-common"
 	"github.com/tendermint/tmsp/example/counter"
 	"github.com/tendermint/tmsp/server"
+	"github.com/tendermint/tmsp/types"
 )
 
 func main() {
 
 	addrPtr := flag.String("addr", "tcp://0.0.0.0:46658", "Listen address")
+	grpcPtr := flag.String("tmsp", "socket", "TMSP server: socket | grpc")
 	serialPtr := flag.Bool("serial", false, "Enforce incrementing (serial) txs")
 	flag.Parse()
 	app := counter.NewCounterApplication(*serialPtr)
 
 	// Start the listener
-	_, err := server.NewServer(*addrPtr, app)
-	if err != nil {
-		Exit(err.Error())
+	switch *grpcPtr {
+	case "socket":
+		_, err := server.NewServer(*addrPtr, app)
+		if err != nil {
+			Exit(err.Error())
+		}
+	case "grpc":
+		_, err := server.NewGRPCServer(*addrPtr, types.NewGRPCApplication(app))
+		if err != nil {
+			Exit(err.Error())
+		}
+	default:
+		Exit(Fmt("Unknown server type %s", *grpcPtr))
 	}
 
 	// Wait forever
diff --git a/example/nil/nil_test.go b/example/nil/nil_test.go
index 0ef143c7..ba038b87 100644
--- a/example/nil/nil_test.go
+++ b/example/nil/nil_test.go
@@ -1,10 +1,14 @@
 package nilapp
 
 import (
+	"net"
 	"reflect"
 	"testing"
 	"time"
 
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+
 	. "github.com/tendermint/go-common"
 	"github.com/tendermint/tmsp/server"
 	"github.com/tendermint/tmsp/types"
@@ -91,3 +95,54 @@ func TestStream(t *testing.T) {
 
 	<-done
 }
+
+//-------------------------
+// test grpc
+
+func dialerFunc(addr string, timeout time.Duration) (net.Conn, error) {
+	return Connect(addr)
+}
+
+func TestGRPCSync(t *testing.T) {
+
+	numAppendTxs := 2000
+
+	// Start the listener
+	server, err := server.NewGRPCServer("unix://test.sock", types.NewGRPCApplication(NewNilApplication()))
+	if err != nil {
+		Exit(err.Error())
+	}
+	defer server.Stop()
+
+	// Connect to the socket
+	conn, err := grpc.Dial("unix://test.sock", grpc.WithInsecure(), grpc.WithDialer(dialerFunc))
+	if err != nil {
+		Exit(err.Error())
+	}
+	defer conn.Close()
+
+	client := types.NewTMSPApplicationClient(conn)
+
+	// Write requests
+	for counter := 0; counter < numAppendTxs; counter++ {
+		// Send request
+		response, err := client.AppendTx(context.Background(), &types.RequestAppendTx{[]byte("test")})
+		if err != nil {
+			t.Fatal(err.Error())
+		}
+		counter += 1
+		if response.Code != types.CodeType_OK {
+			t.Error("AppendTx failed with ret_code", response.Code)
+		}
+		if counter > numAppendTxs {
+			t.Fatal("Too many AppendTx responses")
+		}
+		t.Log("response", counter)
+		if counter == numAppendTxs {
+			go func() {
+				time.Sleep(time.Second * 2) // Wait for a bit to allow counter overflow
+			}()
+		}
+
+	}
+}
diff --git a/server/grpc_server.go b/server/grpc_server.go
new file mode 100644
index 00000000..3a21e3fb
--- /dev/null
+++ b/server/grpc_server.go
@@ -0,0 +1,55 @@
+package server
+
+import (
+	"net"
+	"strings"
+
+	"google.golang.org/grpc"
+
+	. "github.com/tendermint/go-common"
+	"github.com/tendermint/tmsp/types"
+)
+
+// var maxNumberConnections = 2
+
+type GRPCServer struct {
+	QuitService
+
+	proto    string
+	addr     string
+	listener net.Listener
+
+	app types.TMSPApplicationServer
+}
+
+func NewGRPCServer(protoAddr string, app types.TMSPApplicationServer) (Service, error) {
+	parts := strings.SplitN(protoAddr, "://", 2)
+	proto, addr := parts[0], parts[1]
+	s := &GRPCServer{
+		proto:    proto,
+		addr:     addr,
+		listener: nil,
+		app:      app,
+	}
+	s.QuitService = *NewQuitService(nil, "TMSPServer", s)
+	_, err := s.Start() // Just start it
+	return s, err
+}
+
+func (s *GRPCServer) OnStart() error {
+	s.QuitService.OnStart()
+	ln, err := net.Listen(s.proto, s.addr)
+	if err != nil {
+		return err
+	}
+	s.listener = ln
+	grpcServer := grpc.NewServer()
+	types.RegisterTMSPApplicationServer(grpcServer, s.app)
+	go grpcServer.Serve(ln)
+	return nil
+}
+
+func (s *GRPCServer) OnStop() {
+	s.QuitService.OnStop()
+	s.listener.Close()
+}
diff --git a/server/server.go b/server/server.go
index f5d6e556..ed832595 100644
--- a/server/server.go
+++ b/server/server.go
@@ -25,7 +25,7 @@ type Server struct {
 	app    types.Application
 }
 
-func NewServer(protoAddr string, app types.Application) (*Server, error) {
+func NewServer(protoAddr string, app types.Application) (Service, error) {
 	parts := strings.SplitN(protoAddr, "://", 2)
 	proto, addr := parts[0], parts[1]
 	s := &Server{
diff --git a/types/application.go b/types/application.go
index 65ca9ab0..c6e6f24b 100644
--- a/types/application.go
+++ b/types/application.go
@@ -1,5 +1,9 @@
 package types
 
+import (
+	context "golang.org/x/net/context"
+)
+
 // Applications
 type Application interface {
 
@@ -36,3 +40,70 @@ type BlockchainAware interface {
 	// diffs: changed validators from app to TendermintCore
 	EndBlock(height uint64) (diffs []*Validator)
 }
+
+//------------------------------------
+type GRPCApplication struct {
+	app Application
+}
+
+func NewGRPCApplication(app Application) *GRPCApplication {
+	return &GRPCApplication{app}
+}
+
+func (app *GRPCApplication) Echo(ctx context.Context, req *RequestEcho) (*ResponseEcho, error) {
+	return &ResponseEcho{req.Message}, nil
+}
+
+func (app *GRPCApplication) Flush(ctx context.Context, req *RequestFlush) (*ResponseFlush, error) {
+	return &ResponseFlush{}, nil
+}
+
+func (app *GRPCApplication) Info(ctx context.Context, req *RequestInfo) (*ResponseInfo, error) {
+	return &ResponseInfo{app.app.Info()}, nil
+}
+
+func (app *GRPCApplication) SetOption(ctx context.Context, req *RequestSetOption) (*ResponseSetOption, error) {
+	return &ResponseSetOption{app.app.SetOption(req.Key, req.Value)}, nil
+}
+
+func (app *GRPCApplication) AppendTx(ctx context.Context, req *RequestAppendTx) (*ResponseAppendTx, error) {
+	r := app.app.AppendTx(req.Tx)
+	return &ResponseAppendTx{r.Code, r.Data, r.Log}, nil
+}
+
+func (app *GRPCApplication) CheckTx(ctx context.Context, req *RequestCheckTx) (*ResponseCheckTx, error) {
+	r := app.app.CheckTx(req.Tx)
+	return &ResponseCheckTx{r.Code, r.Data, r.Log}, nil
+}
+
+func (app *GRPCApplication) Query(ctx context.Context, req *RequestQuery) (*ResponseQuery, error) {
+	r := app.app.Query(req.Query)
+	return &ResponseQuery{r.Code, r.Data, r.Log}, nil
+}
+
+func (app *GRPCApplication) Commit(ctx context.Context, req *RequestCommit) (*ResponseCommit, error) {
+	r := app.app.Commit()
+	return &ResponseCommit{r.Code, r.Data, r.Log}, nil
+}
+
+func (app *GRPCApplication) InitChain(ctx context.Context, req *RequestInitChain) (*ResponseInitChain, error) {
+	if chainAware, ok := app.app.(BlockchainAware); ok {
+		chainAware.InitChain(req.Validators)
+	}
+	return &ResponseInitChain{}, nil
+}
+
+func (app *GRPCApplication) BeginBlock(ctx context.Context, req *RequestBeginBlock) (*ResponseBeginBlock, error) {
+	if chainAware, ok := app.app.(BlockchainAware); ok {
+		chainAware.BeginBlock(req.Height)
+	}
+	return &ResponseBeginBlock{}, nil
+}
+
+func (app *GRPCApplication) EndBlock(ctx context.Context, req *RequestEndBlock) (*ResponseEndBlock, error) {
+	if chainAware, ok := app.app.(BlockchainAware); ok {
+		diffs := chainAware.EndBlock(req.Height)
+		return &ResponseEndBlock{diffs}, nil
+	}
+	return &ResponseEndBlock{}, nil
+}
diff --git a/types/types.pb.go b/types/types.pb.go
index 3d803236..181a0608 100644
--- a/types/types.pb.go
+++ b/types/types.pb.go
@@ -42,6 +42,11 @@ import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
 import math "math"
 
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
 var _ = fmt.Errorf
@@ -1313,84 +1318,494 @@ func init() {
 	proto.RegisterEnum("types.CodeType", CodeType_name, CodeType_value)
 }
 
-var fileDescriptor0 = []byte{
-	// 1235 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0xc9, 0x72, 0xdb, 0x46,
-	0x10, 0x35, 0xc4, 0xbd, 0x49, 0x51, 0xa3, 0x11, 0x65, 0xc3, 0xa9, 0x1c, 0x1c, 0x64, 0xb3, 0x6c,
-	0x97, 0x92, 0x92, 0x2b, 0xae, 0x28, 0xc9, 0xc5, 0x92, 0x69, 0x45, 0xe5, 0xb2, 0xa5, 0xd0, 0xcb,
-	0x21, 0x4b, 0xa9, 0x40, 0x70, 0x48, 0x22, 0xa2, 0x66, 0x60, 0x2c, 0xb6, 0x94, 0x3f, 0xc8, 0x07,
-	0xe5, 0x92, 0x6b, 0x4e, 0xd9, 0x97, 0x2f, 0xca, 0xf4, 0xcc, 0x00, 0x24, 0x20, 0xc8, 0x27, 0xdd,
-	0x66, 0xba, 0xfb, 0x35, 0x7a, 0xba, 0x5f, 0x3f, 0x16, 0xa1, 0x1d, 0x9f, 0x05, 0x2c, 0xda, 0x0c,
-	0x42, 0x11, 0x0b, 0x5a, 0x53, 0x17, 0xe7, 0x97, 0x2a, 0x34, 0x06, 0xec, 0x65, 0xc2, 0xa2, 0x98,
-	0xde, 0x84, 0x2a, 0xf3, 0xa6, 0xc2, 0xb6, 0x6e, 0x58, 0x37, 0xdb, 0x5b, 0x74, 0x53, 0x87, 0x1b,
-	0x6f, 0x5f, 0x7a, 0xbe, 0xbc, 0x32, 0x50, 0x11, 0xf4, 0x36, 0xd4, 0xc6, 0xb3, 0x24, 0x9a, 0xda,
-	0x4b, 0x2a, 0x74, 0x2d, 0x1f, 0xfa, 0x10, 0x5d, 0x32, 0x56, 0xc7, 0x60, 0x5a, 0x9f, 0x8f, 0x85,
-	0x5d, 0x29, 0x4b, 0xbb, 0x2f, 0x3d, 0x98, 0x16, 0x23, 0xe8, 0xa7, 0x00, 0x11, 0x8b, 0x8f, 0x44,
-	0x10, 0xfb, 0x82, 0xdb, 0x55, 0x15, 0x7f, 0x2d, 0x1f, 0xff, 0x94, 0xc5, 0x07, 0xca, 0x2d, 0x41,
-	0xad, 0x28, 0xbd, 0xd0, 0x4f, 0xa0, 0xe5, 0x06, 0x01, 0xe3, 0xa3, 0xa3, 0xf8, 0xd4, 0xae, 0x29,
-	0xe0, 0xd5, 0x3c, 0xf0, 0xbe, 0x72, 0x3f, 0x3b, 0x95, 0xb8, 0xa6, 0x6b, 0xce, 0x74, 0x0b, 0x9a,
-	0xde, 0x94, 0x79, 0xc7, 0x88, 0xaa, 0x2b, 0xd4, 0x7a, 0x1e, 0xb5, 0x8b, 0x5e, 0x05, 0x6a, 0x78,
-	0xfa, 0x48, 0x37, 0xa1, 0xee, 0x89, 0x93, 0x13, 0x3f, 0xb6, 0x1b, 0x0a, 0xd1, 0x2b, 0x20, 0x94,
-	0x4f, 0x02, 0x4c, 0x14, 0xf6, 0x4a, 0x3a, 0xc2, 0x33, 0xbb, 0x59, 0xd6, 0xab, 0xaf, 0xd0, 0x85,
-	0xbd, 0x52, 0x31, 0xd8, 0x01, 0x9f, 0xfb, 0xf1, 0x91, 0x37, 0x75, 0x7d, 0x6e, 0xb7, 0xca, 0x3a,
-	0xb0, 0x2f, 0xfd, 0xbb, 0xe8, 0xc6, 0x0e, 0xf8, 0xe9, 0x85, 0x7e, 0x0e, 0xed, 0x21, 0x9b, 0xf8,
-	0xfc, 0x68, 0x38, 0x13, 0xde, 0xb1, 0x0d, 0x0a, 0x6a, 0xe7, 0xa1, 0x3b, 0x18, 0xb0, 0x83, 0x7e,
-	0x89, 0x85, 0x61, 0x76, 0xc3, 0xf6, 0x61, 0xef, 0x34, 0xb4, 0x5d, 0xd6, 0xbe, 0x3e, 0x1f, 0xa5,
-	0xc0, 0x26, 0x33, 0xe7, 0x9d, 0x06, 0xd4, 0x5e, 0xb9, 0xb3, 0x84, 0x39, 0x1f, 0x42, 0x7b, 0x81,
-	0x26, 0xd4, 0x86, 0xc6, 0x09, 0x8b, 0x22, 0x77, 0xc2, 0x14, 0x97, 0x5a, 0x83, 0xf4, 0xea, 0x74,
-	0xa1, 0xb3, 0x48, 0x12, 0x67, 0x39, 0x03, 0x22, 0x11, 0x9c, 0xcf, 0x80, 0x14, 0xe7, 0x4c, 0x09,
-	0x54, 0x8e, 0xd9, 0x99, 0x49, 0x84, 0x47, 0xda, 0x33, 0x9f, 0x55, 0xec, 0x6b, 0x0d, 0x4c, 0x0d,
-	0xef, 0xc0, 0x4a, 0x61, 0xd4, 0xb4, 0x0b, 0x4b, 0x72, 0xb0, 0x88, 0xec, 0x0c, 0xe4, 0xc9, 0xb9,
-	0x01, 0xdd, 0xfc, 0x5c, 0xcf, 0x45, 0xbc, 0x97, 0xd5, 0xa7, 0x06, 0x83, 0x9f, 0xd2, 0xc3, 0xd3,
-	0x21, 0xfa, 0xe2, 0xac, 0xc0, 0x72, 0x6e, 0xda, 0xce, 0x83, 0xac, 0xee, 0x6c, 0x3a, 0xf4, 0x63,
-	0x00, 0x59, 0x98, 0x3f, 0x72, 0x63, 0x11, 0x46, 0x12, 0x5f, 0x91, 0x4d, 0x25, 0xa6, 0xa9, 0x2f,
-	0x52, 0xc7, 0x60, 0x21, 0xc6, 0xb9, 0x0d, 0xab, 0xe7, 0x06, 0x45, 0xaf, 0x42, 0x7d, 0xca, 0xfc,
-	0xc9, 0x34, 0x56, 0x25, 0x54, 0x07, 0xe6, 0xe6, 0x6c, 0x64, 0xcf, 0x4d, 0x47, 0x73, 0x61, 0xe8,
-	0x8f, 0x35, 0x68, 0x0e, 0x58, 0x14, 0x08, 0x1e, 0x31, 0xc9, 0xb0, 0x16, 0x3b, 0xf5, 0x98, 0x5e,
-	0x31, 0xab, 0xc0, 0x12, 0x1d, 0xd3, 0x4f, 0xfd, 0xc8, 0xb0, 0x2c, 0x98, 0x6e, 0x18, 0x79, 0x28,
-	0xee, 0xbc, 0x01, 0x2d, 0xea, 0xc3, 0x9d, 0x54, 0x1f, 0x2a, 0x85, 0x15, 0xd1, 0xb1, 0x05, 0x81,
-	0xd8, 0x30, 0x02, 0x51, 0x2d, 0x4d, 0x9c, 0x53, 0x88, 0xed, 0x9c, 0x42, 0xd4, 0x4a, 0xcb, 0xbf,
-	0x40, 0x22, 0xee, 0x2d, 0x4a, 0x44, 0xbd, 0xb0, 0x59, 0x1a, 0x59, 0xaa, 0x11, 0x77, 0x17, 0x34,
-	0xa2, 0x51, 0x58, 0x0d, 0x0d, 0x2b, 0x11, 0x89, 0x8f, 0x32, 0x91, 0x68, 0x16, 0x64, 0xc5, 0x40,
-	0x8a, 0x2a, 0x71, 0x27, 0x25, 0x5a, 0xab, 0xb4, 0x63, 0x05, 0x99, 0xd8, 0xce, 0xc9, 0x04, 0x94,
-	0xb6, 0xe1, 0x02, 0x9d, 0xf8, 0x22, 0xaf, 0x13, 0x7a, 0xd9, 0xaf, 0x17, 0xb0, 0x17, 0x0a, 0xc5,
-	0xbd, 0x45, 0xa1, 0xe8, 0x94, 0x36, 0xf1, 0xcd, 0x4a, 0xb1, 0x81, 0x1c, 0x2f, 0xd0, 0x0c, 0xb7,
-	0x8c, 0x85, 0xa1, 0x08, 0xcd, 0x92, 0xeb, 0x8b, 0x73, 0x13, 0x77, 0x71, 0x4e, 0xae, 0x37, 0xa8,
-	0x8a, 0xda, 0xc7, 0x05, 0x6a, 0x39, 0xce, 0x1c, 0x8a, 0xf4, 0xa1, 0xd4, 0x30, 0x4c, 0xe3, 0xd4,
-	0xd9, 0x79, 0x7f, 0x5e, 0x49, 0x4e, 0x6c, 0x66, 0x62, 0x92, 0x8a, 0x8d, 0x3c, 0x3a, 0xdf, 0xe1,
-	0x6a, 0xe7, 0xe9, 0x41, 0xdf, 0x85, 0xaa, 0x27, 0x46, 0xba, 0x8c, 0xee, 0xd6, 0x8a, 0x69, 0xc0,
-	0xae, 0x34, 0x3d, 0x93, 0xa7, 0x81, 0x72, 0xe2, 0x37, 0xe5, 0x5e, 0xbb, 0x6a, 0x5d, 0x3a, 0x03,
-	0x75, 0x4e, 0xd3, 0x57, 0xe6, 0xe9, 0xbf, 0xc5, 0x35, 0xce, 0xd1, 0xe8, 0x32, 0xb3, 0x7f, 0x3d,
-	0x6f, 0x8c, 0xd6, 0xb3, 0x4b, 0xcc, 0xfd, 0x0d, 0x8a, 0xe9, 0x22, 0x9b, 0x2f, 0x33, 0xf9, 0xda,
-	0x7c, 0x38, 0x19, 0x8f, 0x9d, 0x1e, 0xd0, 0xf3, 0x04, 0xd5, 0xbf, 0x19, 0x79, 0xea, 0xd1, 0x0f,
-	0xa0, 0x36, 0xf2, 0xc7, 0xe3, 0x48, 0x4a, 0x4a, 0xb9, 0xec, 0x6a, 0xb7, 0xb3, 0x0d, 0xad, 0xcc,
-	0x86, 0xf2, 0x19, 0x24, 0xc3, 0x47, 0x2c, 0x15, 0x7b, 0x73, 0x43, 0x76, 0x06, 0xe2, 0x35, 0x0b,
-	0x55, 0xc9, 0xd5, 0x81, 0xbe, 0xdc, 0xfa, 0xd9, 0x82, 0xf6, 0x63, 0xcd, 0x3f, 0x7c, 0x1d, 0x5d,
-	0x81, 0xf6, 0x93, 0x64, 0x36, 0x33, 0x26, 0x72, 0x85, 0x36, 0xa1, 0x8a, 0xb4, 0x25, 0x16, 0x6d,
-	0x41, 0x4d, 0xd1, 0x92, 0x2c, 0xa1, 0x11, 0x09, 0x49, 0x2a, 0x74, 0x19, 0x5a, 0x19, 0xed, 0x48,
-	0x15, 0xaf, 0xd9, 0x3e, 0x90, 0x1a, 0xed, 0x40, 0x33, 0x65, 0x1b, 0x59, 0xa5, 0x6d, 0x68, 0x18,
-	0x72, 0x10, 0xd9, 0x3f, 0xa8, 0xeb, 0x7e, 0x93, 0x35, 0xcc, 0xac, 0xe6, 0x4a, 0x7a, 0x98, 0x20,
-	0xeb, 0x14, 0x59, 0x97, 0x3f, 0x6c, 0x30, 0xef, 0x11, 0xb9, 0x8a, 0x09, 0xd3, 0xee, 0x90, 0x6b,
-	0xb7, 0x7e, 0x92, 0xbf, 0x08, 0xe9, 0x5c, 0x68, 0x1d, 0x96, 0x0e, 0x1e, 0xc9, 0x82, 0x57, 0x61,
-	0x79, 0x9f, 0xc7, 0x2c, 0xe4, 0xee, 0xac, 0x8f, 0x0b, 0x28, 0x2b, 0x97, 0xa6, 0x3e, 0x97, 0x63,
-	0xf3, 0xf9, 0x44, 0x9b, 0x96, 0x30, 0xd1, 0x8e, 0x3b, 0x7a, 0x22, 0xb8, 0xc7, 0xe4, 0x2b, 0x08,
-	0x74, 0x9e, 0x73, 0x37, 0x89, 0xa7, 0x22, 0xf4, 0x7f, 0x60, 0x23, 0xf9, 0x90, 0x75, 0x58, 0xdd,
-	0xe7, 0x51, 0x32, 0x1e, 0xfb, 0x9e, 0xcf, 0x78, 0xfc, 0x30, 0xe1, 0xa3, 0x48, 0x3e, 0x88, 0x42,
-	0xf7, 0x39, 0x3f, 0xe6, 0xe2, 0x35, 0x37, 0xbf, 0x5a, 0xa4, 0x2e, 0x17, 0xba, 0xb7, 0xe3, 0x46,
-	0xec, 0x41, 0x12, 0xcc, 0x7c, 0xcf, 0x8d, 0xd9, 0xfd, 0xd1, 0x28, 0x94, 0xed, 0x23, 0x0c, 0x93,
-	0xa0, 0x27, 0xff, 0xed, 0x71, 0x0a, 0xc8, 0xe5, 0x67, 0x2c, 0x22, 0x13, 0x7a, 0x1d, 0xd6, 0xcf,
-	0x79, 0xd4, 0x97, 0xa7, 0xf4, 0x6d, 0xb0, 0x8b, 0xae, 0x3d, 0x37, 0x3a, 0x0c, 0x7d, 0xf9, 0x00,
-	0x5f, 0x0e, 0x97, 0x68, 0xaf, 0xfa, 0x1d, 0xde, 0xe7, 0x41, 0x12, 0x93, 0xef, 0xd3, 0xef, 0x1b,
-	0xeb, 0x41, 0x12, 0xa3, 0xf9, 0xb8, 0x60, 0x3e, 0x54, 0xf4, 0x20, 0x33, 0x7a, 0x0d, 0xd6, 0x16,
-	0xcc, 0x4f, 0xf1, 0x7d, 0xd8, 0x9d, 0x93, 0x79, 0xbd, 0xda, 0xe1, 0x4f, 0xb8, 0x1b, 0x27, 0x21,
-	0x23, 0x5c, 0x72, 0x8d, 0xa2, 0xc7, 0xb4, 0x24, 0x7d, 0xb8, 0x48, 0xbf, 0x60, 0xec, 0xe6, 0x0b,
-	0x41, 0xd1, 0x3c, 0x4b, 0xe4, 0x64, 0xc9, 0x4b, 0x69, 0x26, 0x7b, 0xe2, 0x95, 0xb1, 0xf6, 0x79,
-	0xec, 0xc7, 0x67, 0xe4, 0x57, 0x4b, 0xbe, 0x69, 0x65, 0x6e, 0xde, 0x0b, 0x45, 0x12, 0x90, 0xdf,
-	0x2c, 0x59, 0x25, 0x9d, 0x5b, 0x0f, 0x43, 0x11, 0x88, 0xc8, 0x9d, 0x91, 0xdf, 0x2d, 0x59, 0xcb,
-	0xaa, 0x74, 0x64, 0x53, 0xd0, 0x80, 0x3f, 0x52, 0x40, 0x66, 0x7f, 0xcc, 0x4e, 0x86, 0x2c, 0x24,
-	0x7f, 0x5a, 0xb2, 0xd9, 0xbd, 0x45, 0x47, 0x96, 0xeb, 0x2f, 0xcb, 0x54, 0x94, 0xb9, 0x5e, 0x88,
-	0x98, 0x91, 0xbf, 0x53, 0xb3, 0xe9, 0x83, 0x49, 0xf4, 0x8f, 0x45, 0xd7, 0xa0, 0x3b, 0x37, 0xab,
-	0xd8, 0x7f, 0x2d, 0xfa, 0x16, 0xac, 0xe7, 0x8c, 0x72, 0xfe, 0x87, 0xb8, 0x71, 0xe4, 0x3f, 0x6b,
-	0x58, 0x57, 0xff, 0x5d, 0xee, 0xfe, 0x1f, 0x00, 0x00, 0xff, 0xff, 0xc3, 0x7d, 0xee, 0xf0, 0xca,
-	0x0c, 0x00, 0x00,
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion2
+
+// Client API for TMSPApplication service
+
+type TMSPApplicationClient interface {
+	Echo(ctx context.Context, in *RequestEcho, opts ...grpc.CallOption) (*ResponseEcho, error)
+	Flush(ctx context.Context, in *RequestFlush, opts ...grpc.CallOption) (*ResponseFlush, error)
+	Info(ctx context.Context, in *RequestInfo, opts ...grpc.CallOption) (*ResponseInfo, error)
+	SetOption(ctx context.Context, in *RequestSetOption, opts ...grpc.CallOption) (*ResponseSetOption, error)
+	AppendTx(ctx context.Context, in *RequestAppendTx, opts ...grpc.CallOption) (*ResponseAppendTx, error)
+	CheckTx(ctx context.Context, in *RequestCheckTx, opts ...grpc.CallOption) (*ResponseCheckTx, error)
+	Query(ctx context.Context, in *RequestQuery, opts ...grpc.CallOption) (*ResponseQuery, error)
+	Commit(ctx context.Context, in *RequestCommit, opts ...grpc.CallOption) (*ResponseCommit, error)
+	InitChain(ctx context.Context, in *RequestInitChain, opts ...grpc.CallOption) (*ResponseInitChain, error)
+	BeginBlock(ctx context.Context, in *RequestBeginBlock, opts ...grpc.CallOption) (*ResponseBeginBlock, error)
+	EndBlock(ctx context.Context, in *RequestEndBlock, opts ...grpc.CallOption) (*ResponseEndBlock, error)
+}
+
+type tMSPApplicationClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewTMSPApplicationClient(cc *grpc.ClientConn) TMSPApplicationClient {
+	return &tMSPApplicationClient{cc}
+}
+
+func (c *tMSPApplicationClient) Echo(ctx context.Context, in *RequestEcho, opts ...grpc.CallOption) (*ResponseEcho, error) {
+	out := new(ResponseEcho)
+	err := grpc.Invoke(ctx, "/types.TMSPApplication/Echo", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *tMSPApplicationClient) Flush(ctx context.Context, in *RequestFlush, opts ...grpc.CallOption) (*ResponseFlush, error) {
+	out := new(ResponseFlush)
+	err := grpc.Invoke(ctx, "/types.TMSPApplication/Flush", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *tMSPApplicationClient) Info(ctx context.Context, in *RequestInfo, opts ...grpc.CallOption) (*ResponseInfo, error) {
+	out := new(ResponseInfo)
+	err := grpc.Invoke(ctx, "/types.TMSPApplication/Info", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *tMSPApplicationClient) SetOption(ctx context.Context, in *RequestSetOption, opts ...grpc.CallOption) (*ResponseSetOption, error) {
+	out := new(ResponseSetOption)
+	err := grpc.Invoke(ctx, "/types.TMSPApplication/SetOption", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *tMSPApplicationClient) AppendTx(ctx context.Context, in *RequestAppendTx, opts ...grpc.CallOption) (*ResponseAppendTx, error) {
+	out := new(ResponseAppendTx)
+	err := grpc.Invoke(ctx, "/types.TMSPApplication/AppendTx", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *tMSPApplicationClient) CheckTx(ctx context.Context, in *RequestCheckTx, opts ...grpc.CallOption) (*ResponseCheckTx, error) {
+	out := new(ResponseCheckTx)
+	err := grpc.Invoke(ctx, "/types.TMSPApplication/CheckTx", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *tMSPApplicationClient) Query(ctx context.Context, in *RequestQuery, opts ...grpc.CallOption) (*ResponseQuery, error) {
+	out := new(ResponseQuery)
+	err := grpc.Invoke(ctx, "/types.TMSPApplication/Query", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *tMSPApplicationClient) Commit(ctx context.Context, in *RequestCommit, opts ...grpc.CallOption) (*ResponseCommit, error) {
+	out := new(ResponseCommit)
+	err := grpc.Invoke(ctx, "/types.TMSPApplication/Commit", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *tMSPApplicationClient) InitChain(ctx context.Context, in *RequestInitChain, opts ...grpc.CallOption) (*ResponseInitChain, error) {
+	out := new(ResponseInitChain)
+	err := grpc.Invoke(ctx, "/types.TMSPApplication/InitChain", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *tMSPApplicationClient) BeginBlock(ctx context.Context, in *RequestBeginBlock, opts ...grpc.CallOption) (*ResponseBeginBlock, error) {
+	out := new(ResponseBeginBlock)
+	err := grpc.Invoke(ctx, "/types.TMSPApplication/BeginBlock", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *tMSPApplicationClient) EndBlock(ctx context.Context, in *RequestEndBlock, opts ...grpc.CallOption) (*ResponseEndBlock, error) {
+	out := new(ResponseEndBlock)
+	err := grpc.Invoke(ctx, "/types.TMSPApplication/EndBlock", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for TMSPApplication service
+
+type TMSPApplicationServer interface {
+	Echo(context.Context, *RequestEcho) (*ResponseEcho, error)
+	Flush(context.Context, *RequestFlush) (*ResponseFlush, error)
+	Info(context.Context, *RequestInfo) (*ResponseInfo, error)
+	SetOption(context.Context, *RequestSetOption) (*ResponseSetOption, error)
+	AppendTx(context.Context, *RequestAppendTx) (*ResponseAppendTx, error)
+	CheckTx(context.Context, *RequestCheckTx) (*ResponseCheckTx, error)
+	Query(context.Context, *RequestQuery) (*ResponseQuery, error)
+	Commit(context.Context, *RequestCommit) (*ResponseCommit, error)
+	InitChain(context.Context, *RequestInitChain) (*ResponseInitChain, error)
+	BeginBlock(context.Context, *RequestBeginBlock) (*ResponseBeginBlock, error)
+	EndBlock(context.Context, *RequestEndBlock) (*ResponseEndBlock, error)
+}
+
+func RegisterTMSPApplicationServer(s *grpc.Server, srv TMSPApplicationServer) {
+	s.RegisterService(&_TMSPApplication_serviceDesc, srv)
+}
+
+func _TMSPApplication_Echo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestEcho)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TMSPApplicationServer).Echo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/types.TMSPApplication/Echo",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TMSPApplicationServer).Echo(ctx, req.(*RequestEcho))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _TMSPApplication_Flush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestFlush)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TMSPApplicationServer).Flush(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/types.TMSPApplication/Flush",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TMSPApplicationServer).Flush(ctx, req.(*RequestFlush))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _TMSPApplication_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestInfo)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TMSPApplicationServer).Info(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/types.TMSPApplication/Info",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TMSPApplicationServer).Info(ctx, req.(*RequestInfo))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _TMSPApplication_SetOption_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestSetOption)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TMSPApplicationServer).SetOption(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/types.TMSPApplication/SetOption",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TMSPApplicationServer).SetOption(ctx, req.(*RequestSetOption))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _TMSPApplication_AppendTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestAppendTx)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TMSPApplicationServer).AppendTx(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/types.TMSPApplication/AppendTx",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TMSPApplicationServer).AppendTx(ctx, req.(*RequestAppendTx))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _TMSPApplication_CheckTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestCheckTx)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TMSPApplicationServer).CheckTx(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/types.TMSPApplication/CheckTx",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TMSPApplicationServer).CheckTx(ctx, req.(*RequestCheckTx))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _TMSPApplication_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestQuery)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TMSPApplicationServer).Query(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/types.TMSPApplication/Query",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TMSPApplicationServer).Query(ctx, req.(*RequestQuery))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _TMSPApplication_Commit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestCommit)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TMSPApplicationServer).Commit(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/types.TMSPApplication/Commit",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TMSPApplicationServer).Commit(ctx, req.(*RequestCommit))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _TMSPApplication_InitChain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestInitChain)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TMSPApplicationServer).InitChain(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/types.TMSPApplication/InitChain",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TMSPApplicationServer).InitChain(ctx, req.(*RequestInitChain))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _TMSPApplication_BeginBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestBeginBlock)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TMSPApplicationServer).BeginBlock(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/types.TMSPApplication/BeginBlock",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TMSPApplicationServer).BeginBlock(ctx, req.(*RequestBeginBlock))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _TMSPApplication_EndBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestEndBlock)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(TMSPApplicationServer).EndBlock(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/types.TMSPApplication/EndBlock",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(TMSPApplicationServer).EndBlock(ctx, req.(*RequestEndBlock))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _TMSPApplication_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "types.TMSPApplication",
+	HandlerType: (*TMSPApplicationServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Echo",
+			Handler:    _TMSPApplication_Echo_Handler,
+		},
+		{
+			MethodName: "Flush",
+			Handler:    _TMSPApplication_Flush_Handler,
+		},
+		{
+			MethodName: "Info",
+			Handler:    _TMSPApplication_Info_Handler,
+		},
+		{
+			MethodName: "SetOption",
+			Handler:    _TMSPApplication_SetOption_Handler,
+		},
+		{
+			MethodName: "AppendTx",
+			Handler:    _TMSPApplication_AppendTx_Handler,
+		},
+		{
+			MethodName: "CheckTx",
+			Handler:    _TMSPApplication_CheckTx_Handler,
+		},
+		{
+			MethodName: "Query",
+			Handler:    _TMSPApplication_Query_Handler,
+		},
+		{
+			MethodName: "Commit",
+			Handler:    _TMSPApplication_Commit_Handler,
+		},
+		{
+			MethodName: "InitChain",
+			Handler:    _TMSPApplication_InitChain_Handler,
+		},
+		{
+			MethodName: "BeginBlock",
+			Handler:    _TMSPApplication_BeginBlock_Handler,
+		},
+		{
+			MethodName: "EndBlock",
+			Handler:    _TMSPApplication_EndBlock_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{},
+}
+
+var fileDescriptor0 = []byte{
+	// 1379 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0xc9, 0x72, 0x14, 0x47,
+	0x13, 0xa6, 0xa5, 0x59, 0x73, 0xb4, 0x94, 0x4a, 0x12, 0x0c, 0x13, 0xff, 0x81, 0xbf, 0xbd, 0x21,
+	0x20, 0xc0, 0x21, 0xc2, 0x84, 0xb1, 0x1d, 0x8e, 0x40, 0x20, 0xb0, 0x82, 0x00, 0xe4, 0x61, 0x39,
+	0x78, 0x09, 0x45, 0x6b, 0xa6, 0x66, 0xa6, 0xad, 0x51, 0x75, 0xd3, 0x0b, 0x20, 0xbf, 0x81, 0x1f,
+	0xc8, 0x17, 0x5f, 0x7d, 0xf2, 0xbe, 0x3c, 0x91, 0x33, 0xab, 0xaa, 0x57, 0x75, 0x73, 0xd2, 0xad,
+	0x2b, 0xb7, 0xaa, 0xca, 0xfc, 0xf2, 0xeb, 0x2c, 0xe8, 0x45, 0x27, 0xbe, 0x08, 0xaf, 0xfb, 0x81,
+	0x17, 0x79, 0xbc, 0xa9, 0x16, 0xf6, 0xcf, 0x0d, 0x68, 0x0f, 0xc5, 0xcb, 0x58, 0x84, 0x11, 0xbf,
+	0x0c, 0x0d, 0x31, 0x9a, 0x79, 0x7d, 0xeb, 0x92, 0x75, 0xb9, 0xb7, 0xcd, 0xaf, 0x6b, 0x73, 0xa3,
+	0xdd, 0x45, 0xcd, 0x17, 0xe7, 0x86, 0xca, 0x82, 0x5f, 0x85, 0xe6, 0x64, 0x1e, 0x87, 0xb3, 0xfe,
+	0x82, 0x32, 0x5d, 0x2f, 0x9a, 0xde, 0x27, 0x15, 0xda, 0x6a, 0x1b, 0x0a, 0xeb, 0xca, 0x89, 0xd7,
+	0x5f, 0xac, 0x0a, 0xbb, 0x87, 0x1a, 0x0a, 0x4b, 0x16, 0xfc, 0x63, 0x80, 0x50, 0x44, 0x07, 0x9e,
+	0x1f, 0xb9, 0x9e, 0xec, 0x37, 0x94, 0xfd, 0x85, 0xa2, 0xfd, 0x53, 0x11, 0x3d, 0x51, 0x6a, 0x74,
+	0xea, 0x86, 0xc9, 0x82, 0x7f, 0x04, 0x5d, 0xc7, 0xf7, 0x85, 0x1c, 0x1f, 0x44, 0x6f, 0xfa, 0x4d,
+	0xe5, 0x78, 0xbe, 0xe8, 0x78, 0x47, 0xa9, 0x9f, 0xbd, 0x41, 0xbf, 0x8e, 0x63, 0xbe, 0xf9, 0x36,
+	0x74, 0x46, 0x33, 0x31, 0x3a, 0x22, 0xaf, 0x96, 0xf2, 0xda, 0x2c, 0x7a, 0xdd, 0x25, 0xad, 0x72,
+	0x6a, 0x8f, 0xf4, 0x27, 0xbf, 0x0e, 0xad, 0x91, 0x77, 0x7c, 0xec, 0x46, 0xfd, 0xb6, 0xf2, 0xd8,
+	0x28, 0x79, 0x28, 0x1d, 0x3a, 0x18, 0x2b, 0xca, 0x15, 0x2a, 0x82, 0x93, 0x7e, 0xa7, 0x2a, 0x57,
+	0x5f, 0x92, 0x8a, 0x72, 0xa5, 0x6c, 0x28, 0x03, 0xae, 0x74, 0xa3, 0x83, 0xd1, 0xcc, 0x71, 0x65,
+	0xbf, 0x5b, 0x95, 0x81, 0x3d, 0xd4, 0xdf, 0x25, 0x35, 0x65, 0xc0, 0x4d, 0x16, 0xfc, 0x53, 0xe8,
+	0x1d, 0x8a, 0xa9, 0x2b, 0x0f, 0x0e, 0xe7, 0xde, 0xe8, 0xa8, 0x0f, 0xca, 0xb5, 0x5f, 0x74, 0xdd,
+	0x21, 0x83, 0x1d, 0xd2, 0xa3, 0x2f, 0x1c, 0xa6, 0x2b, 0x4a, 0x1f, 0xe5, 0x4e, 0xbb, 0xf6, 0xaa,
+	0xd2, 0xb7, 0x2b, 0xc7, 0x89, 0x63, 0x47, 0x98, 0xef, 0x9d, 0x36, 0x34, 0x5f, 0x39, 0xf3, 0x58,
+	0xd8, 0x1f, 0x40, 0x2f, 0x07, 0x13, 0xde, 0x87, 0xf6, 0xb1, 0x08, 0x43, 0x67, 0x2a, 0x14, 0x96,
+	0xba, 0xc3, 0x64, 0x69, 0xaf, 0xc0, 0x52, 0x1e, 0x24, 0xf6, 0x72, 0xea, 0x48, 0x40, 0xb0, 0x3f,
+	0x01, 0x56, 0xae, 0x33, 0x67, 0xb0, 0x78, 0x24, 0x4e, 0x4c, 0x20, 0xfa, 0xe4, 0x1b, 0x66, 0x5b,
+	0x85, 0xbe, 0xee, 0xd0, 0x9c, 0xe1, 0xff, 0xb0, 0x5a, 0x2a, 0x35, 0x5f, 0x81, 0x05, 0x2c, 0x2c,
+	0x79, 0x2e, 0x0d, 0xf1, 0xcb, 0xbe, 0x04, 0x2b, 0xc5, 0xba, 0x9e, 0xb2, 0x78, 0x37, 0x3d, 0x9f,
+	0x2a, 0x0c, 0x6d, 0xa5, 0x8b, 0xa7, 0x4d, 0xf4, 0xc2, 0x5e, 0x85, 0xe5, 0x42, 0xb5, 0xed, 0x7b,
+	0xe9, 0xb9, 0xd3, 0xea, 0xf0, 0x0f, 0x01, 0xf0, 0x60, 0xee, 0xd8, 0x89, 0xbc, 0x20, 0x44, 0xff,
+	0x45, 0x4c, 0x2a, 0x33, 0x49, 0x7d, 0x91, 0x28, 0x86, 0x39, 0x1b, 0xfb, 0x2a, 0xac, 0x9d, 0x2a,
+	0x14, 0x3f, 0x0f, 0xad, 0x99, 0x70, 0xa7, 0xb3, 0x48, 0x1d, 0xa1, 0x31, 0x34, 0x2b, 0x7b, 0x2b,
+	0xbd, 0x6e, 0x52, 0x9a, 0x5a, 0xd3, 0x1f, 0x9a, 0xd0, 0x19, 0x8a, 0xd0, 0xf7, 0x64, 0x28, 0x10,
+	0x61, 0x5d, 0xf1, 0x66, 0x24, 0x74, 0x8b, 0x59, 0x25, 0x94, 0x68, 0x9b, 0xdd, 0x44, 0x4f, 0x08,
+	0x4b, 0x8d, 0xf9, 0x96, 0xa1, 0x87, 0x72, 0xcf, 0x1b, 0xa7, 0x3c, 0x3f, 0x5c, 0x4b, 0xf8, 0x61,
+	0xb1, 0xd4, 0x22, 0xda, 0xb6, 0x44, 0x10, 0x5b, 0x86, 0x20, 0x1a, 0x95, 0x81, 0x0b, 0x0c, 0x71,
+	0xbb, 0xc0, 0x10, 0xcd, 0xca, 0xe3, 0xd7, 0x50, 0xc4, 0xad, 0x3c, 0x45, 0xb4, 0x4a, 0x9d, 0xa5,
+	0x3d, 0x2b, 0x39, 0xe2, 0x66, 0x8e, 0x23, 0xda, 0xa5, 0xd6, 0xd0, 0x6e, 0x15, 0x24, 0x71, 0x23,
+	0x25, 0x89, 0x4e, 0x89, 0x56, 0x8c, 0x4b, 0x99, 0x25, 0xae, 0x25, 0x40, 0xeb, 0x56, 0x66, 0xac,
+	0x44, 0x13, 0xb7, 0x0b, 0x34, 0x01, 0x95, 0x69, 0xa8, 0xe1, 0x89, 0xcf, 0x8a, 0x3c, 0xa1, 0x9b,
+	0xfd, 0x62, 0xc9, 0xb7, 0x96, 0x28, 0x6e, 0xe5, 0x89, 0x62, 0xa9, 0x32, 0x89, 0x6f, 0x67, 0x8a,
+	0x2d, 0xc2, 0x78, 0x09, 0x66, 0xd4, 0x65, 0x22, 0x08, 0xbc, 0xc0, 0x34, 0xb9, 0x5e, 0xd8, 0x97,
+	0xa9, 0x17, 0x33, 0x70, 0xbd, 0x85, 0x55, 0x54, 0x3f, 0xe6, 0xa0, 0x65, 0xdb, 0x99, 0x2b, 0xc1,
+	0x87, 0x73, 0x83, 0x30, 0xed, 0xa7, 0xbe, 0xed, 0xf7, 0xb2, 0x93, 0x14, 0xc8, 0x66, 0xee, 0x4d,
+	0x13, 0xb2, 0xc1, 0x4f, 0xfb, 0x5b, 0x6a, 0xed, 0x22, 0x3c, 0xf8, 0x3b, 0xd0, 0x18, 0x79, 0x63,
+	0x7d, 0x8c, 0x95, 0xed, 0x55, 0x93, 0x80, 0xbb, 0x28, 0x7a, 0x86, 0x5f, 0x43, 0xa5, 0xa4, 0x3d,
+	0xb1, 0xaf, 0x1d, 0xd5, 0x2e, 0x4b, 0x43, 0xf5, 0x9d, 0x84, 0x5f, 0xcc, 0xc2, 0x7f, 0x43, 0x6d,
+	0x5c, 0x80, 0xd1, 0x59, 0x46, 0xff, 0x2a, 0x4b, 0x8c, 0xe6, 0xb3, 0x33, 0x8c, 0xfd, 0x35, 0x91,
+	0x69, 0x1e, 0xcd, 0x67, 0x19, 0x7c, 0x3d, 0x2b, 0x4e, 0x8a, 0x63, 0x7b, 0x03, 0xf8, 0x69, 0x80,
+	0xea, 0x7f, 0x46, 0x11, 0x7a, 0xfc, 0x7d, 0x68, 0x8e, 0xdd, 0xc9, 0x24, 0x44, 0x4a, 0xa9, 0xa6,
+	0x5d, 0xad, 0xb6, 0x6f, 0x43, 0x37, 0x95, 0x11, 0x7d, 0xfa, 0xf1, 0xe1, 0x43, 0x91, 0x90, 0xbd,
+	0x59, 0x11, 0x3a, 0x7d, 0xef, 0xb5, 0x08, 0xd4, 0x91, 0x1b, 0x43, 0xbd, 0xb8, 0xf2, 0x93, 0x05,
+	0xbd, 0x47, 0x1a, 0x7f, 0x74, 0x3b, 0xbe, 0x0a, 0xbd, 0xc7, 0xf1, 0x7c, 0x6e, 0x44, 0xec, 0x1c,
+	0xef, 0x40, 0x83, 0x60, 0xcb, 0x2c, 0xde, 0x85, 0xa6, 0x82, 0x25, 0x5b, 0x20, 0x21, 0x01, 0x92,
+	0x2d, 0xf2, 0x65, 0xe8, 0xa6, 0xb0, 0x63, 0x0d, 0x5a, 0xa6, 0xfd, 0xc0, 0x9a, 0x7c, 0x09, 0x3a,
+	0x09, 0xda, 0xd8, 0x1a, 0xef, 0x41, 0xdb, 0x80, 0x83, 0x61, 0xfe, 0xa0, 0xa5, 0xf3, 0xcd, 0xd6,
+	0x29, 0xb2, 0xaa, 0x2b, 0xdb, 0xa0, 0x00, 0x69, 0xa6, 0xd8, 0x26, 0xfe, 0xd8, 0x20, 0xcb, 0x11,
+	0x3b, 0x4f, 0x01, 0x93, 0xec, 0xb0, 0x0b, 0x57, 0x7e, 0xc4, 0x3f, 0x42, 0x52, 0x17, 0xde, 0x82,
+	0x85, 0x27, 0x0f, 0xf1, 0xc0, 0x6b, 0xb0, 0xbc, 0x27, 0x23, 0x11, 0x48, 0x67, 0xbe, 0x4b, 0x0d,
+	0x88, 0x27, 0x47, 0xd1, 0xae, 0xc4, 0xb2, 0xb9, 0x72, 0xaa, 0x45, 0x0b, 0x14, 0x68, 0xc7, 0x19,
+	0x3f, 0xf6, 0xe4, 0x48, 0xe0, 0x2d, 0x18, 0x2c, 0x3d, 0x97, 0x4e, 0x1c, 0xcd, 0xbc, 0xc0, 0xfd,
+	0x5e, 0x8c, 0xf1, 0x22, 0x9b, 0xb0, 0xb6, 0x27, 0xc3, 0x78, 0x32, 0x71, 0x47, 0xae, 0x90, 0xd1,
+	0xfd, 0x58, 0x8e, 0x43, 0xbc, 0x10, 0x87, 0x95, 0xe7, 0xf2, 0x48, 0x7a, 0xaf, 0xa5, 0xf9, 0x6b,
+	0xb1, 0x16, 0x36, 0xf4, 0xc6, 0x8e, 0x13, 0x8a, 0x7b, 0xb1, 0x3f, 0x77, 0x47, 0x4e, 0x24, 0xee,
+	0x8c, 0xc7, 0x01, 0xa6, 0x8f, 0x09, 0x0a, 0x42, 0x9a, 0xe2, 0xde, 0x93, 0xc4, 0xa1, 0x10, 0x5f,
+	0x88, 0x90, 0x4d, 0xf9, 0x45, 0xd8, 0x3c, 0xa5, 0x51, 0x3b, 0xcf, 0xf8, 0xff, 0xa0, 0x5f, 0x56,
+	0x3d, 0x70, 0xc2, 0xfd, 0xc0, 0xc5, 0x0b, 0xb8, 0x58, 0x5c, 0xa6, 0xb5, 0xea, 0x3f, 0xbc, 0x27,
+	0xfd, 0x38, 0x62, 0xdf, 0x25, 0xfb, 0x1b, 0xe9, 0x93, 0x38, 0x22, 0xf1, 0x51, 0x49, 0xbc, 0xaf,
+	0xe0, 0xc1, 0xe6, 0xfc, 0x02, 0xac, 0xe7, 0xc4, 0x4f, 0xe9, 0x7e, 0x94, 0x9d, 0xe3, 0xec, 0xbc,
+	0x5a, 0xe1, 0x4e, 0xa5, 0x13, 0xc5, 0x81, 0x60, 0x12, 0xb1, 0xc6, 0x49, 0x63, 0x52, 0x92, 0x5c,
+	0xdc, 0x4b, 0x76, 0x30, 0x72, 0xb3, 0x83, 0x5f, 0x16, 0xcf, 0x63, 0xac, 0x2c, 0x7b, 0x89, 0x62,
+	0xf6, 0xc0, 0x7b, 0x65, 0xa4, 0xbb, 0x32, 0x72, 0xa3, 0x13, 0xf6, 0x8b, 0x85, 0x77, 0x5a, 0xcd,
+	0xc4, 0x0f, 0x02, 0x2f, 0xf6, 0xd9, 0xaf, 0x16, 0x9e, 0x92, 0x67, 0xd2, 0xfd, 0xc0, 0xf3, 0xbd,
+	0xd0, 0x99, 0xb3, 0xdf, 0x2c, 0x3c, 0xcb, 0x1a, 0x2a, 0xd2, 0x2a, 0x68, 0x87, 0xdf, 0x13, 0x87,
+	0x54, 0xfe, 0x48, 0x1c, 0x1f, 0x8a, 0x80, 0xfd, 0x61, 0x61, 0xb2, 0x37, 0xf2, 0x8a, 0x34, 0xd6,
+	0x9f, 0x96, 0x39, 0x51, 0xaa, 0x7a, 0xe1, 0x45, 0x82, 0xfd, 0x95, 0x88, 0x4d, 0x1e, 0x4c, 0xa0,
+	0xbf, 0x2d, 0xbe, 0x0e, 0x2b, 0x99, 0x58, 0xd9, 0xfe, 0x63, 0xf1, 0x01, 0x6c, 0x16, 0x84, 0x58,
+	0xff, 0x7d, 0xea, 0x38, 0xf6, 0xaf, 0xb5, 0x8d, 0x93, 0xcc, 0xea, 0xb3, 0x47, 0x4f, 0xf7, 0xb1,
+	0x37, 0xd4, 0x06, 0x44, 0xd9, 0x37, 0x74, 0x9f, 0xf1, 0x8a, 0xf7, 0xca, 0xa0, 0x6a, 0x48, 0xc1,
+	0xa1, 0x5f, 0xb7, 0x23, 0xaf, 0x7a, 0xb6, 0x0c, 0x2a, 0x67, 0x15, 0xda, 0x44, 0xff, 0x48, 0x4e,
+	0xbf, 0x5e, 0x06, 0x55, 0x03, 0x0b, 0xff, 0x3c, 0xd7, 0xde, 0xbc, 0xee, 0x0d, 0x33, 0xa8, 0x1d,
+	0x5d, 0x70, 0x9c, 0x4f, 0x09, 0x80, 0xd7, 0xbc, 0x64, 0x06, 0x75, 0xe3, 0x0b, 0xce, 0x78, 0x09,
+	0x5f, 0xf0, 0xea, 0xf7, 0xcc, 0xa0, 0x66, 0x84, 0xa1, 0xdc, 0xe8, 0x1f, 0x45, 0xd5, 0x33, 0x65,
+	0x50, 0x39, 0x95, 0xe0, 0xe3, 0xc1, 0x10, 0x12, 0xaf, 0x7c, 0x0a, 0x0d, 0xaa, 0x67, 0x1f, 0xca,
+	0x50, 0x36, 0x2c, 0xd7, 0xbd, 0x71, 0x06, 0xb5, 0x53, 0x0d, 0xbf, 0x93, 0x67, 0x38, 0x5e, 0xfb,
+	0xd2, 0x19, 0xd4, 0xcf, 0x36, 0x94, 0xe4, 0x6c, 0x78, 0xae, 0x7e, 0xef, 0x0c, 0xea, 0xc6, 0x9b,
+	0xc3, 0x96, 0x7a, 0x47, 0xdf, 0xfc, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xd8, 0xe3, 0x58, 0x48, 0x56,
+	0x0f, 0x00, 0x00,
 }
diff --git a/types/types.proto b/types/types.proto
index e132ef65..22a2da4f 100644
--- a/types/types.proto
+++ b/types/types.proto
@@ -213,3 +213,22 @@ message Validator {
             bytes             pubKey      = 1;
             uint64            power       = 2;
 }
+
+//----------------------------------------
+// Service Definition
+
+// NOTE: we may want to make CheckTx and AppendTx two way streams.
+// we should be able to drop Flush for sync calls
+service TMSPApplication {
+	rpc Echo(RequestEcho) returns (ResponseEcho) ;
+	rpc Flush(RequestFlush) returns (ResponseFlush);
+	rpc Info(RequestInfo) returns (ResponseInfo);
+	rpc SetOption(RequestSetOption) returns (ResponseSetOption);
+	rpc AppendTx(RequestAppendTx) returns (ResponseAppendTx);
+	rpc CheckTx(RequestCheckTx) returns (ResponseCheckTx);
+	rpc Query(RequestQuery) returns (ResponseQuery);
+	rpc Commit(RequestCommit) returns (ResponseCommit);
+	rpc InitChain(RequestInitChain) returns (ResponseInitChain);
+	rpc BeginBlock(RequestBeginBlock) returns (ResponseBeginBlock);
+	rpc EndBlock(RequestEndBlock) returns (ResponseEndBlock);
+}