Use new tmlibs/common.Error for sdk.Error

types/errors.go

@@ -55,10 +55,7 @@ const (
 	CodeOutOfGas          CodeType = 12
 
 	// CodespaceRoot is a codespace for error codes in this file only.
-	// Notice that 0 is an "unset" codespace, which can be overridden with
-	// Error.WithDefaultCodespace().
-	CodespaceUndefined CodespaceType = 0
-	CodespaceRoot      CodespaceType = 1
+	CodespaceRoot CodespaceType = 1
 
 	// Maximum reservable codespace (2^16 - 1)
 	MaximumCodespace CodespaceType = 65535
@@ -141,49 +138,64 @@ func ErrOutOfGas(msg string) Error {
 //----------------------------------------
 // Error & sdkError
 
+type cmnError = cmn.Error
+
 // sdk Error type
 type Error interface {
-	Error() string
+	// Implements cmn.Error
+	// Error() string
+	// Stacktrace() cmn.Error
+	// Trace(offset int, format string, args ...interface{}) cmn.Error
+	// Data() interface{}
+	cmnError
+
+	// convenience
+	TraceSDK(format string, args ...interface{}) Error
+
 	Code() CodeType
 	Codespace() CodespaceType
 	ABCILog() string
 	ABCICode() ABCICodeType
-	WithDefaultCodespace(codespace CodespaceType) Error
-	Trace(msg string) Error
-	T() interface{}
 	Result() Result
 	QueryResult() abci.ResponseQuery
 }
 
-// NewError - create an error
-func NewError(codespace CodespaceType, code CodeType, msg string) Error {
-	return newError(codespace, code, msg)
+// NewError - create an error.
+func NewError(codespace CodespaceType, code CodeType, format string, args ...interface{}) Error {
+	return newError(codespace, code, format, args...)
 }
 
-func newErrorWithRootCodespace(code CodeType, msg string) *sdkError {
-	return newError(CodespaceRoot, code, msg)
+func newErrorWithRootCodespace(code CodeType, format string, args ...interface{}) *sdkError {
+	return newError(CodespaceRoot, code, format, args...)
 }
 
-func newError(codespace CodespaceType, code CodeType, msg string) *sdkError {
-	if msg == "" {
-		msg = CodeToDefaultMsg(code)
+func newError(codespace CodespaceType, code CodeType, format string, args ...interface{}) *sdkError {
+	if format == "" {
+		format = CodeToDefaultMsg(code)
 	}
 	return &sdkError{
 		codespace: codespace,
 		code:      code,
-		err:       cmn.NewErrorWithT(code, msg),
+		cmnError:  cmn.NewError(format, args...),
 	}
 }
 
 type sdkError struct {
 	codespace CodespaceType
 	code      CodeType
-	err       cmn.Error
+	cmnError
 }
 
 // Implements ABCIError.
+func (err *sdkError) TraceSDK(format string, args ...interface{}) Error {
+	err.Trace(1, format, args...)
+	return err
+}
+
+// Implements ABCIError.
+// Overrides err.Error.Error().
 func (err *sdkError) Error() string {
-	return fmt.Sprintf("Error{%d:%d,%#v}", err.codespace, err.code, err.err)
+	return fmt.Sprintf("Error{%d:%d,%#v}", err.codespace, err.code, err.cmnError)
 }
 
 // Implements ABCIError.
@@ -209,33 +221,7 @@ Code:      %v
 ABCICode:  %v
 Error:     %#v
 === /ABCI Log ===
-`, err.codespace, err.code, err.ABCICode(), err.err)
-}
-
-// Add tracing information with msg.
-func (err *sdkError) Trace(msg string) Error {
-	return &sdkError{
-		codespace: err.codespace,
-		code:      err.code,
-		err:       err.err.Trace(msg),
-	}
-}
-
-// Implements Error.
-func (err *sdkError) WithDefaultCodespace(cs CodespaceType) Error {
-	codespace := err.codespace
-	if codespace == CodespaceUndefined {
-		codespace = cs
-	}
-	return &sdkError{
-		codespace: codespace,
-		code:      err.code,
-		err:       err.err,
-	}
-}
-
-func (err *sdkError) T() interface{} {
-	return err.err.T()
+`, err.codespace, err.code, err.ABCICode(), err.cmnError)
 }
 
 func (err *sdkError) Result() Result {