Group (code,data,log) return values into types.Result

example/counter/counter.go

@@ -29,29 +29,37 @@ func (app *CounterApplication) SetOption(key string, value string) (log string)
 	return ""
 }
 
-func (app *CounterApplication) AppendTx(tx []byte) (code types.CodeType, result []byte, log string) {
+func (app *CounterApplication) AppendTx(tx []byte) types.Result {
 	if app.serial {
 		tx8 := make([]byte, 8)
 		copy(tx8[len(tx8)-len(tx):], tx)
 		txValue := binary.BigEndian.Uint64(tx8)
 		if txValue != uint64(app.txCount) {
-			return types.CodeType_BadNonce, nil, fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.txCount, txValue)
+			return types.Result{
+				Code: types.CodeType_BadNonce,
+				Data: nil,
+				Log:  fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.txCount, txValue),
+			}
 		}
 	}
 	app.txCount += 1
-	return types.CodeType_OK, nil, ""
+	return types.NewResultOK(nil, "")
 }
 
-func (app *CounterApplication) CheckTx(tx []byte) (code types.CodeType, result []byte, log string) {
+func (app *CounterApplication) CheckTx(tx []byte) types.Result {
 	if app.serial {
 		tx8 := make([]byte, 8)
 		copy(tx8[len(tx8)-len(tx):], tx)
 		txValue := binary.BigEndian.Uint64(tx8)
 		if txValue < uint64(app.txCount) {
-			return types.CodeType_BadNonce, nil, fmt.Sprintf("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue)
+			return types.Result{
+				Code: types.CodeType_BadNonce,
+				Data: nil,
+				Log:  fmt.Sprintf("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue),
+			}
 		}
 	}
-	return types.CodeType_OK, nil, ""
+	return types.NewResultOK(nil, "")
 }
 
 func (app *CounterApplication) Commit() (hash []byte, log string) {
@@ -66,6 +74,6 @@ func (app *CounterApplication) Commit() (hash []byte, log string) {
 	}
 }
 
-func (app *CounterApplication) Query(query []byte) (code types.CodeType, result []byte, log string) {
+func (app *CounterApplication) Query(query []byte) types.Result {
-	return types.CodeType_OK, nil, fmt.Sprintf("Query is not supported")
+	return types.NewResultOK(nil, fmt.Sprintf("Query is not supported"))
 }

example/dummy/dummy.go

@@ -28,18 +28,18 @@ func (app *DummyApplication) SetOption(key string, value string) (log string) {
 	return ""
 }
 
-func (app *DummyApplication) AppendTx(tx []byte) (code types.CodeType, result []byte, log string) {
+func (app *DummyApplication) AppendTx(tx []byte) types.Result {
 	parts := strings.Split(string(tx), "=")
 	if len(parts) == 2 {
 		app.state.Set([]byte(parts[0]), []byte(parts[1]))
 	} else {
 		app.state.Set(tx, tx)
 	}
-	return types.CodeType_OK, nil, ""
+	return types.NewResultOK(nil, "")
 }
 
-func (app *DummyApplication) CheckTx(tx []byte) (code types.CodeType, result []byte, log string) {
+func (app *DummyApplication) CheckTx(tx []byte) types.Result {
-	return types.CodeType_OK, nil, ""
+	return types.NewResultOK(nil, "")
 }
 
 func (app *DummyApplication) Commit() (hash []byte, log string) {
@@ -47,8 +47,8 @@ func (app *DummyApplication) Commit() (hash []byte, log string) {
 	return hash, ""
 }
 
-func (app *DummyApplication) Query(query []byte) (code types.CodeType, result []byte, log string) {
+func (app *DummyApplication) Query(query []byte) types.Result {
 	index, value, exists := app.state.Get(query)
 	resStr := Fmt("Index=%v value=%v exists=%v", index, string(value), exists)
-	return types.CodeType_OK, []byte(resStr), ""
+	return types.NewResultOK([]byte(resStr), "")
 }

example/nil/nil_app.go

@@ -19,18 +19,18 @@ func (app *NilApplication) SetOption(key string, value string) (log string) {
 	return ""
 }
 
-func (app *NilApplication) AppendTx(tx []byte) (code types.CodeType, result []byte, log string) {
+func (app *NilApplication) AppendTx(tx []byte) types.Result {
-	return types.CodeType_OK, nil, ""
+	return types.NewResultOK(nil, "")
 }
 
-func (app *NilApplication) CheckTx(tx []byte) (code types.CodeType, result []byte, log string) {
+func (app *NilApplication) CheckTx(tx []byte) types.Result {
-	return types.CodeType_OK, nil, ""
+	return types.NewResultOK(nil, "")
 }
 
 func (app *NilApplication) Commit() (hash []byte, log string) {
 	return []byte("nil"), ""
 }
 
-func (app *NilApplication) Query(query []byte) (code types.CodeType, result []byte, log string) {
+func (app *NilApplication) Query(query []byte) types.Result {
-	return types.CodeType_OK, nil, ""
+	return types.NewResultOK(nil, "")
 }

server/server.go

@@ -137,17 +137,17 @@ func (s *Server) handleRequest(req *types.Request, responses chan<- *types.Respo
 		logStr := s.app.SetOption(req.Key, req.Value)
 		responses <- types.ResponseSetOption(logStr)
 	case types.MessageType_AppendTx:
-		code, result, logStr := s.app.AppendTx(req.Data)
+		res := s.app.AppendTx(req.Data)
-		responses <- types.ResponseAppendTx(code, result, logStr)
+		responses <- types.ResponseAppendTx(res.Code, res.Data, res.Log)
 	case types.MessageType_CheckTx:
-		code, result, logStr := s.app.CheckTx(req.Data)
+		res := s.app.CheckTx(req.Data)
-		responses <- types.ResponseCheckTx(code, result, logStr)
+		responses <- types.ResponseCheckTx(res.Code, res.Data, res.Log)
 	case types.MessageType_Commit:
 		hash, logStr := s.app.Commit()
 		responses <- types.ResponseCommit(hash, logStr)
 	case types.MessageType_Query:
-		code, result, logStr := s.app.Query(req.Data)
+		res := s.app.Query(req.Data)
-		responses <- types.ResponseQuery(code, result, logStr)
+		responses <- types.ResponseQuery(res.Code, res.Data, res.Log)
 	case types.MessageType_InitChain:
 		if app, ok := s.app.(types.BlockchainAware); ok {
 			app.InitChain(req.Validators)

types/application.go

@@ -10,16 +10,16 @@ type Application interface {
 	SetOption(key string, value string) (log string)
 
 	// Append a tx
-	AppendTx(tx []byte) (code CodeType, result []byte, log string)
+	AppendTx(tx []byte) Result
 
 	// Validate a tx for the mempool
-	CheckTx(tx []byte) (code CodeType, result []byte, log string)
+	CheckTx(tx []byte) Result
 
 	// Return the application Merkle root hash
 	Commit() (hash []byte, log string)
 
 	// Query for state
-	Query(query []byte) (code CodeType, result []byte, log string)
+	Query(query []byte) Result
 }
 
 // Some applications can choose to implement BlockchainAware

types/result.go

@@ -0,0 +1,37 @@
+package types
+
+import (
+	"fmt"
+)
+
+type Result struct {
+	Code CodeType
+	Data []byte
+	Log  string // Can be non-deterministic
+}
+
+func NewResult(code CodeType, data []byte, log string) Result {
+	return Result{
+		Code: code,
+		Data: data,
+		Log:  log,
+	}
+}
+
+func (res Result) IsOK() bool {
+	return res.Code == CodeType_OK
+}
+
+func (res Result) Error() string {
+	return fmt.Sprintf("TMSP error code:%v, data:%X, log:%v", res.Code, res.Data, res.Log)
+}
+
+//----------------------------------------
+
+func NewResultOK(data []byte, log string) Result {
+	return Result{
+		Code: CodeType_OK,
+		Data: data,
+		Log:  log,
+	}
+}